aprepro_parser.h

Go to the documentation of this file.

// A Bison parser, made by GNU Bison 3.8.2.
 
// Skeleton interface for Bison LALR(1) parsers in C++
 
// 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/>.
 
// 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 aprepro_parser.h
 ** Define the SEAMS::parser class.
 */
 
// C++ LALR(1) parser skeleton written by Akim Demaille.
 
// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
// especially those whose name start with YY_ or yy_.  They are
// private implementation details that can be changed or removed.
 
#ifndef YY_SEAMS_APREPRO_PARSER_H_INCLUDED
#define YY_SEAMS_APREPRO_PARSER_H_INCLUDED
 
#include <cstdlib> // std::abort
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
 
#if defined __cplusplus
#define YY_CPLUSPLUS __cplusplus
#else
#define YY_CPLUSPLUS 199711L
#endif
 
// Support move semantics when possible.
#if 201103L <= YY_CPLUSPLUS
#define YY_MOVE           std::move
#define YY_MOVE_OR_COPY   move
#define YY_MOVE_REF(Type) Type &&
#define YY_RVREF(Type)    Type &&
#define YY_COPY(Type)     Type
#else
#define YY_MOVE
#define YY_MOVE_OR_COPY   copy
#define YY_MOVE_REF(Type) Type &
#define YY_RVREF(Type)    const Type &
#define YY_COPY(Type)     const Type &
#endif
 
// Support noexcept when possible.
#if 201103L <= YY_CPLUSPLUS
#define YY_NOEXCEPT noexcept
#define YY_NOTHROW
#else
#define YY_NOEXCEPT
#define YY_NOTHROW throw()
#endif
 
// Support constexpr when possible.
#if 201703 <= YY_CPLUSPLUS
#define YY_CONSTEXPR constexpr
#else
#define YY_CONSTEXPR
#endif
 
#ifndef YY_ATTRIBUTE_PURE
#if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
#define YY_ATTRIBUTE_PURE __attribute__((__pure__))
#else
#define YY_ATTRIBUTE_PURE
#endif
#endif
 
#ifndef YY_ATTRIBUTE_UNUSED
#if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
#define YY_ATTRIBUTE_UNUSED __attribute__((__unused__))
#else
#define YY_ATTRIBUTE_UNUSED
#endif
#endif
 
/* Suppress unused-variable warnings by "using" E.  */
#if !defined lint || defined __GNUC__
#define YY_USE(E) ((void)(E))
#else
#define YY_USE(E) /* empty */
#endif
 
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
#if defined __GNUC__ && !defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
#if __GNUC__ * 100 + __GNUC_MINOR__ < 407
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                                                        \
  _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wuninitialized\"")
#else
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                                                        \
  _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wuninitialized\"")             \
      _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
#endif
#define YY_IGNORE_MAYBE_UNINITIALIZED_END _Pragma("GCC diagnostic pop")
#else
#define YY_INITIAL_VALUE(Value) Value
#endif
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
#endif
#ifndef YY_INITIAL_VALUE
#define YY_INITIAL_VALUE(Value) /* Nothing. */
#endif
 
#if defined __cplusplus && defined __GNUC__ && !defined __ICC && 6 <= __GNUC__
#define YY_IGNORE_USELESS_CAST_BEGIN                                                               \
  _Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wuseless-cast\"")
#define YY_IGNORE_USELESS_CAST_END _Pragma("GCC diagnostic pop")
#endif
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_END
#endif
 
#ifndef YY_CAST
#ifdef __cplusplus
#define YY_CAST(Type, Val)             static_cast<Type>(Val)
#define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type>(Val)
#else
#define YY_CAST(Type, Val)             ((Type)(Val))
#define YY_REINTERPRET_CAST(Type, Val) ((Type)(Val))
#endif
#endif
#ifndef YY_NULLPTR
#if defined __cplusplus
#if 201103L <= __cplusplus
#define YY_NULLPTR nullptr
#else
#define YY_NULLPTR 0
#endif
#else
#define YY_NULLPTR ((void *)0)
#endif
#endif
 
/* Debug traces.  */
#ifndef SEAMSDEBUG
#if defined YYDEBUG
#if YYDEBUG
#define SEAMSDEBUG 1
#else
#define SEAMSDEBUG 0
#endif
#else /* ! defined YYDEBUG */
#define SEAMSDEBUG 1
#endif /* ! defined YYDEBUG */
#endif /* ! defined SEAMSDEBUG */
 
namespace SEAMS {
 
