X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/33c195cc37a2d4e20c5437a0334953ea87637c20..757f8f98fca888609b4533aa1d7f00c2427f9564:/data/lalr1.cc diff --git a/data/lalr1.cc b/data/lalr1.cc index 34bcc278..dc397800 100644 --- a/data/lalr1.cc +++ b/data/lalr1.cc @@ -99,8 +99,8 @@ m4_define([b4_rhs_location], # Same as in C, but using references instead of pointers. m4_define([b4_symbol_actions], [m4_pushdef([b4_dollar_dollar], - [b4_symbol_value([yyvalue], [$6])])dnl -m4_pushdef([b4_at_dollar], [yylocation])dnl + [b4_symbol_value([yysym.value], [$6])])dnl +m4_pushdef([b4_at_dollar], [yysym.location])dnl case $4: // $3 b4_syncline([$2], [$1]) $5; @@ -394,23 +394,6 @@ m4_ifdef([b4_stype], /// \param tok the lookahead token. virtual std::string yysyntax_error_ (int yystate, int tok); -#if YYDEBUG - /// \brief Report a symbol value on the debug stream. - /// \param yytype The token type. - /// \param yyvalue Its semantic value. - /// \param yylocation Its location. - virtual void yy_symbol_value_print_ (int yytype, - const semantic_type& yyvalue, - const location_type& yylocation); - /// \brief Report a symbol on the debug stream. - /// \param yytype The token type. - /// \param yyvalue Its semantic value. - /// \param yylocation Its location. - virtual void yy_symbol_print_ (int yytype, - const semantic_type& yyvalue, - const location_type& yylocation); -#endif - /// State numbers. typedef int state_type; @@ -475,28 +458,17 @@ m4_ifdef([b4_stype], /// 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. - /// If null, nothing is printed at all. - /// \param yytype The symbol type. - /// \param yyvalue Its semantic value. - /// \param yylocation Its location. - inline void yydestruct_ (const char* yymsg, - int yytype, - semantic_type& yyvalue, - location_type& yylocation); - - /// Element of the stack: a state and its attributes. - struct data_type + /// A complete symbol, with its type. + struct symbol_base_type { /// Default constructor. - data_type (); + inline symbol_base_type (); /// Constructor. - data_type (state_type s, const semantic_type& v, const location_type& l); + inline symbol_base_type (const semantic_type& v, const location_type& l); - /// The state. - state_type state; + /// Return the type of this symbol. + virtual int type_get () const = 0; /// The semantic value. semantic_type value; @@ -505,8 +477,55 @@ m4_ifdef([b4_stype], location_type location; }; +#if YYDEBUG + /// \brief Display a symbol type, value and location. + /// \param yyo The output stream. + /// \param yysym The symbol. + void yy_print_ (std::ostream& yyo, const symbol_base_type& yysym) const; +#endif + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param s The symbol. + inline void yy_destroy_ (const char* yymsg, symbol_base_type& yysym) const; + + /// Element of the stack: a state and its attributes. + struct symbol_type : symbol_base_type + { + /// Default constructor. + inline symbol_type (); + + /// Constructor. + inline symbol_type (int t, + const semantic_type& v, const location_type& l); + + /// The symbol type. + int type; + + /// Return the type corresponding to this state. + virtual inline int type_get () const; + }; + + /// Element of the stack: a state and its attributes. + struct stack_symbol_type : symbol_base_type + { + /// Default constructor. + inline stack_symbol_type (); + + /// Constructor. + inline stack_symbol_type (state_type s, + const semantic_type& v, const location_type& l); + + /// The state. + state_type state; + + /// Return the type corresponding to this state. + virtual inline int type_get () const; + }; + /// Stack type. - typedef stack stack_type; + typedef stack stack_type; /// The stack. stack_type yystack_; @@ -514,12 +533,17 @@ m4_ifdef([b4_stype], /// Push a new state on the stack. /// \param m a debug message to display /// if null, no trace is output. - /// \param s the state entered - /// \param v semantic value - /// \param l location - /// \warning the contents of \a v is stolen. - inline void yypush_ (const char* m, state_type s, - semantic_type& v, const location_type& l); + /// \param s the symbol + /// \warning the contents of \a s.value is stolen. + inline void yypush_ (const char* m, stack_symbol_type& s); + + /// 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 s.value is stolen. + inline void yypush_ (const char* m, state_type s, symbol_type& sym); /// Pop \a n symbols the three stacks. inline void yypop_ (unsigned int n = 1); @@ -538,6 +562,7 @@ m4_ifdef([b4_stype], static const token_number_type yyundef_token_; ]b4_parse_param_vars[ }; + ]b4_namespace_close[ ]b4_percent_define_flag_if([[global_tokens_and_yystype]], @@ -591,14 +616,14 @@ b4_percent_code_get[]dnl /* A pseudo ostream that takes yydebug_ into account. */ # define YYCDEBUG if (yydebug_) (*yycdebug_) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ - do { \ - if (yydebug_) \ - { \ - *yycdebug_ << Title << ' '; \ - yy_symbol_print_ ((Type), (Value), (Location)); \ - *yycdebug_ << std::endl; \ - } \ +# define YY_SYMBOL_PRINT(Title, Symbol) \ + do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_print_ (*yycdebug_, Symbol); \ + *yycdebug_ << std::endl; \ + } \ } while (false) # define YY_REDUCE_PRINT(Rule) \ @@ -616,9 +641,9 @@ b4_percent_code_get[]dnl #else /* !YYDEBUG */ # define YYCDEBUG if (false) std::cerr -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) static_cast(0) -# define YY_REDUCE_PRINT(Rule) static_cast(0) -# define YY_STACK_PRINT() static_cast(0) +# define YY_SYMBOL_PRINT(Title, Symbol) static_cast(0) +# define YY_REDUCE_PRINT(Rule) static_cast(0) +# define YY_STACK_PRINT() static_cast(0) #endif /* !YYDEBUG */ @@ -686,48 +711,73 @@ b4_percent_code_get[]dnl { } -#if YYDEBUG - /*--------------------------------. - | Print this symbol on YYOUTPUT. | - `--------------------------------*/ - inline void - ]b4_parser_class_name[::yy_symbol_value_print_ (int yytype, - const semantic_type& yyvalue, const location_type& yylocation) + /*---------------. + | Symbol types. | + `---------------*/ + + // symbol_base_type. + ]b4_parser_class_name[::symbol_base_type::symbol_base_type () + : value() + , location() { - YYUSE (yylocation); - YYUSE (yyvalue); - switch (yytype) - { - ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl -[ default: - break; - } } + ]b4_parser_class_name[::symbol_base_type::symbol_base_type (const semantic_type& v, const location_type& l) - void - ]b4_parser_class_name[::yy_symbol_print_ (int yytype, - const semantic_type& yyvalue, const location_type& yylocation) + : value(v) + , location(l) { - *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm") - << ' ' << yytname_[yytype] << " (" - << yylocation << ": "; - yy_symbol_value_print_ (yytype, yyvalue, yylocation); - *yycdebug_ << ')'; } -#endif + + // symbol_type. + ]b4_parser_class_name[::symbol_type::symbol_type () + : type() + , symbol_base_type() + { + } + + ]b4_parser_class_name[::symbol_type::symbol_type (int t, + const semantic_type& v, const location_type& l) + : type(t) + , symbol_base_type(v, l) + { + } + + int + ]b4_parser_class_name[::symbol_type::type_get () const + { + return type; + } + + // stack_symbol_type. + ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type () + : state() + , symbol_base_type() + { + } + + ]b4_parser_class_name[::stack_symbol_type::stack_symbol_type (state_type s, + const semantic_type& v, const location_type& l) + : state(s) + , symbol_base_type(v, l) + { + } + + int + ]b4_parser_class_name[::stack_symbol_type::type_get () const + { + return yystos_[state]; + } + void - ]b4_parser_class_name[::yydestruct_ (const char* yymsg, - int yytype, semantic_type& yyvalue, location_type& yylocation) + ]b4_parser_class_name[::yy_destroy_ (const char* yymsg, symbol_base_type& yysym) const { + int yytype = yysym.type_get (); YYUSE (yymsg); - YYUSE (yyvalue); - YYUSE (yylocation); - if (yymsg) - YY_SYMBOL_PRINT (yymsg, yytype, yyvalue, yylocation); + YY_SYMBOL_PRINT (yymsg, yysym); // User destructor. switch (yytype) @@ -738,34 +788,50 @@ b4_percent_code_get[]dnl }]b4_variant_if([ // Type destructor. - b4_symbol_variant([[yytype]], [[yyvalue]], [[destroy]])])[ + b4_symbol_variant([[yytype]], [[yysym.value]], [[destroy]])])[ } - ]b4_parser_class_name[::data_type::data_type () - : state() - , value() - , location() +#if YYDEBUG + void + ]b4_parser_class_name[::yy_print_ (std::ostream& yyo, const symbol_base_type& yysym) const { + int yytype = yysym.type_get (); + yyo << (yytype < yyntokens_ ? "token" : "nterm") + << ' ' << yytname_[yytype] << " (" + << yysym.location << ": "; + switch (yytype) + { + ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl +[ default: + break; + } + yyo << ')'; } +#endif - ]b4_parser_class_name[::data_type::data_type (state_type s, - const semantic_type& v, const location_type& l) - : state(s) - , value(v) - , location(l) + void + ]b4_parser_class_name[::yypush_ (const char* m, state_type s, + symbol_type& sym) { + if (m) + YY_SYMBOL_PRINT (m, sym); +]b4_variant_if( +[[ yystack_.push (stack_symbol_type (s, semantic_type(), sym.location)); + ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]], + [build], [sym.value])], +[ yystack_.push (stack_symbol_type (s, sym.value, sym.location));])[ } void - ]b4_parser_class_name[::yypush_ (const char* m, state_type s, - semantic_type& v, const location_type& l) + ]b4_parser_class_name[::yypush_ (const char* m, stack_symbol_type& s) { if (m) - YY_SYMBOL_PRINT (m, yystos_[s], v, l); + YY_SYMBOL_PRINT (m, s); ]b4_variant_if( -[[ yystack_.push (data_type (s, semantic_type(), l)); - ]b4_symbol_variant([[yystos_[s]]], [[yystack_[0].value]], [build], [v])], -[ yystack_.push (data_type (s, v, l));])[ +[[ yystack_.push (stack_symbol_type (s.state, semantic_type(), s.location)); + ]b4_symbol_variant([[yystos_[s.state]]], [[yystack_[0].value]], + [build], [s.value])], +[ yystack_.push (s);])[ } void @@ -804,9 +870,8 @@ b4_percent_code_get[]dnl int ]b4_parser_class_name[::parse () { - /// Lookahead and lookahead in internal form. + /// Coded type of the lookahead. int yychar = yyempty_; - int yytoken = 0; /* State. */ int yyn; @@ -817,15 +882,14 @@ b4_percent_code_get[]dnl int yynerrs_ = 0; int yyerrstatus_ = 0; - /// Semantic value of the lookahead. - semantic_type yylval; - /// Location of the lookahead. - location_type yylloc; + /// The lookahead symbol. + symbol_type yyla; + /// The locations where the error started and ended. - data_type yyerror_range[2]; + stack_symbol_type yyerror_range[2]; /// $$ and @@$. - data_type yylhs; + stack_symbol_type yylhs; /// The return value of parse(). int yyresult; @@ -833,8 +897,8 @@ b4_percent_code_get[]dnl YYCDEBUG << "Starting parse" << std::endl; ]m4_ifdef([b4_initial_action], [ -m4_pushdef([b4_at_dollar], [yylloc])dnl -m4_pushdef([b4_dollar_dollar], [yylval])dnl +m4_pushdef([b4_at_dollar], [yyla.location])dnl +m4_pushdef([b4_dollar_dollar], [yyla.value])dnl /* User initialization code. */ b4_user_initial_action m4_popdef([b4_dollar_dollar])dnl @@ -845,7 +909,7 @@ m4_popdef([b4_at_dollar])])dnl location values to have been already stored, initialize these stacks with a primary value. */ yystack_ = stack_type (0); - yypush_ (0, yystate, yylval, yylloc); + yypush_ (0, 0, yyla); // A new state was pushed on the stack. // Invariant: yystate == yystack_[0].state, i.e., @@ -872,8 +936,8 @@ m4_popdef([b4_at_dollar])])dnl { YYCDEBUG << "Reading a token: "; yychar = ]b4_c_function_call([yylex], [int], - [[YYSTYPE*], [&yylval]][]dnl -b4_locations_if([, [[location*], [&yylloc]]])dnl + [[YYSTYPE*], [&yyla.value]][]dnl +b4_locations_if([, [[location*], [&yyla.location]]])dnl m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; } @@ -881,19 +945,19 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; /* Convert token to internal form. */ if (yychar <= yyeof_) { - yychar = yytoken = yyeof_; + yychar = yyla.type = yyeof_; YYCDEBUG << "Now at end of input." << std::endl; } else { - yytoken = yytranslate_ (yychar); - YY_SYMBOL_PRINT ("Next token is", yytoken, yylval, yylloc); + yyla.type = yytranslate_ (yychar); + YY_SYMBOL_PRINT ("Next token is", yyla); } - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken) + /* If the proper action on seeing token YYLA.TYPE is to reduce or + to detect an error, take that action. */ + yyn += yyla.type; + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.type) goto yydefault; /* Reduce or error. */ @@ -901,7 +965,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; if (yyn <= 0) { if (yyn == 0 || yyn == yytable_ninf_) - goto yyerrlab; + goto yyerrlab; yyn = -yyn; goto yyreduce; } @@ -916,7 +980,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; /* Shift the lookahead token. */ yystate = yyn; - yypush_ ("Shifting", yystate, yylval, yylloc); + yypush_ ("Shifting", yystate, yyla); goto yynewstate; /*-----------------------------------------------------------. @@ -950,7 +1014,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; // Compute the default @@$. { - slice slice (yystack_, yylen); + slice slice (yystack_, yylen); YYLLOC_DEFAULT (yylhs.location, slice, yylen); } @@ -971,7 +1035,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; else yystate = yydefgoto_[yyn - yyntokens_]; yylhs.state = yystate; - YY_SYMBOL_PRINT ("-> $$ =", yyn, yylhs.value, yylhs.location); + YY_SYMBOL_PRINT ("-> $$ =", yylhs); ]b4_variant_if([[ // Destroy the lhs symbols. for (int i = 0; i < yylen; ++i) @@ -983,16 +1047,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; // do not try to report the content in the debug trace, it's // junk. Hence yymsg = 0. Besides, that keeps exactly the same // traces as with the other Bison skeletons. - yydestruct_ (0, - yystos_[yystack_[i].state], - yystack_[i].value, yystack_[i].location);]])[ + yy_destroy_ (0, yystack_[i]);]])[ yypop_ (yylen); yylen = 0; YY_STACK_PRINT (); /* Shift the result of the reduction. */ - yypush_ (0, yylhs.state, yylhs.value, yylhs.location); + yypush_ (0, yylhs); goto yynewstate; /*------------------------------------. @@ -1003,10 +1065,10 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; if (!yyerrstatus_) { ++yynerrs_; - error (yylloc, yysyntax_error_ (yystate, yytoken)); + error (yyla.location, yysyntax_error_ (yystate, yyla.type)); } - yyerror_range[0].location = yylloc; + yyerror_range[0].location = yyla.location; if (yyerrstatus_ == 3) { /* If just tried and failed to reuse lookahead token after an @@ -1020,7 +1082,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; } else { - yydestruct_ ("Error: discarding", yytoken, yylval, yylloc); + yy_destroy_ ("Error: discarding", yyla); yychar = yyempty_; } } @@ -1055,7 +1117,7 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; yyerrlab1: yyerrstatus_ = 3; /* Each real token shifted decrements this. */ { - data_type error_token; + stack_symbol_type error_token; for (;;) { yyn = yypact_[yystate]; @@ -1075,20 +1137,18 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; YYABORT; yyerror_range[0].location = yystack_[0].location; - yydestruct_ ("Error: popping", - yystos_[yystate], - yystack_[0].value, yystack_[0].location); + yy_destroy_ ("Error: popping", yystack_[0]); yypop_ (); yystate = yystack_[0].state; YY_STACK_PRINT (); } - yyerror_range[1].location = yylloc; + yyerror_range[1].location = yyla.location; YYLLOC_DEFAULT (error_token.location, (yyerror_range - 1), 2); /* Shift the error token. */ - yystate = yyn; - yypush_ ("Shifting", yystate, error_token.value, error_token.location); + error_token.state = yystate = yyn; + yypush_ ("Shifting", error_token); } goto yynewstate; @@ -1104,16 +1164,14 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; yyreturn: if (yychar != yyempty_) - yydestruct_ ("Cleanup: discarding lookahead", yytoken, yylval, yylloc); + yy_destroy_ ("Cleanup: discarding lookahead", yyla); /* Do not reclaim the symbols of the rule which action triggered this YYABORT or YYACCEPT. */ yypop_ (yylen); while (yystack_.size () != 1) { - yydestruct_ ("Cleanup: popping", - yystos_[yystack_[0].state], - yystack_[0].value, yystack_[0].location); + yy_destroy_ ("Cleanup: popping", yystack_[0]); yypop_ (); } @@ -1251,9 +1309,7 @@ b4_error_verbose_if([ tok])[) /* The symbols being reduced. */ for (int yyi = 0; yyi < yynrhs; yyi++) YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", - ]yystos_@{b4_rhs_state(yynrhs, yyi + 1)@}[, - ]b4_rhs_value(yynrhs, yyi + 1)[, - ]b4_rhs_location(yynrhs, yyi + 1)[); + ]b4_rhs_data(yynrhs, yyi + 1)[); } #endif // YYDEBUG