(Web2c Actions): signed char -> yysigned_char.

[bison.git] / data / glr.c

diff --git a/data/glr.c b/data/glr.c
index 846adeb7a5987de2d1b2c8629c8eef6c9ce99676..3c69ac826075110d532d1158dfd9db4ebfb195fe 100644 (file)
--- a/data/glr.c
+++ b/data/glr.c
@@ -1,4 +1,5 @@
-m4_divert(-1)                                                       -*- YYC -*-
+m4_divert(-1)                                                       -*- C -*-
+m4_include([c.m4])

 
 # GLR skeleton for Bison
 # Copyright (C) 2002 Free Software Foundation, Inc.
 
 # GLR skeleton for Bison
 # Copyright (C) 2002 Free Software Foundation, Inc.


@@ -18,10 +19,6 @@ m4_divert(-1)                                                       -*- YYC -*-
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 # 02111-1307  USA
 
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
 # 02111-1307  USA
 

-m4_include([c.m4])
-
-
-

 # b4_lhs_value([TYPE])
 # --------------------
 # Expansion of $<TYPE>$.
 # b4_lhs_value([TYPE])
 # --------------------
 # Expansion of $<TYPE>$.


@@ -111,11 +108,12 @@ b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
 /* This is the parser code for GLR (Generalized LR) parser. */
 
 /* FIXME: minimize these */
 /* This is the parser code for GLR (Generalized LR) parser. */
 
 /* FIXME: minimize these */

-#include <stdlib.h>
+#include <assert.h>

 #include <setjmp.h>
 #include <setjmp.h>

-#include <stdio.h>

 #include <stdarg.h>
 #include <stdarg.h>

-#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>

 
 /* Identify Bison output.  */
 #define YYBISON        1
 
 /* Identify Bison output.  */
 #define YYBISON        1


