03-traces-alike.patch

[Akim Demaille]

Index: ChangeLog
from  Akim Demaille  <address@hidden>
        Augment the similarity between GLR and LALR traces.
        
        * data/yacc.c (yy_stack_print, YY_STACK_PRINT, yy_reduce_print)
        (YY_REDUCE_PRINT): New.
        (yyparse): Use them.
        * data/glr.c (yy_reduce_print): Use YYFPRINTF, no need for
        YYDPRINT here.
        (yyglrReduce, yyrecoverParseError, yyparse): Don't report the
        state reached after the reduction/recovery, since...
        (yyparse, yyprocessOneStack): Report the state we are entering in.
        
        
Index: data/yacc.c
--- data/yacc.c Sat, 16 Nov 2002 13:08:33 +0100 akim
+++ data/yacc.c Sat, 16 Nov 2002 13:24:21 +0100 akim
@@ -547,6 +547,50 @@ m4_define([b4_rhs_location],
     }                                                          \
 } 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;
@@ -554,8 +598,11 @@ m4_define([b4_rhs_location],
 # 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[
@@ -936,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 by 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
@@ -965,16 +996,7 @@ yyreduce:
   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;])[
@@ -1111,17 +1133,7 @@ yyerrlab1:
       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)
Index: data/glr.c
--- data/glr.c Sat, 16 Nov 2002 09:33:15 +0100 akim
+++ data/glr.c Sat, 16 Nov 2002 13:21:53 +0100 akim
@@ -1106,8 +1106,8 @@ m4_define([b4_rhs_location],
 yy_reduce_print (size_t yyk, yyRuleNum yyrule)
 {
   int yyi;
-  YYDPRINTF ((stderr, "Reducing stack %d by rule %d (line %d), ",
-             yyk, yyrule - 1, yyrline[yyrule]));
+  YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %d), ",
+            yyk, yyrule - 1, yyrline[yyrule]);
   /* Print the symbols being reduced, and their result.  */
   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
     YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));
@@ -1143,8 +1143,6 @@ m4_define([b4_rhs_location],
                  yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
                                 yylhsNonterm (yyrule)),
                  yyposn, yysval, &yyloc]b4_user_args[);
-      YYDPRINTF ((stderr, "Stack %d entering state %d\n",
-                 yyk, yystack->yytops.yystates[yyk]->yylrState));
     }
   else
     {
@@ -1512,6 +1510,7 @@ m4_define([b4_rhs_location],
   while (yystack->yytops.yystates[yyk] != NULL)
     {
       yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState;
+      YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate));
 
       assert (yystate != YYFINAL);
       if (yyisDefaultedState (yystate))
@@ -1711,8 +1710,6 @@ m4_define([b4_rhs_location],
              YYDPRINTF ((stderr, "Shifting error token, "));
              yyglrShift (yystack, 0, yytable[yyj],
                          yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
-             YYDPRINTF ((stderr, "Entering state %d\n",
-                         yystack->yytops.yystates[0]->yylrState));
              break;
            }
        }
@@ -1783,7 +1780,6 @@ m4_define([b4_rhs_location],
       /* For efficiency, we have two loops, the first of which is
         specialized to deterministic operation (single stack, no
         potential ambiguity).  */
-
       /* Standard mode */
       while (yytrue)
        {
@@ -1792,6 +1788,7 @@ m4_define([b4_rhs_location],
          const short* yyconflicts;
 
          yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
+          YYDPRINTF ((stderr, "Entering state %d\n", yystate));
          if (yystate == YYFINAL)
            goto yyDone;
          if (yyisDefaultedState (yystate))
@@ -1827,8 +1824,6 @@ m4_define([b4_rhs_location],
                              yylval, yyllocp]b4_user_args[);
                  if (0 < yystack.yyerrState)
                    yystack.yyerrState -= 1;
-                 YYDPRINTF ((stderr, "Entering state %d\n",
-                             yystack.yytops.yystates[0]->yylrState));
                }
              else if (yyisErrorAction (yyaction))
                {