Remove more 'intl'-related files while bootstrapping.

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index 5d5455534ec84ce77be8a283b39aed244aafbf0d..a77a98570387b8c232897547a075bf34e8fc7172 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -1,7 +1,7 @@
 m4_divert(-1)                                                       -*- C -*-
 
 # GLR skeleton for Bison
 m4_divert(-1)                                                       -*- C -*-
 
 # GLR skeleton for Bison

-# Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+# Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.

 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by


@@ -111,7 +111,7 @@ m4_define([b4_lhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],

-[yyvsp@{YYFILL (m4_eval([$2 - $1]))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3])])
+[((yyGLRStackItem const *)yyvsp)@{YYFILL (m4_eval([$2 - $1]))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3])])

 
 
 
 
 
 


@@ -131,13 +131,13 @@ m4_define([b4_lhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],

-[yyvsp@{YYFILL (m4_eval([$2 - $1]))@}.yystate.yyloc])
+[((yyGLRStackItem const *)yyvsp)@{YYFILL (m4_eval([$2 - $1]))@}.yystate.yyloc])

 
 # We do want M4 expansion after # for CPP macros.
 m4_changecom()
 m4_divert(0)dnl
 @output @output_parser_name@
 
 # We do want M4 expansion after # for CPP macros.
 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. */
 


@@ -197,6 +197,8 @@ typedef struct YYLTYPE
   int first_column;
   int last_line;
   int last_column;
   int first_column;
   int last_line;
   int last_column;

+],[
+  char yydummy;

 ])[
 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1
 ])[
 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1


@@ -217,6 +219,16 @@ static YYLTYPE yyloc_default;
 ]/* Line __line__ of glr.c.  */
 b4_syncline([@oline@], [@ofile@])
 [
 ]/* Line __line__ of glr.c.  */
 b4_syncline([@oline@], [@ofile@])
 [

+#ifndef YYFREE
+# define YYFREE free
+#endif
+#ifndef YYMALLOC
+# define YYMALLOC malloc
+#endif
+#ifndef YYREALLOC
+# define YYREALLOC realloc
+#endif
+

 #ifdef __cplusplus
    typedef bool yybool;
 #else
 #ifdef __cplusplus
    typedef bool yybool;
 #else


@@ -237,6 +249,10 @@ b4_syncline([@oline@], [@ofile@])
 # endif
 #endif
 
 # endif
 #endif
 

+#ifndef YYASSERT
+# define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))
+#endif
+

 #ifndef ATTRIBUTE_UNUSED
 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
 #endif
 #ifndef ATTRIBUTE_UNUSED
 # define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
 #endif


@@ -264,9 +280,9 @@ b4_syncline([@oline@], [@ofile@])
 #define YYUNDEFTOK  ]b4_undef_token_number[
 #define YYMAXUTOK   ]b4_user_token_number_max[
 
 #define YYUNDEFTOK  ]b4_undef_token_number[
 #define YYMAXUTOK   ]b4_user_token_number_max[
 

-#define YYTRANSLATE(YYX)                                               \
+#define YYTRANSLATE(YYX)                                               \

   ((YYX <= 0) ? YYEOF :                                                        \
   ((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[] =


@@ -378,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[
 };


@@ -412,14 +428,14 @@ static const ]b4_int_type_for([b4_stos])[ yystos[] =
 
 #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
 #endif
 ]],[
 #ifndef YYLLOC_DEFAULT

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

 #endif
 ])[
 
 #endif
 ])[
 


@@ -446,7 +462,7 @@ static const int YYEMPTY = -2;
 typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 
 #define YYCHK(YYE)                                                          \
 typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
 
 #define YYCHK(YYE)                                                          \

-   do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; }              \
+   do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; }      \

    while (0)
 
 #if YYDEBUG
    while (0)
 
 #if YYDEBUG


@@ -474,7 +490,7 @@ do {                                                                \
   if (yydebug)                                                 \
     {                                                          \
       YYFPRINTF (stderr, "%s ", Title);                                \
   if (yydebug)                                                 \
     {                                                          \
       YYFPRINTF (stderr, "%s ", Title);                                \

-      yysymprint (stderr,                                      \
+      yysymprint (stderr,                                      \

                   Token, Value]b4_location_if([, Location])[); \
       YYFPRINTF (stderr, "\n");                                        \
     }                                                          \
                   Token, Value]b4_location_if([, Location])[); \
       YYFPRINTF (stderr, "\n");                                        \
     }                                                          \


@@ -536,10 +552,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;


@@ -620,6 +636,9 @@ yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yyformat, ...)
 static inline const char*
 yytokenName (yySymbol yytoken)
 {
 static inline const char*
 yytokenName (yySymbol yytoken)
 {

+  if (yytoken == YYEMPTY)
+    return "";
+

   return yytname[yytoken];
 }
 #endif
   return yytname[yytoken];
 }
 #endif


