X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/12b0043a6d9648eedaa64a4c8445fd9e9a9f781c..386642761d0480036b7af5588d1b3de65de20e4c:/data/lalr1.cc diff --git a/data/lalr1.cc b/data/lalr1.cc index 1a547001..8f3ebad8 100644 --- a/data/lalr1.cc +++ b/data/lalr1.cc @@ -19,6 +19,23 @@ m4_divert(-1) m4_include([c.m4]) +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_init], [200]) + +# Default Parser class name. +m4_define_default([b4_parser_class_name], [Parser]) + + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + # b4_lhs_value([TYPE]) # -------------------- # Expansion of $$. @@ -33,6 +50,7 @@ m4_define([b4_lhs_value], m4_define([b4_rhs_value], [semantic_stack_@<:@m4_eval([$1 - $2])@:>@m4_ifval([$3], [.$3])]) +m4_define_default([b4_location_type], [Location]) # b4_lhs_location() # ----------------- @@ -87,6 +105,8 @@ m4_define([b4_constructor], [])]) +# We do want M4 expansion after # for CPP macros. +m4_changecom() m4_divert(0)dnl #output "b4_output_header_name" b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison], @@ -103,15 +123,14 @@ b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison], /* Using locations. */ #define YYLSP_NEEDED b4_locations_flag +b4_token_defines(b4_tokens) + /* Copy the first part of user declarations. */ b4_pre_prologue /* Line __line__ of __file__. */ #line __oline__ "__ofile__" -/* Tokens. */ -b4_token_defines(b4_tokens) - /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG b4_debug @@ -143,21 +162,9 @@ b4_post_prologue Current.last_column = Rhs[[N]].last_column; #endif -m4_if(b4_locations_flag, [0], [], -[#ifndef YYLTYPE -typedef struct yyltype -{ - int first_line; - int first_column; - int last_line; - int last_column; -} yyltype; -# define YYLTYPE yyltype -#endif]) - namespace yy { - class b4_name; + class b4_parser_class_name; template < typename P > struct Traits @@ -165,47 +172,47 @@ namespace yy }; template < > - struct Traits< b4_name > + struct Traits< b4_parser_class_name > { - typedef b4_uint_type(b4_translate_max) TokenNumberType; - typedef b4_sint_type(b4_rhs_max) RhsNumberType; + typedef b4_int_type_for([b4_translate]) TokenNumberType; + typedef b4_int_type_for([b4_rhs]) RhsNumberType; typedef int StateType; typedef yystype SemanticType; - typedef b4_ltype LocationType; + typedef b4_location_type LocationType; }; } namespace yy { - class b4_name b4_inherit + class b4_parser_class_name b4_inherit { public: - typedef Traits< b4_name >::TokenNumberType TokenNumberType; - typedef Traits< b4_name >::RhsNumberType RhsNumberType; - typedef Traits< b4_name >::StateType StateType; - typedef Traits< b4_name >::SemanticType SemanticType; - typedef Traits< b4_name >::LocationType LocationType; + typedef Traits< b4_parser_class_name >::TokenNumberType TokenNumberType; + typedef Traits< b4_parser_class_name >::RhsNumberType RhsNumberType; + typedef Traits< b4_parser_class_name >::StateType StateType; + typedef Traits< b4_parser_class_name >::SemanticType SemanticType; + typedef Traits< b4_parser_class_name >::LocationType LocationType; typedef Stack< StateType > StateStack; typedef Stack< SemanticType > SemanticStack; typedef Stack< LocationType > LocationStack; #if YYLSP_NEEDED - b4_name (bool debug, + b4_parser_class_name (bool debug, LocationType initlocation[]b4_param) : b4_constructor[]debug_ (debug), cdebug_ (std::cerr), initlocation_ (initlocation) #else - b4_name (bool debug[]b4_param) : + b4_parser_class_name (bool debug[]b4_param) : b4_constructor[]debug_ (debug), cdebug_ (std::cerr) #endif { } - virtual ~b4_name () + virtual ~b4_parser_class_name () { } @@ -223,16 +230,16 @@ namespace yy LocationStack location_stack_; /* Tables. */ - static const b4_sint_type(b4_pact_max) pact_[[]]; - static const b4_sint_type(b4_pact_max) pact_ninf_; - static const short defact_[[]]; - static const short pgoto_[[]]; - static const short defgoto_[[]]; - static const b4_sint_type(b4_table_max) table_[[]]; - static const b4_sint_type(b4_table_max) table_ninf_; - static const short check_[[]]; - static const b4_uint_type(b4_r1_max) r1_[[]]; - static const b4_uint_type(b4_r2_max) r2_[[]]; + static const b4_int_type_for([b4_pact]) pact_[[]]; + static const b4_int_type_for([b4_pact]) pact_ninf_; + static const b4_int_type_for([b4_defact]) defact_[[]]; + static const b4_int_type_for([b4_pgoto]) pgoto_[[]]; + static const b4_int_type_for([b4_defgoto]) defgoto_[[]]; + static const b4_int_type_for([b4_table]) table_[[]]; + static const b4_int_type_for([b4_table]) table_ninf_; + static const b4_int_type_for([b4_check]) check_[[]]; + static const b4_int_type_for([b4_r1]) r1_[[]]; + static const b4_int_type_for([b4_r2]) r2_[[]]; #if YYDEBUG || YYERROR_VERBOSE static const char* const name_[[]]; @@ -241,10 +248,10 @@ namespace yy /* More tables, for debugging. */ #if YYDEBUG static const RhsNumberType rhs_[[]]; - static const b4_uint_type(b4_prhs_max) prhs_[[]]; - static const b4_uint_type(b4_rline_max) rline_[[]]; - static const b4_uint_type(b4_stos_max) stos_[[]]; - static const short token_number_[[]]; + static const b4_int_type_for([b4_prhs]) prhs_[[]]; + static const b4_int_type_for([b4_rline]) rline_[[]]; + static const b4_int_type_for([b4_stos]) stos_[[]]; + static const b4_int_type_for([b4_toknum]) token_number_[[]]; #endif /* Even more tables. */ @@ -252,6 +259,7 @@ namespace yy /* Constants. */ static const int eof_; + /* LAST_ -- Last index in TABLE_. */ static const int last_; static const int nnts_; static const int empty_; @@ -293,7 +301,7 @@ namespace yy } #endif /* not b4_header_guard */ - +dnl #output "b4_output_prefix[]b4_output_infix[].cc" b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison], [2002]) @@ -308,7 +316,7 @@ b4_copyright([C++ Skeleton parser for LALR(1) parsing with Bison], #endif /* !YYDEBUG */ int -yy::b4_name::parse () +yy::b4_parser_class_name::parse () { int nerrs = 0; int errstatus = 0; @@ -369,7 +377,7 @@ yy::b4_name::parse () } n_ += ilooka_; - if (n_ < 0 || n_ > last_ || check_[[n_]] != ilooka_) + if (n_ < 0 || last_ < n_ || check_[[n_]] != ilooka_) goto yydefault; /* Reduce or error. */ @@ -436,8 +444,8 @@ yy::b4_name::parse () { YYCDEBUG << "Reducing via rule " << n_ - 1 << " (line " << rline_[[n_]] << "), "; - for (b4_uint_type(b4_prhs_max) i = prhs_[[n_]]; - rhs_[[i]] >= 0; ++i) + for (b4_int_type_for([b4_prhs]) i = prhs_[[n_]]; + 0 <= rhs_[[i]]; ++i) YYCDEBUG << name_[[rhs_[i]]] << ' '; YYCDEBUG << "-> " << name_[[r1_[n_]]] << std::endl; } @@ -478,7 +486,7 @@ yy::b4_name::parse () /* Shift the result of the reduction. */ n_ = r1_[[n_]]; state_ = pgoto_[[n_ - ntokens_]] + state_stack_[[0]]; - if (state_ >= 0 && state_ <= last_ && check_[[state_]] == state_stack_[[0]]) + if (0 <= state_ && state_ <= last_ && check_[[state_]] == state_stack_[[0]]) state_ = table_[[state_]]; else state_ = defgoto_[[n_ - ntokens_]]; @@ -500,13 +508,13 @@ yy::b4_name::parse () { int count = 0; for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x) - if (check_[[x + n_]] == x) + if (check_[[x + n_]] == x && x != terror_) ++count; if (count < 5) { count = 0; for (int x = (n_ < 0 ? -n_ : 0); x < ntokens_ + nnts_; ++x) - if (check_[[x + n_]] == x) + if (check_[[x + n_]] == x && x != terror_) { message += (!count++) ? ", expecting " : " or "; message += name_[[x]]; @@ -618,7 +626,7 @@ yy::b4_name::parse () } void -yy::b4_name::lex_ () +yy::b4_parser_class_name::lex_ () { #if YYLSP_NEEDED looka_ = yylex (&value, &location); @@ -629,9 +637,9 @@ yy::b4_name::lex_ () /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing STATE-NUM. */ -const b4_sint_type(b4_pact_max) yy::b4_name::pact_ninf_ = b4_pact_ninf; -const b4_sint_type(b4_pact_max) -yy::b4_name::pact_[[]] = +const b4_int_type_for([b4_pact]) yy::b4_parser_class_name::pact_ninf_ = b4_pact_ninf; +const b4_int_type_for([b4_pact]) +yy::b4_parser_class_name::pact_[[]] = { b4_pact }; @@ -639,22 +647,22 @@ yy::b4_name::pact_[[]] = /* YYDEFACT[[S]] -- default rule to reduce with in state S when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ -const short -yy::b4_name::defact_[[]] = +const b4_int_type_for([b4_defact]) +yy::b4_parser_class_name::defact_[[]] = { b4_defact }; /* YYPGOTO[[NTERM-NUM]]. */ -const short -yy::b4_name::pgoto_[[]] = +const b4_int_type_for([b4_pgoto]) +yy::b4_parser_class_name::pgoto_[[]] = { b4_pgoto }; /* YYDEFGOTO[[NTERM-NUM]]. */ -const short -yy::b4_name::defgoto_[[]] = +const b4_int_type_for([b4_defgoto]) +yy::b4_parser_class_name::defgoto_[[]] = { b4_defgoto }; @@ -662,16 +670,16 @@ yy::b4_name::defgoto_[[]] = /* YYTABLE[[YYPACT[STATE-NUM]]]. What to do in state STATE-NUM. If positive, shift that token. If negative, reduce the rule which number is the opposite. If zero, do what YYDEFACT says. */ -const b4_sint_type(b4_table_max) yy::b4_name::table_ninf_ = b4_table_ninf; -const b4_sint_type(b4_table_max) -yy::b4_name::table_[[]] = +const b4_int_type_for([b4_table]) yy::b4_parser_class_name::table_ninf_ = b4_table_ninf; +const b4_int_type_for([b4_table]) +yy::b4_parser_class_name::table_[[]] = { b4_table }; /* YYCHECK. */ -const short -yy::b4_name::check_[[]] = +const b4_int_type_for([b4_check]) +yy::b4_parser_class_name::check_[[]] = { b4_check }; @@ -679,31 +687,31 @@ yy::b4_name::check_[[]] = #if YYDEBUG /* STOS_[[STATE-NUM]] -- The (internal number of the) accessing symbol of state STATE-NUM. */ -const b4_uint_type(b4_stos_max) -yy::b4_name::stos_[[]] = +const b4_int_type_for([b4_stos]) +yy::b4_parser_class_name::stos_[[]] = { b4_stos }; /* TOKEN_NUMBER_[[YYLEX-NUM]] -- Internal token number corresponding to YYLEX-NUM. */ -const short -yy::b4_name::token_number_[[]] = +const b4_int_type_for([b4_toknum]) +yy::b4_parser_class_name::token_number_[[]] = { b4_toknum }; #endif /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */ -const b4_uint_type(b4_r1_max) -yy::b4_name::r1_[[]] = +const b4_int_type_for([b4_r1]) +yy::b4_parser_class_name::r1_[[]] = { b4_r1 }; /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */ -const b4_uint_type(b4_r2_max) -yy::b4_name::r2_[[]] = +const b4_int_type_for([b4_r2]) +yy::b4_parser_class_name::r2_[[]] = { b4_r2 }; @@ -712,7 +720,7 @@ yy::b4_name::r2_[[]] = /* YYTNAME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ const char* -const yy::b4_name::name_[[]] = +const yy::b4_parser_class_name::name_[[]] = { b4_tname }; @@ -720,31 +728,31 @@ const yy::b4_name::name_[[]] = #if YYDEBUG /* YYRHS -- A `-1'-separated list of the rules' RHS. */ -const yy::b4_name::RhsNumberType -yy::b4_name::rhs_[[]] = +const yy::b4_parser_class_name::RhsNumberType +yy::b4_parser_class_name::rhs_[[]] = { b4_rhs }; /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ -const b4_uint_type(b4_prhs_max) -yy::b4_name::prhs_[[]] = +const b4_int_type_for([b4_prhs]) +yy::b4_parser_class_name::prhs_[[]] = { b4_prhs }; /* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ -const b4_uint_type(b4_rline_max) -yy::b4_name::rline_[[]] = +const b4_int_type_for([b4_rline]) +yy::b4_parser_class_name::rline_[[]] = { b4_rline }; #endif /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -yy::b4_name::TokenNumberType -yy::b4_name::translate_ (int token) +yy::b4_parser_class_name::TokenNumberType +yy::b4_parser_class_name::translate_ (int token) { static const TokenNumberType @@ -758,21 +766,21 @@ yy::b4_name::translate_ (int token) return undef_token_; } -const int yy::b4_name::eof_ = 0; -const int yy::b4_name::last_ = b4_last; -const int yy::b4_name::nnts_ = b4_nterms_number; -const int yy::b4_name::empty_ = -2; -const int yy::b4_name::final_ = b4_final_state_number; -const int yy::b4_name::terror_ = 1; -const int yy::b4_name::errcode_ = 256; -const int yy::b4_name::ntokens_ = b4_tokens_number; -const int yy::b4_name::initdepth_ = b4_initdepth; +const int yy::b4_parser_class_name::eof_ = 0; +const int yy::b4_parser_class_name::last_ = b4_last; +const int yy::b4_parser_class_name::nnts_ = b4_nterms_number; +const int yy::b4_parser_class_name::empty_ = -2; +const int yy::b4_parser_class_name::final_ = b4_final_state_number; +const int yy::b4_parser_class_name::terror_ = 1; +const int yy::b4_parser_class_name::errcode_ = 256; +const int yy::b4_parser_class_name::ntokens_ = b4_tokens_number; +const int yy::b4_parser_class_name::initdepth_ = b4_stack_depth_init; -const unsigned yy::b4_name::user_token_number_max_ = b4_user_token_number_max; -const yy::b4_name::TokenNumberType yy::b4_name::undef_token_ = b4_undef_token_number; +const unsigned yy::b4_parser_class_name::user_token_number_max_ = b4_user_token_number_max; +const yy::b4_parser_class_name::TokenNumberType yy::b4_parser_class_name::undef_token_ = b4_undef_token_number; b4_epilogue - +dnl #output "stack.hh" b4_copyright([2002]) @@ -869,7 +877,7 @@ namespace yy } #endif // not BISON_STACK_HH - +dnl #output "location.hh" b4_copyright([2002])