Upgrade to today's gnulib.

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index d2cdd77b5180059073c4894b2071dfa538438259..5d5455534ec84ce77be8a283b39aed244aafbf0d 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -192,10 +192,12 @@ b4_syncline([@oline@], [@ofile@])],
 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
 typedef struct YYLTYPE
 {
 #if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
 typedef struct YYLTYPE
 {

+]b4_location_if([

   int first_line;
   int first_column;
   int last_line;
   int last_column;
   int first_line;
   int first_column;
   int last_line;
   int last_column;

+])[

 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1


@@ -254,6 +256,9 @@ b4_syncline([@oline@], [@ofile@])
 #define YYNSTATES  ]b4_states_number[
 /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
 #define YYMAXRHS ]b4_r2_max[
 #define YYNSTATES  ]b4_states_number[
 /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
 #define YYMAXRHS ]b4_r2_max[

+/* YYMAXLEFT -- Maximum number of symbols to the left of a handle
+   accessed by $0, $-1, etc., in any rule. */
+#define YYMAXLEFT ]b4_max_left_semantic_context[

 
 /* YYTRANSLATE(X) -- Bison symbol number corresponding to X.  */
 #define YYUNDEFTOK  ]b4_undef_token_number[
 
 /* YYTRANSLATE(X) -- Bison symbol number corresponding to X.  */
 #define YYUNDEFTOK  ]b4_undef_token_number[


@@ -402,15 +407,22 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] =
 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
    are run).  */
 
 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
    are run).  */
 

-#define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc)
+]b4_location_if([[
+#define YYRHSLOC(yyRhs,YYK) ((yyRhs)[YYK].yystate.yyloc)

 
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)                 \
 
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)                 \

-  yyCurrent.first_line   = YYRHSLOC(yyRhs,1).first_line;       \
-  yyCurrent.first_column = YYRHSLOC(yyRhs,1).first_column;     \
-  yyCurrent.last_line    = YYRHSLOC(yyRhs,YYN).last_line;      \
-  yyCurrent.last_column  = YYRHSLOC(yyRhs,YYN).last_column;
+  (yyCurrent).first_line   = YYRHSLOC(yyRhs,1).first_line;     \
+  (yyCurrent).first_column = YYRHSLOC(yyRhs,1).first_column;   \
+  (yyCurrent).last_line    = YYRHSLOC(yyRhs,YYN).last_line;    \
+  (yyCurrent).last_column  = YYRHSLOC(yyRhs,YYN).last_column;
+#endif
+]],[
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) 

 #endif
 #endif

+])[
+

 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[


@@ -510,7 +522,8 @@ int yydebug;
 
 #if (! defined (YYSTACKEXPANDABLE) \
      && (! defined (__cplusplus) \
 
 #if (! defined (YYSTACKEXPANDABLE) \
      && (! defined (__cplusplus) \

-        || (]b4_location_if([YYLTYPE_IS_TRIVIAL && ])[YYSTYPE_IS_TRIVIAL)))
+        || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
+            && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))

 #define YYSTACKEXPANDABLE 1
 #else
 #define YYSTACKEXPANDABLE 0
 #define YYSTACKEXPANDABLE 1
 #else
 #define YYSTACKEXPANDABLE 0


@@ -613,14 +626,15 @@ yytokenName (yySymbol yytoken)
 
 /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting
  *  at YYVSP[YYLOW0].yystate.yypred.  Leaves YYVSP[YYLOW1].yystate.yypred
 
 /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting
  *  at YYVSP[YYLOW0].yystate.yypred.  Leaves YYVSP[YYLOW1].yystate.yypred

