* data/lalr1.cc: Move towards a more standard C++ coding style

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index 586da61eda34ad5114d7ab756d2db8ed547fd7f0..0e569841b32e2a2dcbc93007717d97514ed6b5a7 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -60,7 +60,7 @@ m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 
 # b4_lyyerror_args
 # ----------------
 
 # b4_lyyerror_args
 # ----------------

-# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
+# Same as above, but on the look-ahead, hence yyllocp instead of yylocp.

 m4_define([b4_lyyerror_args],
 [b4_pure_if([b4_location_if([yyllocp, ])])dnl
 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
 m4_define([b4_lyyerror_args],
 [b4_pure_if([b4_location_if([yyllocp, ])])dnl
 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])


@@ -82,14 +82,14 @@ m4_define([b4_pure_formals],
 
 # b4_lpure_args
 # -------------
 
 # b4_lpure_args
 # -------------

-# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
+# Same as above, but on the look-ahead, hence yyllocp instead of yylocp.

 m4_define([b4_lpure_args],
 [b4_pure_if([b4_location_if([, yyllocp])])[]b4_user_args])
 
 
 # b4_lpure_formals
 # ----------------
 m4_define([b4_lpure_args],
 [b4_pure_if([b4_location_if([, yyllocp])])[]b4_user_args])
 
 
 # b4_lpure_formals
 # ----------------

-# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
+# Same as above, but on the look-ahead, hence yyllocp instead of yylocp.

 m4_define([b4_lpure_formals],
 [b4_pure_if([b4_location_if([YYLTYPE *yyllocp])])[]b4_user_formals])
 
 m4_define([b4_lpure_formals],
 [b4_pure_if([b4_location_if([YYLTYPE *yyllocp])])[]b4_user_formals])
 


@@ -137,7 +137,7 @@ m4_define([b4_rhs_location],
 m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@
 m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@

-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003, 2004])

 [
 /* This is the parser code for GLR (Generalized LR) parser. */
 
 [
 /* This is the parser code for GLR (Generalized LR) parser. */
 


@@ -158,7 +158,7 @@ m4_if(b4_prefix[], [yy], [],
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs

-b4_location_if([#define yylloc b4_prefix[]lloc])])
+#define yylloc b4_prefix[]lloc])

 
 b4_token_defines(b4_tokens)
 
 
 b4_token_defines(b4_tokens)
 


@@ -282,7 +282,7 @@ b4_syncline([@oline@], [@ofile@])
 
 #define YYTRANSLATE(YYX)                                               \
   ((YYX <= 0) ? YYEOF :                                                        \
 
 #define YYTRANSLATE(YYX)                                               \
   ((YYX <= 0) ? YYEOF :                                                        \

-   (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+   (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =


@@ -394,9 +394,9 @@ static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] =
 /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
    0, pointed into by YYCONFLP.  */
 ]dnl Do not use b4_int_type_for here, since there are places where
 /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
    0, pointed into by YYCONFLP.  */
 ]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 pointers onto yyconfl are taken, which type is "short int *".

 dnl We probably ought to introduce a type for confl.
 dnl We probably ought to introduce a type for confl.

-[static const short yyconfl[] =
+[static const short int yyconfl[] =

 {
   ]b4_conflicting_rules[
 };
 {
   ]b4_conflicting_rules[
 };


@@ -420,18 +420,26 @@ 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].  */

 
 ]b4_location_if([[
 #define YYRHSLOC(yyRhs,YYK) ((yyRhs)[YYK].yystate.yyloc)
 
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)                 \
 
 ]b4_location_if([[
 #define YYRHSLOC(yyRhs,YYK) ((yyRhs)[YYK].yystate.yyloc)
 
 #ifndef YYLLOC_DEFAULT
 # define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)                 \

-   ((yyCurrent).first_line = YYRHSLOC(yyRhs, 1).first_line,    \
+   ((yyCurrent).first_line   = YYRHSLOC(yyRhs, 1).first_line,  \

     (yyCurrent).first_column = YYRHSLOC(yyRhs, 1).first_column,        \
     (yyCurrent).first_column = YYRHSLOC(yyRhs, 1).first_column,        \

-    (yyCurrent).last_line = YYRHSLOC(yyRhs, YYN).last_line,    \
+    (yyCurrent).last_line    = YYRHSLOC(yyRhs, YYN).last_line, \

     (yyCurrent).last_column  = YYRHSLOC(yyRhs, YYN).last_column)
     (yyCurrent).last_column  = YYRHSLOC(yyRhs, YYN).last_column)

+
+/* 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


@@ -439,6 +447,10 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] =
 #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 +491,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 +508,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 */
 


@@ -552,10 +556,10 @@ typedef int yyStateNum;
 typedef int yyRuleNum;
 
 /** Grammar symbol */
 typedef int yyRuleNum;
 
 /** Grammar symbol */

-typedef short yySymbol;
+typedef short int yySymbol;

 
 /** Item references, as in LALR(1) machine */
 
 /** Item references, as in LALR(1) machine */

-typedef short yyItemNum;
+typedef short int yyItemNum;

 
 typedef struct yyGLRState yyGLRState;
 typedef struct yySemanticOption yySemanticOption;
 
 typedef struct yyGLRState yyGLRState;
 typedef struct yySemanticOption yySemanticOption;


@@ -716,7 +720,7 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
   if (yyrhslen == 0)
     {
       *yyvalp = yyval_default;
   if (yyrhslen == 0)
     {
       *yyvalp = yyval_default;

-      *yylocp = yyloc_default;
+      *yylocp = yyvsp[0].yystate.yyloc;

     }
   else
     {
     }
   else
     {


@@ -809,7 +813,7 @@ yydefaultAction (yyStateNum yystate)
  */
 static inline void
 yygetLRActions (yyStateNum yystate, int yytoken,
  */
 static inline void
 yygetLRActions (yyStateNum yystate, int yytoken,

-               int* yyaction, const short** yyconflicts)
+               int* yyaction, const short int** yyconflicts)

 {
   int yyindex = yypact[yystate] + yytoken;
   if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
 {
   int yyindex = yypact[yystate] + yytoken;
   if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)


@@ -1539,7 +1543,7 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
                  ]b4_user_formals[)
 {
   int yyaction;
                  ]b4_user_formals[)
 {
   int yyaction;

-  const short* yyconflicts;
+  const short int* yyconflicts;

   yyRuleNum yyrule;
   yySymbol* const yytokenp = yystack->yytokenp;
 
   yyRuleNum yyrule;
   yySymbol* const yytokenp = yystack->yytokenp;
 


@@ -1568,7 +1572,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 +1590,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;
            }


@@ -1686,7 +1690,7 @@ yyreportSyntaxError (yyGLRStack* yystack,
 
 /* Recover from a syntax error on YYSTACK, assuming that YYTOKENP,
    YYLVALP, and YYLLOCP point to the syntactic category, semantic
 
 /* Recover from a syntax error on YYSTACK, assuming that YYTOKENP,
    YYLVALP, and YYLLOCP point to the syntactic category, semantic

-   value, and location of the lookahead.  */
+   value, and location of the look-ahead.  */

 static void
 yyrecoverSyntaxError (yyGLRStack* yystack,
                      YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
 static void
 yyrecoverSyntaxError (yyGLRStack* yystack,
                      YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)


@@ -1706,10 +1710,8 @@ 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],
+               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 +1720,12 @@ 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])[);
-         }
+         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 +1762,15 @@ 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, "));
+             YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
+                              yylvalp, yyllocp);

              yyglrShift (yystack, 0, yytable[yyj],
                          yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
              break;
            }
        }
              yyglrShift (yystack, 0, yytable[yyj],
                          yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
              break;
            }
        }

-      YYDSYMPRINTF ("Error: popping",
-                   yystos[yys->yylrState],
-                   &yys->yysemantics.yysval, &yys->yyloc);
-      yydestruct (yystos[yys->yylrState],
+      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 +1825,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;
 


@@ -1840,7 +1856,7 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
        {
          yyRuleNum yyrule;
          int yyaction;
        {
          yyRuleNum yyrule;
          int yyaction;

-         const short* yyconflicts;
+         const short int* yyconflicts;

 
          yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
           YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
          yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
           YYDPRINTF ((stderr, "Entering state %d\n", yystate));


@@ -1863,15 +1879,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;


@@ -1924,13 +1939,17 @@ 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;
 }
 
 /* DEBUGGING ONLY */
 
   yyfreeGLRStack (&yystack);
   return yystack.yyerrflag;
 }
 
 /* DEBUGGING ONLY */

+#ifdef YYDEBUG

 static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED;
 static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED;
 
 static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED;
 static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED;
 


@@ -1942,7 +1961,7 @@ yy_yypstack (yyGLRState* yys)
       yy_yypstack (yys->yypred);
       fprintf (stderr, " -> ");
     }
       yy_yypstack (yys->yypred);
       fprintf (stderr, " -> ");
     }

-  fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long) yys->yyposn);
+  fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);

 }
 
 static void
 }
 
 static void


@@ -1972,38 +1991,39 @@ yypdumpstack (yyGLRStack* yystack)
   size_t yyi;
   for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
     {
   size_t yyi;
   for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
     {

-      fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems));
+      fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystack->yyitems));

       if (*(yybool *) yyp)
        {
          fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
                   yyp->yystate.yyresolved, yyp->yystate.yylrState,
       if (*(yybool *) yyp)
        {
          fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
                   yyp->yystate.yyresolved, yyp->yystate.yylrState,

-                  (unsigned long) yyp->yystate.yyposn,
-                  (long) YYINDEX (yyp->yystate.yypred));
+                  (unsigned long int) yyp->yystate.yyposn,
+                  (long int) YYINDEX (yyp->yystate.yypred));

          if (! yyp->yystate.yyresolved)
            fprintf (stderr, ", firstVal: %ld",
          if (! yyp->yystate.yyresolved)
            fprintf (stderr, ", firstVal: %ld",

-                    (long) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
+                    (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));

        }
       else
        {
          fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
                   yyp->yyoption.yyrule,
        }
       else
        {
          fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
                   yyp->yyoption.yyrule,

-                  (long) YYINDEX (yyp->yyoption.yystate),
-                  (long) YYINDEX (yyp->yyoption.yynext));
+                  (long int) YYINDEX (yyp->yyoption.yystate),
+                  (long int) YYINDEX (yyp->yyoption.yynext));

        }
       fprintf (stderr, "\n");
     }
   fprintf (stderr, "Tops:");
   for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
        }
       fprintf (stderr, "\n");
     }
   fprintf (stderr, "Tops:");
   for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)

-    fprintf (stderr, "%lu: %ld; ", (unsigned long) yyi,
-            (long) YYINDEX (yystack->yytops.yystates[yyi]));
+    fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
+            (long int) YYINDEX (yystack->yytops.yystates[yyi]));

   fprintf (stderr, "\n");
 }
   fprintf (stderr, "\n");
 }

+#endif

 ]
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@
 ]
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [@output @output_header_name@

-b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003])
+b4_copyright([Skeleton parser for GLR parsing with Bison], [2002, 2003, 2004])

 
 b4_token_defines(b4_tokens)
 
 
 b4_token_defines(b4_tokens)