X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/947427ae83a46636a7be8a93a90c54b82fe8aed5..2f82502a6fc07c455cbbfa94e75c5febf930d1c9:/data/yacc.c?ds=inline diff --git a/data/yacc.c b/data/yacc.c index 9fabde81..462af2e2 100644 --- a/data/yacc.c +++ b/data/yacc.c @@ -133,29 +133,12 @@ m4_define([b4_rhs_location], ## Defining symbol actions, e.g., printers and destructors. ## ## --------------------------------------------------------- ## -# b4_symbol_actions(FILENAME, LINENO, -# SYMBOL-TAG, SYMBOL-NUM, -# SYMBOL-ACTION, SYMBOL-TYPENAME) -# ------------------------------------------------- -m4_define([b4_symbol_actions], -[m4_pushdef([b4_dollar_dollar], [yyvalue.$6])dnl -m4_pushdef([b4_at_dollar], [yylocation])dnl - case $4: /* $3 */ -b4_syncline([$2], [$1]) - $5; -b4_syncline([@oline@], [@ofile@]) - break; -m4_popdef([b4_at_dollar])dnl -m4_popdef([b4_dollar_dollar])dnl -]) - - # We do want M4 expansion after # for CPP macros. m4_changecom() m4_divert(0)dnl @output @output_parser_name@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison], - [1984, 1989, 1990, 2000, 2001, 2002]) + [1984, 1989, 1990, 2000, 2001, 2002])[ /* As a special exception, when this file is copied by Bison into a Bison output file, you may use that output file without restriction. @@ -172,7 +155,7 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison], define necessary library symbols; they are noted "INFRINGES ON USER NAME SPACE" below. */ -b4_identification +]b4_identification m4_if(b4_prefix[], [yy], [], [/* If NAME_PREFIX is specified substitute the variables and functions names. */ @@ -183,16 +166,16 @@ m4_if(b4_prefix[], [yy], [], #define yychar b4_prefix[]char #define yydebug b4_prefix[]debug #define yynerrs b4_prefix[]nerrs -b4_location_if([#define yylloc b4_prefix[]lloc])]) +b4_location_if([#define yylloc b4_prefix[]lloc])])[ -b4_token_defines(b4_tokens) +]b4_token_defines(b4_tokens)[ /* Copy the first part of user declarations. */ -b4_pre_prologue +]b4_pre_prologue[ /* Enabling traces. */ #ifndef YYDEBUG -# define YYDEBUG b4_debug +# define YYDEBUG ]b4_debug[ #endif /* Enabling verbose error messages. */ @@ -200,16 +183,16 @@ b4_pre_prologue # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else -# define YYERROR_VERBOSE b4_error_verbose +# define YYERROR_VERBOSE ]b4_error_verbose[ #endif #ifndef YYSTYPE -m4_ifdef([b4_stype], +]m4_ifdef([b4_stype], [b4_syncline([b4_stype_line], [b4_filename]) typedef union b4_stype yystype; /* Line __line__ of __file__. */ b4_syncline([@oline@], [@ofile@])], -[typedef int yystype;]) +[typedef int yystype;])[ # define YYSTYPE yystype # define YYSTYPE_IS_TRIVIAL 1 #endif @@ -222,15 +205,15 @@ typedef struct yyltype int last_line; int last_column; } yyltype; -# define YYLTYPE b4_location_type +# define YYLTYPE ]b4_location_type[ # define YYLTYPE_IS_TRIVIAL 1 #endif /* Copy the second part of user declarations. */ -b4_post_prologue +]b4_post_prologue /* Line __line__ of __file__. */ -b4_syncline([@oline@], [@ofile@]) +b4_syncline([@oline@], [@ofile@])[ #if ! defined (yyoverflow) || YYERROR_VERBOSE @@ -273,22 +256,22 @@ union yyalloc { short yyss; YYSTYPE yyvs; - b4_location_if([ YYLTYPE yyls; + ]b4_location_if([ YYLTYPE yyls; ])dnl -}; +[}; /* The size of the maximum gap between one aligned stack and the next. */ # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) /* The size of an array large to enough to hold all stacks, each with N elements. */ -b4_location_if( +]b4_location_if( [# define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ + 2 * YYSTACK_GAP_MAX)], [# define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX)]) + + YYSTACK_GAP_MAX)])[ /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ @@ -302,7 +285,7 @@ b4_location_if( { \ register YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ - (To)[[yyi]] = (From)[[yyi]]; \ + (To)[yyi] = (From)[yyi]; \ } \ while (0) # endif @@ -333,131 +316,132 @@ b4_location_if( #endif /* YYFINAL -- State number of the termination state. */ -#define YYFINAL b4_final_state_number +#define YYFINAL ]b4_final_state_number[ /* YYLAST -- Last index in YYTABLE. */ -#define YYLAST b4_last +#define YYLAST ]b4_last[ /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS b4_tokens_number +#define YYNTOKENS ]b4_tokens_number[ /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS b4_nterms_number +#define YYNNTS ]b4_nterms_number[ /* YYNRULES -- Number of rules. */ -#define YYNRULES b4_rules_number +#define YYNRULES ]b4_rules_number[ /* YYNRULES -- Number of states. */ -#define YYNSTATES b4_states_number +#define YYNSTATES ]b4_states_number[ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK b4_undef_token_number -#define YYMAXUTOK b4_user_token_number_max +#define YYUNDEFTOK ]b4_undef_token_number[ +#define YYMAXUTOK ]b4_user_token_number_max[ -#define YYTRANSLATE(X) \ - ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK) +#define YYTRANSLATE(YYX) \ + ((YYX <= 0) ? YYEOF : \ + (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) -/* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX. */ -static const b4_int_type_for([b4_translate]) yytranslate[[]] = +/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = { - b4_translate + ]b4_translate[ }; #if YYDEBUG -/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in +/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ -static const b4_int_type_for([b4_prhs]) yyprhs[[]] = +static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = { - b4_prhs + ]b4_prhs[ }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const b4_int_type_for([b4_rhs]) yyrhs[[]] = +static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = { - b4_rhs + ]b4_rhs[ }; -/* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ -static const b4_int_type_for([b4_rline]) yyrline[[]] = +/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ +static const ]b4_int_type_for([b4_rline])[ yyrline[] = { - b4_rline + ]b4_rline[ }; #endif #if YYDEBUG || YYERROR_VERBOSE -/* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM. +/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[[]] = +static const char *const yytname[] = { - b4_tname + ]b4_tname[ }; #endif # ifdef YYPRINT -/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to token YYLEX-NUM. */ -static const b4_int_type_for([b4_toknum]) yytoknum[[]] = +static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = { - b4_toknum + ]b4_toknum[ }; # endif -/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */ -static const b4_int_type_for([b4_r1]) yyr1[[]] = +/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ +static const ]b4_int_type_for([b4_r1])[ yyr1[] = { - b4_r1 + ]b4_r1[ }; -/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */ -static const b4_int_type_for([b4_r2]) yyr2[[]] = +/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ +static const ]b4_int_type_for([b4_r2])[ yyr2[] = { - b4_r2 + ]b4_r2[ }; -/* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state +/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state STATE-NUM when YYTABLE doesn't specify something else to do. Zero means the default is an error. */ -static const b4_int_type_for([b4_defact]) yydefact[[]] = +static const ]b4_int_type_for([b4_defact])[ yydefact[] = { - b4_defact + ]b4_defact[ }; -/* YYDEFGOTO[[NTERM-NUM]]. */ -static const b4_int_type_for([b4_defgoto]) yydefgoto[[]] = +/* YYDEFGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = { - b4_defgoto + ]b4_defgoto[ }; -/* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing +/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -#define YYPACT_NINF b4_pact_ninf -static const b4_int_type_for([b4_pact]) yypact[[]] = +#define YYPACT_NINF ]b4_pact_ninf[ +static const ]b4_int_type_for([b4_pact])[ yypact[] = { - b4_pact + ]b4_pact[ }; -/* YYPGOTO[[NTERM-NUM]]. */ -static const b4_int_type_for([b4_pgoto]) yypgoto[[]] = +/* YYPGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = { - b4_pgoto + ]b4_pgoto[ }; -/* YYTABLE[[YYPACT[STATE-NUM]]]. What to do in state STATE-NUM. If +/* 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. - If YYTABLE_NINF, parse error. */ -#define YYTABLE_NINF b4_table_ninf -static const b4_int_type_for([b4_table]) yytable[[]] = + If YYTABLE_NINF, syntax error. */ +#define YYTABLE_NINF ]b4_table_ninf[ +static const ]b4_int_type_for([b4_table])[ yytable[] = { - b4_table + ]b4_table[ }; -static const b4_int_type_for([b4_check]) yycheck[[]] = +static const ]b4_int_type_for([b4_check])[ yycheck[] = { - b4_check + ]b4_check[ }; -/* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing +/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing symbol of state STATE-NUM. */ -static const b4_int_type_for([b4_stos]) yystos[[]] = +static const ]b4_int_type_for([b4_stos])[ yystos[] = { - b4_stos + ]b4_stos[ }; #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) @@ -477,7 +461,7 @@ static const b4_int_type_for([b4_stos]) yystos[[]] = #endif #define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) +#define yyclearin (yytoken = YYEMPTY) #define YYEMPTY -2 #define YYEOF 0 @@ -495,17 +479,17 @@ static const b4_int_type_for([b4_stos]) yystos[[]] = #define YYBACKUP(Token, Value) \ do \ - if (yychar == YYEMPTY && yylen == 1) \ + if (yytoken == YYEMPTY && yylen == 1) \ { \ yychar = (Token); \ yylval = (Value); \ - yychar1 = YYTRANSLATE (yychar); \ + yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ - yyerror (b4_yyerror_args"syntax error: cannot back up"); \ + yyerror (]b4_yyerror_args["syntax error: cannot back up");\ YYERROR; \ } \ while (0) @@ -517,19 +501,19 @@ while (0) are run). */ #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - Current.first_line = Rhs[[1]].first_line; \ - Current.first_column = Rhs[[1]].first_column; \ - Current.last_line = Rhs[[N]].last_line; \ - Current.last_column = Rhs[[N]].last_column; +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + Current.first_line = Rhs[1].first_line; \ + Current.first_column = Rhs[1].first_column; \ + Current.last_line = Rhs[N].last_line; \ + Current.last_column = Rhs[N].last_column; #endif /* YYLEX -- calling `yylex' with the right arguments. */ #ifdef YYLEX_PARAM -# define YYLEX yylex (b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])YYLEX_PARAM) +# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM) #else -# define YYLEX b4_c_function_call([yylex], [int], b4_lex_param) +# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ #endif /* Enable debugging if requested. */ @@ -545,22 +529,83 @@ do { \ if (yydebug) \ YYFPRINTF Args; \ } while (0) + # define YYDSYMPRINT(Args) \ do { \ if (yydebug) \ yysymprint Args; \ } while (0) + +# define YYDSYMPRINTF(Title, Token, Value, Location) \ +do { \ + if (yydebug) \ + { \ + YYFPRINTF (stderr, "%s ", Title); \ + yysymprint (stderr, \ + Token, Value]b4_location_if([, Location])[); \ + YYFPRINTF (stderr, "\n"); \ + } \ +} while (0) + +/*------------------------------------------------------------------. +| yy_stack_print -- Print the state stack from its BOTTOM up to its | +| TOP (cinluded). | +`------------------------------------------------------------------*/ + +]b4_c_function_def([yy_stack_print], [static void], + [[short *bottom], [bottom]], + [[short *top], [top]])[ +{ + YYFPRINTF (stderr, "Stack now"); + for (/* Nothing. */; bottom <= top; ++bottom) + YYFPRINTF (stderr, " %d", *bottom); + YYFPRINTF (stderr, "\n"); +} + +# define YY_STACK_PRINT(Bottom, Top) \ +do { \ + if (yydebug) \ + yy_stack_print ((Bottom), (Top)); \ +} while (0) + + +/*------------------------------------------------. +| Report that the YYRULE is going to be reduced. | +`------------------------------------------------*/ + +]b4_c_function_def([yy_reduce_print], [static void], + [[int yyrule], [yyrule]])[ +{ + int yyi; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %d), ", + yyrule - 1, yyrline[yyrule]); + /* Print the symbols being reduced, and their result. */ + for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) + YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); + YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); +} + +# define YY_REDUCE_PRINT(Rule) \ +do { \ + if (yydebug) \ + yy_reduce_print (Rule); \ +} while (0) + /* Nonzero means print parse trace. It is left uninitialized so that multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ # define YYDPRINTF(Args) # define YYDSYMPRINT(Args) +# define YYDSYMPRINTF(Title, Token, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ + /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH -# define YYINITDEPTH b4_stack_depth_init +# define YYINITDEPTH ]b4_stack_depth_init[ #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only @@ -575,7 +620,7 @@ int yydebug; #endif #ifndef YYMAXDEPTH -# define YYMAXDEPTH b4_stack_depth_max +# define YYMAXDEPTH ]b4_stack_depth_max[ #endif @@ -636,66 +681,9 @@ yystpcpy (yydest, yysrc) #if YYDEBUG -/*-----------------------------. -| Print this symbol on YYOUT. | -`-----------------------------*/ - -b4_c_function_def([yysymprint], - [static void], - [[FILE *yyout], [yyout]], - [[int yytype], [yytype]], - [[YYSTYPE yyvalue], [yyvalue]]b4_location_if([, - [[YYLTYPE yylocation], [yylocation]]])) -{ - /* Pacify ``unused variable'' warnings. */ - (void) yyvalue; -b4_location_if([ (void) yylocation; -])dnl - - if (yytype < YYNTOKENS) - { - YYFPRINTF (yyout, "token %s (", yytname[[yytype]]); -# ifdef YYPRINT - YYPRINT (yyout, yytoknum[[yytype]], yyvalue); -# endif - } - else - YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]); - - switch (yytype) - { -m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl - default: - break; - } - YYFPRINTF (yyout, ")"); -} -#endif /* YYDEBUG. */ - - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -b4_c_function_def([yydestruct], - [static void], - [[int yytype], [yytype]], - [[YYSTYPE yyvalue], [yyvalue]]b4_location_if([, - [[YYLTYPE yylocation], [yylocation]]])) -{ - /* Pacify ``unused variable'' warnings. */ - (void) yyvalue; -b4_location_if([ (void) yylocation; -])dnl - - switch (yytype) - { -m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl - default: - break; - } -} - +]b4_yysymprint_generate([b4_c_function_def])[ +#endif /* ! YYDEBUG */ +]b4_yydestruct_generate([b4_c_function_def]) /* Prevent warnings from -Wmissing-prototypes. */ @@ -708,7 +696,7 @@ int yyparse (); # endif #else /* ! YYPARSE_PARAM */ b4_c_function_decl([yyparse], [int], b4_parse_param) -#endif +#endif /* ! YYPARSE_PARAM */ m4_divert_push([KILL])# ======================== M4 code. @@ -723,7 +711,7 @@ int yychar; /* The semantic value of the lookahead symbol. */ YYSTYPE yylval; -/* Number of parse errors so far. */ +/* Number of syntax errors so far. */ int yynerrs;b4_location_if([ /* Location data for the lookahead symbol. */ YYLTYPE yylloc;]) @@ -756,7 +744,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param) /* Number of tokens to shift before error messages enabled. */ int yyerrstatus; /* Lookahead token as an internal (translated) token number. */ - int yychar1 = 0; + int yytoken = 0; /* Three stacks and their tools: `yyss': related to states, @@ -800,7 +788,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param) yystate = 0; yyerrstatus = 0; yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ + yychar = yytoken = YYEMPTY; /* Cause a token to be read. */ /* Initialize stack pointers. Waste one element of value and location stack @@ -910,39 +898,29 @@ yybackup: /* Not known => get a lookahead token if don't already have one. */ - /* yychar is either YYEMPTY or YYEOF - or a valid token in external form. */ - - if (yychar == YYEMPTY) + /* YYTOKEN is either YYEMPTY or YYEOF or a valid token. */ + if (yytoken == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; + yytoken = YYTRANSLATE (yychar); } - /* Convert token to internal form (in yychar1) for indexing tables with. */ - - if (yychar <= 0) /* This means end of input. */ + if (yytoken == YYEOF) { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more. */ - YYDPRINTF ((stderr, "Now at end of input.\n")); } else { - yychar1 = YYTRANSLATE (yychar); - /* We have to keep this `#if YYDEBUG', since we use variables which are defined only if `YYDEBUG' is set. */ - YYDPRINTF ((stderr, "Next token is ")); - YYDSYMPRINT ((stderr, yychar1, yylval]b4_location_if([, yyloc])[)); - YYDPRINTF ((stderr, "\n")); + YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); } - /* If the proper action on seeing token YYCHAR1 is to reduce or to + /* If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action. */ - yyn += yychar1; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; yyn = yytable[yyn]; if (yyn <= 0) @@ -957,12 +935,11 @@ yybackup: YYACCEPT; /* Shift the lookahead token. */ - YYDPRINTF ((stderr, "Shifting token %d (%s), ", - yychar, yytname[yychar1])); + YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); /* Discard the token being shifted unless it is eof. */ - if (yychar != YYEOF) - yychar = YYEMPTY; + if (yytoken != YYEOF) + yytoken = YYEMPTY; *++yyvsp = yylval; ]b4_location_if([ *++yylsp = yylloc;])[ @@ -1006,23 +983,7 @@ yyreduce: ]b4_location_if( [ /* Default location. */ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[ - -#if YYDEBUG - /* We have to keep this `#if YYDEBUG', since we use variables which - are defined only if `YYDEBUG' is set. */ - if (yydebug) - { - int yyi; - - YYFPRINTF (stderr, "Reducing via rule %d (line %d), ", - yyn - 1, yyrline[yyn]); - - /* Print the symbols being reduced, and their result. */ - for (yyi = yyprhs[yyn]; 0 <= yyrhs[yyi]; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif + YY_REDUCE_PRINT (yyn); switch (yyn) ]{ b4_actions @@ -1035,16 +996,7 @@ b4_syncline([@oline@], [@ofile@]) yyssp -= yylen; ]b4_location_if([ yylsp -= yylen;])[ -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + YY_STACK_PRINT (yyss, yyssp); *++yyvsp = yyval; ]b4_location_if([ *++yylsp = yyloc;])[ @@ -1089,12 +1041,12 @@ yyerrlab: yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; + yysize += yystrlen ("syntax error, unexpected ") + 1; yysize += yystrlen (yytname[yytype]); yymsg = (char *) YYSTACK_ALLOC (yysize); if (yymsg != 0) { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); yyp = yystpcpy (yyp, yytname[yytype]); if (yycount < 5) @@ -1115,11 +1067,11 @@ yyerrlab: YYSTACK_FREE (yymsg); } else - yyerror (]b4_yyerror_args["parse error; also virtual memory exhausted"); + yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted"); } else #endif /* YYERROR_VERBOSE */ - yyerror (]b4_yyerror_args["parse error"); + yyerror (]b4_yyerror_args["syntax error"); } goto yyerrlab1; @@ -1134,28 +1086,23 @@ yyerrlab1: error, discard it. */ /* Return failure if at end of input. */ - if (yychar == YYEOF) + if (yytoken == YYEOF) { /* Pop the error token. */ YYPOPSTACK; /* Pop the rest of the stack. */ while (yyss < yyssp) { - YYDPRINTF ((stderr, "Error: popping ")); - YYDSYMPRINT ((stderr, - yystos[*yyssp], - *yyvsp]b4_location_if([, *yylsp])[)); - YYDPRINTF ((stderr, "\n")); - yydestruct (yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[); + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[); YYPOPSTACK; } YYABORT; } - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yydestruct (yychar1, yylval]b4_location_if([, yylloc])[); - yychar = YYEMPTY; + YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); + yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[); + yytoken = YYEMPTY; } /* Else will try to reuse lookahead token after shifting the error @@ -1181,26 +1128,12 @@ yyerrlab1: if (yyssp == yyss) YYABORT; - YYDPRINTF ((stderr, "Error: popping ")); - YYDSYMPRINT ((stderr, - yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[)); - YYDPRINTF ((stderr, "\n")); - - yydestruct (yystos[yystate], *yyvsp]b4_location_if([, *yylsp])[); + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[); yyvsp--; yystate = *--yyssp; ]b4_location_if([ yylsp--;])[ - -#if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "Error: state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } -#endif + YY_STACK_PRINT (yyss, yyssp); } if (yyn == YYFINAL)