@@ -637,8 +656,7 @@ yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
   s = yyvsp[yylow0].yystate.yypred;
   for (i = yylow0-1; i >= yylow1; i -= 1)
     {
   s = yyvsp[yylow0].yystate.yypred;
   for (i = yylow0-1; i >= yylow1; i -= 1)
     {

-      if (! s->yyresolved)
-       abort ();
+      YYASSERT (s->yyresolved);

       yyvsp[i].yystate.yyresolved = yytrue;
       yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;
       yyvsp[i].yystate.yyloc = s->yyloc;
       yyvsp[i].yystate.yyresolved = yytrue;
       yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;
       yyvsp[i].yystate.yyloc = s->yyloc;


@@ -682,7 +700,7 @@ 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 do { yystack->yyerrState = 0; return yyerr; } while (0)
+# define YYERROR return yyerrok, yyerr

 # undef YYRECOVERING
 # define YYRECOVERING (yystack->yyerrState != 0)
 # undef yyclearin
 # undef YYRECOVERING
 # define YYRECOVERING (yystack->yyerrState != 0)
 # undef yyclearin


@@ -691,10 +709,8 @@ yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \
 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
 # undef YYBACKUP
 # define YYBACKUP(Token, Value)                                                     \

-  do {                                                                      \
-    yyerror (]b4_yyerror_args["syntax error: cannot back up");              \
-    YYERROR;                                                                \
-  } while (0)
+  return yyerror (]b4_yyerror_args["syntax error: cannot back up"),         \
+        yyerrok, yyerr

 
   yylow = 1;
   if (yyrhslen == 0)
 
   yylow = 1;
   if (yyrhslen == 0)


@@ -727,10 +743,9 @@ b4_syncline([@oline@], [@ofile@])
 }
 \f
 
 }
 \f
 

