// 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 QLParser.tab.hh ** Define the QL::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_YY_QLPARSER_TAB_HH_INCLUDED# define YY_YY_QLPARSER_TAB_HH_INCLUDED// "%code requires" blocks.#line 34 "QLParser.yy" #include "libiberty.h"#include "QLParser.h"#include "DbeSession.h"#include "Expression.h"#include "Table.h"#include "i18n.h" #line 58 "QLParser.tab.hh" # include <cassert># 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 #include <typeinfo>#ifndef YY_ASSERT# include <cassert># define YY_ASSERT assert#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 YYDEBUG# define YYDEBUG 0#endif #line 69 "QLParser.yy"namespace QL {#line 199 "QLParser.tab.hh"      /// A Bison parser.  class Parser  {  public:#ifdef YYSTYPE# ifdef __GNUC__#  pragma GCC message "bison: do not #define YYSTYPE in C++, use %define api.value.type"# endif    typedef YYSTYPE value_type;#else  /// A buffer to store and retrieve objects.  ///  /// Sort of a variant, but does not keep track of the nature  /// of the stored data, since that knowledge is available  /// via the current parser state.  class value_type  {  public:    /// Type of *this.    typedef value_type self_type;     /// Empty construction.    value_type () YY_NOEXCEPT      : yyraw_ ()      , yytypeid_ (YY_NULLPTR)    {}     /// Construct and fill.    template <typename T>    value_type (YY_RVREF (T) t)      : yytypeid_ (&typeid (T))    {      YY_ASSERT (sizeof (T) <= size);      new (yyas_<T> ()) T (YY_MOVE (t));    } #if 201103L <= YY_CPLUSPLUS    /// Non copyable.    value_type (const self_type&) = delete;    /// Non copyable.    self_type& operator= (const self_type&) = delete;#endif     /// Destruction, allowed only if empty.    ~value_type () YY_NOEXCEPT    {      YY_ASSERT (!yytypeid_);    } # if 201103L <= YY_CPLUSPLUS    /// Instantiate a \a T in here from \a t.    template <typename T, typename... U>    T&    emplace (U&&... u)    {      YY_ASSERT (!yytypeid_);      YY_ASSERT (sizeof (T) <= size);      yytypeid_ = & typeid (T);      return *new (yyas_<T> ()) T (std::forward <U>(u)...);    }# else    /// Instantiate an empty \a T in here.    template <typename T>    T&    emplace ()    {      YY_ASSERT (!yytypeid_);      YY_ASSERT (sizeof (T) <= size);      yytypeid_ = & typeid (T);      return *new (yyas_<T> ()) T ();    }     /// Instantiate a \a T in here from \a t.    template <typename T>    T&    emplace (const T& t)    {      YY_ASSERT (!yytypeid_);      YY_ASSERT (sizeof (T) <= size);      yytypeid_ = & typeid (T);      return *new (yyas_<T> ()) T (t);    }# endif     /// Instantiate an empty \a T in here.    /// Obsolete, use emplace.    template <typename T>    T&    build ()    {      return emplace<T> ();    }     /// Instantiate a \a T in here from \a t.    /// Obsolete, use emplace.    template <typename T>    T&    build (const T& t)    {      return emplace<T> (t);    }     /// Accessor to a built \a T.    template <typename T>    T&    as () YY_NOEXCEPT    {      YY_ASSERT (yytypeid_);      YY_ASSERT (*yytypeid_ == typeid (T));      YY_ASSERT (sizeof (T) <= size);      return *yyas_<T> ();    }     /// Const accessor to a built \a T (for %printer).    template <typename T>    const T&    as () const YY_NOEXCEPT    {      YY_ASSERT (yytypeid_);      YY_ASSERT (*yytypeid_ == typeid (T));      YY_ASSERT (sizeof (T) <= size);      return *yyas_<T> ();    }     /// Swap the content with \a that, of same type.    ///    /// Both variants must be built beforehand, because swapping the actual    /// data requires reading it (with as()), and this is not possible on    /// unconstructed variants: it would require some dynamic testing, which    /// should not be the variant's responsibility.    /// Swapping between built and (possibly) non-built is done with    /// self_type::move ().    template <typename T>    void    swap (self_type& that) YY_NOEXCEPT    {      YY_ASSERT (yytypeid_);      YY_ASSERT (*yytypeid_ == *that.yytypeid_);      std::swap (as<T> (), that.as<T> ());    }     /// Move the content of \a that to this.    ///    /// Destroys \a that.    template <typename T>    void    move (self_type& that)    {# if 201103L <= YY_CPLUSPLUS      emplace<T> (std::move (that.as<T> ()));# else      emplace<T> ();      swap<T> (that);# endif      that.destroy<T> ();    } # if 201103L <= YY_CPLUSPLUS    /// Move the content of \a that to this.    template <typename T>    void    move (self_type&& that)    {      emplace<T> (std::move (that.as<T> ()));      that.destroy<T> ();    }#endif     /// Copy the content of \a that to this.    template <typename T>    void    copy (const self_type& that)    {      emplace<T> (that.as<T> ());    }     /// Destroy the stored \a T.    template <typename T>    void    destroy ()    {      as<T> ().~T ();      yytypeid_ = YY_NULLPTR;    }   private:#if YY_CPLUSPLUS < 201103L    /// Non copyable.    value_type (const self_type&);    /// Non copyable.    self_type& operator= (const self_type&);#endif     /// Accessor to raw memory as \a T.    template <typename T>    T*    yyas_ () YY_NOEXCEPT    {      void *yyp = yyraw_;      return static_cast<T*> (yyp);     }     /// Const accessor to raw memory as \a T.    template <typename T>    const T*    yyas_ () const YY_NOEXCEPT    {      const void *yyp = yyraw_;      return static_cast<const T*> (yyp);     }     /// An auxiliary type to compute the largest semantic type.    union union_type    {      // exp      // term      char dummy1[sizeof (Expression *)];       // NAME      char dummy2[sizeof (std::string)];       // NUM      // FNAME      // JGROUP      // JPARENT      // QSTR      char dummy3[sizeof (uint64_t)];    };     /// The size of the largest semantic type.    enum { size = sizeof (union_type) };     /// A buffer to store semantic values.    union    {      /// Strongest alignment constraints.      long double yyalign_me_;      /// A buffer large enough to store any of the semantic values.      char yyraw_[size];    };     /// Whether the content is built: if defined, the name of the stored type.    const std::type_info *yytypeid_;  }; #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      {        L_YYEMPTY = -2,    L_YYEOF = 0,                   // YYEOF    L_YYerror = 256,               // error    L_YYUNDEF = 257,               // "invalid token"    L_LPAR = 258,                  // "("    L_RPAR = 259,                  // ")"    L_HASPROP = 260,               // HASPROP    L_FILEIOVFD = 261,             // FILEIOVFD    L_NUM = 262,                   // NUM    L_FNAME = 263,                 // FNAME    L_JGROUP = 264,                // JGROUP    L_JPARENT = 265,               // JPARENT    L_QSTR = 266,                  // QSTR    L_NAME = 267,                  // NAME    L_IN = 268,                    // IN    L_SOME = 269,                  // SOME    L_ORDR = 270,                  // ORDR    L_COMMA = 271,                 // COMMA    L_QWE = 273,                   // QWE    L_COLON = 275,                 // COLON    L_AND = 277,                   // AND    L_OR = 279,                    // OR    L_EQV = 281,                   // EQV    L_NEQV = 282,                  // NEQV    L_BITAND = 283,                // BITAND    L_BITOR = 284,                 // BITOR    L_BITXOR = 285,                // BITXOR    L_EQ = 287,                    // EQ    L_NE = 289,                    // NE

Lines 1–500 of 2068. Load more