text: // A Bison parser, made by GNU Bison 3.0.4.
  
  // Stack handling for Bison parsers in C++
  
  // Copyright (C) 2002-2015 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 <http://www.gnu.org/licenses/>.
  
  // As a special exception, you may create a larger work that contains
  // part or all of the Bison parser skeleton and distribute that work
  // under terms of your choice, so long as that work isn't itself a
  // parser generator using the skeleton or a modified version thereof
  // as a parser skeleton.  Alternatively, if you modify or redistribute
  // the parser skeleton itself, you may (at your option) remove this
  // special exception, which will cause the skeleton and the resulting
  // Bison output files to be licensed under the GNU General Public
  // License without this special exception.
  
  // This special exception was added by the Free Software Foundation in
  // version 2.2 of Bison.
  
  /**
   ** \file stack.hh
   ** Define the hoayy::stack class.
   */
  
  #ifndef YY_HOAYY_STACK_HH_INCLUDED
  # define YY_HOAYY_STACK_HH_INCLUDED
  
  # include <vector>
  
  
  namespace hoayy {
  #line 46 "stack.hh" // stack.hh:132
    template <class T, class S = std::vector<T> >
    class stack
    {
    public:
      // Hide our reversed order.
      typedef typename S::reverse_iterator iterator;
      typedef typename S::const_reverse_iterator const_iterator;
  
      stack ()
        : seq_ ()
      {
        seq_.reserve (200);
      }
  
      stack (unsigned int n)
        : seq_ (n)
      {}
  
      inline
      T&
      operator[] (unsigned int i)
      {
        return seq_[seq_.size () - 1 - i];
      }
  
      inline
      const T&
      operator[] (unsigned int i) const
      {
        return seq_[seq_.size () - 1 - i];
      }
  
      /// Steal the contents of \a t.
      ///
      /// Close to move-semantics.
      inline
      void
      push (T& t)
      {
        seq_.push_back (T());
        operator[](0).move (t);
      }
  
      inline
      void
      pop (unsigned int n = 1)
      {
        for (; n; --n)
          seq_.pop_back ();
      }
  
      void
      clear ()
      {
        seq_.clear ();
      }
  
      inline
      typename S::size_type
      size () const
      {
        return seq_.size ();
      }
  
      inline
      const_iterator
      begin () const
      {
        return seq_.rbegin ();
      }
  
      inline
      const_iterator
      end () const
      {
        return seq_.rend ();
      }
  
    private:
      stack (const stack&);
      stack& operator= (const stack&);
      /// The wrapped container.
      S seq_;
    };
  
    /// Present a slice of the top of a stack.
    template <class T, class S = stack<T> >
    class slice
    {
    public:
      slice (const S& stack, unsigned int range)
        : stack_ (stack)
        , range_ (range)
      {}
  
      inline
      const T&
      operator [] (unsigned int i) const
      {
        return stack_[range_ - i];
      }
  
    private:
      const S& stack_;
      unsigned int range_;
    };
  
  
  } // hoayy
  #line 156 "stack.hh" // stack.hh:132
  
  #endif // !YY_HOAYY_STACK_HH_INCLUDED
  