* data/m4sugar/m4sugar.m4 (m4_map): Recognize when the list of

[bison.git] / data / bison.simple

diff --git a/data/bison.simple b/data/bison.simple
index 668d528ab2050ee4cf791efd04d2c4c35456ccdf..80314c0c584acc497cd2b8119da03696e3a20ca5 100644 (file)
--- a/data/bison.simple
+++ b/data/bison.simple
@@ -1,4 +1,52 @@
-m4_divert(-1)
+m4_divert(-1)                                                       -*- C -*-
+
+# b4_sint_type(MAX)
+# -----------------
+# Return the smallest signed int type able to handle the number MAX.
+m4_define([b4_sint_type],
+[m4_if(m4_eval([$1 <= 127]),        [1], [signed char],
+       m4_eval([$1 <= 32767]),      [1], [signed short],
+       [signed int])])
+
+
+# b4_uint_type(MAX)
+# -----------------
+# Return the smallest unsigned int type able to handle the number MAX.
+m4_define([b4_uint_type],
+[m4_if(m4_eval([$1 <= 255]),        [1], [unsigned char],
+       m4_eval([$1 <= 65535]),      [1], [unsigned short],
+       [unsigned int])])
+
+
+# b4_lhs_value([TYPE])
+# --------------------
+# Expansion of $<TYPE>$.
+m4_define([b4_lhs_value],
+[yyval[]m4_ifval([$1], [.$1])])
+
+
+# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
+# --------------------------------------
+# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
+# symbols on RHS.
+m4_define([b4_rhs_value],
+[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
+
+
+# b4_lhs_location()
+# -----------------
+# Expansion of @$.
+m4_define([b4_lhs_location],
+[yyloc])
+
+
+# b4_rhs_location(RULE-LENGTH, NUM)
+# ---------------------------------
+# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
+# on RHS.
+m4_define([b4_rhs_location],
+[yylsp@<:@m4_eval([$2 - $1])@:>@])
+

 
 m4_define_default([b4_input_suffix], [.y])
 
 
 m4_define_default([b4_input_suffix], [.y])
 


@@ -20,19 +68,47 @@ m4_define_default([b4_header_guard],
                                 [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
 
 
                                 [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
 
 

-# b4_token_defines(TOKEN-NAME, TOKEN-NUMBER)
-# ------------------------------------------
+## ------------------------- ##
+## Assigning token numbers.  ##
+## ------------------------- ##
+
+# b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
+# -----------------------------------------

 # Output the definition of this token as #define.
 m4_define([b4_token_define],
 [#define $1 $2
 ])
 
 
 # Output the definition of this token as #define.
 m4_define([b4_token_define],
 [#define $1 $2
 ])
 
 

+# b4_token_enum(TOKEN-NAME, TOKEN-NUMBER)
+# ---------------------------------------
+# Output the definition of this token as an enum.
+m4_define([b4_token_enum],
+[$1 = $2])
+
+

 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 # -------------------------------------------------------
 # b4_token_defines(LIST-OF-PAIRS-TOKEN-NAME-TOKEN-NUMBER)
 # -------------------------------------------------------

-# Output the definition of the tokens as #define.
+# Output the definition of the tokens (if there are) as enums and #define.

 m4_define([b4_token_defines],
 m4_define([b4_token_defines],

-[m4_map([b4_token_define], [$@])])
+[m4_if([$@], [[]], [],
+[/* Tokens.  */
+#ifndef YYTOKENTYPE
+# if defined (__STDC__) || defined (__cplusplus)
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+m4_map_sep([     b4_token_enum], [,
+],
+           [$@])
+   };
+# endif
+  /* POSIX requires `int' for tokens in interfaces.  */
+# define YYTOKENTYPE int
+#endif /* !YYTOKENTYPE */
+m4_map([b4_token_define], [$@])
+])
+])

 
 
 m4_divert(0)dnl
 
 
 m4_divert(0)dnl


@@ -66,8 +142,15 @@ m4_divert(0)dnl
 
 /* This is the parser code that is written into each bison parser when
    the %semantic_parser declaration is not specified in the grammar.
 
 /* This is the parser code that is written into each bison parser when
    the %semantic_parser declaration is not specified in the grammar.

-   It was written by Richard Stallman by simplifying the hairy parser
-   used when %semantic_parser is specified.  */
+   It was written by Richard Stallman by simplifying the original so
+   called ``semantic'' parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */

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


@@ -93,8 +176,10 @@ m4_if(b4_prefix[], [yy], [],
 #endif
 ])
 
 #endif
 ])
 

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

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


@@ -110,11 +195,14 @@ b4_prologue
 #endif
 
 #ifndef YYSTYPE
 #endif
 
 #ifndef YYSTYPE

-m4_ifdef([b4_stype_line],
+m4_ifdef([b4_stype],

 [#line b4_stype_line "b4_filename"
 [#line b4_stype_line "b4_filename"

-])dnl
-typedef b4_stype yystype;
+typedef union b4_stype yystype;
+/* Line __line__ of __file__.  */
+#line __oline__ "__ofile__"],
+[typedef int yystype;])

 # define YYSTYPE yystype
 # define YYSTYPE yystype

+# define YYSTYPE_IS_TRIVIAL 1

 #endif
 
 #ifndef YYLTYPE
 #endif
 
 #ifndef YYLTYPE


@@ -126,19 +214,16 @@ typedef struct yyltype
   int last_column;
 } yyltype;
 # define YYLTYPE b4_ltype
   int last_column;
 } yyltype;
 # define YYLTYPE b4_ltype

