Remove more 'intl'-related files while bootstrapping.

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index eebea9d721fcd135ead55a3fd66111cb6b8d1eac..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. */
 


@@ -249,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


@@ -278,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[] =


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


@@ -548,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;


@@ -632,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


@@ -649,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;


@@ -737,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;


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

-  return yyval;

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


@@ -805,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)


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

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

   yyset->yystates[0] = NULL;
 }
 
   yyset->yystates[0] = NULL;
 }
 


@@ -894,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 =

-    YYMALLOC (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);


@@ -1099,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;


@@ -1117,8 +1120,7 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
       for (yyi = 0; yyi < yynrhs; yyi += 1)
        {
          yys = yys->yypred;
       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;


@@ -1194,14 +1196,12 @@ 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 %lu by rule #%d; action deferred. "
-                 "Now in state %d.\n",
+                 "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)
                  (unsigned long int) yyk, yyrule - 1, yynewLRState));
       for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
        if (yyi != yyk && yystack->yytops.yystates[yyi] != NULL)


@@ -1233,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 =

-       YYREALLOC (yystack->yytops.yystates,
-                  (yystack->yytops.yycapacity
-                   * sizeof yystack->yytops.yystates[0]));
+       (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];


@@ -1332,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;


@@ -1478,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;


@@ -1541,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;
 


@@ -1550,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);


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

-         yymsg = YYMALLOC (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)


@@ -1841,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));


@@ -1943,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


@@ -1973,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");
 }
 ]


@@ -2004,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)