]> git.saurik.com Git - bison.git/blobdiff - data/bison.simple
* src/reader.c (parse_action): Don't store directly into the
[bison.git] / data / bison.simple
index f4af302c18267c531317ee175c7dd9871c56b859..8b5eda87610192b9094d35706384493cb4fd65de 100644 (file)
-%%{section} %%{output-prefix} %%{output-infix} %%".c"
-/* -*- C -*- */
+m4_divert(-1)                                                       -*- C -*-
 
 
-/* A Bison parser, made from %%{filename}
-   by GNU bison %%{version}.  */
+# 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])])
 
 
-/* Skeleton output parser for bison,
 
 
+# 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_output_parser_suffix],
+[m4_translit(b4_input_suffix, [yY], [cC])])
+
+m4_define_default([b4_output_parser_name],
+[b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
+
+
+m4_define_default([b4_output_header_suffix],
+[m4_translit(b4_input_suffix, [yY], [hH])])
+
+m4_define_default([b4_output_header_name],
+[b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
+
+m4_define_default([b4_header_guard],
+                  [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
+                                [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
+
+
+# b4_token_define(TOKEN-NAME, TOKEN-NUMBER)
+# -----------------------------------------
+# 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)
+# -------------------------------------------------------
+# Output the definition of the tokens (if there are) as enums and #define.
+m4_define([b4_token_defines],
+[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
+#output "b4_output_parser_name"
+/* A Bison parser, made from b4_filename
+   by GNU bison b4_version.  */
+
+/* Skeleton output parser for Bison,
    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
    Foundation, Inc.
 
    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
    Foundation, Inc.
 
 
 /* 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
 
 /* Pure parsers.  */
 
 /* Identify Bison output.  */
 #define YYBISON        1
 
 /* Pure parsers.  */
-#define YYPURE %%{pure}
+#define YYPURE b4_pure
 
 /* Using locations.  */
 
 /* Using locations.  */
-#define YYLSP_NEEDED %%{locations-flag}
+#define YYLSP_NEEDED b4_locations_flag
 
 
-/* If NAME_PREFIX is specified substitute the variables and functions
+m4_if(b4_prefix[], [yy], [],
+[/* If NAME_PREFIX is specified substitute the variables and functions
    names.  */
    names.  */
-#define yyparse %%{prefix}parse
-#define yylex   %%{prefix}lex
-#define yyerror %%{prefix}error
-#define yylval  %%{prefix}lval
-#define yychar  %%{prefix}char
-#define yydebug %%{prefix}debug
-#define yynerrs %%{prefix}nerrs
+#define yyparse b4_prefix[]parse
+#define yylex   b4_prefix[]lex
+#define yyerror b4_prefix[]error
+#define yylval  b4_prefix[]lval
+#define yychar  b4_prefix[]char
+#define yydebug b4_prefix[]debug
+#define yynerrs b4_prefix[]nerrs
 #if YYLSP_NEEDED
 #if YYLSP_NEEDED
-# define yylloc %%{prefix}lloc
+# define yylloc b4_prefix[]lloc
 #endif
 #endif
+])
 
 
+/* Copy the first part of user declarations.  */
+b4_pre_prologue
 
 
-/* Copy the user declarations.  */
-%%{prologue}
+b4_token_defines(b4_tokens)
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
-# define YYDEBUG %%{debug}
+# define YYDEBUG b4_debug
 #endif
 
 /* Enabling verbose error messages.  */
 #endif
 
 /* Enabling verbose error messages.  */
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
-# define YYERROR_VERBOSE %%{error-verbose}
+# define YYERROR_VERBOSE b4_error_verbose
 #endif
 
 #ifndef YYSTYPE
 #endif
 
 #ifndef YYSTYPE
-typedef %%{stype} yystype;
+m4_ifdef([b4_stype_line],
+[#line b4_stype_line "b4_filename"
+])dnl
+typedef b4_stype yystype;
 # define YYSTYPE yystype
 # define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 #ifndef YYLTYPE
 #endif
 
 #ifndef YYLTYPE
@@ -86,26 +207,17 @@ typedef struct yyltype
   int last_line;
   int last_column;
 } yyltype;
   int last_line;
   int last_column;
 } yyltype;
-# define YYLTYPE %%{ltype}
+# define YYLTYPE b4_ltype
+# define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 #endif
 
-/* Line %%{skeleton-line} of %%{skeleton}.  */
-#line %%{line} "%%{parser-file-name}"
-
-/* 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.  */
+/* Copy the second part of user declarations.  */
+b4_post_prologue
 
 
-#ifdef __cplusplus
-# define YYSTD(x) std::x
-#else
-# define YYSTD(x) x
-#endif
+/* 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.  */
 
