kc3-lang/angle/tools/flex-bison/third_party/skeletons/stack.hh

Branch - branch -main

• Show log

  Commit

• Hash : f39a9659
  Author :
  Date : 2022-09-09T10:09:58
  

  Update flex/bison binaries.
  
  These binaries were updated using update_flex_bison_binaries.py.
  Please see instructions in tools/flex-bison/README.md.
  
  flex is at version 2.6.4.
  bison is at version 3.8.2.
  
  Bug: None
  Change-Id: Ia3189b678fc8ddacdf14bbfd3f4750f938d32ac3
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3886807
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• tools/flex-bison/third_party/skeletons/stack.hh

• # C++ skeleton for Bison
  
  # Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc.
  
  # This program is free software: you can redistribute it and/or modify
  # it under the terms of the GNU General Public License as published by
  # the Free Software Foundation, either version 3 of the License, or
  # (at your option) any later version.
  #
  # This program is distributed in the hope that it will be useful,
  # but WITHOUT ANY WARRANTY; without even the implied warranty of
  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  # GNU General Public License for more details.
  #
  # You should have received a copy of the GNU General Public License
  # along with this program.  If not, see <https://www.gnu.org/licenses/>.
  
  
  # b4_stack_file
  # -------------
  # Name of the file containing the stack class, if we want this file.
  b4_header_if([b4_required_version_if([30200], [],
                                       [m4_define([b4_stack_file], [stack.hh])])])
  
  
  # b4_stack_define
  # ---------------
  m4_define([b4_stack_define],
  [[    /// A stack with random access from its top.
      template <typename T, typename S = std::vector<T> >
      class stack
      {
      public:
        // Hide our reversed order.
        typedef typename S::iterator iterator;
        typedef typename S::const_iterator const_iterator;
        typedef typename S::size_type size_type;
        typedef typename std::ptrdiff_t index_type;
  
        stack (size_type n = 200) YY_NOEXCEPT
          : seq_ (n)
        {}
  
  #if 201103L <= YY_CPLUSPLUS
        /// Non copyable.
        stack (const stack&) = delete;
        /// Non copyable.
        stack& operator= (const stack&) = delete;
  #endif
  
        /// Random access.
        ///
        /// Index 0 returns the topmost element.
        const T&
        operator[] (index_type i) const
        {
          return seq_[size_type (size () - 1 - i)];
        }
  
        /// Random access.
        ///
        /// Index 0 returns the topmost element.
        T&
        operator[] (index_type i)
        {
          return seq_[size_type (size () - 1 - i)];
        }
  
        /// Steal the contents of \a t.
        ///
        /// Close to move-semantics.
        void
        push (YY_MOVE_REF (T) t)
        {
          seq_.push_back (T ());
          operator[] (0).move (t);
        }
  
        /// Pop elements from the stack.
        void
        pop (std::ptrdiff_t n = 1) YY_NOEXCEPT
        {
          for (; 0 < n; --n)
            seq_.pop_back ();
        }
  
        /// Pop all elements from the stack.
        void
        clear () YY_NOEXCEPT
        {
          seq_.clear ();
        }
  
        /// Number of elements on the stack.
        index_type
        size () const YY_NOEXCEPT
        {
          return index_type (seq_.size ());
        }
  
        /// Iterator on top of the stack (going downwards).
        const_iterator
        begin () const YY_NOEXCEPT
        {
          return seq_.begin ();
        }
  
        /// Bottom of the stack.
        const_iterator
        end () const YY_NOEXCEPT
        {
          return seq_.end ();
        }
  
        /// Present a slice of the top of a stack.
        class slice
        {
        public:
          slice (const stack& stack, index_type range) YY_NOEXCEPT
            : stack_ (stack)
            , range_ (range)
          {}
  
          const T&
          operator[] (index_type i) const
          {
            return stack_[range_ - i];
          }
  
        private:
          const stack& stack_;
          index_type range_;
        };
  
      private:
  #if YY_CPLUSPLUS < 201103L
        /// Non copyable.
        stack (const stack&);
        /// Non copyable.
        stack& operator= (const stack&);
  #endif
        /// The wrapped container.
        S seq_;
      };
  ]])
  
  m4_ifdef([b4_stack_file],
  [b4_output_begin([b4_dir_prefix], [b4_stack_file])[
  ]b4_generated_by[
  // Starting with Bison 3.2, this file is useless: the structure it
  // used to define is now defined with the parser itself.
  //
  // To get rid of this file:
  // 1. add '%require "3.2"' (or newer) to your grammar file
  // 2. remove references to this file from your build system.
  ]b4_output_end[
  ]])
  

Download