Fix bug such that the first pushed token's value and location are

[bison.git] / data / push.c

diff --git a/data/push.c b/data/push.c
index 87a02e78ccebe7032fa578aa90975b006adbe46c..51d75890e6830fb89a99a3fd0e9d3a8a61cc7c38 100644 (file)
--- a/data/push.c
+++ b/data/push.c
@@ -151,10 +151,11 @@ b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl '
 ]b4_identification
 m4_if(b4_prefix, [yy], [],
 [/* Substitute the variable and function names.  */
 ]b4_identification
 m4_if(b4_prefix, [yy], [],
 [/* Substitute the variable and function names.  */

-#define yyparse b4_prefix[]parse

 ]b4_push_if([#define yypush_parse b4_prefix[]push_parse
 ]b4_push_if([#define yypush_parse b4_prefix[]push_parse

-#define yypstate_init b4_prefix[]pstate_init
-#define yypstate b4_prefix[]pstate])[
+#define yypstate_new b4_prefix[]pstate_new
+#define yypstate_delete b4_prefix[]pstate_delete
+#define yypstate b4_prefix[]pstate],
+[#define yyparse b4_prefix[]parse])[

 #define yylex   b4_prefix[]lex
 #define yyerror b4_prefix[]error
 #define yylval  b4_prefix[]lval
 #define yylex   b4_prefix[]lex
 #define yyerror b4_prefix[]error
 #define yylval  b4_prefix[]lval


@@ -216,6 +217,22 @@ typedef struct YYLTYPE
 # define YYLTYPE_IS_TRIVIAL 1
 #endif])
 
 # define YYLTYPE_IS_TRIVIAL 1
 #endif])
 

+b4_push_if([[#ifndef YYPUSH_DECLS
+#  define YYPUSH_DECLS
+struct yypstate;
+typedef struct yypstate yypstate;
+enum { YYPUSH_MORE = 4 };
+]b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
+b4_c_function_decl([[yypstate_delete]], [[void]],
+                   [[[yypstate *yyps]], [[yyps]]])
+b4_c_function_decl([[yypush_parse]], [[int]],
+  [[[yypstate *yyps]], [[yyps]]],
+  [[[int yypushed_char]], [[yypushed_char]]],
+  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
+  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])m4_ifset([b4_parse_param], [,
+  b4_parse_param]))[
+#endif
+]])

 m4_ifdef([b4_provides],
 [[/* Copy the %provides blocks.  */
 ]b4_user_provides])[]dnl
 m4_ifdef([b4_provides],
 [[/* Copy the %provides blocks.  */
 ]b4_user_provides])[]dnl


@@ -372,9 +389,9 @@ void free (void *); /* INFRINGES ON USER NAME SPACE */
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 {

-  yytype_int16 yyss;
-  YYSTYPE yyvs;
-  ]b4_locations_if([  YYLTYPE yyls;
+  yytype_int16 yyss_alloc;
+  YYSTYPE yyvs_alloc;
+  ]b4_locations_if([  YYLTYPE yyls_alloc;

 ])dnl
 [};
 
 ])dnl
 [};
 


@@ -414,12 +431,12 @@ union yyalloc
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */

-# define YYSTACK_RELOCATE(Stack)                                       \
+# define YYSTACK_RELOCATE(Stack_alloc, Stack)                          \

     do                                                                 \
       {                                                                        \
        YYSIZE_T yynewbytes;                                            \
     do                                                                 \
       {                                                                        \
        YYSIZE_T yynewbytes;                                            \

-       YYCOPY (&yyptr->Stack, Stack, yysize);                          \
-       Stack = &yyptr->Stack;                                          \
+       YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
+       Stack = &yyptr->Stack_alloc;                                    \

        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \


@@ -705,7 +722,7 @@ do {                                                                \
                   [[YYSTYPE *yyvsp], [yyvsp]],
     b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
                   ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
                   [[YYSTYPE *yyvsp], [yyvsp]],
     b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
                   ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,

-                  ])b4_parse_param)[
+                  b4_parse_param]))[

 {
   int yynrhs = yyr2[yyrule];
   int yyi;
 {
   int yynrhs = yyr2[yyrule];
   int yyi;


@@ -956,35 +973,23 @@ yysyntax_error (char *yyresult, int yystate, int yychar)
 \f
 
 ]b4_yydestruct_generate([b4_c_function_def])[
 \f
 
 ]b4_yydestruct_generate([b4_c_function_def])[

-\f
-
-/* Prevent warnings from -Wmissing-prototypes.  */

 
 

+]b4_push_if([],
+[[/* Prevent warnings from -Wmissing-prototypes.  */

 #ifdef YYPARSE_PARAM
 ]b4_c_function_decl([yyparse], [int],
    [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
 #else /* ! YYPARSE_PARAM */
 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
 #ifdef YYPARSE_PARAM
 ]b4_c_function_decl([yyparse], [int],
    [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
 #else /* ! YYPARSE_PARAM */
 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[

-#endif /* ! YYPARSE_PARAM */
+#endif /* ! YYPARSE_PARAM */]])

 
 

-]b4_push_if([
-struct yypstate;
-enum { YYPUSH_MORE = 4 };
-]b4_c_function_decl([yypstate_init], [struct yypstate *], [[void], []])[
-]b4_c_function_decl([yypush_parse], [int],
-   [[struct yypstate *yyps], [yyps]],
-   [[int yynchar], [yynchar]],
-   [[YYSTYPE *yynlval], [yynlval]]
-   b4_locations_if([,[[YYLTYPE *yynlloc], [yynlloc]]]))[
-])[
-
-]m4_divert_push([KILL])# ======================== M4 code.
-# b4_declare_parser_variables
-# ---------------------------
+m4_divert_push([KILL])# ======================== M4 code.
+# b4_declare_scanner_communication_variables
+# ------------------------------------------

 # Declare the variables that are global, or local to YYPARSE if
 # pure-parser.
 # Declare the variables that are global, or local to YYPARSE if
 # pure-parser.

-m4_define([b4_declare_parser_variables],
-[/* The lookahead symbol.  */
+m4_define([b4_declare_scanner_communication_variables],
+[[/* The lookahead symbol.  */

 int yychar;
 
 /* The semantic value of the lookahead symbol.  */
 int yychar;
 
 /* The semantic value of the lookahead symbol.  */


@@ -992,20 +997,19 @@ YYSTYPE yylval;
 
 /* Number of syntax errors so far.  */
 ]b4_push_if([],[
 
 /* Number of syntax errors so far.  */
 ]b4_push_if([],[

-int yynerrs;])[b4_locations_if([
+int yynerrs;])b4_locations_if([[

 /* Location data for the lookahead symbol.  */
 /* Location data for the lookahead symbol.  */

-YYLTYPE yylloc;])
+YYLTYPE yylloc;]])

 ])
 
 ])
 

-m4_define([b4_yyssa],b4_push_if([yyps->yyssa],[yyssa]))

 m4_define([b4_yyerror_range],b4_push_if([yyps->yyerror_range],[yyerror_range]))
 
 m4_define([b4_yyerror_range],b4_push_if([yyps->yyerror_range],[yyerror_range]))
 

-# b4_declare_yyparse_variables
-# ----------------------------
-# Declare all the variables that are needed local to YYPARSE
-m4_define([b4_declare_yyparse_variables],
-[[struct yypstate
-  {
+# b4_declare_parser_state_variables
+# ---------------------------------
+# Declare all the variables that are needed to maintain the parser state
+# between calls to yypush_parse.
+m4_define([b4_declare_parser_state_variables],
+[[

     int yystate;
     int yyn;
     int yyresult;
     int yystate;
     int yyn;
     int yyresult;


@@ -1030,78 +1034,87 @@ m4_define([b4_declare_yyparse_variables],
     /* The semantic value stack.  */
     YYSTYPE yyvsa[YYINITDEPTH];
     YYSTYPE *yyvs;
     /* The semantic value stack.  */
     YYSTYPE yyvsa[YYINITDEPTH];
     YYSTYPE *yyvs;

-    YYSTYPE *yyvsp;]]b4_locations_if([[[
+    YYSTYPE *yyvsp;
+]b4_locations_if([[

     /* The location stack.  */
     YYLTYPE yylsa[YYINITDEPTH];
     YYLTYPE *yyls;
     YYLTYPE *yylsp;
     /* The locations where the error started and ended.  */
     /* The location stack.  */
     YYLTYPE yylsa[YYINITDEPTH];
     YYLTYPE *yyls;
     YYLTYPE *yylsp;
     /* The locations where the error started and ended.  */

-    YYLTYPE yyerror_range[2];]]])[
+    YYLTYPE yyerror_range[2];]])[

     YYSIZE_T yystacksize;
     /* The variables used to return semantic value and location from the
        action routines.  */
     YYSTYPE yyval;
     YYSIZE_T yystacksize;
     /* The variables used to return semantic value and location from the
        action routines.  */
     YYSTYPE yyval;

+]b4_locations_if([[  YYLTYPE yyloc;
+]])])
+
+m4_divert_pop([KILL])dnl# ====================== End of M4 code.
+
+b4_pure_if([], [b4_declare_scanner_communication_variables])
+
+b4_push_if(
+[[struct yypstate
+  {
+    ]b4_declare_parser_state_variables[

     /* Used to determine if this is the first time this instance has
        been used.  */
     /* Used to determine if this is the first time this instance has
        been used.  */

-    int yynew;]b4_locations_if([YYLTYPE yyloc;])[
+    int yynew;

   };
 
 /* Initialize the parser data structure.  */
   };
 
 /* Initialize the parser data structure.  */

-struct yypstate*
-yypstate_init (void)
+]b4_c_function_def([[yypstate_new]], [[yypstate *]])[

 {
 {

-  struct yypstate *yyps = (struct yypstate *) malloc (sizeof *yyps);
-  yyps->yystate = 0;
+  yypstate *yyps = (yypstate *) malloc (sizeof *yyps);

   yyps->yyresult = -1;
   yyps->yyresult = -1;

-  yyps->yyerrstatus = 0;
-  yyps->yytoken = 0;
-
-  yyps->yyss = yyps->yyssa;
-  yyps->yyvs = yyps->yyvsa;
-
-  ]b4_locations_if([
-    yyps->yyls = yyps->yylsa;])[
-  yyps->yystacksize = YYINITDEPTH;
-
-  yyps->yyssp = yyps->yyss;
-  yyps->yyvsp = yyps->yyvs;
-

   yyps->yynew = 1;
   yyps->yynew = 1;

-
-]b4_locations_if([  yyps->yylsp = yyps->yyls;])[
-

   return yyps;
   return yyps;

-}])
-m4_divert_pop([KILL])dnl# ====================== End of M4 code.
+}

 
 

-b4_push_if([],[b4_pure_if([],
-          [b4_declare_parser_variables])])
+]b4_c_function_def([[yypstate_delete]], [[void]],
+                   [[[yypstate *yyps]], [[yyps]]])[
+{
+  free (yyps);
+}

 
 

-b4_push_if([b4_declare_yyparse_variables])
+#define yystate yyps->yystate
+#define yyn yyps->yyn
+#define yyresult yyps->yyresult
+#define yyerrstatus yyps->yyerrstatus
+#define yytoken yyps->yytoken
+#define yyssa yyps->yyssa
+#define yyss yyps->yyss
+#define yyssp yyps->yyssp
+#define yyvsa yyps->yyvsa
+#define yyvs yyps->yyvs
+#define yyvsp yyps->yyvsp
+]b4_locations_if([[#define yylsa yyps->yylsa
+#define yyls yyps->yyls
+#define yylsp yyps->yylsp
+]])[#define yystacksize yyps->yystacksize
+#define yyval yyps->yyval
+]b4_locations_if([[#define yyloc yyps->yyloc
+]])])[

 
 /*-------------------------.
 | yyparse or yypush_parse.  |
 `-------------------------*/
 
 
 /*-------------------------.
 | yyparse or yypush_parse.  |
 `-------------------------*/
 

-b4_push_if([
-b4_c_function_def([yypush_parse], [int], [[struct yypstate *yyps], [yyps]], 
-                  [[int yynchar], [yynchar]], [[YYSTYPE *yynlval], [yynlval]]
-                 b4_locations_if([,[[YYLTYPE *yynlloc], [yynlloc]]]))],[
+]b4_push_if([
+b4_c_function_def([[yypush_parse]], [[int]], [[[yypstate *yyps]], [[yyps]]], 
+  [[[int yypushed_char]], [[yypushed_char]]],
+  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
+  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])m4_ifset([b4_parse_param], [,
+  b4_parse_param]))], [

 #ifdef YYPARSE_PARAM
 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
 #else /* ! YYPARSE_PARAM */
 b4_c_function_def([yyparse], [int], b4_parse_param)
 #ifdef YYPARSE_PARAM
 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
 #else /* ! YYPARSE_PARAM */
 b4_c_function_def([yyparse], [int], b4_parse_param)

-#endif])
-{[
-  ]b4_pure_if([b4_declare_parser_variables])[
-  ]b4_push_if([b4_declare_parser_variables])[
-  int yystate;
-  int yyn;
-  int yyresult;
-  /* Number of tokens to shift before error messages enabled.  */
-  int yyerrstatus;
-  /* Lookahead token as an internal (translated) token number.  */
-  int yytoken = 0;
+#endif])[
+{
+  ]b4_pure_if([b4_declare_scanner_communication_variables])
+  b4_push_if([], [b4_declare_parser_state_variables])[
+

 #if YYERROR_VERBOSE
   /* Buffer for error messages, and its allocated size.  */
   char yymsgbuf[128];
 #if YYERROR_VERBOSE
   /* Buffer for error messages, and its allocated size.  */
   char yymsgbuf[128];


@@ -1109,76 +1122,47 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 #endif
 
   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
 #endif
 

-  /* Three stacks and their tools:
-     `yyss': related to states,
-     `yyvs': related to semantic values,
-     `yyls': related to locations.
-
-     Refer to the stacks thru separate pointers, to allow yyoverflow
-     to reallocate them elsewhere.  */
-
-  /* The state stack.  */
-  yytype_int16 yyssa[YYINITDEPTH];
-  yytype_int16 *yyss = yyssa;
-  yytype_int16 *yyssp;
-
-  /* The semantic value stack.  */
-  YYSTYPE yyvsa[YYINITDEPTH];
-  YYSTYPE *yyvs = yyvsa;
-  YYSTYPE *yyvsp;
-
-]b4_locations_if(
-[[  /* The location stack.  */
-  YYLTYPE yylsa[YYINITDEPTH];
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;
-  /* The locations where the error started and ended.  */
-  ]b4_push_if([],[YYLTYPE yyerror_range[[2]]])[;
-  ]])[
-

 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
 
 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
 

-  YYSIZE_T yystacksize = YYINITDEPTH;
-
-  /* The variables used to return semantic value and location from the
-     action routines.  */
-  YYSTYPE yyval;
-]b4_locations_if([  YYLTYPE yyloc;])[
-

   /* The number of symbols on the RHS of the reduced rule.
      Keep to zero when no symbol should be popped.  */
   int yylen = 0;
   /* The number of symbols on the RHS of the reduced rule.
      Keep to zero when no symbol should be popped.  */
   int yylen = 0;

+]b4_push_if([[
+  if (!yyps->yynew)
+    goto yyread_pushed_token;
+]])[
+  yytoken = 0;
+  yyss = yyssa;
+  yyvs = yyvsa;
+]b4_locations_if([[  yyls = yylsa;
+]])[
+  yystacksize = YYINITDEPTH;

 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;

-]b4_push_if([  yychar = yynchar;
-  if (yynlval)
-    yylval = *yynlval;
-]b4_locations_if([  if (yynlloc)
-     yylloc = *yynlloc;])[],[yynerrs = 0;
-  yychar = YYEMPTY; /* Cause a token to be read.  */])[
+]b4_push_if([], [[  yynerrs = 0;]])[
+  yychar = YYEMPTY; /* Cause a token to be read.  */

 
   /* Initialize stack pointers.
      Waste one element of value and location stack
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
 
   /* Initialize stack pointers.
      Waste one element of value and location stack
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */

-

   yyssp = yyss;
   yyvsp = yyvs;
 ]b4_locations_if([[  yylsp = yyls;
   yyssp = yyss;
   yyvsp = yyvs;
 ]b4_locations_if([[  yylsp = yyls;

-]b4_push_if([],[
+

 #if YYLTYPE_IS_TRIVIAL
   /* Initialize the default location before parsing starts.  */
   yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
   yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
 #if YYLTYPE_IS_TRIVIAL
   /* Initialize the default location before parsing starts.  */
   yylloc.first_line   = yylloc.last_line   = ]b4_location_initial_line[;
   yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;

-#endif])[
+#endif

 ]])
 m4_ifdef([b4_initial_action], [
 m4_pushdef([b4_at_dollar],     [m4_define([b4_at_dollar_used])yylloc])dnl
 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
 ]])
 m4_ifdef([b4_initial_action], [
 m4_pushdef([b4_at_dollar],     [m4_define([b4_at_dollar_used])yylloc])dnl
 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl

-  /* User initialization code.  */
+/* User initialization code.  */

 b4_user_initial_action
 m4_popdef([b4_dollar_dollar])dnl
 m4_popdef([b4_at_dollar])])dnl
 b4_user_initial_action
 m4_popdef([b4_dollar_dollar])dnl
 m4_popdef([b4_at_dollar])])dnl


@@ -1186,32 +1170,7 @@ m4_ifdef([b4_dollar_dollar_used],[[  yyvsp[0] = yylval;
 ]])dnl
 m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
 ]])dnl
 ]])dnl
 m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
 ]])dnl

-[  ]b4_push_if([
-       /* Initialize the locals to the current context. */
-       yystate = yyps->yystate;
-       yyn = yyps->yyn;
-       yyresult = yyps->yyresult;
-       yyerrstatus = yyps->yyerrstatus;
-       yytoken = yyps->yytoken;
-
-       yyss = yyps->yyss;
-       yyssp = yyps->yyssp;
-
-       yyvs = yyps->yyvs;
-       yyvsp = yyps->yyvsp;
-
-       ]b4_locations_if([[  /* The location stack.  */
-       yyls = yyps->yyls;
-       yylsp = yyps->yylsp;]])[
-
-       yystacksize = yyps->yystacksize;
-       yyval = yyps->yyval;
-       ]b4_locations_if([yyloc = yyps->yyloc;])[
-      if (yyps->yynew == 0)
-      {
-       goto gottoken;
-      }
-      yyps->yynew= 0;])[
+[

   goto yysetstate;
 
 /*------------------------------------------------------------.
   goto yysetstate;
 
 /*------------------------------------------------------------.


@@ -1269,11 +1228,11 @@ m4_ifdef([b4_at_dollar_used], [[  yylsp[0] = yylloc;
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
          goto yyexhaustedlab;
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
          goto yyexhaustedlab;

-       YYSTACK_RELOCATE (yyss);
-       YYSTACK_RELOCATE (yyvs);
-]b4_locations_if([     YYSTACK_RELOCATE (yyls);])[
+       YYSTACK_RELOCATE (yyss_alloc, yyss);
+       YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+]b4_locations_if([     YYSTACK_RELOCATE (yyls_alloc, yyls);])[

 #  undef YYSTACK_RELOCATE
 #  undef YYSTACK_RELOCATE

-       if (yyss1 != ]b4_yyssa[)
+       if (yyss1 != yyssa)

          YYSTACK_FREE (yyss1);
       }
 # endif
          YYSTACK_FREE (yyss1);
       }
 # endif


@@ -1315,33 +1274,23 @@ yybackup:
   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
   if (yychar == YYEMPTY)
     {
   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
   if (yychar == YYEMPTY)
     {

-      ]b4_push_if([
-       YYDPRINTF ((stderr, "Return for a new token:\n"));
-       yyresult = YYPUSH_MORE;
-       /* Initialize the locals to the current context. */
-       yyps->yystate = yystate;
-       yyps->yyn = yyn;
-       yyps->yyerrstatus = yyerrstatus;
-       yyps->yytoken = yytoken;
-
-       yyps->yyss = yyss;
-       yyps->yyssp = yyssp;
-
-       yyps->yyvs = yyvs;
-       yyps->yyvsp = yyvsp;
-
-       ]b4_locations_if([[  /* The location stack.  */
-       yyps->yyls = yyls;
-       yyps->yylsp = yylsp;]])[
-
-       yyps->yystacksize = yystacksize;
-       yyps->yyval = yyval;
-       ]b4_locations_if([yyps->yyloc = yyloc;])[
-       goto yypushreturn;
-gottoken:])[
-      YYDPRINTF ((stderr, "Reading a token: "));
-      ]b4_push_if([], [yychar = YYLEX;])[
-    }
+]b4_push_if([[      if (!yyps->yynew)
+        {
+          YYDPRINTF ((stderr, "Return for a new token:\n"));
+          yyresult = YYPUSH_MORE;
+          goto yypushreturn;
+        }
+      yyps->yynew = 0;
+
+yyread_pushed_token:
+]])[      YYDPRINTF ((stderr, "Reading a token: "));
+]b4_push_if([[      yychar = yypushed_char;
+      if (yypushed_val)
+        yylval = *yypushed_val;
+]b4_locations_if([[      if (yypushed_loc)
+        yylloc = *yypushed_loc;]])],
+[[      yychar = YYLEX;
+]])[    }

 
   if (yychar <= YYEOF)
     {
 
   if (yychar <= YYEOF)
     {


@@ -1623,7 +1572,7 @@ yyreturn:
       YYPOPSTACK (1);
     }
 #ifndef yyoverflow
       YYPOPSTACK (1);
     }
 #ifndef yyoverflow

-  if (yyss != ]b4_yyssa[)
+  if (yyss != yyssa)

     YYSTACK_FREE (yyss);
 #endif
 ]b4_push_if([yypushreturn:])[
     YYSTACK_FREE (yyss);
 #endif
 ]b4_push_if([yypushreturn:])[


@@ -1631,7 +1580,6 @@ yyreturn:
   if (yymsg != yymsgbuf)
     YYSTACK_FREE (yymsg);
 #endif
   if (yymsg != yymsgbuf)
     YYSTACK_FREE (yymsg);
 #endif

-  ]b4_push_if([yyps->yyresult = YYID (yyresult);])[

   /* Make sure YYID is used.  */
   return YYID (yyresult);
 ]}
   /* Make sure YYID is used.  */
   return YYID (yyresult);
 ]}


