X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/fb8135fa993b77b8cfc0ff652b02424aea3c6754..8442d6ba228133aba0bc2ada30b8796229884223:/data/glr.c diff --git a/data/glr.c b/data/glr.c index 846adeb7..6824d2bf 100644 --- a/data/glr.c +++ b/data/glr.c @@ -1,4 +1,5 @@ -m4_divert(-1) -*- YYC -*- +m4_divert(-1) -*- C -*- +m4_include([c.m4]) # GLR skeleton for Bison # Copyright (C) 2002 Free Software Foundation, Inc. @@ -18,10 +19,6 @@ m4_divert(-1) -*- YYC -*- # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA # 02111-1307 USA -m4_include([c.m4]) - - - # b4_lhs_value([TYPE]) # -------------------- # Expansion of $$. @@ -111,11 +108,12 @@ b4_copyright([Skeleton parser for GLR parsing with Bison], [2002]) /* This is the parser code for GLR (Generalized LR) parser. */ /* FIXME: minimize these */ -#include +#include #include -#include #include -#include +#include +#include +#include /* Identify Bison output. */ #define YYBISON 1 @@ -200,23 +198,39 @@ static YYLTYPE yyloc_default; # define yyfalse 0 #endif -#if ! defined (yy__GNUC__) -# define inline +/*-----------------. +| GCC extensions. | +`-----------------*/ + +#ifndef __attribute__ +/* This feature is available in gcc versions 2.5 and later. */ +# if !defined (__GNUC__) || __GNUC__ < 2 || \ +(__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__ +# define __attribute__(Spec) /* empty */ +# endif +#endif + +#ifndef ATTRIBUTE_UNUSED +# define ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +#endif + +#if ! defined (__GNUC__) +# define inline #endif /* YYFINAL -- State number of the termination state. */ -#define YYFINAL ]b4_final[ +#define YYFINAL ]b4_final_state_number[ #define YYFLAG ]b4_flag[ #define YYLAST ]b4_last[ /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS ]b4_ntokens[ +#define YYNTOKENS ]b4_tokens_number[ /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS ]b4_nnts[ +#define YYNNTS ]b4_nterms_number[ /* YYNRULES -- Number of rules. */ -#define YYNRULES ]b4_nrules[ +#define YYNRULES ]b4_rules_number[ /* YYNRULES -- Number of states. */ -#define YYNSTATES ]b4_nstates[ +#define YYNSTATES ]b4_states_number[ /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */ #define YYMAXRHS ]b4_r2_max[ @@ -228,7 +242,7 @@ static YYLTYPE yyloc_default; ((unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const ]b4_uint_type(b4_translate_max)[ yytranslate[] = +static const ]b4_int_type_for([b4_translate])[ yytranslate[] = { ]b4_translate[ }; @@ -236,19 +250,19 @@ static const ]b4_uint_type(b4_translate_max)[ yytranslate[] = #if YYDEBUG /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in YYRHS. */ -static const ]b4_uint_type(b4_prhs_max)[ yyprhs[] = +static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = { ]b4_prhs[ }; /* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const ]b4_sint_type(b4_rhs_max)[ yyrhs[] = +static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = { ]b4_rhs[ }; /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const ]b4_uint_type(b4_rline_max)[ yyrline[] = +static const ]b4_int_type_for([b4_rline])[ yyrline[] = { ]b4_rline[ }; @@ -262,29 +276,29 @@ static const char *const yytname[] = ]b4_tname[ }; -#define yytname_size (sizeof (yytname) / sizeof (yytname[0])) +#define yytname_size ((int) (sizeof (yytname) / sizeof (yytname[0]))) #endif /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const ]b4_uint_type(b4_r1_max)[ yyr1[] = +static const ]b4_int_type_for([b4_r1])[ yyr1[] = { ]b4_r1[ }; /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const ]b4_uint_type(b4_r2_max)[ yyr2[] = +static const ]b4_int_type_for([b4_r2])[ yyr2[] = { ]b4_r2[ }; /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */ -static const short yydprec[] = +static const ]b4_int_type_for([b4_dprec])[ yydprec[] = { ]b4_dprec[ }; /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */ -static const short yymerger[] = +static const ]b4_int_type_for([b4_merger])[ yymerger[] = { ]b4_merger[ }; @@ -292,26 +306,27 @@ static const short yymerger[] = /* 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. */ -static const short yydefact[] = +static const ]b4_int_type_for([b4_defact])[ yydefact[] = { ]b4_defact[ }; -/* YYPGOTO[NTERM-NUM]. */ -static const short yydefgoto[] = +/* YYPDEFGOTO[NTERM-NUM]. */ +static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = { ]b4_defgoto[ }; /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing STATE-NUM. */ -static const short yypact[] = +#define YYPACT_NINF ]b4_pact_ninf[ +static const ]b4_int_type_for([b4_pact])[ yypact[] = { ]b4_pact[ }; /* YYPGOTO[NTERM-NUM]. */ -static const short yypgoto[] = +static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = { ]b4_pgoto[ }; @@ -319,7 +334,8 @@ static const short yypgoto[] = /* 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. */ -static const short yytable[] = +#define YYTABLE_NINF ]b4_table_ninf[ +static const ]b4_int_type_for([b4_table])[ yytable[] = { ]b4_table[ }; @@ -328,19 +344,22 @@ static const short yytable[] = of conflicting reductions corresponding to action entry for state STATE-NUM in yytable. 0 means no conflicts. The list in yyconfl is terminated by a rule number of 0. */ -static const short yyconflp[] = +static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] = { ]b4_conflict_list_heads[ }; /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by 0, pointed into by YYCONFLP. */ -static const short yyconfl[] = +]dnl Do not use b4_int_type_for here, since there are places where +dnl pointers onto yyconfl are taken, which type is "short *". +dnl We probably ought to introduce a type for confl. +[static const short yyconfl[] = { ]b4_conflicting_rules[ }; -static const short yycheck[] = +static const ]b4_int_type_for([b4_check])[ yycheck[] = { ]b4_check[ }; @@ -376,10 +395,10 @@ int yyparse (void); #define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc) #ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) \ - yyCurrent.yyfirst_line = YYRHSLOC(yyRhs,1).yyfirst_line; \ - yyCurrent.yyfirst_column = YYRHSLOC(yyRhs,1).yyfirst_column; \ - yyCurrent.yylast_line = YYRHSLOC(yyRhs,YYN).yylast_line; \ +# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) \ + yyCurrent.yyfirst_line = YYRHSLOC(yyRhs,1).yyfirst_line; \ + yyCurrent.yyfirst_column = YYRHSLOC(yyRhs,1).yyfirst_column; \ + yyCurrent.yylast_line = YYRHSLOC(yyRhs,YYN).yylast_line; \ yyCurrent.yylast_column = YYRHSLOC(yyRhs,YYN).yylast_column; #endif @@ -431,7 +450,8 @@ do { \ multiple parsers can coexist. */ int yydebug; #else /* !YYDEBUG */ -# define YYDPRINTF(Args) + /* Avoid empty `if' bodies. */ +# define YYDPRINTF(Args) {} #endif /* !YYDEBUG */ /* YYINITDEPTH -- initial size of the parser's stacks. */ @@ -572,6 +592,9 @@ static YYRESULTTAG yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp, YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack) { + /* Avoid `unused' warnings in there are no $n. */ + (void) yystack; + if (yyrhslen == 0) { *yyvalp = yyval_default; @@ -627,6 +650,10 @@ static YYSTYPE yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1) { YYSTYPE yyval = *yy0; + /* `Use' the arguments. */ + (void) yy0; + (void) yy1; + switch (yyn) { b4_mergers @@ -655,7 +682,7 @@ yylhsNonterm (yyRuleNum yyrule) static inline bool yyisDefaultedState (yyStateNum yystate) { - return yypact[yystate] == YYFLAG; + return yypact[yystate] == YYPACT_NINF; } /** The default reduction for STATE, assuming it has one. */ @@ -710,7 +737,7 @@ yyisShiftAction (int yyaction) static inline bool yyisErrorAction (int yyaction) { - return yyaction == 0 || yyaction == YYFLAG; + return yyaction == 0 || yyaction == YYPACT_NINF; } /* GLRStates */ @@ -723,8 +750,9 @@ yyhasResolvedValue (yyGLRState* yystate) return yystate->yyresolved; } -void yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate, - yyGLRState* yyrhs, yyRuleNum yyrule) +static void +yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate, + yyGLRState* yyrhs, yyRuleNum yyrule) { yySemanticOption* yynewItem; yynewItem = &yystack->yynextFree->yyoption; @@ -885,13 +913,13 @@ yyundeleteLastStack (yyGLRStack* yystack) static inline void yyremoveDeletes (yyGLRStack* yystack) { - int yyi, yyj; + size_t yyi, yyj; yyi = yyj = 0; while (yyj < yystack->yytops.yysize) { if (yystack->yytops.yystates[yyi] == NULL) { - if (YYDEBUG && yyi == yyj) + if (yyi == yyj) YYDPRINTF ((stderr, "Removing dead stacks.\n")); yystack->yytops.yysize -= 1; } @@ -1025,9 +1053,10 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, * added to the options for the existing state's semantic value. */ static inline YYRESULTTAG -yyglrReduce (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, bool yyforceEval) +yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule, + bool yyforceEval) { - int yyposn = yystack->yytops.yystates[yyk]->yyposn; + size_t yyposn = yystack->yytops.yystates[yyk]->yyposn; if (yyforceEval || yystack->yysplitPoint == NULL) { @@ -1044,7 +1073,8 @@ yyglrReduce (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, bool yyforceEval) } else { - int yyi, yyn; + size_t yyi; + int yyn; yyGLRState* yys, *yys0 = yystack->yytops.yystates[yyk]; yyStateNum yynewLRState; @@ -1156,23 +1186,23 @@ yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1) * parsing state; return 0 if no combination is possible, * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */ static int -yypreference (yySemanticOption* yyy0, yySemanticOption* yyy1) +yypreference (yySemanticOption* y0, yySemanticOption* y1) { - yyRuleNum yyr0 = yyy0->yyrule, yyr1 = yyy1->yyrule; - int yyp0 = yydprec[yyr0], yyp1 = yydprec[yyr1]; + yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule; + int p0 = yydprec[r0], p1 = yydprec[r1]; - if (yyp0 == yyp1) + if (p0 == p1) { - if (yymerger[yyr0] == 0 || yymerger[yyr0] != yymerger[yyr1]) + if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1]) return 0; else return 1; } - if (yyp0 == 0 || yyp1 == 0) + if (p0 == 0 || p1 == 0) return 0; - if (yyp0 < yyp1) + if (p0 < p1) return 3; - if (yyp0 > yyp1) + if (p0 > p1) return 2; return 0; } @@ -1272,6 +1302,10 @@ static void yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1, yyGLRStack* yystack) { + /* `Unused' warnings. */ + (void) yyx0; + (void) yyx1; + #if YYDEBUG YYFPRINTF (stderr, "Ambiguity detected.\n"); YYFPRINTF (stderr, "Option 1,\n"); @@ -1456,17 +1490,21 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk, static void yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) { - yySymbol* const yytokenp = yystack->yytokenp; + /* `Unused' warnings. */ + (void) yylvalp; + (void) yyllocp; if (yystack->yyerrState == 0) { #if YYERROR_VERBOSE - int yyn, yyx, yycount, yysize; - char* yyprefix; + yySymbol* const yytokenp = yystack->yytokenp; + int yyn, yyx, yycount; + size_t yysize; + const char* yyprefix; char* yyp; char* yymsg; yyn = yypact[yystack->yytops.yystates[0]->yylrState]; - if (yyn > YYFLAG && yyn < YYLAST) + if (YYPACT_NINF < yyn && yyn < YYLAST) { yycount = 0; /* Start YYX at -YYN if negative to avoid negative indexes in @@ -1476,7 +1514,7 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) yyprefix = ", expecting "; for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5; yyx += 1) - if (yycheck[yyx + yyn] == yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) yysize += strlen (yytokenName (yyx)) + strlen (yyprefix), yycount += 1, yyprefix = " or "; yymsg = yyp = (char*) malloc (yysize); @@ -1513,7 +1551,8 @@ static void yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) { yySymbol* const yytokenp = yystack->yytokenp; - int yyk, yyj; + size_t yyk; + int yyj; if (yystack->yyerrState == 0) yystack->yyerrState = 3; @@ -1531,7 +1570,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) *yytokenp = YYTRANSLATE (yychar); YYDPRINTF ((stderr, "Read token %s\n", yytokenName (*yytokenp))); yyj = yypact[yystack->yytops.yystates[0]->yylrState]; - if (yyj == YYFLAG) + if (yyj == YYPACT_NINF) /* Something's not right; we shouldn't be here */ yyFail (yystack, NULL); yyj += *yytokenp; @@ -1540,7 +1579,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0) return; } - else if (yytable[yyj] != 0 && yytable[yyj] != YYFLAG) + else if (yytable[yyj] != 0 && yytable[yyj] != YYTABLE_NINF) return; } while (yytrue); } @@ -1560,7 +1599,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp) while (yystack->yytops.yystates[0] != NULL) { yyj = yypact[yystack->yytops.yystates[0]->yylrState] + YYTERROR; - if (yyj != YYFLAG + YYTERROR && yyj >= 0 && yyj <= YYLAST && + if (yyj != YYPACT_NINF + YYTERROR && yyj >= 0 && yyj <= YYLAST && yycheck[yyj] == YYTERROR && yyisShiftAction (yytable[yyj])) { yyglrShift (yystack, 0, yytable[yyj], @@ -1720,21 +1759,23 @@ yyparse (YYPARSE_PARAM_ARG) } /* DEBUGGING ONLY */ +static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED; +static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED; -void -yypstates (yyGLRState* yyst) +static void +yy_yypstack (yyGLRState* yys) { - void yy_yypstack (yyGLRState* yys) + if (yys->yypred) { - if (yys->yypred == NULL) - fprintf (stderr, "%d@%d", yys->yylrState, yys->yyposn); - else - { - yy_yypstack (yys->yypred); - fprintf (stderr, " -> %d@%d", yys->yylrState, yys->yyposn); - } + yy_yypstack (yys->yypred); + fprintf (stderr, " -> "); } + fprintf (stderr, "%d@%lu", yys->yylrState, (unsigned long) yys->yyposn); +} +static void +yypstates (yyGLRState* yyst) +{ if (yyst == NULL) fprintf (stderr, ""); else @@ -1742,7 +1783,7 @@ yypstates (yyGLRState* yyst) fprintf (stderr, "\n"); } -void +static void yypstack (yyGLRStack* yystack, int yyk) { yypstates (yystack->yytops.yystates[yyk]); @@ -1752,35 +1793,37 @@ yypstack (yyGLRStack* yystack, int yyk) ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems) -void +static void yypdumpstack (yyGLRStack* yystack) { yyGLRStackItem* yyp; - int yyi; + size_t yyi; for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1) { - fprintf (stderr, "%3d. ", yyp - yystack->yyitems); + fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems)); if (*(bool*) yyp) { - fprintf (stderr, "Res: %d, LR State: %d, posn: %d, pred: %d", + fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld", yyp->yystate.yyresolved, yyp->yystate.yylrState, - yyp->yystate.yyposn, - YYINDEX(yyp->yystate.yypred)); + (unsigned long) yyp->yystate.yyposn, + (long) YYINDEX (yyp->yystate.yypred)); if (! yyp->yystate.yyresolved) - fprintf (stderr, ", firstVal: %d", - YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); + fprintf (stderr, ", firstVal: %ld", + (long) YYINDEX (yyp->yystate.yysemantics.yyfirstVal)); } else { - fprintf (stderr, "Option. rule: %d, state: %d, next: %d", - yyp->yyoption.yyrule, YYINDEX (yyp->yyoption.yystate), - YYINDEX (yyp->yyoption.yynext)); + fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld", + yyp->yyoption.yyrule, + (long) YYINDEX (yyp->yyoption.yystate), + (long) YYINDEX (yyp->yyoption.yynext)); } fprintf (stderr, "\n"); } fprintf (stderr, "Tops:"); for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1) - fprintf (stderr, "%d: %d; ", yyi, YYINDEX (yystack->yytops.yystates[yyi])); + fprintf (stderr, "%lu: %ld; ", (unsigned long) yyi, + (long) YYINDEX (yystack->yytops.yystates[yyi])); fprintf (stderr, "\n"); }