+# define YYLTYPE_IS_TRIVIAL 1

 #endif
 
 #endif
 

-/* Line __line__ of __file__.  */
-#line __oline__ "b4_output_parser_name"
+/* Copy the second part of user declarations.  */
+b4_post_prologue

 
 

-/* All symbols defined below should begin with yy or YY, to avoid
-   infringing on user name space.  This should be done even for local
-   variables, as they might otherwise be expanded by user macros.
-   There are some unavoidable exceptions within include files to
-   define necessary library symbols; they are noted "INFRINGES ON
-   USER NAME SPACE" below.  */
+/* Line __line__ of __file__.  */
+#line __oline__ "__ofile__"

 
 

-#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
+#if ! defined (yyoverflow) || YYERROR_VERBOSE

 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 
 
 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 


@@ -167,6 +252,12 @@ typedef struct yyltype
 #  define YYSTACK_ALLOC malloc
 #  define YYSTACK_FREE free
 # endif
 #  define YYSTACK_ALLOC malloc
 #  define YYSTACK_FREE free
 # endif

+#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+
+
+#if (! defined (yyoverflow) \
+     && (! defined (__cplusplus) \
+        || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))

 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc
 
 /* A type that is properly aligned for any stack member.  */
 union yyalloc


@@ -185,12 +276,12 @@ union yyalloc
    N elements.  */
 # if YYLSP_NEEDED
 #  define YYSTACK_BYTES(N) \
    N elements.  */
 # if YYLSP_NEEDED
 #  define YYSTACK_BYTES(N) \

-    ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
-     + 2 * YYSTACK_GAP_MAX)
+     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
+      + 2 * YYSTACK_GAP_MAX)

 # else
 #  define YYSTACK_BYTES(N) \
 # else
 #  define YYSTACK_BYTES(N) \

-    ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
-     + YYSTACK_GAP_MAX)
+     ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
+      + YYSTACK_GAP_MAX)

 # endif
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
 # endif
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do


@@ -205,7 +296,7 @@ union yyalloc
        {                                       \
          register YYSIZE_T yyi;                \
          for (yyi = 0; yyi < (Count); yyi++)   \
        {                                       \
          register YYSIZE_T yyi;                \
          for (yyi = 0; yyi < (Count); yyi++)   \

-           (To)[yyi] = (From)[yyi];            \
+           (To)[[yyi]] = (From)[[yyi]];        \

        }                                       \
       while (0)
 #  endif
        }                                       \
       while (0)
 #  endif


@@ -227,10 +318,7 @@ union yyalloc
       }                                                                        \
     while (0)
 
       }                                                                        \
     while (0)
 

-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
-
-/* Tokens.  */
-b4_token_defines(b4_tokens)
+#endif

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


