X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/0c76a0c91119bf2e02c5104f2c211d2cc7215dac..f25bfb75aa45ded96d5e8060a637d366c3a47924:/data/bison.simple diff --git a/data/bison.simple b/data/bison.simple index 803d1a48..6059e160 100644 --- a/data/bison.simple +++ b/data/bison.simple @@ -6,8 +6,7 @@ m4_divert(-1) -*- C -*- m4_define([b4_sint_type], [m4_if(m4_eval([$1 <= 127]), [1], [signed char], m4_eval([$1 <= 32767]), [1], [signed short], - m4_eval([$1 <= 2147483647]), [1], [signed int], - [m4_fatal([no signed int type for $1])])]) + [signed int])]) # b4_uint_type(MAX) @@ -16,8 +15,37 @@ m4_define([b4_sint_type], m4_define([b4_uint_type], [m4_if(m4_eval([$1 <= 255]), [1], [unsigned char], m4_eval([$1 <= 65535]), [1], [unsigned short], - m4_eval([$1 <= 4294967295]), [1], [unsigned int], - [m4_fatal([no unsigned int type for $1])])]) + [unsigned int])]) + + +# b4_lhs_value([TYPE]) +# -------------------- +# Expansion of $$. +m4_define([b4_lhs_value], +[yyval[]m4_ifval([$1], [.$1])]) + + +# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) +# -------------------------------------- +# Expansion of $NUM, where the current rule has RULE-LENGTH +# symbols on RHS. +m4_define([b4_rhs_value], +[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])]) + + +# b4_lhs_location() +# ----------------- +# Expansion of @$. +m4_define([b4_lhs_location], +[yyloc]) + + +# b4_rhs_location(RULE-LENGTH, NUM) +# --------------------------------- +# Expansion of @NUM, where the current rule has RULE-LENGTH symbols +# on RHS. +m4_define([b4_rhs_location], +[yylsp@<:@m4_eval([$2 - $1])@:>@]) m4_define_default([b4_input_suffix], [.y]) @@ -40,19 +68,47 @@ m4_define_default([b4_header_guard], [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])]) -# b4_token_defines(TOKEN-NAME, TOKEN-NUMBER) -# ------------------------------------------ +## ------------------------- ## +## Assigning token numbers. ## +## ------------------------- ## + +# b4_token_define(TOKEN-NAME, TOKEN-NUMBER) +# ----------------------------------------- # Output the definition of this token as #define. m4_define([b4_token_define], [#define $1 $2 ]) +# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER) +# --------------------------------------- +# Output the definition of this token as an enum. +m4_define([b4_token_enum], +[$1 = $2]) + + # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER) # ------------------------------------------------------- -# Output the definition of the tokens as #define. +# Output the definition of the tokens (if there are) as enums and #define. m4_define([b4_token_defines], -[m4_map([b4_token_define], [$@])]) +[m4_if([$@], [[]], [], +[/* Tokens. */ +#ifndef YYTOKENTYPE +# if defined (__STDC__) || defined (__cplusplus) + /* Put the tokens into the symbol table, so that GDB and other debuggers + know about them. */ + enum yytokentype { +m4_map_sep([ b4_token_enum], [, +], + [$@]) + }; +# endif + /* POSIX requires `int' for tokens in interfaces. */ +# define YYTOKENTYPE int +#endif /* !YYTOKENTYPE */ +m4_map([b4_token_define], [$@]) +]) +]) m4_divert(0)dnl @@ -86,8 +142,8 @@ m4_divert(0)dnl /* This is the parser code that is written into each bison parser when the %semantic_parser declaration is not specified in the grammar. - It was written by Richard Stallman by simplifying the hairy parser - used when %semantic_parser is specified. */ + It was written by Richard Stallman by simplifying the original so + called ``semantic'' parser. */ /* All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local @@ -123,6 +179,8 @@ m4_if(b4_prefix[], [yy], [], /* Copy the first part of user declarations. */ b4_pre_prologue +b4_token_defines(b4_tokens) + /* Enabling traces. */ #ifndef YYDEBUG # define YYDEBUG b4_debug @@ -137,10 +195,12 @@ b4_pre_prologue #endif #ifndef YYSTYPE -m4_ifdef([b4_stype_line], +m4_ifdef([b4_stype], [#line b4_stype_line "b4_filename" -])dnl -typedef b4_stype yystype; +typedef union b4_stype yystype; +/* Line __line__ of __file__. */ +#line __oline__ "__ofile__"], +[typedef int yystype;]) # define YYSTYPE yystype # define YYSTYPE_IS_TRIVIAL 1 #endif @@ -260,9 +320,6 @@ union yyalloc #endif -/* Tokens. */ -b4_token_defines(b4_tokens) - /* YYFINAL -- State number of the termination state. */ #define YYFINAL b4_final #define YYFLAG b4_flag @@ -281,12 +338,11 @@ b4_token_defines(b4_tokens) #define YYUNDEFTOK b4_undef_token_number #define YYMAXUTOK b4_user_token_number_max -typedef b4_uint_type(b4_token_number_max) yy_token_number_type; #define YYTRANSLATE(X) \ ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK) /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX. */ -static const yy_token_number_type yytranslate[[]] = +static const b4_uint_type(b4_translate_max) yytranslate[[]] = { b4_translate }; @@ -294,26 +350,25 @@ static const yy_token_number_type yytranslate[[]] = #if YYDEBUG /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ -static const short yyprhs[[]] = +static const b4_uint_type(b4_prhs_max) yyprhs[[]] = { b4_prhs }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ -typedef b4_sint_type(b4_rhs_number_max) yyrhs_t; -static const yyrhs_t yyrhs[[]] = +static const b4_sint_type(b4_rhs_max) yyrhs[[]] = { b4_rhs }; /* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */ -static const short yyrline[[]] = +static const b4_uint_type(b4_rline_max) yyrline[[]] = { b4_rline }; #endif -#if (YYDEBUG) || YYERROR_VERBOSE +#if YYDEBUG || YYERROR_VERBOSE /* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at YYNTOKENS, nonterminals. */ static const char *const yytname[[]] = @@ -322,27 +377,28 @@ static const char *const yytname[[]] = }; #endif -/* YYTOKNUM[[YYN]] -- Index in YYTNAME corresponding to YYLEX. */ +/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to + token YYLEX-NUM. */ static const short yytoknum[[]] = { b4_toknum }; /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */ -static const yy_token_number_type yyr1[[]] = +static const b4_uint_type(b4_r1_max) yyr1[[]] = { b4_r1 }; /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */ -static const short yyr2[[]] = +static const b4_uint_type(b4_r2_max) yyr2[[]] = { b4_r2 }; -/* 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. */ +/* 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 short yydefact[[]] = { b4_defact @@ -380,6 +436,12 @@ static const short yycheck[[]] = b4_check }; +/* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing + symbol of state STATE-NUM. */ +static const b4_uint_type(b4_stos_max) yystos[[]] = +{ + b4_stos +}; #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) # define YYSIZE_T __SIZE_TYPE__ @@ -435,16 +497,14 @@ while (0) #define YYERRCODE 256 /* YYLLOC_DEFAULT -- Compute the default location (before the actions - are run). - - When YYLLOC_DEFAULT is run, CURRENT is set the location of the - first token. By default, to implement support for ranges, extend - its range to the last symbol. */ + are run). */ #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - 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. */ @@ -591,6 +651,7 @@ int yyparse (void *); int yyparse (void); # endif #endif +static void yydestructor (int symbol_type, YYSTYPE symbol_value); /* YY_DECL_VARIABLES -- depending whether we use a pure parser, variables are global, or local to YYPARSE. */ @@ -926,9 +987,7 @@ yyreduce: yyval = yyvsp[1-yylen]; #if YYLSP_NEEDED - /* Similarly for the default location. Let the user run additional - commands if for instance locations are ranges. */ - yyloc = yylsp[1-yylen]; + /* Default location. */ YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen); #endif @@ -1064,9 +1123,41 @@ yyerrlab1: /* Return failure if at end of input. */ if (yychar == YYEOF) - YYABORT; + { + /* Pop the error token. */ + YYPOPSTACK; + /* Pop the rest of the stack. */ + while (yyssp > yyss) + { +#if YYDEBUG + if (yydebug) + { + if (yystos[*yyssp] < YYNTOKENS) + { + YYFPRINTF (stderr, "Error: popping token %d (%s", + yytoknum[yystos[*yyssp]], + yytname[yystos[*yyssp]]); +# ifdef YYPRINT + YYPRINT (stderr, yytoknum[yystos[*yyssp]], *yyvsp); +# endif + YYFPRINTF (stderr, ")\n"); + } + else + { + YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n", + yytname[yystos[*yyssp]]); + } + } +#endif + yydestructor (yystos[*yyssp], *yyvsp); + YYPOPSTACK; + } + YYABORT; + } + YYDPRINTF ((stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1])); + yydestructor (yychar1, yylval); yychar = YYEMPTY; } @@ -1075,71 +1166,62 @@ yyerrlab1: yyerrstatus = 3; /* Each real token shifted decrements this. */ - goto yyerrhandle; - + for (;;) + { + yyn = yypact[yystate]; + if (yyn != YYFLAG) + { + yyn += YYTERROR; + if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) + { + yyn = yytable[yyn]; + if (0 < yyn) + break; + } + } -/*-------------------------------------------------------------------. -| yyerrdefault -- current state does not do anything special for the | -| error token. | -`-------------------------------------------------------------------*/ -yyerrdefault: -#if 0 - /* This is wrong; only states that explicitly want error tokens - should shift them. */ + /* Pop the current state because it cannot handle the error token. */ + if (yyssp == yyss) + YYABORT; - /* If its default is to accept any token, ok. Otherwise pop it. */ - yyn = yydefact[yystate]; - if (yyn) - goto yydefault; +#if YYDEBUG + if (yydebug) + { + if (yystos[yystate] < YYNTOKENS) + { + YYFPRINTF (stderr, "Error: popping token %d (%s", + yytoknum[yystos[yystate]], yytname[yystos[yystate]]); +# ifdef YYPRINT + YYPRINT (stderr, yytoknum[yystos[yystate]], *yyvsp); +# endif + YYFPRINTF (stderr, ")\n"); + } + else + { + YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n", + yytname[yystos[yystate]]); + } + } #endif - -/*---------------------------------------------------------------. -| yyerrpop -- pop the current state because it cannot handle the | -| error token. | -`---------------------------------------------------------------*/ -yyerrpop: - if (yyssp == yyss) - YYABORT; - yyvsp--; - yystate = *--yyssp; + yydestructor (yystos[yystate], *yyvsp); + yyvsp--; + yystate = *--yyssp; #if YYLSP_NEEDED - yylsp--; + yylsp--; #endif #if YYDEBUG - if (yydebug) - { - short *yyssp1 = yyss - 1; - YYFPRINTF (stderr, "Error: state stack now"); - while (yyssp1 != yyssp) - YYFPRINTF (stderr, " %d", *++yyssp1); - YYFPRINTF (stderr, "\n"); - } + if (yydebug) + { + short *yyssp1 = yyss - 1; + YYFPRINTF (stderr, "Error: state stack now"); + while (yyssp1 != yyssp) + YYFPRINTF (stderr, " %d", *++yyssp1); + YYFPRINTF (stderr, "\n"); + } #endif - -/*--------------. -| yyerrhandle. | -`--------------*/ -yyerrhandle: - yyn = yypact[yystate]; - if (yyn == YYFLAG) - goto yyerrdefault; - - yyn += YYTERROR; - if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) - goto yyerrdefault; - - yyn = yytable[yyn]; - if (yyn < 0) - { - if (yyn == YYFLAG) - goto yyerrpop; - yyn = -yyn; - goto yyreduce; } - else if (yyn == 0) - goto yyerrpop; if (yyn == YYFINAL) YYACCEPT; @@ -1169,13 +1251,15 @@ yyabortlab: yyresult = 1; goto yyreturn; -/*---------------------------------------------. -| yyoverflowab -- parser overflow comes here. | -`---------------------------------------------*/ +#ifndef yyoverflow +/*----------------------------------------------. +| yyoverflowlab -- parser overflow comes here. | +`----------------------------------------------*/ yyoverflowlab: yyerror ("parser stack overflow"); yyresult = 2; /* Fall through. */ +#endif yyreturn: #ifndef yyoverflow @@ -1185,6 +1269,37 @@ yyreturn: return yyresult; ]} + +/*-------------------------------------------------. +| Release the memory associated to SYMBOL-NUMBER. | +`-------------------------------------------------*/ + +m4_divert_push([KILL])# M4 code. +# b4_symbol_destructor(SYMBOL-NUMBER, DESTRUCTOR, TYPE-NAME) +# ---------------------------------------------------------- +m4_define([b4_symbol_destructor], +[m4_pushdef([b4_dollar_dollar], [symbol_value.$6])dnl + case $4: /* $3 */ +#line $2 "$1" + $5; +#line __oline__ "__ofile__" + break; +m4_popdef([b4_dollar_dollar])]) + +m4_divert_pop([KILL])dnl# End of M4 code. +static void +yydestructor (int symbol_type, YYSTYPE symbol_value) +{ + switch (symbol_type) + { +m4_map([b4_symbol_destructor], m4_defn([b4_symbol_destructors]))dnl + default: + YYDPRINTF ((stderr, "yydestructor: unknown symbol type: %d (%s)\n", + symbol_type, yytname[[symbol_type]])); + break; + } +} + b4_epilogue m4_if(b4_defines_flag, 0, [], [#output "b4_output_header_name" @@ -1194,11 +1309,12 @@ m4_if(b4_defines_flag, 0, [], b4_token_defines(b4_tokens) #ifndef YYSTYPE -m4_ifdef([b4_stype_line], +m4_ifdef([b4_stype], [#line b4_stype_line "b4_filename" -])dnl -typedef b4_stype -yystype; +typedef union b4_stype yystype; +/* Line __line__ of __file__. */ +#line __oline__ "__ofile__"], +[typedef int yystype;]) # define YYSTYPE yystype #endif