  /// A Bison parser.
  class Parser
  {
  public:
#ifdef SEAMSSTYPE
#ifdef __GNUC__
#pragma GCC message "bison: do not #define SEAMSSTYPE in C++, use %define api.value.type"
#endif
    typedef SEAMSSTYPE value_type;
#else
    /// Symbol semantic values.
    union value_type {
 
      double         val;    /* For returning numbers.               */
      struct symrec *tptr;   /* For returning symbol-table pointers  */
      char          *string; /* For returning quoted strings         */
      struct array  *arrval; /* For returning arrays                 */
    };
#endif
    /// Backward compatibility (Bison 3.8).
    typedef value_type semantic_type;
 
    /// Syntax errors thrown from user actions.
    struct syntax_error : std::runtime_error
    {
      syntax_error(const std::string &m) : std::runtime_error(m) {}
 
      syntax_error(const syntax_error &s) : std::runtime_error(s.what()) {}
 
      ~syntax_error() YY_NOEXCEPT YY_NOTHROW;
    };
 
    /// Token kinds.
    struct token
    {
      enum token_kind_type {
        SEAMSEMPTY = -2,
        END        = 0,   // "end of file"
        SEAMSerror = 256, // error
        SEAMSUNDEF = 257, // "invalid token"
        NUM        = 258, // NUM
        QSTRING    = 259, // QSTRING
        UNDVAR     = 260, // UNDVAR
        VAR        = 261, // VAR
        SVAR       = 262, // SVAR
        IMMVAR     = 263, // IMMVAR
        IMMSVAR    = 264, // IMMSVAR
        AVAR       = 265, // AVAR
        FNCT       = 266, // FNCT
        SFNCT      = 267, // SFNCT
        AFNCT      = 268, // AFNCT
        COMMA      = 269, // COMMA
        LPAR       = 270, // LPAR
        RPAR       = 271, // RPAR
        LBRACK     = 272, // LBRACK
        RBRACK     = 273, // RBRACK
        LBRACE     = 274, // LBRACE
        RBRACE     = 275, // RBRACE
        SEMI       = 276, // SEMI
        EQUAL      = 277, // EQUAL
        EQ_PLUS    = 278, // EQ_PLUS
        EQ_MINUS   = 279, // EQ_MINUS
        EQ_TIME    = 280, // EQ_TIME
        EQ_DIV     = 281, // EQ_DIV
        EQ_POW     = 282, // EQ_POW
        QUEST      = 283, // QUEST
        COLON      = 284, // COLON
        LOR        = 285, // LOR
        LAND       = 286, // LAND
        LT         = 287, // LT
        GT         = 288, // GT
        LE         = 289, // LE
        GE         = 290, // GE
        EQ         = 291, // EQ
        NE         = 292, // NE
        PLU        = 293, // PLU
        SUB        = 294, // SUB
        DIV        = 295, // DIV
        TIM        = 296, // TIM
        MOD        = 297, // MOD
        UNARY      = 298, // UNARY
        NOT        = 299, // NOT
        POW        = 300, // POW
        INC        = 301, // INC
        DEC        = 302, // DEC
        CONCAT     = 303  // CONCAT
      };
      /// Backward compatibility alias (Bison 3.6).
      typedef token_kind_type yytokentype;
    };
 
    /// Token kind, as returned by yylex.
    typedef token::token_kind_type token_kind_type;
 
    /// Backward compatibility alias (Bison 3.6).
    typedef token_kind_type token_type;
 