@@ -138,10 +136,10 @@ b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
 #define yynerrs b4_prefix[]nerrs
 b4_location_if([#define yylloc b4_prefix[]lloc])])
 
 #define yynerrs b4_prefix[]nerrs
 b4_location_if([#define yylloc b4_prefix[]lloc])])
 

-/* Copy the first part of user declarations.  */
-b4_pre_prologue
+b4_token_defines(b4_tokens)

 
 

-b4_token_defines(b4_tokens)[
+/* Copy the first part of user declarations.  */
+b4_pre_prologue[

 
 /* Enabling traces.  */
 #ifndef YYDEBUG
 
 /* Enabling traces.  */
 #ifndef YYDEBUG


@@ -171,10 +169,10 @@ typedef union b4_stype yystype;
 typedef struct yyltype
 {
 ]b4_location_if([
 typedef struct yyltype
 {
 ]b4_location_if([

-  int yyfirst_line;
-  int yyfirst_column;
-  int yylast_line;
-  int yylast_column;])[
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;])[

 } yyltype;
 # define YYLTYPE ]b4_ltype[
 # define YYLTYPE_IS_TRIVIAL 1
 } yyltype;
 # define YYLTYPE ]b4_ltype[
 # define YYLTYPE_IS_TRIVIAL 1


@@ -200,23 +198,38 @@ static YYLTYPE yyloc_default;
 #  define yyfalse 0
 #endif
 
 #  define yyfalse 0
 #endif
 

-#if ! defined (yy__GNUC__)
-#  define inline
+/*-----------------.
+| GCC extensions.  |
+`-----------------*/
+
+#ifndef __attribute__
+/* This feature is available in gcc versions 2.5 and later.  */
+# if !defined (__GNUC__) || __GNUC__ < 2 || \
+(__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
+#  define __attribute__(Spec) /* empty */
+# endif
+#endif
+
+#ifndef ATTRIBUTE_UNUSED
+# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
+#endif
+
+#if ! defined (__GNUC__)
+# define inline

 #endif
 
 /* YYFINAL -- State number of the termination state. */
 #endif
 
 /* YYFINAL -- State number of the termination state. */

-#define YYFINAL  ]b4_final[
-#define YYFLAG  ]b4_flag[
+#define YYFINAL  ]b4_final_state_number[

 #define YYLAST   ]b4_last[
 
 /* YYNTOKENS -- Number of terminals. */
 #define YYLAST   ]b4_last[
 
 /* YYNTOKENS -- Number of terminals. */

-#define YYNTOKENS  ]b4_ntokens[
+#define YYNTOKENS  ]b4_tokens_number[

 /* YYNNTS -- Number of nonterminals. */
 /* YYNNTS -- Number of nonterminals. */

-#define YYNNTS  ]b4_nnts[
+#define YYNNTS  ]b4_nterms_number[

 /* YYNRULES -- Number of rules. */
 /* YYNRULES -- Number of rules. */

-#define YYNRULES  ]b4_nrules[
+#define YYNRULES  ]b4_rules_number[

 /* YYNRULES -- Number of states. */
 /* YYNRULES -- Number of states. */

-#define YYNSTATES  ]b4_nstates[
+#define YYNSTATES  ]b4_states_number[

 /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
 #define YYMAXRHS ]b4_r2_max[
 
 /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
 #define YYMAXRHS ]b4_r2_max[
 


@@ -228,7 +241,7 @@ static YYLTYPE yyloc_default;
   ((unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
   ((unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */

-static const ]b4_uint_type(b4_translate_max)[ yytranslate[] =
+static const ]b4_int_type_for([b4_translate])[ yytranslate[] =

 {
   ]b4_translate[
 };
 {
   ]b4_translate[
 };


@@ -236,19 +249,19 @@ static const ]b4_uint_type(b4_translate_max)[ yytranslate[] =
 #if YYDEBUG
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
 #if YYDEBUG
 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */

-static const ]b4_uint_type(b4_prhs_max)[ yyprhs[] =
+static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =

 {
   ]b4_prhs[
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 {
   ]b4_prhs[
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */

-static const ]b4_sint_type(b4_rhs_max)[ yyrhs[] =
+static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =

 {
   ]b4_rhs[
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 {
   ]b4_rhs[
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */

-static const ]b4_uint_type(b4_rline_max)[ yyrline[] =
+static const ]b4_int_type_for([b4_rline])[ yyrline[] =

 {
   ]b4_rline[
 };
 {
   ]b4_rline[
 };


@@ -262,29 +275,29 @@ static const char *const yytname[] =
   ]b4_tname[
 };
 
   ]b4_tname[
 };
 

-#define yytname_size (sizeof (yytname) / sizeof (yytname[0]))
+#define yytname_size ((int) (sizeof (yytname) / sizeof (yytname[0])))

 #endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 #endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */

-static const ]b4_uint_type(b4_r1_max)[ yyr1[] =
+static const ]b4_int_type_for([b4_r1])[ yyr1[] =

 {
   ]b4_r1[
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 {
   ]b4_r1[
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */

-static const ]b4_uint_type(b4_r2_max)[ yyr2[] =
+static const ]b4_int_type_for([b4_r2])[ yyr2[] =

 {
   ]b4_r2[
 };
 
 /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */
 {
   ]b4_r2[
 };
 
 /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */

-static const short yydprec[] =
+static const ]b4_int_type_for([b4_dprec])[ yydprec[] =

 {
   ]b4_dprec[
 };
 
 /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */
 {
   ]b4_dprec[
 };
 
 /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */

-static const short yymerger[] =
+static const ]b4_int_type_for([b4_merger])[ yymerger[] =

 {
   ]b4_merger[
 };
 {
   ]b4_merger[
 };


@@ -292,55 +305,61 @@ static const short yymerger[] =
 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
    doesn't specify something else to do.  Zero means the default is an
    error.  */
 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
    doesn't specify something else to do.  Zero means the default is an
    error.  */

-static const short yydefact[] =
+static const ]b4_int_type_for([b4_defact])[ yydefact[] =

 {
   ]b4_defact[
 };
 
 {
   ]b4_defact[
 };
 

-/* YYPGOTO[NTERM-NUM]. */
-static const short yydefgoto[] =
+/* YYPDEFGOTO[NTERM-NUM]. */
+static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =

 {
   ]b4_defgoto[
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 {
   ]b4_defgoto[
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */

-static const short yypact[] =
+#define YYPACT_NINF ]b4_pact_ninf[
+static const ]b4_int_type_for([b4_pact])[ yypact[] =

 {
   ]b4_pact[
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 {
   ]b4_pact[
 };
 
 /* YYPGOTO[NTERM-NUM].  */

-static const short yypgoto[] =
+static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =

 {
   ]b4_pgoto[
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
 {
   ]b4_pgoto[
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which

-   number is the opposite.  If zero, do what YYDEFACT says.  */
-static const short yytable[] =
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, parse error.  */
+#define YYTABLE_NINF ]b4_table_ninf[
+static const ]b4_int_type_for([b4_table])[ yytable[] =

 {
   ]b4_table[
 };
 
 {
   ]b4_table[
 };
 

-/* YYCONFLP[YYPACT[STATE-NUM]] -- pointer into yyconfl of start of list
-   of conflicting reductions corresponding to action entry for state
-   STATE-NUM in yytable.  0 means no conflicts.  The list in yyconfl
-   is terminated by a rule number of 0. */
-static const short yyconflp[] =
+/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
+   list of conflicting reductions corresponding to action entry for
+   state STATE-NUM in yytable.  0 means no conflicts.  The list in
+   yyconfl is terminated by a rule number of 0.  */
+static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] =

 {
   ]b4_conflict_list_heads[
 };
 
 {
   ]b4_conflict_list_heads[
 };
 

-/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated
-   by 0, pointed into by YYCONFLP. */
-static const short yyconfl[] =
+/* 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 We probably ought to introduce a type for confl.
+[static const short yyconfl[] =

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

-static const short yycheck[] =
+static const ]b4_int_type_for([b4_check])[ yycheck[] =

 {
   ]b4_check[
 };
 {
   ]b4_check[
 };


@@ -376,11 +395,11 @@ int yyparse (void);
 #define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc)
 
 #ifndef YYLLOC_DEFAULT
 #define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc)
 
 #ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN)           \
-  yyCurrent.yyfirst_line   = YYRHSLOC(yyRhs,1).yyfirst_line;      \
-  yyCurrent.yyfirst_column = YYRHSLOC(yyRhs,1).yyfirst_column;    \
-  yyCurrent.yylast_line    = YYRHSLOC(yyRhs,YYN).yylast_line;       \
-  yyCurrent.yylast_column  = YYRHSLOC(yyRhs,YYN).yylast_column;
+# 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;

 #endif
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 #endif
 
 /* YYLEX -- calling `yylex' with the right arguments.  */


@@ -431,7 +450,8 @@ do {                                                \
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */

-# define YYDPRINTF(Args)
+  /* Avoid empty `if' bodies.  */
+# define YYDPRINTF(Args)  {}

 #endif /* !YYDEBUG */
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #endif /* !YYDEBUG */
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */


@@ -572,6 +592,9 @@ static YYRESULTTAG
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack)
 {
 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
              YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack)
 {

+  /* Avoid `unused' warnings in there are no $n. */
+  (void) yystack;
+

   if (yyrhslen == 0)
     {
       *yyvalp = yyval_default;
   if (yyrhslen == 0)
     {
       *yyvalp = yyval_default;


@@ -627,6 +650,10 @@ static YYSTYPE
 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 {
   YYSTYPE yyval = *yy0;
 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
 {
   YYSTYPE yyval = *yy0;

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

   switch (yyn)
     {
       b4_mergers
   switch (yyn)
     {
       b4_mergers


@@ -655,7 +682,7 @@ yylhsNonterm (yyRuleNum yyrule)
 static inline bool
 yyisDefaultedState (yyStateNum yystate)
 {
 static inline bool
 yyisDefaultedState (yyStateNum yystate)
 {

-  return yypact[yystate] == YYFLAG;
+  return yypact[yystate] == YYPACT_NINF;

 }
 
 /** The default reduction for STATE, assuming it has one. */
 }
 
 /** The default reduction for STATE, assuming it has one. */


@@ -665,7 +692,7 @@ yydefaultAction (yyStateNum yystate)
   return yydefact[yystate];
 }
 
   return yydefact[yystate];
 }
 

-/** Set *ACTION to the action to take in STATE on seeing TOKEN.
+/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.

  *  Result R means
  *    R < 0:  Reduce on rule -R.
  *    R = 0:  Error.
  *  Result R means
  *    R < 0:  Reduce on rule -R.
  *    R = 0:  Error.


@@ -678,16 +705,21 @@ yygetLRActions (yyStateNum yystate, int yytoken,
                int* yyaction, const short** yyconflicts)
 {
   int yyindex = yypact[yystate] + yytoken;
                int* yyaction, const short** yyconflicts)
 {
   int yyindex = yypact[yystate] + yytoken;

-  if (yyindex < 0 || yyindex > YYLAST || yycheck[yyindex] != yytoken)
+  if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)

     {
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }
     {
       *yyaction = -yydefact[yystate];
       *yyconflicts = yyconfl;
     }

-  else
+  else if (yytable[yyindex] != YYTABLE_NINF)

     {
       *yyaction = yytable[yyindex];
       *yyconflicts = yyconfl + yyconflp[yyindex];
     }
     {
       *yyaction = yytable[yyindex];
       *yyconflicts = yyconfl + yyconflp[yyindex];
     }

+  else
+    {
+      *yyaction = 0;
+      *yyconflicts = yyconfl + yyconflp[yyindex];
+    }

 }
 
 static inline yyStateNum
 }
 
 static inline yyStateNum


@@ -695,7 +727,7 @@ yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
 {
   int yyr;
   yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
 {
   int yyr;
   yyr = yypgoto[yylhs - YYNTOKENS] + yystate;

-  if (yyr >= 0 && yyr <= YYLAST && yycheck[yyr] == yystate)
+  if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)

     return yytable[yyr];
   else
     return yydefgoto[yylhs - YYNTOKENS];
     return yytable[yyr];
   else
     return yydefgoto[yylhs - YYNTOKENS];


@@ -710,7 +742,7 @@ yyisShiftAction (int yyaction)
 static inline bool
 yyisErrorAction (int yyaction)
 {
 static inline bool
 yyisErrorAction (int yyaction)
 {

-  return yyaction == 0 || yyaction == YYFLAG;
+  return yyaction == 0;

 }
 
                                /* GLRStates */
 }
 
                                /* GLRStates */


@@ -723,15 +755,16 @@ yyhasResolvedValue (yyGLRState* yystate)
   return yystate->yyresolved;
 }
 
   return yystate->yyresolved;
 }
 

-void yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
-                         yyGLRState* yyrhs, yyRuleNum yyrule)
+static void
+yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
+                    yyGLRState* rhs, yyRuleNum yyrule)

 {
   yySemanticOption* yynewItem;
   yynewItem = &yystack->yynextFree->yyoption;
   yystack->yyspaceLeft -= 1;
   yystack->yynextFree += 1;
   yynewItem->yyisState = yyfalse;
 {
   yySemanticOption* yynewItem;
   yynewItem = &yystack->yynextFree->yyoption;
   yystack->yyspaceLeft -= 1;
   yystack->yynextFree += 1;
   yynewItem->yyisState = yyfalse;

-  yynewItem->yystate = yyrhs;
+  yynewItem->yystate = rhs;

   yynewItem->yyrule = yyrule;
   yynewItem->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewItem;
   yynewItem->yyrule = yyrule;
   yynewItem->yynext = yystate->yysemantics.yyfirstVal;
   yystate->yysemantics.yyfirstVal = yynewItem;


@@ -885,13 +918,13 @@ yyundeleteLastStack (yyGLRStack* yystack)
 static inline void
 yyremoveDeletes (yyGLRStack* yystack)
 {
 static inline void
 yyremoveDeletes (yyGLRStack* yystack)
 {

-  int yyi, yyj;
+  size_t yyi, yyj;

   yyi = yyj = 0;
   while (yyj < yystack->yytops.yysize)
     {
       if (yystack->yytops.yystates[yyi] == NULL)
        {
   yyi = yyj = 0;
   while (yyj < yystack->yytops.yysize)
     {
       if (yystack->yytops.yystates[yyi] == NULL)
        {

-         if (YYDEBUG && yyi == yyj)
+         if (yyi == yyj)

            YYDPRINTF ((stderr, "Removing dead stacks.\n"));
          yystack->yytops.yysize -= 1;
        }
            YYDPRINTF ((stderr, "Removing dead stacks.\n"));
          yystack->yytops.yysize -= 1;
        }


@@ -934,7 +967,7 @@ yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn,
  * the (unresolved) semantic value of RHS under the action for RULE. */
 static inline void
 yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
  * the (unresolved) semantic value of RHS under the action for RULE. */
 static inline void
 yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,

-                size_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule)
+                size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule)

 {
   yyGLRStackItem* yynewItem;
 
 {
   yyGLRStackItem* yynewItem;
 


@@ -948,7 +981,7 @@ yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
   yystack->yytops.yystates[yyk] = &yynewItem->yystate;
   yystack->yynextFree += 1;
   yystack->yyspaceLeft -= 1;
   yystack->yytops.yystates[yyk] = &yynewItem->yystate;
   yystack->yynextFree += 1;
   yystack->yyspaceLeft -= 1;

-  yyaddDeferredAction (yystack, &yynewItem->yystate, yyrhs, yyrule);
+  yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule);

 }
 
 /** Pop the symbols consumed by reduction #RULE from the top of stack
 }
 
 /** Pop the symbols consumed by reduction #RULE from the top of stack


@@ -966,7 +999,7 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
   if (yystack->yysplitPoint == NULL)
     {
       /* Standard special case: single stack. */
   if (yystack->yysplitPoint == NULL)
     {
       /* Standard special case: single stack. */

-      yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];
+      yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];

       assert (yyk == 0);
       yystack->yynextFree -= yynrhs;
       yystack->yyspaceLeft += yynrhs;
       assert (yyk == 0);
       yystack->yynextFree -= yynrhs;
       yystack->yyspaceLeft += yynrhs;


@@ -978,10 +1011,10 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
        }
       else
        {
        }
       else
        {

-         *yyvalp = yyrhs[1-yynrhs].yystate.yysemantics.yysval;
-         *yylocp = yyrhs[1-yynrhs].yystate.yyloc;
+         *yyvalp = rhs[1-yynrhs].yystate.yysemantics.yysval;
+         *yylocp = rhs[1-yynrhs].yystate.yyloc;

        }
        }

-      return yyuserAction (yyrule, yynrhs, yyrhs, yyvalp, yylocp, yystack);
+      return yyuserAction (yyrule, yynrhs, rhs, yyvalp, yylocp, yystack);

     }
   else
     {
     }
   else
     {


@@ -1025,26 +1058,40 @@ yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
  *  added to the options for the existing state's semantic value.
  */
 static inline YYRESULTTAG
  *  added to the options for the existing state's semantic value.
  */
 static inline YYRESULTTAG

-yyglrReduce (yyGLRStack* yystack, int yyk, yyRuleNum yyrule, bool yyforceEval)
+yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
+             bool yyforceEval)

 {
 {

-  int yyposn = yystack->yytops.yystates[yyk]->yyposn;
+  size_t yyposn = yystack->yytops.yystates[yyk]->yyposn;

 
   if (yyforceEval || yystack->yysplitPoint == NULL)
     {
       YYSTYPE yysval;
       YYLTYPE yyloc;
 
 
   if (yyforceEval || yystack->yysplitPoint == NULL)
     {
       YYSTYPE yysval;
       YYLTYPE yyloc;
 

+#if YYDEBUG
+      if (yydebug)
+       {
+         int yyi;
+         YYDPRINTF ((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]; yyrhs[yyi] >= 0; yyi++)
+           YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));
+         YYFPRINTF (stderr, " -> %s\n", yytokenName (yyr1[yyrule]));
+       }
+#endif

       YYCHK (yydoAction (yystack, yyk, yyrule, &yysval, &yyloc));
       yyglrShift (yystack, yyk,
                  yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
                                 yylhsNonterm (yyrule)),
                yyposn, yysval, &yyloc);
       YYCHK (yydoAction (yystack, yyk, yyrule, &yysval, &yyloc));
       yyglrShift (yystack, yyk,
                  yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
                                 yylhsNonterm (yyrule)),
                yyposn, yysval, &yyloc);

-      YYDPRINTF ((stderr, "Reduced stack %d by rule #%d. Now in state %d.\n",
-                 yyk, yyrule-1, yystack->yytops.yystates[yyk]->yylrState));
+      YYDPRINTF ((stderr, "Stack %d entering state %d\n",
+                 yyk, yystack->yytops.yystates[yyk]->yylrState));

     }
   else
     {
     }
   else
     {

-      int yyi, yyn;
+      size_t yyi;
+      int yyn;

       yyGLRState* yys, *yys0 = yystack->yytops.yystates[yyk];
       yyStateNum yynewLRState;
 
       yyGLRState* yys, *yys0 = yystack->yytops.yystates[yyk];
       yyStateNum yynewLRState;
 


@@ -1156,23 +1203,23 @@ yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
  *  parsing state; return 0 if no combination is possible,
  *  1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
 static int
  *  parsing state; return 0 if no combination is possible,
  *  1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
 static int

-yypreference (yySemanticOption* yyy0, yySemanticOption* yyy1)
+yypreference (yySemanticOption* y0, yySemanticOption* y1)

 {
 {

-  yyRuleNum yyr0 = yyy0->yyrule, yyr1 = yyy1->yyrule;
-  int yyp0 = yydprec[yyr0], yyp1 = yydprec[yyr1];
+  yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
+  int p0 = yydprec[r0], p1 = yydprec[r1];

 
 

-  if (yyp0 == yyp1)
+  if (p0 == p1)

     {
     {

-      if (yymerger[yyr0] == 0 || yymerger[yyr0] != yymerger[yyr1])
+      if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])

        return 0;
       else
        return 1;
     }
        return 0;
       else
        return 1;
     }

-  if (yyp0 == 0 || yyp1 == 0)
+  if (p0 == 0 || p1 == 0)

     return 0;
     return 0;

-  if (yyp0 < yyp1)
+  if (p0 < p1)

     return 3;
     return 3;

-  if (yyp0 > yyp1)
+  if (p0 > p1)

     return 2;
   return 0;
 }
     return 2;
   return 0;
 }


@@ -1226,7 +1273,8 @@ yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
 }
 
 #if YYDEBUG
 }
 
 #if YYDEBUG

-static yyGLRState YYLEFTMOST_STATE = { 0, NULL, -1, 0, { NULL } };
+/* FIXME: How can we initialize the lloc bit?  */
+static yyGLRState YYLEFTMOST_STATE = { 0, 0, -1, NULL, 0, { NULL } };

 
 static void yyreportTree (yySemanticOption* yyx, int yyindent)
 {
 
 static void yyreportTree (yySemanticOption* yyx, int yyindent)
 {


@@ -1272,6 +1320,10 @@ static void
 yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
                   yyGLRStack* yystack)
 {
 yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
                   yyGLRStack* yystack)
 {

+  /* `Unused' warnings.  */
+  (void) yyx0;
+  (void) yyx1;
+

 #if YYDEBUG
   YYFPRINTF (stderr, "Ambiguity detected.\n");
   YYFPRINTF (stderr, "Option 1,\n");
 #if YYDEBUG
   YYFPRINTF (stderr, "Ambiguity detected.\n");
   YYFPRINTF (stderr, "Option 1,\n");


@@ -1414,9 +1466,11 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
        {
          if (*yytokenp == YYEMPTY)
            {
        {
          if (*yytokenp == YYEMPTY)
            {

+             YYDPRINTF ((stderr, "Reading a token: "));

              yychar = YYLEX;
              *yytokenp = YYTRANSLATE(yychar);
              yychar = YYLEX;
              *yytokenp = YYTRANSLATE(yychar);

-             YYDPRINTF ((stderr, "Read token %s\n", yytokenName (*yytokenp)));
+             YYDPRINTF ((stderr, "Next token is %s\n",
+                         yytokenName (*yytokenp)));

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


@@ -1433,7 +1487,7 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
 
          if (yyisShiftAction (yyaction))
            {
 
          if (yyisShiftAction (yyaction))
            {

-             YYDPRINTF ((stderr, "Shifted token %s on stack %d, ",
+             YYDPRINTF ((stderr, "Shifting token %s on stack %d, ",

                          yytokenName (*yytokenp), yyk));
              yyglrShift (yystack, yyk, yyaction, yyposn+1, *yylvalp, yyllocp);
              YYDPRINTF ((stderr, "which is now in state #%d\n",
                          yytokenName (*yytokenp), yyk));
              yyglrShift (yystack, yyk, yyaction, yyposn+1, *yylvalp, yyllocp);
              YYDPRINTF ((stderr, "which is now in state #%d\n",


@@ -1456,17 +1510,21 @@ yyprocessOneStack (yyGLRStack* yystack, int yyk,
 static void
 yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
 {
 static void
 yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
 {

-  yySymbol* const yytokenp = yystack->yytokenp;
+  /* `Unused' warnings. */
+  (void) yylvalp;
+  (void) yyllocp;

 
   if (yystack->yyerrState == 0)
     {
 #if YYERROR_VERBOSE
 
   if (yystack->yyerrState == 0)
     {
 #if YYERROR_VERBOSE

-      int yyn, yyx, yycount, yysize;
-      char* yyprefix;
+      yySymbol* const yytokenp = yystack->yytokenp;
+      int yyn, yyx, yycount;
+      size_t yysize;
+      const char* yyprefix;

       char* yyp;
       char* yymsg;
       yyn = yypact[yystack->yytops.yystates[0]->yylrState];
       char* yyp;
       char* yymsg;
       yyn = yypact[yystack->yytops.yystates[0]->yylrState];

-      if (yyn > YYFLAG && yyn < YYLAST)
+      if (YYPACT_NINF < yyn && yyn < YYLAST)

        {
          yycount = 0;
          /* Start YYX at -YYN if negative to avoid negative indexes in
        {
          yycount = 0;
          /* Start YYX at -YYN if negative to avoid negative indexes in


@@ -1476,7 +1534,7 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
          yyprefix = ", expecting ";
          for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5;
               yyx += 1)
          yyprefix = ", expecting ";
          for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5;
               yyx += 1)

-           if (yycheck[yyx + yyn] == yyx)
+           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

              yysize += strlen (yytokenName (yyx)) + strlen (yyprefix),
                yycount += 1, yyprefix = " or ";
          yymsg = yyp = (char*) malloc (yysize);
              yysize += strlen (yytokenName (yyx)) + strlen (yyprefix),
                yycount += 1, yyprefix = " or ";
          yymsg = yyp = (char*) malloc (yysize);


@@ -1486,7 +1544,7 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
            {
              yyprefix = ", expecting ";
              for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size; yyx += 1)
            {
              yyprefix = ", expecting ";
              for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size; yyx += 1)

-               if (yycheck[yyx + yyn] == yyx)
+               if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

                  {
                    yyp += sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx));
                    yyprefix = " or ";
                  {
                    yyp += sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx));
                    yyprefix = " or ";


@@ -1502,50 +1560,47 @@ yyreportParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
     }
 }
 
     }
 }
 

-/* Recover from a syntax error on STACK, assuming that TOKENP,
+/* Recover from a syntax error on YYSTACK, assuming that YYTOKENP,

    YYLVALP, and YYLLOCP point to the syntactic category, semantic
    YYLVALP, and YYLLOCP point to the syntactic category, semantic

-   value, and location of the lookahead.
-   NOTE: This uses the panic-mode recovery algorithm described in the
-   Bison documentation, which differs from what is in bison.simple.
-   Specifically, this routine performs no reductions before shifting
-   the error token. */
+   value, and location of the lookahead.  */

 static void
 yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
 {
   yySymbol* const yytokenp = yystack->yytokenp;
 static void
 yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
 {
   yySymbol* const yytokenp = yystack->yytokenp;

-  int yyk, yyj;
+  size_t yyk;
+  int yyj;

 
   if (yystack->yyerrState == 0)
     yystack->yyerrState = 3;
   else if (yystack->yyerrState == 3)
 
   if (yystack->yyerrState == 0)
     yystack->yyerrState = 3;
   else if (yystack->yyerrState == 3)

-    {
-      /* We just shifted the error token and (perhaps) took some
-        reductions. Skip tokens until we can proceed. */
-      do {
+    /* We just shifted the error token and (perhaps) took some
+       reductions.  Skip tokens until we can proceed.  */
+    while (yytrue)
+      {

        if (*yytokenp == YYEOF)
          yyFail (yystack, NULL);
        if (*yytokenp != YYEMPTY)
          YYDPRINTF ((stderr, "Discarding token %s\n",
                      yytokenName (*yytokenp)));
        if (*yytokenp == YYEOF)
          yyFail (yystack, NULL);
        if (*yytokenp != YYEMPTY)
          YYDPRINTF ((stderr, "Discarding token %s\n",
                      yytokenName (*yytokenp)));

+       YYDPRINTF ((stderr, "Reading a token: "));

        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);
        yychar = YYLEX;
        *yytokenp = YYTRANSLATE (yychar);

-       YYDPRINTF ((stderr, "Read token %s\n", yytokenName (*yytokenp)));
+       YYDPRINTF ((stderr, "Next token is %s\n", yytokenName (*yytokenp)));

        yyj = yypact[yystack->yytops.yystates[0]->yylrState];
        yyj = yypact[yystack->yytops.yystates[0]->yylrState];

-       if (yyj == YYFLAG)
-         /* Something's not right; we shouldn't be here */
+       if (yyj == YYPACT_NINF)
+         /* Something's not right; we shouldn't be here.  */

          yyFail (yystack, NULL);
        yyj += *yytokenp;
          yyFail (yystack, NULL);
        yyj += *yytokenp;

-       if (yyj < 0 || yyj > YYLAST || yycheck[yyj] != *yytokenp)
+       if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp)

          {
            if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0)
              return;
          }
          {
            if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0)
              return;
          }

-       else if (yytable[yyj] != 0 && yytable[yyj] != YYFLAG)
+       else if (yytable[yyj] != 0 && yytable[yyj] != YYTABLE_NINF)

          return;
          return;

-      } while (yytrue);
-    }
+      }

 
 

-  /* Reduce to one stack */
+  /* Reduce to one stack.  */

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


@@ -1560,7 +1615,7 @@ yyrecoverParseError (yyGLRStack* yystack, YYSTYPE* yylvalp, YYLTYPE* yyllocp)
   while (yystack->yytops.yystates[0] != NULL)
     {
       yyj = yypact[yystack->yytops.yystates[0]->yylrState] + YYTERROR;
   while (yystack->yytops.yystates[0] != NULL)
     {
       yyj = yypact[yystack->yytops.yystates[0]->yylrState] + YYTERROR;

-      if (yyj != YYFLAG + YYTERROR && yyj >= 0 && yyj <= YYLAST &&
+      if (yyj != YYPACT_NINF + YYTERROR && yyj >= 0 && yyj <= YYLAST &&

          yycheck[yyj] == YYTERROR && yyisShiftAction (yytable[yyj]))
        {
          yyglrShift (yystack, 0, yytable[yyj],
          yycheck[yyj] == YYTERROR && yyisShiftAction (yytable[yyj]))
        {
          yyglrShift (yystack, 0, yytable[yyj],


@@ -1611,6 +1666,8 @@ yyparse (YYPARSE_PARAM_ARG)
   yyinitGLRStack (&yystack, YYINITDEPTH);
   yystack.yytokenp = &yytoken;
 
   yyinitGLRStack (&yystack, YYINITDEPTH);
   yystack.yytokenp = &yytoken;
 

+  YYDPRINTF ((stderr, "Starting parse\n"));
+

   if (setjmp (yystack.yyexception_buffer) != 0)
     goto yyDone;
 
   if (setjmp (yystack.yyexception_buffer) != 0)
     goto yyDone;
 


@@ -1648,9 +1705,10 @@ yyparse (YYPARSE_PARAM_ARG)
            {
              if (yytoken == YYEMPTY)
                {
            {
              if (yytoken == YYEMPTY)
                {

+                 YYDPRINTF ((stderr, "Reading a token: "));

                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);
                  yychar = YYLEX;
                  yytoken = YYTRANSLATE (yychar);

-                 YYDPRINTF ((stderr, "Read token %s\n",
+                 YYDPRINTF ((stderr, "Next token is %s\n",

                              yytokenName (yytoken)));
                }
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
                              yytokenName (yytoken)));
                }
              yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);


@@ -1658,7 +1716,7 @@ yyparse (YYPARSE_PARAM_ARG)
                break;
              if (yyisShiftAction (yyaction))
                {
                break;
              if (yyisShiftAction (yyaction))
                {

-                 YYDPRINTF ((stderr, "Shifted token %s. ",
+                 YYDPRINTF ((stderr, "Shifting token %s, ",

                              yytokenName (yytoken)));
                  if (yytoken != YYEOF)
                    yytoken = YYEMPTY;
                              yytokenName (yytoken)));
                  if (yytoken != YYEOF)
                    yytoken = YYEMPTY;


@@ -1666,7 +1724,7 @@ yyparse (YYPARSE_PARAM_ARG)
                  yyglrShift (&yystack, 0, yyaction, yyposn, yylval, yyllocp);
                  if (yystack.yyerrState > 0)
                    yystack.yyerrState -= 1;
                  yyglrShift (&yystack, 0, yyaction, yyposn, yylval, yyllocp);
                  if (yystack.yyerrState > 0)
                    yystack.yyerrState -= 1;

-                 YYDPRINTF ((stderr, "Now in state #%d\n",
+                 YYDPRINTF ((stderr, "Entering state %d\n",

                              yystack.yytops.yystates[0]->yylrState));
                }
              else if (yyisErrorAction (yyaction))
                              yystack.yytops.yystates[0]->yylrState));
                }
              else if (yyisErrorAction (yyaction))


@@ -1720,21 +1778,23 @@ yyparse (YYPARSE_PARAM_ARG)
 }
 
 /* DEBUGGING ONLY */
 }
 
 /* DEBUGGING ONLY */

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

 
 

-void
-yypstates (yyGLRState* yyst)
+static void
+yy_yypstack (yyGLRState* yys)

 {
 {

-  void yy_yypstack (yyGLRState* yys)
+  if (yys->yypred)

     {
     {

-      if (yys->yypred == NULL)
-       fprintf (stderr, "%d@%d", yys->yylrState, yys->yyposn);
-      else
-       {
-         yy_yypstack (yys->yypred);
-         fprintf (stderr, " -> %d@%d", yys->yylrState, yys->yyposn);
-       }
+      yy_yypstack (yys->yypred);
+      fprintf (stderr, " -> ");

     }
     }

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

 
 

+static void
+yypstates (yyGLRState* yyst)
+{

   if (yyst == NULL)
     fprintf (stderr, "<null>");
   else
   if (yyst == NULL)
     fprintf (stderr, "<null>");
   else


@@ -1742,7 +1802,7 @@ yypstates (yyGLRState* yyst)
   fprintf (stderr, "\n");
 }
 
   fprintf (stderr, "\n");
 }
 

-void
+static void

 yypstack (yyGLRStack* yystack, int yyk)
 {
   yypstates (yystack->yytops.yystates[yyk]);
 yypstack (yyGLRStack* yystack, int yyk)
 {
   yypstates (yystack->yytops.yystates[yyk]);


@@ -1752,35 +1812,37 @@ yypstack (yyGLRStack* yystack, int yyk)
     ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems)
 
 
     ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems)
 
 

-void
+static void

 yypdumpstack (yyGLRStack* yystack)
 {
   yyGLRStackItem* yyp;
 yypdumpstack (yyGLRStack* yystack)
 {
   yyGLRStackItem* yyp;

-  int yyi;
+  size_t yyi;

   for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
     {
   for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
     {

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

       if (*(bool*) yyp)
        {
       if (*(bool*) yyp)
        {

-         fprintf (stderr, "Res: %d, LR State: %d, posn: %d, pred: %d",
+         fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",

                   yyp->yystate.yyresolved, yyp->yystate.yylrState,
                   yyp->yystate.yyresolved, yyp->yystate.yylrState,

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

          if (! yyp->yystate.yyresolved)
          if (! yyp->yystate.yyresolved)

-           fprintf (stderr, ", firstVal: %d",
-                    YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
+           fprintf (stderr, ", firstVal: %ld",
+                    (long) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));

        }
       else
        {
        }
       else
        {

-         fprintf (stderr, "Option. rule: %d, state: %d, next: %d",
-                  yyp->yyoption.yyrule, YYINDEX (yyp->yyoption.yystate),
-                  YYINDEX (yyp->yyoption.yynext));
+         fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
+                  yyp->yyoption.yyrule,
+                  (long) YYINDEX (yyp->yyoption.yystate),
+                  (long) 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, "%d: %d; ", yyi, YYINDEX (yystack->yytops.yystates[yyi]));
+    fprintf (stderr, "%lu: %ld; ", (unsigned long) yyi,
+            (long) YYINDEX (yystack->yytops.yystates[yyi]));

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


@@ -1812,10 +1874,10 @@ b4_location_if(
 [#ifndef YYLTYPE
 typedef struct yyltype
 {
 [#ifndef YYLTYPE
 typedef struct yyltype
 {

-  int yyfirst_line;
-  int yyfirst_column;
-  int yylast_line;
-  int yylast_column;
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;

 } yyltype;
 # define YYLTYPE yyltype
 #endif
 } yyltype;
 # define YYLTYPE yyltype
 #endif