@@ -1678,18 +1626,27 @@ typedef struct YYLTYPE
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 

-]b4_push_if([struct ]b4_prefix[pstate;
-]b4_c_function_decl([]b4_prefix[pstate_init], [struct ]b4_prefix[pstate *], [[void], []])[
-]b4_c_function_decl([]b4_prefix[push_parse], [int],
-   [[struct ]b4_prefix[pstate *]b4_prefix[pstate], []b4_prefix[pstate]],
-   [[int yynchar], [yynchar]],
-   [[YYSTYPE *yynlval], [yynlval]]
-   b4_locations_if([,[[YYLTYPE *yynlloc], [yynlloc]]]))[
-enum { YYPUSH_MORE = 4 };])[

 ]b4_pure_if([],
           [extern YYLTYPE b4_prefix[]lloc;])
 )dnl b4_locations_if
 
 ]b4_pure_if([],
           [extern YYLTYPE b4_prefix[]lloc;])
 )dnl b4_locations_if
 

+b4_push_if([[#ifndef YYPUSH_DECLS
+#  define YYPUSH_DECLS
+struct ]b4_prefix[pstate;
+typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
+enum { YYPUSH_MORE = 4 };
+]b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
+                    [[[void]], []])
+b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
+                   [[b4_prefix[pstate *yyps]], [[yyps]]])
+b4_c_function_decl([b4_prefix[push_parse]], [[int]],
+  [[b4_prefix[pstate *yyps]], [[yyps]]],
+  [[[int yypushed_char]], [[yypushed_char]]],
+  [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
+  [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])m4_ifset([b4_parse_param], [,
+  b4_parse_param]))[
+#endif
+]])

 m4_ifdef([b4_provides],
 [[/* Copy the %provides blocks.  */
 ]b4_user_provides])[]
 m4_ifdef([b4_provides],
 [[/* Copy the %provides blocks.  */
 ]b4_user_provides])[]