@@ -245,13 +333,16 @@ b4_token_defines(b4_tokens)
 #define YYNRULES  b4_nrules
 /* YYNRULES -- Number of states. */
 #define YYNSTATES  b4_nstates
 #define YYNRULES  b4_nrules
 /* YYNRULES -- Number of states. */
 #define YYNSTATES  b4_nstates

-#define YYMAXUTOK  b4_maxtok

 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */

-#define YYTRANSLATE(x) ((unsigned)(x) <= b4_maxtok ? yytranslate[[x]] : b4_nsym)
+#define YYUNDEFTOK  b4_undef_token_number
+#define YYMAXUTOK   b4_user_token_number_max
+
+#define YYTRANSLATE(X) \
+  ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)

 
 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
 
 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */

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

 {
   b4_translate
 };
 {
   b4_translate
 };


@@ -259,25 +350,25 @@ static const char 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 short yyprhs[[]] =
+static const b4_uint_type(b4_prhs_max) 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 short yyrhs[[]] =
+static const b4_sint_type(b4_rhs_max) 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 short yyrline[[]] =
+static const b4_uint_type(b4_rline_max) yyrline[[]] =

 {
   b4_rline
 };
 #endif
 
 {
   b4_rline
 };
 #endif
 

-#if (YYDEBUG) || YYERROR_VERBOSE
+#if YYDEBUG || YYERROR_VERBOSE

 /* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[[]] =
 /* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
 static const char *const yytname[[]] =


@@ -286,27 +377,28 @@ static const char *const yytname[[]] =
 };
 #endif
 
 };
 #endif
 

-/* YYTOKNUM[[YYN]] -- Index in YYTNAME corresponding to YYLEX.  */
+/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
+   token YYLEX-NUM.  */

 static const short yytoknum[[]] =
 {
   b4_toknum
 };
 
 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
 static const short yytoknum[[]] =
 {
   b4_toknum
 };
 
 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */

-static const short yyr1[[]] =
+static const b4_uint_type(b4_r1_max) 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 short yyr2[[]] =
+static const b4_uint_type(b4_r2_max) yyr2[[]] =

 {
   b4_r2
 };
 
 {
   b4_r2
 };
 

-/* 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[[STATE-NAME]] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */

 static const short yydefact[[]] =
 {
   b4_defact
 static const short yydefact[[]] =
 {
   b4_defact


@@ -344,6 +436,12 @@ static const short yycheck[[]] =
   b4_check
 };
 
   b4_check
 };
 

+/* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const b4_uint_type(b4_stos_max) yystos[[]] =
+{
+  b4_stos
+};

 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 # define YYSIZE_T __SIZE_TYPE__
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 # define YYSIZE_T __SIZE_TYPE__


@@ -399,16 +497,14 @@ while (0)
 #define YYERRCODE      256
 
 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
 #define YYERRCODE      256
 
 /* YYLLOC_DEFAULT -- Compute the default location (before the actions

-   are run).
-
-   When YYLLOC_DEFAULT is run, CURRENT is set the location of the
-   first token.  By default, to implement support for ranges, extend
-   its range to the last symbol.  */
+   are run).  */

 
 #ifndef YYLLOC_DEFAULT
 
 #ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(Current, Rhs, N)               \
-   Current.last_line   = Rhs[[N]].last_line;   \
-   Current.last_column = Rhs[[N]].last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N)           \
+  Current.first_line   = Rhs[[1]].first_line;      \
+  Current.first_column = Rhs[[1]].first_column;    \
+  Current.last_line    = Rhs[[N]].last_line;       \
+  Current.last_column  = Rhs[[N]].last_column;

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


@@ -444,8 +540,8 @@ do {                                                \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)

-/* Nonzero means print parse trace.  Since this is uninitialized, it
-   does not stop multiple parsers from coexisting.  */
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */

 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)


@@ -555,6 +651,7 @@ int yyparse (void *);
 int yyparse (void);
 # endif
 #endif
 int yyparse (void);
 # endif
 #endif

+static void yydestructor (int symbol_type, YYSTYPE symbol_value);

 
 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
    variables are global, or local to YYPARSE.  */
 
 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
    variables are global, or local to YYPARSE.  */