-static YYSTYPE
+static void

 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 {
 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 {

-  YYSTYPE yyval = *yy0;

   /* `Use' the arguments.  */
   (void) yy0;
   (void) yy1;
   /* `Use' the arguments.  */
   (void) yy0;
   (void) yy1;


@@ -739,7 +754,6 @@ yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
     {
       b4_mergers
     }
     {
       b4_mergers
     }

-  return yyval;

 }
 [
                              /* Bison grammar-table manipulation.  */
 }
 [
                              /* Bison grammar-table manipulation.  */


@@ -795,7 +809,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)


@@ -865,13 +879,13 @@ yyinitStateSet (yyGLRStateSet* yyset)
 {
   yyset->yysize = 1;
   yyset->yycapacity = 16;
 {
   yyset->yysize = 1;
   yyset->yycapacity = 16;

-  yyset->yystates = (yyGLRState**) malloc (16 * sizeof (yyset->yystates[0]));
+  yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);

   yyset->yystates[0] = NULL;
 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {
   yyset->yystates[0] = NULL;
 }
 
 static void yyfreeStateSet (yyGLRStateSet* yyset)
 {

-  free (yyset->yystates);
+  YYFREE (yyset->yystates);

 }
 
 /** Initialize STACK to a single empty stack, with total maximum
 }
 
 /** Initialize STACK to a single empty stack, with total maximum


@@ -884,7 +898,7 @@ yyinitGLRStack (yyGLRStack* yystack, size_t yysize)
   yynerrs = 0;
   yystack->yyspaceLeft = yysize;
   yystack->yynextFree = yystack->yyitems =
   yynerrs = 0;
   yystack->yyspaceLeft = yysize;
   yystack->yynextFree = yystack->yyitems =

-    (yyGLRStackItem*) malloc (yysize * sizeof (yystack->yynextFree[0]));
+    (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystack->yynextFree[0]);

   yystack->yysplitPoint = NULL;
   yystack->yylastDeleted = NULL;
   yyinitStateSet (&yystack->yytops);
   yystack->yysplitPoint = NULL;
   yystack->yylastDeleted = NULL;
   yyinitStateSet (&yystack->yytops);


@@ -948,7 +962,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
       yystack->yytops.yystates[yyn] =
        YYRELOC (yystack->yyitems, yynewStack.yyitems,
                 yystack->yytops.yystates[yyn], yystate);
       yystack->yytops.yystates[yyn] =
        YYRELOC (yystack->yyitems, yynewStack.yyitems,
                 yystack->yytops.yystates[yyn], yystate);

-  free (yystack->yyitems);
+  YYFREE (yystack->yyitems);

   yystack->yyitems = yynewStack.yyitems;
   yystack->yynextFree = yynewStack.yynextFree + yysize;
   yystack->yyspaceLeft = yynewStack.yyspaceLeft - yysize;
   yystack->yyitems = yynewStack.yyitems;
   yystack->yynextFree = yynewStack.yynextFree + yysize;
   yystack->yyspaceLeft = yynewStack.yyspaceLeft - yysize;


@@ -962,7 +976,7 @@ yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
 static void
 yyfreeGLRStack (yyGLRStack* yystack)
 {
 static void
 yyfreeGLRStack (yyGLRStack* yystack)
 {

-  free (yystack->yyitems);
+  YYFREE (yystack->yyitems);

   yyfreeStateSet (&yystack->yytops);
 }
 
   yyfreeStateSet (&yystack->yytops);
 }
 


@@ -1019,7 +1033,8 @@ yyremoveDeletes (yyGLRStack* yystack)
          yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi];
          if (yyj != yyi)
            {
          yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi];
          if (yyj != yyi)
            {

-             YYDPRINTF ((stderr, "Rename stack %d -> %d.\n", yyi, yyj));
+             YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
+                         (unsigned long int) yyi, (unsigned long int) yyj));

            }
          yyj += 1;
        }
            }
          yyj += 1;
        }


@@ -1080,7 +1095,7 @@ yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
  *  for userAction. */
 static inline YYRESULTTAG
 yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
  *  for userAction. */
 static inline YYRESULTTAG
 yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,

-           YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
+           YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)

 {
   int yynrhs = yyrhsLength (yyrule);
 
 {
   int yynrhs = yyrhsLength (yyrule);
 


@@ -1088,8 +1103,7 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
     {
       /* Standard special case: single stack. */
       yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];
     {
       /* Standard special case: single stack. */
       yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];

-      if (yyk != 0)
-       abort ();
+      YYASSERT (yyk == 0);

       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;


@@ -1101,13 +1115,12 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
       int yyi;
       yyGLRState* yys;
       yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
       int yyi;
       yyGLRState* yys;
       yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];

-      yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred 
+      yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred

        = yystack->yytops.yystates[yyk];
       for (yyi = 0; yyi < yynrhs; yyi += 1)
        {
          yys = yys->yypred;
        = yystack->yytops.yystates[yyk];
       for (yyi = 0; yyi < yynrhs; yyi += 1)
        {
          yys = yys->yypred;

-         if (yys == NULL)
-           abort ();
+         YYASSERT (yys);

        }
       yyupdateSplit (yystack, yys);
       yystack->yytops.yystates[yyk] = yys;
        }
       yyupdateSplit (yystack, yys);
       yystack->yytops.yystates[yyk] = yys;


@@ -1133,9 +1146,9 @@ static inline void
 yy_reduce_print (size_t yyk, yyRuleNum yyrule)
 {
   int yyi;
 yy_reduce_print (size_t yyk, yyRuleNum yyrule)
 {
   int yyi;

-  unsigned int yylno = yyrline[yyrule];
-  YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %u), ",
-            yyk, yyrule - 1, yylno);
+  YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu), ",
+            (unsigned long int) yyk, yyrule - 1,
+            (unsigned long int) yyrline[yyrule]);

   /* Print the symbols being reduced, and their result.  */
   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
     YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));
   /* Print the symbols being reduced, and their result.  */
   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
     YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));