@@ -127,18 +239,19 @@ typedef struct yyltype
    /* Pacify GCC's `empty if-body' warning. */
 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 # else
    /* Pacify GCC's `empty if-body' warning. */
 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
 # else
-#  ifdef __cplusplus
-#   include <cstdlib> /* INFRINGES ON USER NAME SPACE */
-#   define YYSIZE_T std::size_t
-#  else
-#   ifdef __STDC__
-#    include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#    define YYSIZE_T size_t
-#   endif
+#  if defined (__STDC__) || defined (__cplusplus)
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   define YYSIZE_T size_t
 #  endif
 #  endif
-#  define YYSTACK_ALLOC YYSTD (malloc)
-#  define YYSTACK_FREE YYSTD (free)
+#  define YYSTACK_ALLOC malloc
+#  define YYSTACK_FREE free
 # endif
 # 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
@@ -157,148 +270,174 @@ 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
 
 # endif
 
-/* Relocate the TYPE STACK from its old location to the new one.  The
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)             \
+      do                                       \
+       {                                       \
+         register YYSIZE_T yyi;                \
+         for (yyi = 0; yyi < (Count); yyi++)   \
+           (To)[[yyi]] = (From)[[yyi]];        \
+       }                                       \
+      while (0)
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
    local variables YYSIZE and YYSTACKSIZE give the old and new number of
    elements in the stack, and YYPTR gives the new location of the
    stack.  Advance YYPTR to a properly aligned location for the next
    stack.  */
    local variables YYSIZE and YYSTACKSIZE give the old and new number of
    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(Type, Stack)                                 \