@@ -713,6 +810,9 @@ yyparse (YYPARSE_PARAM_ARG)
        yyvs = yyvs1;
       }
 #else /* no yyoverflow */
        yyvs = yyvs1;
       }
 #else /* no yyoverflow */

+# ifndef YYSTACK_RELOCATE
+      goto yyoverflowlab;
+# else

       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)
        goto yyoverflowlab;
       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)
        goto yyoverflowlab;


@@ -728,13 +828,14 @@ yyparse (YYPARSE_PARAM_ARG)
          goto yyoverflowlab;
        YYSTACK_RELOCATE (yyss);
        YYSTACK_RELOCATE (yyvs);
          goto yyoverflowlab;
        YYSTACK_RELOCATE (yyss);
        YYSTACK_RELOCATE (yyvs);

-# if YYLSP_NEEDED
+#  if YYLSP_NEEDED

        YYSTACK_RELOCATE (yyls);
        YYSTACK_RELOCATE (yyls);

-# endif
-# undef YYSTACK_RELOCATE
+#  endif
+#  undef YYSTACK_RELOCATE

        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
       }
        if (yyss1 != yyssa)
          YYSTACK_FREE (yyss1);
       }

+# endif

 #endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;
 #endif /* no yyoverflow */
 
       yyssp = yyss + yysize - 1;


@@ -886,9 +987,7 @@ yyreduce:
   yyval = yyvsp[1-yylen];
 
 #if YYLSP_NEEDED
   yyval = yyvsp[1-yylen];
 
 #if YYLSP_NEEDED

-  /* Similarly for the default location.  Let the user run additional
-     commands if for instance locations are ranges.  */
-  yyloc = yylsp[1-yylen];
+  /* Default location. */

   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
 #endif
 
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
 #endif
 


@@ -914,7 +1013,7 @@ yyreduce:
     }
 
 /* Line __line__ of __file__.  */
     }
 
 /* Line __line__ of __file__.  */

-#line __oline__ "b4_output_parser_name"
+#line __oline__ "__ofile__"

 \f
 [  yyvsp -= yylen;
   yyssp -= yylen;
 \f
 [  yyvsp -= yylen;
   yyssp -= yylen;


@@ -1027,79 +1126,71 @@ yyerrlab1:
        YYABORT;
       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
                  yychar, yytname[yychar1]));
        YYABORT;
       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
                  yychar, yytname[yychar1]));

+      yydestructor (yychar1, yylval);

       yychar = YYEMPTY;
     }
 
   /* Else will try to reuse lookahead token after shifting the error
      token.  */
 
       yychar = YYEMPTY;
     }
 
   /* Else will try to reuse lookahead token after shifting the error
      token.  */
 

-  yyerrstatus = 3;             /* Each real token shifted decrements this.  */
-
-  goto yyerrhandle;
+  yyerrstatus = 3;     /* Each real token shifted decrements this.  */

 
 

+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (yyn != YYFLAG)
+       {
+         yyn += YYTERROR;
+         if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+           {
+             yyn = yytable[yyn];
+             if (0 < yyn)
+               break;
+           }
+       }

 
 

-/*-------------------------------------------------------------------.
-| yyerrdefault -- current state does not do anything special for the |
-| error token.                                                       |
-`-------------------------------------------------------------------*/
-yyerrdefault:
-#if 0
-  /* This is wrong; only states that explicitly want error tokens
-     should shift them.  */
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+       YYABORT;

 
 

-  /* If its default is to accept any token, ok.  Otherwise pop it.  */
-  yyn = yydefact[yystate];
-  if (yyn)
-    goto yydefault;
+#if YYDEBUG
+      if (yydebug)
+       {
+         if (yystos[yystate] < YYNTOKENS)
+           {
+             YYFPRINTF (stderr, "Error: popping token %d (%s",
+                        yytoknum[yystos[yystate]], yytname[yystos[yystate]]);
+# ifdef YYPRINT
+             YYPRINT (stderr, yytoknum[yystos[yystate]], *yyvsp);
+# endif
+             YYFPRINTF (stderr, ")\n");
+           }
+         else
+           {
+             YYFPRINTF (stderr, "Error: popping nonterminal (%s)\n",
+                        yytname[yystos[yystate]]);
+           }
+       }

 #endif
 
 #endif
 