@@ -1183,15 +1196,13 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
           0 < yyn; yyn -= 1)
        {
          yys = yys->yypred;
           0 < yyn; yyn -= 1)
        {
          yys = yys->yypred;

-         if (yys == NULL)
-           abort ();
+         YYASSERT (yys);

        }
       yyupdateSplit (yystack, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
       YYDPRINTF ((stderr,
        }
       yyupdateSplit (yystack, yys);
       yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
       YYDPRINTF ((stderr,

-                 "Reduced stack %d by rule #%d; action deferred. "
-                 "Now in state %d.\n",
-                 yyk, yyrule-1, yynewLRState));
+                 "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n",
+                 (unsigned long int) yyk, yyrule - 1, yynewLRState));

       for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
        if (yyi != yyk && yystack->yytops.yystates[yyi] != NULL)
          {
       for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
        if (yyi != yyk && yystack->yytops.yystates[yyi] != NULL)
          {


@@ -1203,8 +1214,9 @@ yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
                  {
                    yyaddDeferredAction (yystack, yyp, yys0, yyrule]b4_pure_args[);
                    yymarkStackDeleted (yystack, yyk);
                  {
                    yyaddDeferredAction (yystack, yyp, yys0, yyrule]b4_pure_args[);
                    yymarkStackDeleted (yystack, yyk);

-                   YYDPRINTF ((stderr, "Merging stack %d into stack %d.\n",
-                               yyk, yyi));
+                   YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
+                               (unsigned long int) yyk,
+                               (unsigned long int) yyi));

                    return yyok;
                  }
                yyp = yyp->yypred;
                    return yyok;
                  }
                yyp = yyp->yypred;


@@ -1221,17 +1233,16 @@ yysplitStack (yyGLRStack* yystack, int yyk)
 {
   if (yystack->yysplitPoint == NULL)
     {
 {
   if (yystack->yysplitPoint == NULL)
     {

-      if (yyk != 0)
-       abort ();
+      YYASSERT (yyk == 0);

       yystack->yysplitPoint = yystack->yytops.yystates[yyk];
     }
   if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
     {
       yystack->yytops.yycapacity *= 2;
       yystack->yytops.yystates =
       yystack->yysplitPoint = yystack->yytops.yystates[yyk];
     }
   if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
     {
       yystack->yytops.yycapacity *= 2;
       yystack->yytops.yystates =

-       (yyGLRState**) realloc (yystack->yytops.yystates,
-                               yystack->yytops.yycapacity
-                               * sizeof (yyGLRState*));
+       (yyGLRState**) YYREALLOC (yystack->yytops.yystates,
+                                 (yystack->yytops.yycapacity
+                                  * sizeof yystack->yytops.yystates[0]));

     }
   yystack->yytops.yystates[yystack->yytops.yysize]
     = yystack->yytops.yystates[yyk];
     }
   yystack->yytops.yystates[yystack->yytops.yysize]
     = yystack->yytops.yystates[yyk];


@@ -1320,8 +1331,7 @@ yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack]b4_user_formals[)
   YYRESULTTAG yyflag;
   if (0 < yyn)
     {
   YYRESULTTAG yyflag;
   if (0 < yyn)
     {

-      if (yys->yypred == NULL)
-       abort ();
+      YYASSERT (yys->yypred);

       yyflag = yyresolveStates (yys->yypred, yyn-1, yystack]b4_user_args[);
       if (yyflag != yyok)
        return yyflag;
       yyflag = yyresolveStates (yys->yypred, yyn-1, yystack]b4_user_args[);
       if (yyflag != yyok)
        return yyflag;


@@ -1348,7 +1358,7 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
   yynrhs = yyrhsLength (yyopt->yyrule);
   YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[));
   yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;
   yynrhs = yyrhsLength (yyopt->yyrule);
   YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[));
   yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;

-  return yyuserAction (yyopt->yyrule, yynrhs, 
+  return yyuserAction (yyopt->yyrule, yynrhs,

                       yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
                       yyvalp, yylocp, yystack]b4_user_args[);
 }
                       yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
                       yyvalp, yylocp, yystack]b4_user_args[);
 }


@@ -1378,9 +1388,10 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
               yyx->yyrule);
   else
               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
               yyx->yyrule);
   else

-    YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %d .. %d>\n",
+    YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",

               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
               yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),

-              yyx->yyrule, yys->yyposn+1, yyx->yystate->yyposn);
+              yyx->yyrule, (unsigned long int) (yys->yyposn + 1),
+              (unsigned long int) yyx->yystate->yyposn);

   for (yyi = 1; yyi <= yynrhs; yyi += 1)
     {
       if (yystates[yyi]->yyresolved)
   for (yyi = 1; yyi <= yynrhs; yyi += 1)
     {
       if (yystates[yyi]->yyresolved)


@@ -1389,9 +1400,10 @@ yyreportTree (yySemanticOption* yyx, int yyindent)
            YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
          else
            YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
          else

-           YYFPRINTF (stderr, "%*s%s <tokens %d .. %d>\n", yyindent+2, "",
+           YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",

                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
                       yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),

-                      yystates[yyi-1]->yyposn+1, yystates[yyi]->yyposn);
+                      (unsigned long int) (yystates[yyi - 1]->yyposn + 1),
+                      (unsigned long int) yystates[yyi]->yyposn);

        }
       else
        yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
        }
       else
        yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);