+# define YYSTACK_RELOCATE(Stack)                                       \
     do                                                                 \
       {                                                                        \
        YYSIZE_T yynewbytes;                                            \
     do                                                                 \
       {                                                                        \
        YYSIZE_T yynewbytes;                                            \
-       yymemcpy ((char *) yyptr, (char *) (Stack),                     \
-                 yysize * (YYSIZE_T) sizeof (Type));                   \
+       YYCOPY (&yyptr->Stack, Stack, yysize);                          \
        Stack = &yyptr->Stack;                                          \
        Stack = &yyptr->Stack;                                          \
-       yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX;     \
+       yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
     while (0)
 
        yyptr += yynewbytes / sizeof (*yyptr);                          \
       }                                                                        \
     while (0)
 
-#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
-
-/* Tokens.  */
-%%{tokendef}
+#endif
 
 /* YYFINAL -- State number of the termination state. */
 
 /* YYFINAL -- State number of the termination state. */
-#define YYFINAL  %%{final}
-#define YYFLAG  %%{flag}
-#define YYLAST   %%{last}
+#define YYFINAL  b4_final
+#define YYFLAG  b4_flag
+#define YYLAST   b4_last
 
 /* YYNTOKENS -- Number of terminals. */
 
 /* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS  %%{ntokens}
+#define YYNTOKENS  b4_ntokens
 /* YYNNTS -- Number of nonterminals. */
 /* YYNNTS -- Number of nonterminals. */
-#define YYNNTS  %%{nnts}
+#define YYNNTS  b4_nnts
 /* YYNRULES -- Number of rules. */
 /* YYNRULES -- Number of rules. */
-#define YYNRULES  %%{nrules}
+#define YYNRULES  b4_nrules
 /* YYNRULES -- Number of states. */
 /* YYNRULES -- Number of states. */
-#define YYNSTATES  %%{nstates}
-#define YYMAXUTOK  %%{maxtok}
+#define YYNSTATES  b4_nstates
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYTRANSLATE(x) ((unsigned)(x) <= %%{maxtok} ? yytranslate[x] : %%{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.  */
-static const char yytranslate[] =
+/* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
+static const b4_uint_type(b4_translate_max) yytranslate[[]] =
 {
 {
-  %%{translate}
+  b4_translate
 };
 
 #if YYDEBUG
 };
 
 #if YYDEBUG
-/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+/* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
    YYRHS.  */
-static const short yyprhs[] =
+static const b4_uint_type(b4_prhs_max) yyprhs[[]] =
 {
 {
-  %%{prhs}
+  b4_prhs
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const short yyrhs[] =
+static const b4_sint_type(b4_rhs_max) yyrhs[[]] =
 {
 {
-  %%{rhs}
+  b4_rhs
 };
 
 };
 
-/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
-static const short yyrline[] =
+/* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
+static const b4_uint_type(b4_rline_max) yyrline[[]] =
 {
 {
-  %%{rline}
+  b4_rline
 };
 #endif
 
 };
 #endif
 
-#if (YYDEBUG) || YYERROR_VERBOSE
-/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+#if YYDEBUG || YYERROR_VERBOSE
+/* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
-static const char *const yytname[] =
+static const char *const yytname[[]] =
 {
 {
-  %%{tname}
+  b4_tname
 };
 #endif
 
 };
 #endif
 
-/* YYTOKNUM[YYN] -- Index in YYTNAME corresponding to YYLEX.  */
-static const short yytoknum[] =
+/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const short yytoknum[[]] =
 {
 {
-  %%{toknum}
+  b4_toknum
 };
 
 };
 
-/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
-static const short yyr1[] =
+/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
+static const b4_uint_type(b4_r1_max) yyr1[[]] =
 {
 {
-  %%{r1}
+  b4_r1
 };
 
 };
 
-/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
-static const short yyr2[] =
+/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
+static const b4_uint_type(b4_r2_max) yyr2[[]] =
 {
 {
-  %%{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.  */
-static const short yydefact[] =
+/* 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[[]] =
 {
 {
-  %%{defact}
+  b4_defact
 };
 
 };
 
-/* YYPGOTO[NTERM-NUM]. */
-static const short yydefgoto[] =
+/* YYPGOTO[[NTERM-NUM]]. */
+static const short yydefgoto[[]] =
 {
 {
-  %%{defgoto}
+  b4_defgoto
 };
 
 };
 
-/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+/* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
    STATE-NUM.  */
-static const short yypact[] =
+static const short yypact[[]] =
 {
 {
-  %%{pact}
+  b4_pact
 };
 
 };
 
-/* YYPGOTO[NTERM-NUM].  */
-static const short yypgoto[] =
+/* YYPGOTO[[NTERM-NUM]].  */
+static const short yypgoto[[]] =
 {
 {
-  %%{pgoto}
+  b4_pgoto
 };
 
 };
 
-/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+/* 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.  */
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */
-static const short yytable[] =
+static const short yytable[[]] =
 {
 {
-  %%{table}
+  b4_table
 };
 
 };
 
-static const short yycheck[] =
+static const short yycheck[[]] =
 {
 {
-  %%{check}
+  b4_check
 };
 
 };
 
+#if YYDEBUG
+/* 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
+};
+#endif
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 # define YYSIZE_T __SIZE_TYPE__
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 # define YYSIZE_T __SIZE_TYPE__
@@ -307,14 +446,9 @@ static const short yycheck[] =
 # define YYSIZE_T size_t
 #endif
 #if ! defined (YYSIZE_T)
 # define YYSIZE_T size_t
 #endif
 #if ! defined (YYSIZE_T)
-# ifdef __cplusplus
-#  include <cstddef> /* INFRINGES ON USER NAME SPACE */
-#  define YYSIZE_T std::size_t
-# else
-#  ifdef __STDC__
-#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-#   define YYSIZE_T size_t
-#  endif
+# if defined (__STDC__) || defined (__cplusplus)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
 # endif
 #endif
 #if ! defined (YYSIZE_T)
 # endif
 #endif
 #if ! defined (YYSIZE_T)
@@ -359,16 +493,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.  */
@@ -395,12 +527,8 @@ while (0)
 #if YYDEBUG
 
 # ifndef YYFPRINTF
 #if YYDEBUG
 
 # ifndef YYFPRINTF
-#  ifdef __cplusplus
-#   include <cstdio>  /* INFRINGES ON USER NAME SPACE */
-#  else
-#   include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-#  endif
-#  define YYFPRINTF YYSTD (fprintf)
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
 # endif
 
 # define YYDPRINTF(Args)                       \
 # endif
 
 # define YYDPRINTF(Args)                       \
@@ -408,10 +536,8 @@ do {                                               \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
-/* Nonzero means print parse trace. [The following comment makes no
-   sense to me.  Could someone clarify it?  --akim] 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)
@@ -419,7 +545,7 @@ int yydebug;
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
-# define YYINITDEPTH %%{initdepth}
+# define YYINITDEPTH b4_initdepth
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
@@ -434,38 +560,11 @@ int yydebug;
 #endif
 
 #ifndef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH
-# define YYMAXDEPTH %%{maxdepth}
+# define YYMAXDEPTH b4_maxdepth
 #endif
 
 \f
 
 #endif
 
 \f
 
-#if ! defined (yyoverflow) && ! defined (yymemcpy)
-# if __GNUC__ > 1              /* GNU C and GNU C++ define this.  */
-#  define yymemcpy __builtin_memcpy
-# else                         /* not GNU C or C++ */
-
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
-static void
-#  if defined (__STDC__) || defined (__cplusplus)
-yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
-#  else
-yymemcpy (yyto, yyfrom, yycount)
-     char *yyto;
-     const char *yyfrom;
-     YYSIZE_T yycount;
-#  endif
-{
-  register const char *yyf = yyfrom;
-  register char *yyt = yyto;
-  register YYSIZE_T yyi = yycount;
-
-  while (yyi-- != 0)
-    *yyt++ = *yyf++;
-}
-# endif
-#endif
-
 #if YYERROR_VERBOSE
 
 # ifndef yystrlen
 #if YYERROR_VERBOSE
 
 # ifndef yystrlen
@@ -528,13 +627,13 @@ yystpcpy (yydest, yysrc)
    to the proper pointer type.  */
 
 #ifdef YYPARSE_PARAM
    to the proper pointer type.  */
 
 #ifdef YYPARSE_PARAM
-# ifdef __cplusplus
+# if defined (__STDC__) || defined (__cplusplus)
 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL
 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL
-# else /* !__cplusplus */
+# else
 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-# endif /* !__cplusplus */
+# endif
 #else /* !YYPARSE_PARAM */
 # define YYPARSE_PARAM_ARG
 # define YYPARSE_PARAM_DECL
 #else /* !YYPARSE_PARAM */
 # define YYPARSE_PARAM_ARG
 # define YYPARSE_PARAM_DECL
@@ -582,7 +681,7 @@ YY_DECL_VARIABLES
 int
 yyparse (YYPARSE_PARAM_ARG)
      YYPARSE_PARAM_DECL
 int
 yyparse (YYPARSE_PARAM_ARG)
      YYPARSE_PARAM_DECL
-{
+{[
   /* If reentrant, generate the variables here.  */
 #if YYPURE
   YY_DECL_VARIABLES
   /* If reentrant, generate the variables here.  */
 #if YYPURE
   YY_DECL_VARIABLES
@@ -706,6 +805,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;
@@ -719,15 +821,16 @@ yyparse (YYPARSE_PARAM_ARG)
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
          goto yyoverflowlab;
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
        if (! yyptr)
          goto yyoverflowlab;
-       YYSTACK_RELOCATE (short, yyss);
-       YYSTACK_RELOCATE (YYSTYPE, yyvs);
-# if YYLSP_NEEDED
-       YYSTACK_RELOCATE (YYLTYPE, yyls);
-# endif
-# undef YYSTACK_RELOCATE
+       YYSTACK_RELOCATE (yyss);
+       YYSTACK_RELOCATE (yyvs);
+#  if YYLSP_NEEDED
+       YYSTACK_RELOCATE (yyls);
+#  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;
@@ -879,9 +982,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
 
@@ -902,14 +1003,14 @@ yyreduce:
     }
 #endif
   switch (yyn)
     }
 #endif
   switch (yyn)
-    {
-      %%{actions}
+    ]{
+      b4_actions
     }
 
     }
 
-/* Line %%{skeleton-line} of %%{skeleton}.  */
-#line %%{line} "%%{parser-file-name}"
+/* Line __line__ of __file__.  */
+#line __oline__ "__ofile__"
 \f
 \f
-  yyvsp -= yylen;
+[  yyvsp -= yylen;
   yyssp -= yylen;
 #if YYLSP_NEEDED
   yylsp -= yylen;
   yyssp -= yylen;
 #if YYLSP_NEEDED
   yylsp -= yylen;
@@ -1026,73 +1127,63 @@ yyerrlab1:
   /* Else will try to reuse lookahead token after shifting the error
      token.  */
 
   /* 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;
+      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;
@@ -1136,6 +1227,42 @@ yyreturn:
     YYSTACK_FREE (yyss);
 #endif
   return yyresult;
     YYSTACK_FREE (yyss);
 #endif
   return yyresult;
-}
+]}
+
+b4_epilogue
+m4_if(b4_defines_flag, 0, [],
+[#output "b4_output_header_name"
+#ifndef b4_header_guard
+# define b4_header_guard
+
+b4_token_defines(b4_tokens)
+
+#ifndef YYSTYPE
+m4_ifdef([b4_stype_line],
+[#line b4_stype_line "b4_filename"
+])dnl
+typedef b4_stype
+yystype;
+# define YYSTYPE yystype
+#endif
+
+m4_if(b4_pure, [0],
+[extern YYSTYPE b4_prefix[]lval;])
+
+m4_if(b4_locations_flag, [0], [],
+[#ifndef YYLTYPE
+typedef struct yyltype
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} yyltype;
+# define YYLTYPE yyltype
+#endif
 
 
-%%{epilogue}
+m4_if(b4_pure, [0],
+[extern YYLTYPE b4_prefix[]lloc;])
+])
+#endif /* not b4_header_guard */
+])