- *  containing the pointer to the next state in the chain. Assumes 
- *  YYLOW1 < YYLOW0.  For convenience, returns YYLOW1. */
-static int
-yyfill (yyGLRStackItem* yyvsp, int yylow0, int yylow1) 
+ *  containing the pointer to the next state in the chain. Assumes
+ *  YYLOW1 < YYLOW0.  */
+static void yyfillin (yyGLRStackItem *, int, int) ATTRIBUTE_UNUSED;
+static void
+yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)

 {
   yyGLRState* s;
   int i;
 {
   yyGLRState* s;
   int i;

-  s = yyvsp[yylow0].yystate.yypred; 
+  s = yyvsp[yylow0].yystate.yypred;

   for (i = yylow0-1; i >= yylow1; i -= 1)
     {
       if (! s->yyresolved)
   for (i = yylow0-1; i >= yylow1; i -= 1)
     {
       if (! s->yyresolved)


@@ -630,6 +644,21 @@ yyfill (yyGLRStackItem* yyvsp, int yylow0, int yylow1)
       yyvsp[i].yystate.yyloc = s->yyloc;
       s = yyvsp[i].yystate.yypred = s->yypred;
     }
       yyvsp[i].yystate.yyloc = s->yyloc;
       s = yyvsp[i].yystate.yypred = s->yypred;
     }

+}
+
+/* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1.  Otherwise, fill in
+   YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
+   For convenience, always return YYLOW1.  */
+static inline int yyfill (yyGLRStackItem *, int *, int, yybool)
+     ATTRIBUTE_UNUSED;
+static inline int
+yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
+{
+  if (!yynormal && yylow1 < *yylow)
+    {
+      yyfillin (yyvsp, *yylow, yylow1);
+      *yylow = yylow1;
+    }

   return yylow1;
 }
 
   return yylow1;
 }
 


@@ -643,19 +672,9 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack
               ]b4_user_formals[)
 {
              YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack
               ]b4_user_formals[)
 {

-  int yynormal = (yystack->yysplitPoint == NULL);
+  yybool yynormal ATTRIBUTE_UNUSED = (yystack->yysplitPoint == NULL);

   int yylow;
 
   int yylow;
 

-  if (yyrhslen == 0)
-    {
-      *yyvalp = yyval_default;
-      *yylocp = yyloc_default;
-    }
-  else
-    {
-      *yyvalp = yyvsp[1-yyrhslen].yystate.yysemantics.yysval;
-      *yylocp = yyvsp[1-yyrhslen].yystate.yyloc;
-    }

 # undef yyerrok
 # define yyerrok (yystack->yyerrState = 0)
 # undef YYACCEPT
 # undef yyerrok
 # define yyerrok (yystack->yyerrState = 0)
 # undef YYACCEPT


@@ -663,14 +682,13 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # undef YYABORT
 # define YYABORT return yyabort
 # undef YYERROR
 # undef YYABORT
 # define YYABORT return yyabort
 # undef YYERROR

-# define YYERROR return yyerr
+# define YYERROR do { yystack->yyerrState = 0; return yyerr; } while (0)

 # undef YYRECOVERING
 # define YYRECOVERING (yystack->yyerrState != 0)
 # undef yyclearin
 # define yyclearin (yychar = *(yystack->yytokenp) = YYEMPTY)
 # undef YYFILL
 # undef YYRECOVERING
 # define YYRECOVERING (yystack->yyerrState != 0)
 # undef yyclearin
 # define yyclearin (yychar = *(yystack->yytokenp) = YYEMPTY)
 # undef YYFILL

-# define YYFILL(N)                                                          \
-  ((yynormal || yylow <= (N)) ? (N) : (yylow = yyfill (yyvsp, yylow, N)))
+# define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)

 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \
   do {                                                                      \
 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \
   do {                                                                      \


@@ -678,14 +696,25 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
     YYERROR;                                                                \
   } while (0)
 
     YYERROR;                                                                \
   } while (0)
 

+  yylow = 1;
+  if (yyrhslen == 0)
+    {
+      *yyvalp = yyval_default;
+      *yylocp = yyloc_default;
+    }
+  else
+    {
+      *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
+      YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen);
+    }
+

 ]
 ]

-   yylow = 1;
-   switch (yyn)
-     {
-       b4_actions
-     }
+  switch (yyn)
+    {
+      b4_actions
+    }

 
 

-   return yyok;
+  return yyok;

 # undef yyerrok
 # undef YYABORT
 # undef YYACCEPT
 # undef yyerrok
 # undef YYABORT
 # undef YYACCEPT


@@ -926,7 +955,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
 
 #else
 
 
 #else
 

-  yyFail (yystack][]b4_lpure_args[, "parser stack overflow");
+  yyFail (yystack][]b4_pure_args[, "parser stack overflow");

 #endif
 }
 
 #endif
 }
 


