(struct yyGLRStack): yyerror_range now has 3 items,

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index e82282d426437a42db892bcac36ebc99a47cfa40..d99fc70ced8e6e975260d2f87d42cdc63bc669d3 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -205,13 +205,12 @@ typedef struct YYLTYPE
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 

-/* Default (constant) values used for initialization for null
+/* Default (constant) value used for initialization for null

    right-hand sides.  Unlike the standard yacc.c template,
    right-hand sides.  Unlike the standard yacc.c template,

-   here we set the default values of $$ and $@@ to zeroed-out
-   values.  Since the default value of these quantities is undefined,
-   this behavior is technically correct. */
+   here we set the default value of $$ to a zeroed-out value.
+   Since the default value is undefined, this behavior is
+   technically correct. */

 static YYSTYPE yyval_default;
 static YYSTYPE yyval_default;

-static YYLTYPE yyloc_default;

 
 /* Copy the second part of user declarations.  */
 ]b4_post_prologue[
 
 /* Copy the second part of user declarations.  */
 ]b4_post_prologue[


@@ -420,25 +419,50 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] =
 /* Error token number */
 #define YYTERROR 1
 
 /* Error token number */
 #define YYTERROR 1
 

-/* YYLLOC_DEFAULT -- Compute the default location (before the actions
-   are run).  */
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */

 
 ]b4_location_if([[
 
 ]b4_location_if([[

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

 #ifndef YYLLOC_DEFAULT
 #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)
+# define YYLLOC_DEFAULT(Current, Rhs, N)                               \
+    do                                                                 \
+      if (N)                                                           \
+       {                                                               \
+         (Current).first_line   = YYRHSLOC(Rhs, 1).first_line;         \
+         (Current).first_column = YYRHSLOC(Rhs, 1).first_column;       \
+         (Current).last_line    = YYRHSLOC(Rhs, N).last_line;          \
+         (Current).last_column  = YYRHSLOC(Rhs, N).last_column;        \
+       }                                                               \
+      else                                                             \
+       {                                                               \
+         (Current).first_line   = (Current).last_line   =              \
+           YYRHSLOC(Rhs, 0).last_line;                                 \
+         (Current).first_column = (Current).last_column =              \
+           YYRHSLOC(Rhs, 0).last_column;                               \
+       }                                                               \
+    while (0)
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+# define YY_LOCATION_PRINT(File, Loc)                  \
+    fprintf (File, "%d.%d-%d.%d",                      \
+             (Loc).first_line, (Loc).first_column,     \
+             (Loc).last_line,  (Loc).last_column)

 #endif
 ]],[
 #ifndef YYLLOC_DEFAULT
 #endif
 ]],[
 #ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) ((void) 0)
+# define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0)

 #endif
 ])[
 
 #endif
 ])[
 

+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#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)[


@@ -479,19 +503,13 @@ do {                                              \
 
 ]b4_yysymprint_generate([b4_c_ansi_function_def])[
 
 
 ]b4_yysymprint_generate([b4_c_ansi_function_def])[
 

-# define YYDSYMPRINT(Args)                     \
-do {                                           \
-  if (yydebug)                                 \
-    yysymprint Args;                           \
-} while (0)
-
-# define YYDSYMPRINTF(Title, Token, Value, Location)           \
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)         \

 do {                                                           \
   if (yydebug)                                                 \
     {                                                          \
       YYFPRINTF (stderr, "%s ", Title);                                \
       yysymprint (stderr,                                      \
 do {                                                           \
   if (yydebug)                                                 \
     {                                                          \
       YYFPRINTF (stderr, "%s ", Title);                                \
       yysymprint (stderr,                                      \

-                  Token, Value]b4_location_if([, Location])[); \
+                  Type, Value]b4_location_if([, Location])[);  \

       YYFPRINTF (stderr, "\n");                                        \
     }                                                          \
 } while (0)
       YYFPRINTF (stderr, "\n");                                        \
     }                                                          \
 } while (0)


@@ -502,10 +520,8 @@ int yydebug;
 
 #else /* !YYDEBUG */
 
 
 #else /* !YYDEBUG */
 

-  /* Avoid empty `if' bodies.  */

 # define YYDPRINTF(Args)
 # define YYDPRINTF(Args)

-# define YYDSYMPRINT(Args)
-# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)

 
 #endif /* !YYDEBUG */
 
 
 #endif /* !YYDEBUG */
 


@@ -596,6 +612,8 @@ union yyGLRStackItem {
 struct yyGLRStack {
   int yyerrflag;
   int yyerrState;
 struct yyGLRStack {
   int yyerrflag;
   int yyerrState;

+]b4_location_if([[  /* To compute the location of the error token.  */
+  yyGLRStackItem yyerror_range[3];]])[

 ]b4_pure_if(
 [
   int yyerrcnt;
 ]b4_pure_if(
 [
   int yyerrcnt;


@@ -687,7 +705,9 @@ yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
  *  yyerr for YYERROR, yyabort for YYABORT. */
 static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
  *  yyerr for YYERROR, yyabort for YYABORT. */
 static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,

-             YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack
+             YYSTYPE* yyvalp,
+             YYLTYPE* yylocp]b4_location_if(, [ ATTRIBUTE_UNUSED])[,
+             yyGLRStack* yystack

               ]b4_user_formals[)
 {
   yybool yynormal ATTRIBUTE_UNUSED = (yystack->yysplitPoint == NULL);
               ]b4_user_formals[)
 {
   yybool yynormal ATTRIBUTE_UNUSED = (yystack->yysplitPoint == NULL);


@@ -714,16 +734,10 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 
   yylow = 1;
   if (yyrhslen == 0)
 
   yylow = 1;
   if (yyrhslen == 0)

-    {
-      *yyvalp = yyval_default;
-      *yylocp = yyloc_default;
-    }
+    *yyvalp = yyval_default;

   else
   else

-    {
-      *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
-      YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen);
-    }
-
+    *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
+  YYLLOC_DEFAULT (*yylocp, yyvsp - yyrhslen, yyrhslen);

 ]
   switch (yyn)
     {
 ]
   switch (yyn)
     {


@@ -1568,7 +1582,7 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
              *yytokenp = YYTRANSLATE (yychar);
              YYDPRINTF ((stderr, "Reading a token: "));
              yychar = YYLEX;
              *yytokenp = YYTRANSLATE (yychar);

-             YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
+             YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);

            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 
            }
          yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
 


@@ -1586,11 +1600,11 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
 
          if (yyisShiftAction (yyaction))
            {
 
          if (yyisShiftAction (yyaction))
            {

-             YYDPRINTF ((stderr, "Shifting token %s on stack %d, ",
-                         yytokenName (*yytokenp), yyk));
+             YYDPRINTF ((stderr, "On stack %d, ", yyk));
+             YY_SYMBOL_PRINT ("shifting", *yytokenp, yylvalp, yyllocp);

              yyglrShift (yystack, yyk, yyaction, yyposn+1,
                          *yylvalp, yyllocp]b4_user_args[);
              yyglrShift (yystack, yyk, yyaction, yyposn+1,
                          *yylvalp, yyllocp]b4_user_args[);

-             YYDPRINTF ((stderr, "which is now in state #%d\n",
+             YYDPRINTF ((stderr, ", now in state #%d\n",

                          yystack->yytops.yystates[yyk]->yylrState));
              break;
            }
                          yystack->yytops.yystates[yyk]->yylrState));
              break;
            }


@@ -1689,7 +1703,9 @@ yyreportSyntaxError (yyGLRStack* yystack,
    value, and location of the look-ahead.  */
 static void
 yyrecoverSyntaxError (yyGLRStack* yystack,
    value, and location of the look-ahead.  */
 static void
 yyrecoverSyntaxError (yyGLRStack* yystack,

-                     YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
+                     YYSTYPE* yylvalp,
+                     YYLTYPE* yyllocp]b4_location_if(, [ ATTRIBUTE_UNUSED])[
+                     ]b4_user_formals[)

 {
   yySymbol* const yytokenp = yystack->yytokenp;
   size_t yyk;
 {
   yySymbol* const yytokenp = yystack->yytokenp;
   size_t yyk;


@@ -1706,10 +1722,9 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
            while (yystack->yytops.yystates[0] != NULL)
              {
                yyGLRState *yys = yystack->yytops.yystates[0];
            while (yystack->yytops.yystates[0] != NULL)
              {
                yyGLRState *yys = yystack->yytops.yystates[0];

-               YYDSYMPRINTF ("Error: popping",
-                             yystos[yys->yylrState],
-                             &yys->yysemantics.yysval, &yys->yyloc);
-               yydestruct (yystos[yys->yylrState],
+]b4_location_if([[             yystack->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
+               yydestruct ("Error: popping",
+                            yystos[yys->yylrState],

                            &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
                yystack->yytops.yystates[0] = yys->yypred;
                yystack->yynextFree -= 1;
                            &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
                yystack->yytops.yystates[0] = yys->yypred;
                yystack->yynextFree -= 1;


@@ -1718,14 +1733,21 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
            yyFail (yystack][]b4_lpure_args[, NULL);
          }
        if (*yytokenp != YYEMPTY)
            yyFail (yystack][]b4_lpure_args[, NULL);
          }
        if (*yytokenp != YYEMPTY)

-         {
-           YYDSYMPRINTF ("Error: discarding", *yytokenp, yylvalp, yyllocp);
-           yydestruct (*yytokenp, yylvalp]b4_location_if([, yyllocp])[);
+         {]b4_location_if([[
+           /* We throw away the lookahead, but the error range
+              of the shifted error token must take it into account. */
+           yyGLRState *yys = yystack->yytops.yystates[0];
+           yyGLRStackItem yyerror_range[3];
+           yyerror_range[1].yystate.yyloc = yys->yyloc;
+           yyerror_range[2].yystate.yyloc = *yyllocp;
+           YYLLOC_DEFAULT (yys->yyloc, yyerror_range, 2);]])[
+           yydestruct ("Error: discarding",
+                       *yytokenp, yylvalp]b4_location_if([, yyllocp])[);

          }
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);
          }
        YYDPRINTF ((stderr, "Reading a token: "));
        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);

-       YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
+       YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);

        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          return;
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        if (yyis_pact_ninf (yyj))
          return;


@@ -1762,16 +1784,21 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
          if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
              && yyisShiftAction (yytable[yyj]))
            {
          if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
              && yyisShiftAction (yytable[yyj]))
            {

-             YYDPRINTF ((stderr, "Shifting error token, "));
+             /* Shift the error token having adjusted its location.  */
+             YYLTYPE yyerrloc;]b4_location_if([[
+             yystack->yyerror_range[2].yystate.yyloc = *yyllocp;
+             YYLLOC_DEFAULT (yyerrloc, yystack->yyerror_range, 2);]])[
+             YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
+                              yylvalp, &yyerrloc);

              yyglrShift (yystack, 0, yytable[yyj],
              yyglrShift (yystack, 0, yytable[yyj],

-                         yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
+                         yys->yyposn, *yylvalp, &yyerrloc]b4_user_args[);
+             yys = yystack->yytops.yystates[0];

              break;
            }
        }
              break;
            }
        }

-      YYDSYMPRINTF ("Error: popping",
-                   yystos[yys->yylrState],
-                   &yys->yysemantics.yysval, &yys->yyloc);
-      yydestruct (yystos[yys->yylrState],
+]b4_location_if([[      yystack->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
+      yydestruct ("Error: popping",
+                 yystos[yys->yylrState],

                  &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
       yystack->yytops.yystates[0] = yys->yypred;
       yystack->yynextFree -= 1;
                  &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
       yystack->yytops.yystates[0] = yys->yypred;
       yystack->yynextFree -= 1;


@@ -1826,7 +1853,24 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
   if (setjmp (yystack.yyexception_buffer) != 0)
     goto yyDone;
 
   if (setjmp (yystack.yyexception_buffer) != 0)
     goto yyDone;
 

-  yyglrShift (&yystack, 0, 0, 0, yyval_default, &yyloc_default]b4_user_args[);
+  yylval = yyval_default;
+]b4_location_if([
+#if YYLTYPE_IS_TRIVIAL
+  yylloc.first_line   = yylloc.last_line   = 1;
+  yylloc.first_column = yylloc.last_column = 0;
+#endif
+])
+m4_ifdef([b4_initial_action], [
+m4_pushdef([b4_at_dollar],     [yylval])dnl
+m4_pushdef([b4_dollar_dollar], [yylloc])dnl
+  /* User initialization code. */
+  b4_initial_action
+m4_popdef([b4_dollar_dollar])dnl
+m4_popdef([b4_at_dollar])dnl
+/* Line __line__ of glr.c.  */
+b4_syncline([@oline@], [@ofile@])])dnl
+[
+  yyglrShift (&yystack, 0, 0, 0, yylval, &yylloc]b4_user_args[);

   yytoken = YYEMPTY;
   yyposn = 0;
 
   yytoken = YYEMPTY;
   yyposn = 0;
 


@@ -1851,6 +1895,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {
              yyrule = yydefaultAction (yystate);
              if (yyrule == 0)
                {

+]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = *yyllocp;]])[

                  yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
                  goto yyuser_error;
                }
                  yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
                  goto yyuser_error;
                }


@@ -1863,15 +1908,14 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                  YYDPRINTF ((stderr, "Reading a token: "));
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);

-                  YYDSYMPRINTF ("Next token is", yytoken, yylvalp, yyllocp);
+                  YY_SYMBOL_PRINT ("Next token is", yytoken, yylvalp, yyllocp);

                }
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                break;
              if (yyisShiftAction (yyaction))
                {
                }
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
              if (*yyconflicts != 0)
                break;
              if (yyisShiftAction (yyaction))
                {

-                 YYDPRINTF ((stderr, "Shifting token %s, ",
-                             yytokenName (yytoken)));
+                 YY_SYMBOL_PRINT ("Shifting", yytoken, yylvalp, yyllocp);

                  if (yytoken != YYEOF)
                    yytoken = YYEMPTY;
                  yyposn += 1;
                  if (yytoken != YYEOF)
                    yytoken = YYEMPTY;
                  yyposn += 1;


@@ -1882,6 +1926,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
                }
              else if (yyisErrorAction (yyaction))
                {
                }
              else if (yyisErrorAction (yyaction))
                {

+]b4_location_if([[               yystack.yyerror_range[1].yystate.yyloc = *yyllocp;]])[

                  yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
                  goto yyuser_error;
                }
                  yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
                  goto yyuser_error;
                }


@@ -1907,6 +1952,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
                yyFail (&yystack][]b4_lpure_args[, "syntax error");
              YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
              YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
                yyFail (&yystack][]b4_lpure_args[, "syntax error");
              YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
              YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));

+]b4_location_if([[           yystack.yyerror_range[1].yystate.yyloc = *yyllocp;]])[

              yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
              goto yyuser_error;
            }
              yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
              goto yyuser_error;
            }


@@ -1924,7 +1970,10 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
       yyposn = yystack.yytops.yystates[0]->yyposn;
     }
  yyDone:
       yyposn = yystack.yytops.yystates[0]->yyposn;
     }
  yyDone:

-  ;
+  /* On YYABORT, free the lookahead. */
+  if (yystack.yyerrflag == 1 && yytoken != YYEMPTY)
+    yydestruct ("Error: discarding lookahead",
+                yytoken, yylvalp]b4_location_if([, yyllocp])[);

 
   yyfreeGLRStack (&yystack);
   return yystack.yyerrflag;
 
   yyfreeGLRStack (&yystack);
   return yystack.yyerrflag;


@@ -2039,7 +2088,7 @@ b4_location_if([
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 

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

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