    /// Symbol kinds.
    struct symbol_kind
    {
      enum symbol_kind_type {
        YYNTOKENS  = 50, ///< Number of tokens.
        S_YYEMPTY  = -2,
        S_YYEOF    = 0,  // "end of file"
        S_YYerror  = 1,  // error
        S_YYUNDEF  = 2,  // "invalid token"
        S_NUM      = 3,  // NUM
        S_QSTRING  = 4,  // QSTRING
        S_UNDVAR   = 5,  // UNDVAR
        S_VAR      = 6,  // VAR
        S_SVAR     = 7,  // SVAR
        S_IMMVAR   = 8,  // IMMVAR
        S_IMMSVAR  = 9,  // IMMSVAR
        S_AVAR     = 10, // AVAR
        S_FNCT     = 11, // FNCT
        S_SFNCT    = 12, // SFNCT
        S_AFNCT    = 13, // AFNCT
        S_COMMA    = 14, // COMMA
        S_LPAR     = 15, // LPAR
        S_RPAR     = 16, // RPAR
        S_LBRACK   = 17, // LBRACK
        S_RBRACK   = 18, // RBRACK
        S_LBRACE   = 19, // LBRACE
        S_RBRACE   = 20, // RBRACE
        S_SEMI     = 21, // SEMI
        S_EQUAL    = 22, // EQUAL
        S_EQ_PLUS  = 23, // EQ_PLUS
        S_EQ_MINUS = 24, // EQ_MINUS
        S_EQ_TIME  = 25, // EQ_TIME
        S_EQ_DIV   = 26, // EQ_DIV
        S_EQ_POW   = 27, // EQ_POW
        S_QUEST    = 28, // QUEST
        S_COLON    = 29, // COLON
        S_LOR      = 30, // LOR
        S_LAND     = 31, // LAND
        S_LT       = 32, // LT
        S_GT       = 33, // GT
        S_LE       = 34, // LE
        S_GE       = 35, // GE
        S_EQ       = 36, // EQ
        S_NE       = 37, // NE
        S_PLU      = 38, // PLU
        S_SUB      = 39, // SUB
        S_DIV      = 40, // DIV
        S_TIM      = 41, // TIM
        S_MOD      = 42, // MOD
        S_UNARY    = 43, // UNARY
        S_NOT      = 44, // NOT
        S_POW      = 45, // POW
        S_INC      = 46, // INC
        S_DEC      = 47, // DEC
        S_CONCAT   = 48, // CONCAT
        S_49_n_    = 49, // '\n'
        S_YYACCEPT = 50, // $accept
        S_input    = 51, // input
        S_line     = 52, // line
        S_bool     = 53, // bool
        S_aexp     = 54, // aexp
        S_sexp     = 55, // sexp
        S_exp      = 56  // exp
      };
    };
 
    /// (Internal) symbol kind.
    typedef symbol_kind::symbol_kind_type symbol_kind_type;
 
    /// The number of tokens.
    static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS;
 
    /// A complete symbol.
    ///
    /// Expects its Base type to provide access to the symbol kind
    /// via kind ().
    ///
    /// Provide access to semantic value.
    template <typename Base> struct basic_symbol : Base
    {
      /// Alias to Base.
      typedef Base super_type;
 
      /// Default constructor.
      basic_symbol() YY_NOEXCEPT : value() {}
 
#if 201103L <= YY_CPLUSPLUS
      /// Move constructor.
      basic_symbol(basic_symbol &&that) : Base(std::move(that)), value(std::move(that.value)) {}
#endif
 
      /// Copy constructor.
      basic_symbol(const basic_symbol &that);
      /// Constructor for valueless symbols.
      basic_symbol(typename Base::kind_type t);
 
      /// Constructor for symbols with semantic value.
      basic_symbol(typename Base::kind_type t, YY_RVREF(value_type) v);
 
      /// Destroy the symbol.
      ~basic_symbol() { clear(); }
 
      /// Destroy contents, and record that is empty.
      void clear() YY_NOEXCEPT { Base::clear(); }
 
      /// The user-facing name of this symbol.
      std::string name() const YY_NOEXCEPT { return Parser::symbol_name(this->kind()); }
 
      /// Backward compatibility (Bison 3.6).
      symbol_kind_type type_get() const YY_NOEXCEPT;
 
      /// Whether empty.
      bool empty() const YY_NOEXCEPT;
 
      /// Destructive move, \a s is emptied into this.
      void move(basic_symbol &s);
 
      /// The semantic value.
      value_type value;
 
    private:
#if YY_CPLUSPLUS < 201103L
      /// Assignment operator.
      basic_symbol &operator=(const basic_symbol &that);
#endif
    };
 
    /// Type access provider for token (enum) based symbols.
    struct by_kind
    {
      /// The symbol kind as needed by the constructor.
      typedef token_kind_type kind_type;
 
      /// Default constructor.
      by_kind() YY_NOEXCEPT;
 
#if 201103L <= YY_CPLUSPLUS
      /// Move constructor.
      by_kind(by_kind &&that) YY_NOEXCEPT;
#endif
 
      /// Copy constructor.
      by_kind(const by_kind &that) YY_NOEXCEPT;
 
      /// Constructor from (external) token numbers.
      by_kind(kind_type t) YY_NOEXCEPT;
 
      /// Record that this symbol is empty.
      void clear() YY_NOEXCEPT;
 
      /// Steal the symbol kind from \a that.
      void move(by_kind &that);
 
      /// The (internal) type number (corresponding to \a type).
      /// \a empty when empty.
      symbol_kind_type kind() const YY_NOEXCEPT;
 
      /// Backward compatibility (Bison 3.6).
      symbol_kind_type type_get() const YY_NOEXCEPT;
 
      /// The symbol kind.
      /// \a S_YYEMPTY when empty.
      symbol_kind_type kind_;
    };
 