@@ -1022,7 +1051,7 @@ yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn,
 }
 
 /** Shift stack #K of YYSTACK, to a new state corresponding to LR
 }
 
 /** Shift stack #K of YYSTACK, to a new state corresponding to LR

- *  state YYLRSTATE, at input position YYPOSN, with the (unresolved) 
+ *  state YYLRSTATE, at input position YYPOSN, with the (unresolved)

  *  semantic value of YYRHS under the action for YYRULE. */
 static inline void
 yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
  *  semantic value of YYRHS under the action for YYRULE. */
 static inline void
 yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,


@@ -1064,16 +1093,6 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
       yystack->yynextFree -= yynrhs;
       yystack->yyspaceLeft += yynrhs;
       yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate;
       yystack->yynextFree -= yynrhs;
       yystack->yyspaceLeft += yynrhs;
       yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate;

-      if (yynrhs == 0)
-       {
-         *yyvalp = yyval_default;
-         *yylocp = yyloc_default;
-       }
-      else
-       {
-         *yyvalp = rhs[1-yynrhs].yystate.yysemantics.yysval;
-         *yylocp = rhs[1-yynrhs].yystate.yyloc;
-       }

       return yyuserAction (yyrule, yynrhs, rhs,
                           yyvalp, yylocp, yystack]b4_user_args[);
     }
       return yyuserAction (yyrule, yynrhs, rhs,
                           yyvalp, yylocp, yystack]b4_user_args[);
     }


@@ -1081,8 +1100,9 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
     {
       int yyi;
       yyGLRState* yys;
     {
       int yyi;
       yyGLRState* yys;

-      yyGLRStackItem yyrhsVals[YYMAXRHS+1];
-      yys = yyrhsVals[YYMAXRHS].yystate.yypred = yystack->yytops.yystates[yyk];
+      yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
+      yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred 
+       = yystack->yytops.yystates[yyk];

       for (yyi = 0; yyi < yynrhs; yyi += 1)
        {
          yys = yys->yypred;
       for (yyi = 0; yyi < yynrhs; yyi += 1)
        {
          yys = yys->yypred;


@@ -1091,17 +1111,7 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
        }
       yyupdateSplit (yystack, yys);
       yystack->yytops.yystates[yyk] = yys;
        }
       yyupdateSplit (yystack, yys);
       yystack->yytops.yystates[yyk] = yys;

-      if (yynrhs == 0)
-       {
-         *yyvalp = yyval_default;
-         *yylocp = yyloc_default;
-       }
-      else
-       {
-         *yyvalp = yyrhsVals[1].yystate.yysemantics.yysval;
-         *yylocp = yyrhsVals[1].yystate.yyloc;
-       }
-      return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS - 1,
+      return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,

                           yyvalp, yylocp, yystack]b4_user_args[);
     }
 }
                           yyvalp, yylocp, yystack]b4_user_args[);
     }
 }


@@ -1332,13 +1342,14 @@ static YYRESULTTAG
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {
 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
                 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
 {

-  yyGLRStackItem yyrhsVals[YYMAXRHS+1];
+  yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];

   int yynrhs;
 
   yynrhs = yyrhsLength (yyopt->yyrule);
   YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[));
   int yynrhs;
 
   yynrhs = yyrhsLength (yyopt->yyrule);
   YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[));

-  yyrhsVals[YYMAXRHS].yystate.yypred = yyopt->yystate;
-  return yyuserAction (yyopt->yyrule, yynrhs, yyrhsVals + YYMAXRHS - 1,
+  yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;
+  return yyuserAction (yyopt->yyrule, yynrhs, 
+                      yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,

                       yyvalp, yylocp, yystack]b4_user_args[);
 }
 
                       yyvalp, yylocp, yystack]b4_user_args[);
 }
 


