]> git.saurik.com Git - bison.git/blobdiff - data/yacc.c
projects / bison.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
(struniq_assert): Now returns void, and aborts if the assertion is false.
[bison.git] / data / yacc.c
diff --git a/data/yacc.c b/data/yacc.c
index 11edba30403940eb1080a422682adaf7efc815c6..462af2e218bb701f3ad46f8910b55806a14ed4c8 100644 (file)
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -33,19 +33,38 @@ m4_define_default([b4_stack_depth_init],  [200])
 # Location type.
 m4_define_default([b4_location_type], [yyltype])
 
 # Location type.
 m4_define_default([b4_location_type], [yyltype])
 
+
+## ------------------------ ##
+## Pure/impure interfaces.  ##
+## ------------------------ ##
+
+
+# b4_pure_if(IF-TRUE, IF-FALSE)
+# -----------------------------
+# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
+m4_define([b4_Pure_if],
+[b4_pure_if([m4_ifset([b4_parse_param],
+                      [$1], [$2])],
+            [$2])])
+
+
+# b4_yyerror_args
+# ---------------
+# Arguments passed to yyerror: user args plus yylloc.
+m4_define([b4_yyerror_args],
+[b4_Pure_if([b4_location_if([&yylloc, ])])dnl
+m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
+
+
+# b4_lex_param
+# ------------
 # Accumule in b4_lex_param all the yylex arguments.
 # Accumule in b4_lex_param all the yylex arguments.
-# Yes, this is quite ugly...
+# b4_lex_param arrives quoted twice, but we want to keep only one level.
 m4_define([b4_lex_param],
 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
 b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl
 m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
 
 m4_define([b4_lex_param],
 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
 b4_location_if([, [[YYLTYPE *], [&yylloc]]])])dnl
 m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
 
-# Yes, this is quite ugly...
-m4_define_default([b4_parse_param])
-m4_ifdef([b4_parse_param],
-[m4_define([b4_parse_param],
-          b4_parse_param)])
-
 
 
 ## ------------ ##
 
 
 ## ------------ ##
@@ -56,7 +75,7 @@ m4_ifdef([b4_parse_param],
 # ---------------------
 # Return the smallest int type able to handle numbers ranging from
 # MIN to MAX (included).  We overwrite the version from c.m4 which relies
 # ---------------------
 # Return the smallest int type able to handle numbers ranging from
 # MIN to MAX (included).  We overwrite the version from c.m4 which relies
-# on `signed char' which is not portable to old K&R compilers.
+# on "signed char" which is not portable to old K&R compilers.
 m4_define([b4_int_type],
 [m4_if(b4_ints_in($@,      [0],   [255]), [1], [unsigned char],
        b4_ints_in($@,   [-128],   [127]), [1], [yysigned_char],
 m4_define([b4_int_type],
 [m4_if(b4_ints_in($@,      [0],   [255]), [1], [unsigned char],
        b4_ints_in($@,   [-128],   [127]), [1], [yysigned_char],
@@ -86,7 +105,7 @@ m4_define([b4_lhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
 # symbols on RHS.
 m4_define([b4_rhs_value],
-[yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
+[yyvsp@{m4_eval([$2 - $1])@}m4_ifval([$3], [.$3])])
 
 
 
 
 
 
@@ -106,32 +125,7 @@ m4_define([b4_lhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
 # on RHS.
 m4_define([b4_rhs_location],
-[yylsp@<:@m4_eval([$2 - $1])@:>@])
-
-
-
-## ------------------- ##
-## Output file names.  ##
-## ------------------- ##
-
-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]], [_])])
+[yylsp@{m4_eval([$2 - $1])@}])
 
 
 
 
 
 
@@ -139,28 +133,12 @@ m4_define_default([b4_header_guard],
 ## Defining symbol actions, e.g., printers and destructors.  ##
 ## --------------------------------------------------------- ##
 
 ## Defining symbol actions, e.g., printers and destructors.  ##
 ## --------------------------------------------------------- ##
 
-# b4_symbol_actions(FILENAME, LINENO,
-#                   SYMBOL-TAG, SYMBOL-NUM,
-#                   SYMBOL-ACTION, SYMBOL-TYPENAME)
-# -------------------------------------------------
-m4_define([b4_symbol_actions],
-[m4_pushdef([b4_dollar_dollar], [yyvalue.$6])dnl
-m4_pushdef([b4_at_dollar], [yylocation])dnl
-      case $4: /* $3 */
-#line $2 "$1"
-        $5;
-#line __oline__ "__ofile__"
-        break;
-m4_popdef([b4_at_dollar])dnl
-m4_popdef([b4_dollar_dollar])dnl
-])
-
-
-
+# We do want M4 expansion after # for CPP macros.
+m4_changecom()
 m4_divert(0)dnl
 m4_divert(0)dnl
-#output "b4_output_parser_name"
+@output @output_parser_name@
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
-             [1984, 1989, 1990, 2000, 2001, 2002])
+             [1984, 1989, 1990, 2000, 2001, 2002])[
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
 
 /* As a special exception, when this file is copied by Bison into a
    Bison output file, you may use that output file without restriction.
@@ -177,15 +155,7 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
    define necessary library symbols; they are noted "INFRINGES ON
    USER NAME SPACE" below.  */
 
-/* Identify Bison output.  */
-#define YYBISON        1
-
-/* Pure parsers.  */
-#define YYPURE b4_pure
-
-/* Using locations.  */
-#define YYLSP_NEEDED b4_locations_flag
-
+]b4_identification
 m4_if(b4_prefix[], [yy], [],
 [/* If NAME_PREFIX is specified substitute the variables and functions
    names.  */
 m4_if(b4_prefix[], [yy], [],
 [/* If NAME_PREFIX is specified substitute the variables and functions
    names.  */
@@ -196,16 +166,16 @@ m4_if(b4_prefix[], [yy], [],
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs
 #define yychar  b4_prefix[]char
 #define yydebug b4_prefix[]debug
 #define yynerrs b4_prefix[]nerrs
-b4_location_if([#define yylloc b4_prefix[]lloc])])
+b4_location_if([#define yylloc b4_prefix[]lloc])])[
 
 
-b4_token_defines(b4_tokens)
+]b4_token_defines(b4_tokens)[
 
 /* Copy the first part of user declarations.  */
 
 /* Copy the first part of user declarations.  */
-b4_pre_prologue
+]b4_pre_prologue[
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
-# define YYDEBUG b4_debug
+# define YYDEBUG ]b4_debug[
 #endif
 
 /* Enabling verbose error messages.  */
 #endif
 
 /* Enabling verbose error messages.  */
@@ -213,16 +183,16 @@ b4_pre_prologue
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
 # undef YYERROR_VERBOSE
 # define YYERROR_VERBOSE 1
 #else
-# define YYERROR_VERBOSE b4_error_verbose
+# define YYERROR_VERBOSE ]b4_error_verbose[
 #endif
 
 #ifndef YYSTYPE
 #endif
 
 #ifndef YYSTYPE
-m4_ifdef([b4_stype],
-[#line b4_stype_line "b4_filename"
+]m4_ifdef([b4_stype],
+[b4_syncline([b4_stype_line], [b4_filename])
 typedef union b4_stype yystype;
 /* Line __line__ of __file__.  */
 typedef union b4_stype yystype;
 /* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"],
-[typedef int yystype;])
+b4_syncline([@oline@], [@ofile@])],
+[typedef int yystype;])[
 # define YYSTYPE yystype
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
 # define YYSTYPE yystype
 # define YYSTYPE_IS_TRIVIAL 1
 #endif
@@ -235,15 +205,15 @@ typedef struct yyltype
   int last_line;
   int last_column;
 } yyltype;
   int last_line;
   int last_column;
 } yyltype;
-# define YYLTYPE b4_location_type
+# define YYLTYPE ]b4_location_type[
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 /* Copy the second part of user declarations.  */
 # define YYLTYPE_IS_TRIVIAL 1
 #endif
 
 /* Copy the second part of user declarations.  */
-b4_post_prologue
+]b4_post_prologue
 
 /* Line __line__ of __file__.  */
 
 /* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"
+b4_syncline([@oline@], [@ofile@])[
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
 
 #if ! defined (yyoverflow) || YYERROR_VERBOSE
 
@@ -286,22 +256,22 @@ union yyalloc
 {
   short yyss;
   YYSTYPE yyvs;
 {
   short yyss;
   YYSTYPE yyvs;
-  b4_location_if([  YYLTYPE yyls;
+  ]b4_location_if([  YYLTYPE yyls;
 ])dnl
 ])dnl
-};
+[};
 
 /* The size of the maximum gap between one aligned stack and the next.  */
 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
 
 /* The size of the maximum gap between one aligned stack and the next.  */
 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
 
 /* The size of an array large to enough to hold all stacks, each with
    N elements.  */
-b4_location_if(
+]b4_location_if(
 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
       + 2 * YYSTACK_GAP_MAX)],
 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
       + 2 * YYSTACK_GAP_MAX)],
 [# define YYSTACK_BYTES(N) \
      ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
-      + YYSTACK_GAP_MAX)])
+      + YYSTACK_GAP_MAX)])[
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
 
 /* Copy COUNT objects from FROM to TO.  The source and destination do
    not overlap.  */
@@ -315,7 +285,7 @@ b4_location_if(
        {                                       \
          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
@@ -346,131 +316,132 @@ b4_location_if(
 #endif
 
 /* YYFINAL -- State number of the termination state. */
 #endif
 
 /* YYFINAL -- State number of the termination state. */
-#define YYFINAL  b4_final_state_number
+#define YYFINAL  ]b4_final_state_number[
 /* YYLAST -- Last index in YYTABLE.  */
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   b4_last
+#define YYLAST   ]b4_last[
 
 /* YYNTOKENS -- Number of terminals. */
 
 /* YYNTOKENS -- Number of terminals. */
-#define YYNTOKENS  b4_tokens_number
+#define YYNTOKENS  ]b4_tokens_number[
 /* YYNNTS -- Number of nonterminals. */
 /* YYNNTS -- Number of nonterminals. */
-#define YYNNTS  b4_nterms_number
+#define YYNNTS  ]b4_nterms_number[
 /* YYNRULES -- Number of rules. */
 /* YYNRULES -- Number of rules. */
-#define YYNRULES  b4_rules_number
+#define YYNRULES  ]b4_rules_number[
 /* YYNRULES -- Number of states. */
 /* YYNRULES -- Number of states. */
-#define YYNSTATES  b4_states_number
+#define YYNSTATES  ]b4_states_number[
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
-#define YYUNDEFTOK  b4_undef_token_number
-#define YYMAXUTOK   b4_user_token_number_max
+#define YYUNDEFTOK  ]b4_undef_token_number[
+#define YYMAXUTOK   ]b4_user_token_number_max[
 
 
-#define YYTRANSLATE(X) \
-  ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
+#define YYTRANSLATE(YYX)                                               \
+  ((YYX <= 0) ? YYEOF :                                                        \
+   (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
 
-/* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
-static const b4_int_type_for([b4_translate]) yytranslate[[]] =
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
 {
 {
-  b4_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 b4_int_type_for([b4_prhs]) yyprhs[[]] =
+static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
 {
 {
-  b4_prhs
+  ]b4_prhs[
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
-static const b4_int_type_for([b4_rhs]) yyrhs[[]] =
+static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
 {
 {
-  b4_rhs
+  ]b4_rhs[
 };
 
 };
 
-/* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
-static const b4_int_type_for([b4_rline]) yyrline[[]] =
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const ]b4_int_type_for([b4_rline])[ yyrline[] =
 {
 {
-  b4_rline
+  ]b4_rline[
 };
 #endif
 
 #if YYDEBUG || YYERROR_VERBOSE
 };
 #endif
 
 #if YYDEBUG || YYERROR_VERBOSE
-/* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
+/* 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[] =
 {
 {
-  b4_tname
+  ]b4_tname[
 };
 #endif
 
 # ifdef YYPRINT
 };
 #endif
 
 # ifdef YYPRINT
-/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    token YYLEX-NUM.  */
    token YYLEX-NUM.  */
-static const b4_int_type_for([b4_toknum]) yytoknum[[]] =
+static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
 {
 {
-  b4_toknum
+  ]b4_toknum[
 };
 # endif
 
 };
 # endif
 
-/* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
-static const b4_int_type_for([b4_r1]) yyr1[[]] =
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const ]b4_int_type_for([b4_r1])[ yyr1[] =
 {
 {
-  b4_r1
+  ]b4_r1[
 };
 
 };
 
-/* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
-static const b4_int_type_for([b4_r2]) yyr2[[]] =
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const ]b4_int_type_for([b4_r2])[ yyr2[] =
 {
 {
-  b4_r2
+  ]b4_r2[
 };
 
 };
 
-/* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
+/* 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.  */
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
-static const b4_int_type_for([b4_defact]) yydefact[[]] =
+static const ]b4_int_type_for([b4_defact])[ yydefact[] =
 {
 {
-  b4_defact
+  ]b4_defact[
 };
 
 };
 
-/* YYDEFGOTO[[NTERM-NUM]]. */
-static const b4_int_type_for([b4_defgoto]) yydefgoto[[]] =
+/* YYDEFGOTO[NTERM-NUM]. */
+static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
 {
 {
-  b4_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.  */
-#define YYPACT_NINF b4_pact_ninf
-static const b4_int_type_for([b4_pact]) yypact[[]] =
+#define YYPACT_NINF ]b4_pact_ninf[
+static const ]b4_int_type_for([b4_pact])[ yypact[] =
 {
 {
-  b4_pact
+  ]b4_pact[
 };
 
 };
 
-/* YYPGOTO[[NTERM-NUM]].  */
-static const b4_int_type_for([b4_pgoto]) yypgoto[[]] =
+/* YYPGOTO[NTERM-NUM].  */
+static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
 {
 {
-  b4_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.
-   If YYTABLE_NINF, parse error.  */
-#define YYTABLE_NINF b4_table_ninf
-static const b4_int_type_for([b4_table]) yytable[[]] =
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF ]b4_table_ninf[
+static const ]b4_int_type_for([b4_table])[ yytable[] =
 {
 {
-  b4_table
+  ]b4_table[
 };
 
 };
 
-static const b4_int_type_for([b4_check]) yycheck[[]] =
+static const ]b4_int_type_for([b4_check])[ yycheck[] =
 {
 {
-  b4_check
+  ]b4_check[
 };
 
 };
 
-/* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
    symbol of state STATE-NUM.  */
-static const b4_int_type_for([b4_stos]) yystos[[]] =
+static const ]b4_int_type_for([b4_stos])[ yystos[] =
 {
 {
-  b4_stos
+  ]b4_stos[
 };
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
 };
 
 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
@@ -490,7 +461,7 @@ static const b4_int_type_for([b4_stos]) yystos[[]] =
 #endif
 
 #define yyerrok                (yyerrstatus = 0)
 #endif
 
 #define yyerrok                (yyerrstatus = 0)
-#define yyclearin      (yychar = YYEMPTY)
+#define yyclearin      (yytoken = YYEMPTY)
 #define YYEMPTY                -2
 #define YYEOF          0
 
 #define YYEMPTY                -2
 #define YYEOF          0
 
@@ -508,17 +479,17 @@ static const b4_int_type_for([b4_stos]) yystos[[]] =
 
 #define YYBACKUP(Token, Value)                                 \
 do                                                             \
 
 #define YYBACKUP(Token, Value)                                 \
 do                                                             \
-  if (yychar == YYEMPTY && yylen == 1)                         \
+  if (yytoken == YYEMPTY && yylen == 1)                                \
     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \
     {                                                          \
       yychar = (Token);                                                \
       yylval = (Value);                                                \
-      yychar1 = YYTRANSLATE (yychar);                          \
+      yytoken = YYTRANSLATE (yychar);                          \
       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
     {                                                          \
       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
     {                                                          \
-      yyerror ("syntax error: cannot back up");                        \
+      yyerror (]b4_yyerror_args["syntax error: cannot back up");\
       YYERROR;                                                 \
     }                                                          \
 while (0)
       YYERROR;                                                 \
     }                                                          \
 while (0)
@@ -530,19 +501,19 @@ while (0)
    are run).  */
 
 #ifndef YYLLOC_DEFAULT
    are run).  */
 
 #ifndef YYLLOC_DEFAULT
-# 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;
+# 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.  */
 
 #ifdef YYLEX_PARAM
 #endif
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 #ifdef YYLEX_PARAM
-# define YYLEX yylex (b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])YYLEX_PARAM)
+# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
 #else
 #else
-# define YYLEX b4_c_function_call([yylex], [int], b4_lex_param)
+# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
 #endif
 
 /* Enable debugging if requested.  */
 #endif
 
 /* Enable debugging if requested.  */
@@ -558,22 +529,83 @@ do {                                              \
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
   if (yydebug)                                 \
     YYFPRINTF Args;                            \
 } while (0)
+
 # define YYDSYMPRINT(Args)                     \
 do {                                           \
   if (yydebug)                                 \
     yysymprint Args;                           \
 } while (0)
 # define YYDSYMPRINT(Args)                     \
 do {                                           \
   if (yydebug)                                 \
     yysymprint Args;                           \
 } while (0)
+
+# define YYDSYMPRINTF(Title, Token, Value, Location)           \
+do {                                                           \
+  if (yydebug)                                                 \
+    {                                                          \
+      YYFPRINTF (stderr, "%s ", Title);                                \
+      yysymprint (stderr,                                      \
+                  Token, Value]b4_location_if([, Location])[); \
+      YYFPRINTF (stderr, "\n");                                        \
+    }                                                          \
+} while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (cinluded).                                                   |
+`------------------------------------------------------------------*/
+
+]b4_c_function_def([yy_stack_print], [static void],
+                   [[short *bottom], [bottom]],
+                   [[short *top],    [top]])[
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (/* Nothing. */; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)                           \
+do {                                                           \
+  if (yydebug)                                                 \
+    yy_stack_print ((Bottom), (Top));                          \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+]b4_c_function_def([yy_reduce_print], [static void],
+                   [[int yyrule], [yyrule]])[
+{
+  int yyi;
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d), ",
+             yyrule - 1, yyrline[yyrule]);
+  /* Print the symbols being reduced, and their result.  */
+  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
+  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+}
+
+# define YY_REDUCE_PRINT(Rule)         \
+do {                                   \
+  if (yydebug)                         \
+    yy_reduce_print (Rule);            \
+} while (0)
+
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 # define YYDSYMPRINT(Args)
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
 int yydebug;
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args)
 # define YYDSYMPRINT(Args)
+# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
 #endif /* !YYDEBUG */
 
 #endif /* !YYDEBUG */
 
+
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
-# define YYINITDEPTH b4_stack_depth_init
+# define YYINITDEPTH ]b4_stack_depth_init[
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
@@ -588,7 +620,7 @@ int yydebug;
 #endif
 
 #ifndef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH
-# define YYMAXDEPTH b4_stack_depth_max
+# define YYMAXDEPTH ]b4_stack_depth_max[
 #endif
 
 \f
 #endif
 
 \f
@@ -649,66 +681,9 @@ yystpcpy (yydest, yysrc)
 \f
 
 #if YYDEBUG
 \f
 
 #if YYDEBUG
-/*-----------------------------.
-| Print this symbol on YYOUT.  |
-`-----------------------------*/
-
-b4_c_function_def([yysymprint],
-                 [static void],
-                 [[FILE *yyout],        [yyout]],
-                 [[int yytype],         [yytype]],
-                 [[YYSTYPE yyvalue],    [yyvalue]]b4_location_if([,
-                 [[YYLTYPE yylocation], [yylocation]]]))
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
-
-  if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyout, "token %s (", yytname[[yytype]]);
-# ifdef YYPRINT
-      YYPRINT (yyout, yytoknum[[yytype]], yyvalue);
-# endif
-    }
-  else
-    YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]);
-
-  switch (yytype)
-    {
-m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
-      default:
-        break;
-    }
-  YYFPRINTF (yyout, ")");
-}
-#endif /* YYDEBUG. */
-
-
-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-b4_c_function_def([yydestruct],
-                 [static void],
-                 [[int yytype],         [yytype]],
-                 [[YYSTYPE yyvalue],    [yyvalue]]b4_location_if([,
-                 [[YYLTYPE yylocation], [yylocation]]]))
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
-
-  switch (yytype)
-    {
-m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
-      default:
-        break;
-    }
-}
-
+]b4_yysymprint_generate([b4_c_function_def])[
+#endif /* ! YYDEBUG */
+]b4_yydestruct_generate([b4_c_function_def])
 \f
 
 /* Prevent warnings from -Wmissing-prototypes.  */
 \f
 
 /* Prevent warnings from -Wmissing-prototypes.  */
@@ -721,7 +696,7 @@ int yyparse ();
 # endif
 #else /* ! YYPARSE_PARAM */
 b4_c_function_decl([yyparse], [int], b4_parse_param)
 # endif
 #else /* ! YYPARSE_PARAM */
 b4_c_function_decl([yyparse], [int], b4_parse_param)
-#endif
+#endif /* ! YYPARSE_PARAM */
 
 
 m4_divert_push([KILL])# ======================== M4 code.
 
 
 m4_divert_push([KILL])# ======================== M4 code.
@@ -736,7 +711,7 @@ int yychar;
 /* The semantic value of the lookahead symbol.  */
 YYSTYPE yylval;
 
 /* The semantic value of the lookahead symbol.  */
 YYSTYPE yylval;
 
-/* Number of parse errors so far.  */
+/* Number of syntax errors so far.  */
 int yynerrs;b4_location_if([
 /* Location data for the lookahead symbol.  */
 YYLTYPE yylloc;])
 int yynerrs;b4_location_if([
 /* Location data for the lookahead symbol.  */
 YYLTYPE yylloc;])
@@ -769,7 +744,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   /* Lookahead token as an internal (translated) token number.  */
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   /* Lookahead token as an internal (translated) token number.  */
-  int yychar1 = 0;
+  int yytoken = 0;
 
   /* Three stacks and their tools:
      `yyss': related to states,
 
   /* Three stacks and their tools:
      `yyss': related to states,
@@ -813,7 +788,7 @@ b4_c_function_def([yyparse], [int], b4_parse_param)
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
   yystate = 0;
   yyerrstatus = 0;
   yynerrs = 0;
-  yychar = YYEMPTY;            /* Cause a token to be read.  */
+  yychar = yytoken = YYEMPTY;          /* Cause a token to be read.  */
 
   /* Initialize stack pointers.
      Waste one element of value and location stack
 
   /* Initialize stack pointers.
      Waste one element of value and location stack
@@ -923,39 +898,29 @@ yybackup:
 
   /* Not known => get a lookahead token if don't already have one.  */
 
 
   /* Not known => get a lookahead token if don't already have one.  */
 
-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
-
-  if (yychar == YYEMPTY)
+  /* YYTOKEN is either YYEMPTY or YYEOF or a valid token.  */
+  if (yytoken == YYEMPTY)
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     {
       YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
+      yytoken = YYTRANSLATE (yychar);
     }
 
     }
 
-  /* Convert token to internal form (in yychar1) for indexing tables with.  */
-
-  if (yychar <= 0)             /* This means end of input.  */
+  if (yytoken == YYEOF)
     {
     {
-      yychar1 = 0;
-      yychar = YYEOF;          /* Don't call YYLEX any more.  */
-
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
-      yychar1 = YYTRANSLATE (yychar);
-
       /* We have to keep this `#if YYDEBUG', since we use variables
         which are defined only if `YYDEBUG' is set.  */
       /* We have to keep this `#if YYDEBUG', since we use variables
         which are defined only if `YYDEBUG' is set.  */
-      YYDPRINTF ((stderr, "Next token is "));
-      YYDSYMPRINT ((stderr, yychar1, yylval]b4_location_if([, yyloc])[));
-      YYDPRINTF ((stderr, "\n"));
+      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
     }
 
     }
 
-  /* If the proper action on seeing token YYCHAR1 is to reduce or to
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
      detect an error, take that action.  */
      detect an error, take that action.  */
-  yyn += yychar1;
-  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
     goto yydefault;
   yyn = yytable[yyn];
   if (yyn <= 0)
     goto yydefault;
   yyn = yytable[yyn];
   if (yyn <= 0)
@@ -970,12 +935,11 @@ yybackup:
     YYACCEPT;
 
   /* Shift the lookahead token.  */
     YYACCEPT;
 
   /* Shift the lookahead token.  */
-  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
-             yychar, yytname[yychar1]));
+  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
 
   /* Discard the token being shifted unless it is eof.  */
 
   /* Discard the token being shifted unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
+  if (yytoken != YYEOF)
+    yytoken = YYEMPTY;
 
   *++yyvsp = yylval;
 ]b4_location_if([  *++yylsp = yylloc;])[
 
   *++yyvsp = yylval;
 ]b4_location_if([  *++yylsp = yylloc;])[
@@ -1019,45 +983,20 @@ yyreduce:
 ]b4_location_if(
 [  /* Default location. */
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
 ]b4_location_if(
 [  /* Default location. */
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
-
-#if YYDEBUG
-  /* We have to keep this `#if YYDEBUG', since we use variables which
-     are defined only if `YYDEBUG' is set.  */
-  if (yydebug)
-    {
-      int yyi;
-
-      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
-                yyn - 1, yyrline[yyn]);
-
-      /* Print the symbols being reduced, and their result.  */
-      for (yyi = yyprhs[yyn]; 0 <= yyrhs[yyi]; yyi++)
-       YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
-      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
+  YY_REDUCE_PRINT (yyn);
   switch (yyn)
     ]{
       b4_actions
     }
 
 /* Line __line__ of __file__.  */
   switch (yyn)
     ]{
       b4_actions
     }
 
 /* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"
+b4_syncline([@oline@], [@ofile@])
 \f
 [  yyvsp -= yylen;
   yyssp -= yylen;
 ]b4_location_if([  yylsp -= yylen;])[
 
 \f
 [  yyvsp -= yylen;
   yyssp -= yylen;
 ]b4_location_if([  yylsp -= yylen;])[
 
-#if YYDEBUG
-  if (yydebug)
-    {
-      short *yyssp1 = yyss - 1;
-      YYFPRINTF (stderr, "state stack now");
-      while (yyssp1 != yyssp)
-       YYFPRINTF (stderr, " %d", *++yyssp1);
-      YYFPRINTF (stderr, "\n");
-    }
-#endif
+  YY_STACK_PRINT (yyss, yyssp);
 
   *++yyvsp = yyval;
 ]b4_location_if([  *++yylsp = yyloc;])[
 
   *++yyvsp = yyval;
 ]b4_location_if([  *++yylsp = yyloc;])[
@@ -1102,12 +1041,12 @@ yyerrlab:
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
-         yysize += yystrlen ("parse error, unexpected ") + 1;
+         yysize += yystrlen ("syntax error, unexpected ") + 1;
          yysize += yystrlen (yytname[yytype]);
          yymsg = (char *) YYSTACK_ALLOC (yysize);
          if (yymsg != 0)
            {
          yysize += yystrlen (yytname[yytype]);
          yymsg = (char *) YYSTACK_ALLOC (yysize);
          if (yymsg != 0)
            {
-             char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+             char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
              yyp = yystpcpy (yyp, yytname[yytype]);
 
              if (yycount < 5)
              yyp = yystpcpy (yyp, yytname[yytype]);
 
              if (yycount < 5)
@@ -1124,15 +1063,15 @@ yyerrlab:
                        yycount++;
                      }
                }
                        yycount++;
                      }
                }
-             yyerror (yymsg);
+             yyerror (]b4_yyerror_args[yymsg);
              YYSTACK_FREE (yymsg);
            }
          else
              YYSTACK_FREE (yymsg);
            }
          else
-           yyerror ("parse error; also virtual memory exhausted");
+           yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted");
        }
       else
 #endif /* YYERROR_VERBOSE */
        }
       else
 #endif /* YYERROR_VERBOSE */
-       yyerror ("parse error");
+       yyerror (]b4_yyerror_args["syntax error");
     }
   goto yyerrlab1;
 
     }
   goto yyerrlab1;
 
@@ -1147,28 +1086,23 @@ yyerrlab1:
         error, discard it.  */
 
       /* Return failure if at end of input.  */
         error, discard it.  */
 
       /* Return failure if at end of input.  */
-      if (yychar == YYEOF)
+      if (yytoken == YYEOF)
         {
          /* Pop the error token.  */
           YYPOPSTACK;
          /* Pop the rest of the stack.  */
          while (yyss < yyssp)
            {
         {
          /* Pop the error token.  */
           YYPOPSTACK;
          /* Pop the rest of the stack.  */
          while (yyss < yyssp)
            {
-             YYDPRINTF ((stderr, "Error: popping "));
-             YYDSYMPRINT ((stderr,
-                           yystos[*yyssp],
-                           *yyvsp]b4_location_if([, *yylsp])[));
-             YYDPRINTF ((stderr, "\n"));
-             yydestruct (yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[);
+             YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+             yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
              YYPOPSTACK;
            }
          YYABORT;
         }
 
              YYPOPSTACK;
            }
          YYABORT;
         }
 
-      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
-                 yychar, yytname[yychar1]));
-      yydestruct (yychar1, yylval]b4_location_if([, yylloc])[);
-      yychar = YYEMPTY;
+      YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
+      yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
+      yytoken = YYEMPTY;
     }
 
   /* Else will try to reuse lookahead token after shifting the error
     }
 
   /* Else will try to reuse lookahead token after shifting the error
@@ -1194,26 +1128,12 @@ yyerrlab1:
       if (yyssp == yyss)
        YYABORT;
 
       if (yyssp == yyss)
        YYABORT;
 
-      YYDPRINTF ((stderr, "Error: popping "));
-      YYDSYMPRINT ((stderr,
-                   yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[));
-      YYDPRINTF ((stderr, "\n"));
-
-      yydestruct (yystos[yystate], *yyvsp]b4_location_if([, *yylsp])[);
+      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+      yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
       yyvsp--;
       yystate = *--yyssp;
 ]b4_location_if([      yylsp--;])[
       yyvsp--;
       yystate = *--yyssp;
 ]b4_location_if([      yylsp--;])[
-
-#if YYDEBUG
-      if (yydebug)
-       {
-         short *yyssp1 = yyss - 1;
-         YYFPRINTF (stderr, "Error: state stack now");
-         while (yyssp1 != yyssp)
-           YYFPRINTF (stderr, " %d", *++yyssp1);
-         YYFPRINTF (stderr, "\n");
-       }
-#endif
+      YY_STACK_PRINT (yyss, yyssp);
     }
 
   if (yyn == YYFINAL)
     }
 
   if (yyn == YYFINAL)
@@ -1247,7 +1167,7 @@ yyabortlab:
 | yyoverflowlab -- parser overflow comes here.  |
 `----------------------------------------------*/
 yyoverflowlab:
 | yyoverflowlab -- parser overflow comes here.  |
 `----------------------------------------------*/
 yyoverflowlab:
-  yyerror ("parser stack overflow");
+  yyerror (]b4_yyerror_args["parser stack overflow");
   yyresult = 2;
   /* Fall through.  */
 #endif
   yyresult = 2;
   /* Fall through.  */
 #endif
@@ -1263,7 +1183,7 @@ yyreturn:
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
-[#output "b4_output_header_name"
+[@output @output_header_name@
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 
@@ -1272,19 +1192,17 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
    This special exception was added by the Free Software Foundation
    in version 1.24 of Bison.  */
 
    This special exception was added by the Free Software Foundation
    in version 1.24 of Bison.  */
 
-#ifndef b4_header_guard
-# define b4_header_guard
-
 b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE
 m4_ifdef([b4_stype],
 b4_token_defines(b4_tokens)
 
 #ifndef YYSTYPE
 m4_ifdef([b4_stype],
-[#line b4_stype_line "b4_filename"
+[b4_syncline([b4_stype_line], [b4_filename])
 typedef union b4_stype yystype;
 /* Line __line__ of __file__.  */
 typedef union b4_stype yystype;
 /* Line __line__ of __file__.  */
-#line __oline__ "__ofile__"],
+b4_syncline([@oline@], [@ofile@])],
 [typedef int yystype;])
 # define YYSTYPE yystype
 [typedef int yystype;])
 # define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
 #endif
 
 b4_pure_if([],
 #endif
 
 b4_pure_if([],
@@ -1305,5 +1223,4 @@ typedef struct yyltype
 m4_if(b4_pure, [0],
 [extern YYLTYPE b4_prefix[]lloc;])
 ])
 m4_if(b4_pure, [0],
 [extern YYLTYPE b4_prefix[]lloc;])
 ])
-#endif /* not b4_header_guard */
 ])
 ])
bison