/* A Bison parser, made by GNU Bison 2.4.1. */ /* Skeleton interface for Bison LALR(1) parsers in C++ SPDX-FileCopyrightText: 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc. SPDX-License-Identifier: GPL-3.0-or-later WITH Bison-exception-2.2 */ /* C++ LALR(1) parser skeleton written by Akim Demaille. */ #ifndef PARSER_HEADER_H # define PARSER_HEADER_H #include #include #include "stack.hh" /* Line 35 of lalr1.cc */ #line 1 "[Bison:b4_percent_define_default]" namespace KHolidays { /* Line 35 of lalr1.cc */ #line 54 "holidayparserplan.hpp" class position; class location; /* Line 35 of lalr1.cc */ #line 1 "[Bison:b4_percent_define_default]" } // KHolidays /* Line 35 of lalr1.cc */ #line 64 "holidayparserplan.hpp" #include "location.hh" /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG 1 #endif /* Enabling verbose error messages. */ #ifdef YYERROR_VERBOSE # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else # define YYERROR_VERBOSE 1 #endif /* Enabling the token table. */ #ifndef YYTOKEN_TABLE # define YYTOKEN_TABLE 0 #endif /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. If N is 0, then set CURRENT to the empty location which ends the previous symbol: RHS[0] (always defined). */ #ifndef YYLLOC_DEFAULT # define YYLLOC_DEFAULT(Current, Rhs, N) \ do { \ if (N) \ { \ (Current).begin = (Rhs)[1].begin; \ (Current).end = (Rhs)[N].end; \ } \ else \ { \ (Current).begin = (Current).end = (Rhs)[0].end; \ } \ } while (false) #endif /* Line 35 of lalr1.cc */ #line 1 "[Bison:b4_percent_define_default]" namespace KHolidays { /* Line 35 of lalr1.cc */ #line 112 "holidayparserplan.hpp" /// A Bison parser. class HolidayParserPlan { public: /// Symbol semantic values. #ifndef YYSTYPE union semantic_type { /* Line 35 of lalr1.cc */ #line 86 "holidayparserplan.ypp" int ival; char *sval; /* Line 35 of lalr1.cc */ #line 129 "holidayparserplan.hpp" }; #else typedef YYSTYPE semantic_type; #endif /// Symbol locations. typedef location location_type; /// Tokens. struct token { /* Tokens. */ enum yytokentype { END = 0, NUMBER = 258, MONTH = 259, WDAY = 260, STRING = 261, CATEGORY = 262, CALENDAR = 263, INOP = 264, PLUS = 265, MINUS = 266, YEAR = 267, LEAPYEAR = 268, SHIFT = 269, IF = 270, LENGTH = 271, EASTER = 272, EQ = 273, NE = 274, LE = 275, GE = 276, LT = 277, GT = 278, PASCHA = 279, COUNTRY = 280, LANGUAGE = 281, NAME = 282, DESCRIPTION = 283, OR = 284, AND = 285, UMINUS = 286, }; }; /// Token type. typedef token::yytokentype token_type; /// Build a parser object. HolidayParserPlan (class HolidayParserDriverPlan& driver_yyarg); virtual ~HolidayParserPlan (); /// Parse. /// \returns 0 iff parsing succeeded. virtual int parse (); #if YYDEBUG /// The current debugging stream. std::ostream& debug_stream () const; /// 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; /// Set the current debugging level. void set_debug_level (debug_level_type l); #endif private: /// Report a syntax error. /// \param loc where the syntax error is found. /// \param msg a description of the syntax error. virtual void error (const location_type& loc, const std::string& msg); /// Generate an error message. /// \param state the state where the error occurred. /// \param tok the lookahead token. virtual std::string yysyntax_error_ (std::string *filename, int yystate, int tok); #if YYDEBUG /// \brief Report a symbol value on the debug stream. /// \param yytype The token type. /// \param yyvaluep Its semantic value. /// \param yylocationp Its location. virtual void yy_symbol_value_print_ (int yytype, const semantic_type* yyvaluep, const location_type* yylocationp); /// \brief Report a symbol on the debug stream. /// \param yytype The token type. /// \param yyvaluep Its semantic value. /// \param yylocationp Its location. virtual void yy_symbol_print_ (int yytype, const semantic_type* yyvaluep, const location_type* yylocationp); #endif /// State numbers. typedef int state_type; /// State stack type. typedef stack state_stack_type; /// Semantic value stack type. typedef stack semantic_stack_type; /// location stack type. typedef stack location_stack_type; /// The state stack. state_stack_type yystate_stack_; /// The semantic value stack. semantic_stack_type yysemantic_stack_; /// The location stack. location_stack_type yylocation_stack_; /// Internal symbol numbers. typedef unsigned char token_number_type; /* Tables. */ /// For a state, the index in \a yytable_ of its portion. static const short int yypact_[]; static const signed char yypact_ninf_; /// For a state, default rule to reduce. /// Unless\a yytable_ specifies something else to do. /// Zero means the default is an error. static const unsigned char yydefact_[]; static const signed char yypgoto_[]; static const signed char yydefgoto_[]; /// What to do in a state. /// \a yytable_[yypact_[s]]: what to do in state \a s. /// - if positive, shift that token. /// - if negative, reduce the rule which number is the opposite. /// - if zero, do what YYDEFACT says. static const short int yytable_[]; static const signed char yytable_ninf_; static const short int yycheck_[]; /// For a state, its accessing symbol. static const unsigned char yystos_[]; /// For a rule, its LHS. static const unsigned char yyr1_[]; /// For a rule, its RHS length. static const unsigned char yyr2_[]; #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE /// For a symbol, its name in clear. static const char* const yytname_[]; #endif #if YYERROR_VERBOSE /// Convert the symbol name \a n to a form suitable for a diagnostic. virtual std::string yytnamerr_ (const char *n); #endif #if YYDEBUG /// A type to store symbol numbers and -1. typedef signed char rhs_number_type; /// A `-1'-separated list of the rules' RHS. static const rhs_number_type yyrhs_[]; /// For each rule, the index of the first RHS symbol in \a yyrhs_. static const unsigned short int yyprhs_[]; /// For each rule, its source line number. static const unsigned char yyrline_[]; /// For each scanner token number, its symbol number. static const unsigned short int yytoken_number_[]; /// Report on the debug stream that the rule \a r is going to be reduced. virtual void yy_reduce_print_ (int r); /// Print the state stack on the debug stream. virtual void yystack_print_ (); /* Debugging. */ int yydebug_; std::ostream* yycdebug_; #endif /// Convert a scanner token number \a t to a symbol number. token_number_type yytranslate_ (int t); /// \brief Reclaim the memory associated to a symbol. /// \param yymsg Why this token is reclaimed. /// \param yytype The symbol type. /// \param yyvaluep Its semantic value. /// \param yylocationp Its location. inline void yydestruct_ (const char* yymsg, int yytype, semantic_type* yyvaluep, location_type* yylocationp); /// Pop \a n symbols the three stacks. inline void yypop_ (unsigned int n = 1); /* Constants. */ static const int yyeof_; /* LAST_ -- Last index in TABLE_. */ static const int yylast_; static const int yynnts_; static const int yyempty_; static const int yyfinal_; static const int yyterror_; static const int yyerrcode_; static const int yyntokens_; static const unsigned int yyuser_token_number_max_; static const token_number_type yyundef_token_; /* User arguments. */ class HolidayParserDriverPlan& driver; }; /* Line 35 of lalr1.cc */ #line 1 "[Bison:b4_percent_define_default]" } // KHolidays /* Line 35 of lalr1.cc */ #line 347 "holidayparserplan.hpp" #endif /* ! defined PARSER_HEADER_H */