@@ -1597,29 +1608,28 @@ yyreportSyntaxError (yyGLRStack* yystack,
 #if YYERROR_VERBOSE
       yySymbol* const yytokenp = yystack->yytokenp;
       int yyn;
 #if YYERROR_VERBOSE
       yySymbol* const yytokenp = yystack->yytokenp;
       int yyn;

-      const char* yyprefix;

       yyn = yypact[yystack->yytops.yystates[0]->yylrState];
       if (YYPACT_NINF < yyn && yyn < YYLAST)
        {
          size_t yysize = 0;
       yyn = yypact[yystack->yytops.yystates[0]->yylrState];
       if (YYPACT_NINF < yyn && yyn < YYLAST)
        {
          size_t yysize = 0;

+         const char* yyprefix;

          char* yymsg;
          int yyx;
 
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */
          char* yymsg;
          int yyx;
 
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  */

-         int yyxbase = yyn < 0 ? -yyn : 0;
+         int yyxbegin = yyn < 0 ? -yyn : 0;

 
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn;
 
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn;

-         int yynsyms = sizeof (yytname) / sizeof (yytname[0]);
-         int yyxlim = yychecklim < yynsyms ? yychecklim : yynsyms;
+         int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;

          int yycount = 0;
 
          yyprefix = ", expecting ";
          int yycount = 0;
 
          yyprefix = ", expecting ";

-         for (yyx = yyxbase; yyx < yyxlim && yycount < 5; yyx += 1)
+         for (yyx = yyxbegin; yyx < yyxend; ++yyx)

            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              {
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              {

-               yysize += strlen (yytokenName (yyx)) + strlen (yyprefix);
+               yysize += strlen (yyprefix) + strlen (yytokenName (yyx));

                yycount += 1;
                if (yycount == 5)
                  {
                yycount += 1;
                if (yycount == 5)
                  {


@@ -1640,7 +1650,7 @@ yyreportSyntaxError (yyGLRStack* yystack,
              if (yycount < 5)
                {
                  yyprefix = ", expecting ";
              if (yycount < 5)
                {
                  yyprefix = ", expecting ";

-                 for (yyx = yyxbase; yyx < yyxlim; yyx += 1)
+                 for (yyx = yyxbegin; yyx < yyxend; ++yyx)

                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
                      {
                        sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx));
                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
                      {
                        sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx));


@@ -1672,17 +1682,14 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
   size_t yyk;
   int yyj;
 
   size_t yyk;
   int yyj;
 

-  if (yystack->yyerrState == 0)
-    yystack->yyerrState = 3;
-  else if (yystack->yyerrState == 3)
+  if (yystack->yyerrState == 3)

     /* We just shifted the error token and (perhaps) took some
        reductions.  Skip tokens until we can proceed.  */
     while (yytrue)
       {
        if (*yytokenp == YYEOF)
          {
     /* We just shifted the error token and (perhaps) took some
        reductions.  Skip tokens until we can proceed.  */
     while (yytrue)
       {
        if (*yytokenp == YYEOF)
          {

-           /* Now pop stack until we find a state that shifts the
-              error token.  */
+           /* Now pop stack until empty and fail. */

            while (yystack->yytops.yystates[0] != NULL)
              {
                yyGLRState *yys = yystack->yytops.yystates[0];
            while (yystack->yytops.yystates[0] != NULL)
              {
                yyGLRState *yys = yystack->yytops.yystates[0];


@@ -1708,8 +1715,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
        YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
        YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))

-         /* Something's not right; we shouldn't be here.  */
-         yyFail (yystack][]b4_lpure_args[, NULL);
+         return;

        yyj += *yytokenp;
        if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp)
          {
        yyj += *yytokenp;
        if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp)
          {


@@ -1732,6 +1738,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
   yycompressStack (yystack);
 
   /* Now pop stack until we find a state that shifts the error token. */
   yycompressStack (yystack);
 
   /* Now pop stack until we find a state that shifts the error token. */

+  yystack->yyerrState = 3;

   while (yystack->yytops.yystates[0] != NULL)
     {
       yyGLRState *yys = yystack->yytops.yystates[0];
   while (yystack->yytops.yystates[0] != NULL)
     {
       yyGLRState *yys = yystack->yytops.yystates[0];


@@ -2001,20 +2008,21 @@ b4_syncline([@oline@], [@ofile@])],
 b4_pure_if([],
 [extern YYSTYPE b4_prefix[]lval;])
 
 b4_pure_if([],
 [extern YYSTYPE b4_prefix[]lval;])
 

-b4_location_if(
-[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
+#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)

 typedef struct YYLTYPE
 {
 typedef struct YYLTYPE
 {

+b4_location_if([

   int first_line;
   int first_column;
   int last_line;
   int last_column;
   int first_line;
   int first_column;
   int last_line;
   int last_column;

+])

 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 

-m4_if(b4_pure, [0],
+b4_location_if([m4_if(b4_pure, [0],

 [extern YYLTYPE b4_prefix[]lloc;])
 ])
 ])
 [extern YYLTYPE b4_prefix[]lloc;])
 ])
 ])