File indexing completed on 2024-12-08 03:39:30

 
 /* 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 <string>
 #include <iostream>
 #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_type>    state_stack_type;
     /// Semantic value stack type.
     typedef stack<semantic_type> semantic_stack_type;
     /// location stack type.
     typedef stack<location_type> 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 */