@@ -1464,7 +1476,7 @@ yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack,
              YYSTYPE yyval1;
              YYLTYPE yydummy;
              YYCHK (yyresolveAction (yyp, yystack, &yyval1, &yydummy]b4_user_args[));
              YYSTYPE yyval1;
              YYLTYPE yydummy;
              YYCHK (yyresolveAction (yyp, yystack, &yyval1, &yydummy]b4_user_args[));

-             *yyvalp = yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1);
+             yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1);

            }
        }
       return yyok;
            }
        }
       return yyok;


@@ -1527,7 +1539,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;
 


@@ -1536,8 +1548,8 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
       yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState;
       YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate));
 
       yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState;
       YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate));
 

-      if (yystate == YYFINAL)
-       abort ();
+      YYASSERT (yystate != YYFINAL);
+

       if (yyisDefaultedState (yystate))
        {
          yyrule = yydefaultAction (yystate);
       if (yyisDefaultedState (yystate))
        {
          yyrule = yydefaultAction (yystate);


@@ -1640,11 +1652,12 @@ yyreportSyntaxError (yyGLRStack* yystack,
              }
          yysize += (sizeof ("syntax error, unexpected ")
                     + strlen (yytokenName (*yytokenp)));
              }
          yysize += (sizeof ("syntax error, unexpected ")
                     + strlen (yytokenName (*yytokenp)));

-         yymsg = (char*) malloc (yysize);
+         yymsg = (char*) YYMALLOC (yysize);

          if (yymsg != 0)
            {
              char* yyp = yymsg;
          if (yymsg != 0)
            {
              char* yyp = yymsg;

-             sprintf (yyp, "syntax error, unexpected %s",
+             sprintf (yyp, "syntax error%s%s",
+                      (*yytokenp == YYEMPTY ? "" : ", unexpected "),

                       yytokenName (*yytokenp));
              yyp += strlen (yyp);
              if (yycount < 5)
                       yytokenName (*yytokenp));
              yyp += strlen (yyp);
              if (yycount < 5)


@@ -1659,7 +1672,7 @@ yyreportSyntaxError (yyGLRStack* yystack,
                      }
                }
              yyerror (]b4_lyyerror_args[yymsg);
                      }
                }
              yyerror (]b4_lyyerror_args[yymsg);

-             free (yymsg);
+             YYFREE (yymsg);

            }
          else
            yyerror (]b4_lyyerror_args["syntax error; also virtual memory exhausted");
            }
          else
            yyerror (]b4_lyyerror_args["syntax error; also virtual memory exhausted");


@@ -1756,10 +1769,10 @@ yyrecoverSyntaxError (yyGLRStack* yystack,
            }
        }
       YYDSYMPRINTF ("Error: popping",
            }
        }
       YYDSYMPRINTF ("Error: popping",

-                   yystos[yys->yylrState],
-                   &yys->yysemantics.yysval, &yys->yyloc);
+                   yystos[yys->yylrState],
+                   &yys->yysemantics.yysval, &yys->yyloc);

       yydestruct (yystos[yys->yylrState],
       yydestruct (yystos[yys->yylrState],

-                 &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
+                 &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);

       yystack->yytops.yystates[0] = yys->yypred;
       yystack->yynextFree -= 1;
       yystack->yyspaceLeft += 1;
       yystack->yytops.yystates[0] = yys->yypred;
       yystack->yynextFree -= 1;
       yystack->yyspaceLeft += 1;


@@ -1827,7 +1840,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));


@@ -1929,7 +1942,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


@@ -1948,7 +1961,7 @@ yypstack (yyGLRStack* yystack, int yyk)
   yypstates (yystack->yytops.yystates[yyk]);
 }
 
   yypstates (yystack->yytops.yystates[yyk]);
 }
 

-#define YYINDEX(YYX)                                                        \
+#define YYINDEX(YYX)                                                        \

     ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems)
 
 
     ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems)
 
 


@@ -1959,30 +1972,30 @@ 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");
 }
 ]


@@ -1990,7 +2003,7 @@ yypdumpstack (yyGLRStack* yystack)
 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)
 


@@ -2016,6 +2029,8 @@ b4_location_if([
   int first_column;
   int last_line;
   int last_column;
   int first_column;
   int last_line;
   int last_column;

+],[
+  char yydummy;

 ])
 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1
 ])
 } YYLTYPE;
 # define YYLTYPE_IS_DECLARED 1