-
-/*---------------------------------------------------------------.
-| yyerrpop -- pop the current state because it cannot handle the |
-| error token.                                                   |
-`---------------------------------------------------------------*/
-yyerrpop:
-  if (yyssp == yyss)
-    YYABORT;
-  yyvsp--;
-  yystate = *--yyssp;
+      yydestructor (yystos[yystate], *yyvsp);
+      yyvsp--;
+      yystate = *--yyssp;

 #if YYLSP_NEEDED
 #if YYLSP_NEEDED

-  yylsp--;
+      yylsp--;

 #endif
 
 #if YYDEBUG
 #endif
 
 #if YYDEBUG

-  if (yydebug)
-    {
-      short *yyssp1 = yyss - 1;
-      YYFPRINTF (stderr, "Error: state stack now");
-      while (yyssp1 != yyssp)
-       YYFPRINTF (stderr, " %d", *++yyssp1);
-      YYFPRINTF (stderr, "\n");
-    }
+      if (yydebug)
+       {
+         short *yyssp1 = yyss - 1;
+         YYFPRINTF (stderr, "Error: state stack now");
+         while (yyssp1 != yyssp)
+           YYFPRINTF (stderr, " %d", *++yyssp1);
+         YYFPRINTF (stderr, "\n");
+       }

 #endif
 #endif

-
-/*--------------.
-| yyerrhandle.  |
-`--------------*/
-yyerrhandle:
-  yyn = yypact[yystate];
-  if (yyn == YYFLAG)
-    goto yyerrdefault;
-
-  yyn += YYTERROR;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
-    goto yyerrdefault;
-
-  yyn = yytable[yyn];
-  if (yyn < 0)
-    {
-      if (yyn == YYFLAG)
-       goto yyerrpop;
-      yyn = -yyn;
-      goto yyreduce;

     }
     }

-  else if (yyn == 0)
-    goto yyerrpop;

 
   if (yyn == YYFINAL)
     YYACCEPT;
 
   if (yyn == YYFINAL)
     YYACCEPT;


@@ -1145,6 +1236,39 @@ yyreturn:
   return yyresult;
 ]}
 
   return yyresult;
 ]}
 

+/* Release the memory associated to SYMBOL-NUMBER. */
+m4_divert_push([KILL])# M4 code.
+# b4_eval
+# -------
+# FIXME: This is really wrong, we no longer guarantee we don't evaluate
+# the user's input.  This demonstrates that decoding actions (BRACED_CODE)
+# ought to be done when output, not when read.
+m4_define([b4_eval],
+[$*])
+
+# b4_symbol_destructor(SYMBOL-NUMBER, DESTRUCTOR, TYPE-NAME)
+# ----------------------------------------------------------
+m4_define([b4_symbol_destructor],
+[m4_pushdef([b4_dollar_dollar], [symbol_value.$3])dnl
+      case $1:
+        b4_eval($2);
+        break;
+m4_popdef([b4_dollar_dollar])])
+
+m4_divert_pop([KILL])dnl# End of M4 code.
+static void
+yydestructor (int symbol_type, YYSTYPE symbol_value)
+{
+  switch (symbol_type)
+    {
+m4_map([b4_symbol_destructor], m4_defn([b4_symbol_destructors]))dnl
+      default:
+        YYDPRINTF ((stderr, "yydestructor: unknown symbol type: %s\n",
+                   yytname[[symbol_type]]));
+        break;
+    }
+}
+

 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [#output "b4_output_header_name"
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [#output "b4_output_header_name"


@@ -1154,11 +1278,12 @@ m4_if(b4_defines_flag, 0, [],
 b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE
 b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE

-m4_ifdef([b4_stype_line],
+m4_ifdef([b4_stype],

 [#line b4_stype_line "b4_filename"
 [#line b4_stype_line "b4_filename"

-])dnl
-typedef b4_stype
-yystype;
+typedef union b4_stype yystype;
+/* Line __line__ of __file__.  */
+#line __oline__ "__ofile__"],
+[typedef int yystype;])

 # define YYSTYPE yystype
 #endif
 
 # define YYSTYPE yystype
 #endif