    /// Backward compatibility for a private implementation detail (Bison 3.6).
    typedef by_kind by_type;
 
    /// "External" symbols: returned by the scanner.
    struct symbol_type : basic_symbol<by_kind>
    {
    };
 
    /// Build a parser object.
    Parser(class Aprepro &aprepro_yyarg);
    virtual ~Parser();
 
#if 201103L <= YY_CPLUSPLUS
    /// Non copyable.
    Parser(const Parser &) = delete;
    /// Non copyable.
    Parser &operator=(const Parser &) = delete;
#endif
 
    /// Parse.  An alias for parse ().
    /// \returns  0 iff parsing succeeded.
    int operator()();
 
    /// Parse.
    /// \returns  0 iff parsing succeeded.
    virtual int parse();
 
#if SEAMSDEBUG
    /// The current debugging stream.
    std::ostream &debug_stream() const YY_ATTRIBUTE_PURE;
    /// Set the current debugging stream.
    void set_debug_stream(std::ostream &);
 
    /// Type for debugging levels.
    typedef int debug_level_type;
    /// The current debugging level.
    debug_level_type debug_level() const YY_ATTRIBUTE_PURE;
    /// Set the current debugging level.
    void set_debug_level(debug_level_type l);
#endif
 
    /// Report a syntax error.
    /// \param msg    a description of the syntax error.
    virtual void error(const std::string &msg);
 
    /// Report a syntax error.
    void error(const syntax_error &err);
 
    /// The user-facing name of the symbol whose (internal) number is
    /// YYSYMBOL.  No bounds checking.
    static std::string symbol_name(symbol_kind_type yysymbol);
 
    class context
    {
    public:
      context(const Parser &yyparser, const symbol_type &yyla);
      const symbol_type &lookahead() const YY_NOEXCEPT { return yyla_; }
      symbol_kind_type   token() const YY_NOEXCEPT { return yyla_.kind(); }
      /// Put in YYARG at most YYARGN of the expected tokens, and return the
      /// number of tokens stored in YYARG.  If YYARG is null, return the
      /// number of expected tokens (guaranteed to be less than YYNTOKENS).
      int expected_tokens(symbol_kind_type yyarg[], int yyargn) const;
 
    private:
      const Parser      &yyparser_;
      const symbol_type &yyla_;
    };
 
  private:
#if YY_CPLUSPLUS < 201103L
    /// Non copyable.
    Parser(const Parser &);
    /// Non copyable.
    Parser &operator=(const Parser &);
#endif
 
    /// Stored state numbers (used for stacks).
    typedef short state_type;
 
    /// The arguments of the error message.
    int yy_syntax_error_arguments_(const context &yyctx, symbol_kind_type yyarg[],
                                   int yyargn) const;
 
    /// Generate an error message.
    /// \param yyctx     the context in which the error occurred.
    virtual std::string yysyntax_error_(const context &yyctx) const;
    /// Compute post-reduction state.
    /// \param yystate   the current state
    /// \param yysym     the nonterminal to push on the stack
    static state_type yy_lr_goto_state_(state_type yystate, int yysym);
 
    /// Whether the given \c yypact_ value indicates a defaulted state.
    /// \param yyvalue   the value to check
    static bool yy_pact_value_is_default_(int yyvalue) YY_NOEXCEPT;
 
    /// Whether the given \c yytable_ value indicates a syntax error.
    /// \param yyvalue   the value to check
    static bool yy_table_value_is_error_(int yyvalue) YY_NOEXCEPT;
 
    static const signed char yypact_ninf_;
    static const signed char yytable_ninf_;
 
    /// Convert a scanner token kind \a t to a symbol kind.
    /// In theory \a t should be a token_kind_type, but character literals
    /// are valid, yet not members of the token_kind_type enum.
    static symbol_kind_type yytranslate_(int t) YY_NOEXCEPT;
 
    /// Convert the symbol name \a n to a form suitable for a diagnostic.
    static std::string yytnamerr_(const char *yystr);
 
    /// For a symbol, its name in clear.
    static const char *const yytname_[];
 
    // Tables.
    // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    // STATE-NUM.
    static const short yypact_[];
 
    // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
    // Performed when YYTABLE does not specify something else to do.  Zero
    // means the default is an error.
    static const unsigned char yydefact_[];
 
    // YYPGOTO[NTERM-NUM].
    static const short yypgoto_[];
 
    // YYDEFGOTO[NTERM-NUM].
    static const unsigned char yydefgoto_[];
 
    // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
    // positive, shift that token.  If negative, reduce the rule whose
    // number is the opposite.  If YYTABLE_NINF, syntax error.
    static const short yytable_[];
 
    static const short yycheck_[];
 
    // YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
    // state STATE-NUM.
    static const signed char yystos_[];
 
    // YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM.
    static const signed char yyr1_[];
 
    // YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM.
    static const signed char yyr2_[];
 
#if SEAMSDEBUG
    // YYRLINE[YYN] -- Source line where rule number YYN was defined.
    static const short yyrline_[];
    /// Report on the debug stream that the rule \a r is going to be reduced.
    virtual void yy_reduce_print_(int r) const;
    /// Print the state stack on the debug stream.
    virtual void yy_stack_print_() const;
 
    /// Debugging level.
    int yydebug_;
    /// Debug stream.
    std::ostream *yycdebug_;
 
    /// \brief Display a symbol kind, value and location.
    /// \param yyo    The output stream.
    /// \param yysym  The symbol.
    template <typename Base>
    void yy_print_(std::ostream &yyo, const basic_symbol<Base> &yysym) const;
#endif
 
    /// \brief Reclaim the memory associated to a symbol.
    /// \param yymsg     Why this token is reclaimed.
    ///                  If null, print nothing.
    /// \param yysym     The symbol.
    template <typename Base> void yy_destroy_(const char *yymsg, basic_symbol<Base> &yysym) const;
 
  private:
    /// Type access provider for state based symbols.
    struct by_state
    {
      /// Default constructor.
      by_state() YY_NOEXCEPT;
 
      /// The symbol kind as needed by the constructor.
      typedef state_type kind_type;
 
      /// Constructor.
      by_state(kind_type s) YY_NOEXCEPT;
 
      /// Copy constructor.
      by_state(const by_state &that) YY_NOEXCEPT;
 
      /// Record that this symbol is empty.
      void clear() YY_NOEXCEPT;
 
      /// Steal the symbol kind from \a that.
      void move(by_state &that);
 
      /// The symbol kind (corresponding to \a state).
      /// \a symbol_kind::S_YYEMPTY when empty.
      symbol_kind_type kind() const YY_NOEXCEPT;
 
      /// The state number used to denote an empty symbol.
      /// We use the initial state, as it does not have a value.
      enum { empty_state = 0 };
 
      /// The state.
      /// \a empty when empty.
      state_type state;
    };
 
    /// "Internal" symbol: element of the stack.
    struct stack_symbol_type : basic_symbol<by_state>
    {
      /// Superclass.
      typedef basic_symbol<by_state> super_type;
      /// Construct an empty symbol.
      stack_symbol_type();
      /// Move or copy construction.
      stack_symbol_type(YY_RVREF(stack_symbol_type) that);
      /// Steal the contents from \a sym to build this.
      stack_symbol_type(state_type s, YY_MOVE_REF(symbol_type) sym);
#if YY_CPLUSPLUS < 201103L
      /// Assignment, needed by push_back by some old implementations.
      /// Moves the contents of that.
      stack_symbol_type &operator=(stack_symbol_type &that);
 
      /// Assignment, needed by push_back by other implementations.
      /// Needed by some other old implementations.
      stack_symbol_type &operator=(const stack_symbol_type &that);
#endif
    };
 
    /// 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_;
    };
 
    /// Stack type.
    typedef stack<stack_symbol_type> stack_type;
 
    /// The stack.
    stack_type yystack_;
 
    /// Push a new state on the stack.
    /// \param m    a debug message to display
    ///             if null, no trace is output.
    /// \param sym  the symbol
    /// \warning the contents of \a s.value is stolen.
    void yypush_(const char *m, YY_MOVE_REF(stack_symbol_type) sym);
 
    /// Push a new look ahead token on the state on the stack.
    /// \param m    a debug message to display
    ///             if null, no trace is output.
    /// \param s    the state
    /// \param sym  the symbol (for its value and location).
    /// \warning the contents of \a sym.value is stolen.
    void yypush_(const char *m, state_type s, YY_MOVE_REF(symbol_type) sym);
 
    /// Pop \a n symbols from the stack.
    void yypop_(int n = 1) YY_NOEXCEPT;
 
    /// Constants.
    enum {
      yylast_  = 2057, ///< Last index in yytable_.
      yynnts_  = 7,    ///< Number of nonterminal symbols.
      yyfinal_ = 2     ///< Termination state number.
    };
 
    // User arguments.
    class Aprepro &aprepro;
  };
 
} // namespace SEAMS
 
#endif // !YY_SEAMS_APREPRO_PARSER_H_INCLUDED