X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/4a2a22f4c0b1ce06a0a473038436bd8a8116b2aa..0ced3098fd97e1483b4ac938bdce99bfc7942539:/data/yacc.c?ds=inline diff --git a/data/yacc.c b/data/yacc.c index eed1a8a1..6ef0775c 100644 --- a/data/yacc.c +++ b/data/yacc.c @@ -1,8 +1,7 @@ m4_divert(-1) -*- C -*- -m4_include([c.m4]) # Yacc compatible skeleton for Bison -# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 +# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 # Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify @@ -20,6 +19,76 @@ m4_include([c.m4]) # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA # 02111-1307 USA + + +## ---------------- ## +## Default values. ## +## ---------------- ## + +# Stack parameters. +m4_define_default([b4_stack_depth_max], [10000]) +m4_define_default([b4_stack_depth_init], [200]) + + +## ------------------------ ## +## 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 +# ------------ +# Accumulate in b4_lex_param all the yylex arguments. +# 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]]])m4_ifdef([b4_lex_param], [, ])])dnl +m4_ifdef([b4_lex_param], b4_lex_param))) + + + +## ------------ ## +## Data Types. ## +## ------------ ## + +# b4_int_type(MIN, MAX) +# --------------------- +# 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. +m4_define([b4_int_type], +[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char], + b4_ints_in($@, [-128], [127]), [1], [yysigned_char], + + b4_ints_in($@, [0], [65535]), [1], [unsigned short], + b4_ints_in($@, [-32768], [32767]), [1], [short], + + m4_eval([0 <= $1]), [1], [unsigned int], + + [int])]) + + +## ----------------- ## +## Semantic Values. ## +## ----------------- ## + + # b4_lhs_value([TYPE]) # -------------------- # Expansion of $$. @@ -32,7 +101,7 @@ m4_define([b4_lhs_value], # Expansion of $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])]) @@ -40,15 +109,6 @@ m4_define([b4_rhs_value], ## Locations. ## ## ----------- ## -# b4_location_if(IF-TRUE, IF-FALSE) -# --------------------------------- -# Expand IF-TRUE, if locations are used, IF-FALSE otherwise. -m4_define([b4_location_if], -[m4_if(b4_locations_flag, [1], - [$1], - [$2])]) - - # b4_lhs_location() # ----------------- # Expansion of @$. @@ -61,45 +121,7 @@ m4_define([b4_lhs_location], # Expansion of @NUM, where the current rule has RULE-LENGTH symbols # on RHS. m4_define([b4_rhs_location], -[yylsp@<:@m4_eval([$2 - $1])@:>@]) - - - -## -------------- ## -## %pure-parser. ## -## -------------- ## - -# b4_pure_if(IF-TRUE, IF-FALSE) -# ----------------------------- -# Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise. -m4_define([b4_pure_if], -[m4_if(b4_pure, [1], - [$1], - [$2])]) - - -## ------------------- ## -## 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])@}]) @@ -107,28 +129,17 @@ m4_define_default([b4_header_guard], ## 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 -#output "b4_output_parser_name" +@output @output_parser_name@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison], - [1984, 1989, 1990, 2000, 2001, 2002]) + [1984, 1989, 1990, 2000, 2001, 2002, 2003])[ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ /* Written by Richard Stallman by simplifying the original so called ``semantic'' parser. */ @@ -140,15 +151,7 @@ b4_copyright([Skeleton parser for Yacc-like parsing with Bison], 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. */ @@ -159,16 +162,16 @@ m4_if(b4_prefix[], [yy], [], #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])])[ -/* Copy the first part of user declarations. */ -b4_pre_prologue +]b4_token_defines(b4_tokens)[ -b4_token_defines(b4_tokens) +/* Copy the first part of user declarations. */ +]b4_pre_prologue[ /* Enabling traces. */ #ifndef YYDEBUG -# define YYDEBUG b4_debug +# define YYDEBUG ]b4_debug[ #endif /* Enabling verbose error messages. */ @@ -176,52 +179,62 @@ b4_token_defines(b4_tokens) # undef YYERROR_VERBOSE # define YYERROR_VERBOSE 1 #else -# define YYERROR_VERBOSE b4_error_verbose +# define YYERROR_VERBOSE ]b4_error_verbose[ #endif -#ifndef YYSTYPE -m4_ifdef([b4_stype], -[#line b4_stype_line "b4_filename" -typedef union b4_stype yystype; -/* Line __line__ of __file__. */ -#line __oline__ "__ofile__"], -[typedef int yystype;]) -# define YYSTYPE yystype +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) +]m4_ifdef([b4_stype], +[b4_syncline([b4_stype_line], [b4_filename]) +typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; +/* Line __line__ of yacc.c. */ +b4_syncline([@oline@], [@ofile@])], +[typedef int YYSTYPE;])[ +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 # define YYSTYPE_IS_TRIVIAL 1 #endif -#ifndef YYLTYPE -typedef struct yyltype +]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) +typedef struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; -} yyltype; -# define YYLTYPE b4_ltype +} YYLTYPE; +# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ +# define YYLTYPE_IS_DECLARED 1 # define YYLTYPE_IS_TRIVIAL 1 #endif +])[ /* Copy the second part of user declarations. */ -b4_post_prologue +]b4_post_prologue -/* Line __line__ of __file__. */ -#line __oline__ "__ofile__" +/* Line __line__ of yacc.c. */ +b4_syncline([@oline@], [@ofile@])[ #if ! defined (yyoverflow) || YYERROR_VERBOSE +# ifndef YYFREE +# define YYFREE free +# endif +# ifndef YYMALLOC +# define YYMALLOC malloc +# endif + /* The parser invokes alloca or malloc; define the necessary symbols. */ -# if YYSTACK_USE_ALLOCA -# define YYSTACK_ALLOC alloca +# ifdef YYSTACK_USE_ALLOCA +# if YYSTACK_USE_ALLOCA +# define YYSTACK_ALLOC alloca +# endif # else -# ifndef YYSTACK_USE_ALLOCA -# if defined (alloca) || defined (_ALLOCA_H) -# define YYSTACK_ALLOC alloca -# else -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# endif +# if defined (alloca) || defined (_ALLOCA_H) +# define YYSTACK_ALLOC alloca +# else +# ifdef __GNUC__ +# define YYSTACK_ALLOC __builtin_alloca # endif # endif # endif @@ -234,42 +247,43 @@ b4_post_prologue # include /* INFRINGES ON USER NAME SPACE */ # define YYSIZE_T size_t # endif -# define YYSTACK_ALLOC malloc -# define YYSTACK_FREE free +# define YYSTACK_ALLOC YYMALLOC +# define YYSTACK_FREE YYFREE # endif #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ #if (! defined (yyoverflow) \ && (! defined (__cplusplus) \ - || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) + || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \ + && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) /* A type that is properly aligned for any stack member. */ union yyalloc { short yyss; YYSTYPE yyvs; - b4_location_if([ YYLTYPE yyls; + ]b4_location_if([ YYLTYPE yyls; ])dnl -}; +[}; /* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1) +# define YYSTACK_GAP_MAXIMUM (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)], + + 2 * YYSTACK_GAP_MAXIMUM)], [# define YYSTACK_BYTES(N) \ ((N) * (sizeof (short) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAX)]) + + YYSTACK_GAP_MAXIMUM)])[ /* Copy COUNT objects from FROM to TO. The source and destination do not overlap. */ # ifndef YYCOPY -# if 1 < __GNUC__ +# if defined (__GNUC__) && 1 < __GNUC__ # define YYCOPY(To, From, Count) \ __builtin_memcpy (To, From, (Count) * sizeof (*(From))) # else @@ -278,7 +292,7 @@ b4_location_if( { \ register YYSIZE_T yyi; \ for (yyi = 0; yyi < (Count); yyi++) \ - (To)[[yyi]] = (From)[[yyi]]; \ + (To)[yyi] = (From)[yyi]; \ } \ while (0) # endif @@ -295,135 +309,145 @@ b4_location_if( YYSIZE_T yynewbytes; \ YYCOPY (&yyptr->Stack, Stack, yysize); \ Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \ + yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ yyptr += yynewbytes / sizeof (*yyptr); \ } \ while (0) #endif +#if defined (__STDC__) || defined (__cplusplus) + typedef signed char yysigned_char; +#else + typedef short yysigned_char; +#endif + /* YYFINAL -- State number of the termination state. */ -#define YYFINAL b4_final_state_number -#define YYLAST b4_last +#define YYFINAL ]b4_final_state_number[ +/* YYLAST -- Last index in YYTABLE. */ +#define YYLAST ]b4_last[ /* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS b4_tokens_number +#define YYNTOKENS ]b4_tokens_number[ /* YYNNTS -- Number of nonterminals. */ -#define YYNNTS b4_nterms_number +#define YYNNTS ]b4_nterms_number[ /* YYNRULES -- Number of rules. */ -#define YYNRULES b4_rules_number +#define YYNRULES ]b4_rules_number[ /* YYNRULES -- Number of states. */ -#define YYNSTATES b4_states_number +#define YYNSTATES ]b4_states_number[ /* 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) \ + ((unsigned int) (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 -/* 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. */ -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. */ -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 -/* 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. */ -static const char *const yytname[[]] = +static const char *const yytname[] = { - b4_tname + ]b4_tname[ }; #endif -/* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to +# ifdef YYPRINT +/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 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 -/* 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. */ -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. */ -#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. */ -#define YYTABLE_NINF b4_table_ninf -static const b4_int_type_for([b4_table]) yytable[[]] = + number is the opposite. If zero, do what YYDEFACT says. + 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. */ -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__) @@ -444,12 +468,13 @@ static const b4_int_type_for([b4_stos]) yystos[[]] = #define yyerrok (yyerrstatus = 0) #define yyclearin (yychar = YYEMPTY) -#define YYEMPTY -2 +#define YYEMPTY (-2) #define YYEOF 0 #define YYACCEPT goto yyacceptlab #define YYABORT goto yyabortlab -#define YYERROR goto yyerrlab1 +#define YYERROR goto yyerrorlab + /* Like YYERROR except do call yyerror. This remains here temporarily to ease the transition to the new meaning of YYERROR, for GCC. @@ -465,13 +490,13 @@ do \ { \ yychar = (Token); \ yylval = (Value); \ - yychar1 = YYTRANSLATE (yychar); \ + yytoken = YYTRANSLATE (yychar); \ YYPOPSTACK; \ goto yybackup; \ } \ else \ { \ - yyerror ("syntax error: cannot back up"); \ + yyerror (]b4_yyerror_args["syntax error: cannot back up");\ YYERROR; \ } \ while (0) @@ -483,22 +508,20 @@ while (0) 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. */ -b4_pure_if( -[#ifdef YYLEX_PARAM -# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]), YYLEX_PARAM) +#ifdef YYLEX_PARAM +# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM) #else -# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc])) -#endif], -[#define YYLEX yylex ()]) +# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ +#endif /* Enable debugging if requested. */ #if YYDEBUG @@ -513,22 +536,84 @@ do { \ if (yydebug) \ YYFPRINTF 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 (included). | +`------------------------------------------------------------------*/ + +]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; + unsigned int yylno = yyrline[yyrule]; + YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", + yyrule - 1, yylno); + /* 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) +# define YYDSYMPRINTF(Title, Token, Value, Location) +# define YY_STACK_PRINT(Bottom, Top) +# define YY_REDUCE_PRINT(Rule) #endif /* !YYDEBUG */ + /* YYINITDEPTH -- initial size of the parser's stacks. */ #ifndef YYINITDEPTH -# define YYINITDEPTH b4_initdepth +# define YYINITDEPTH ]b4_stack_depth_init[ #endif /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only @@ -538,12 +623,12 @@ int yydebug; SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic. */ -#if YYMAXDEPTH == 0 +#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 # undef YYMAXDEPTH #endif #ifndef YYMAXDEPTH -# define YYMAXDEPTH b4_maxdepth +# define YYMAXDEPTH ]b4_stack_depth_max[ #endif @@ -604,169 +689,29 @@ yystpcpy (yydest, yysrc) #if YYDEBUG -/*-----------------------------. -| Print this symbol on YYOUT. | -`-----------------------------*/ - -b4_c_function([yysymprint], - [static void], - [[FILE*], [yyout]], - [[int], [yytype]], - [[YYSTYPE], [yyvalue]]b4_location_if([, - [[YYLTYPE], [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. */ - - -/*----------------------------------------------------------. -| yyreport_parse_error -- report a parse error in YYSTATE. | -`----------------------------------------------------------*/ - -b4_c_function([yyreport_parse_error], - [static void], - [[int], [yystate]], - [[int], [yychar]], - [[YYSTYPE], [yyvalue]]b4_location_if([, - [[YYLTYPE], [yylocation]]])) -[{ -#if YYERROR_VERBOSE - int yyn = yypact[yystate]; - - if (YYPACT_NINF < yyn && yyn < YYLAST) - { - YYSIZE_T yysize = 0; - int yytype = YYTRANSLATE (yychar); - char *yymsg; - int yyx, yycount; - - yycount = 0; - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++) - if (yycheck[yyx + yyn] == yyx) - yysize += yystrlen (yytname[yyx]) + 15, yycount++; - yysize += yystrlen ("parse error, unexpected ") + 1; - yysize += yystrlen (yytname[yytype]); - yymsg = (char *) YYSTACK_ALLOC (yysize); - if (yymsg != 0) - { - char *yyp = yystpcpy (yymsg, "parse error, unexpected "); - yyp = yystpcpy (yyp, yytname[yytype]); - - if (yycount < 5) - { - yycount = 0; - for (yyx = yyn < 0 ? -yyn : 0; - yyx < (int) (sizeof (yytname) / sizeof (char *)); - yyx++) - if (yycheck[yyx + yyn] == yyx) - { - const char *yyq = ! yycount ? ", expecting " : " or "; - yyp = yystpcpy (yyp, yyq); - yyp = yystpcpy (yyp, yytname[yyx]); - yycount++; - } - } - yyerror (yymsg); - YYSTACK_FREE (yymsg); - } - else - yyerror ("parse error; also virtual memory exhausted"); - } - else -#endif /* YYERROR_VERBOSE */ - yyerror ("parse error"); - - /* Pacify ``unused variable'' warnings. */ - (void) yystate; - (void) yychar; - (void) yyvalue; - ]b4_location_if([(void) yylocation;])[ -}] - - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -b4_c_function([yydestruct], - [static void], - [[int], [yytype]], - [[YYSTYPE], [yyvalue]]b4_location_if([, - [[YYLTYPE], [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]) -/* The user can define YYPARSE_PARAM as the name of an argument to be passed - into yyparse. The argument should have type void *. - It should actually point to an object. - Grammar actions can access the variable by casting it - to the proper pointer type. */ +/* Prevent warnings from -Wmissing-prototypes. */ #ifdef YYPARSE_PARAM # if defined (__STDC__) || defined (__cplusplus) -# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM -# define YYPARSE_PARAM_DECL +int yyparse (void *YYPARSE_PARAM); # else -# define YYPARSE_PARAM_ARG YYPARSE_PARAM -# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; +int yyparse (); # endif -#else /* !YYPARSE_PARAM */ -# define YYPARSE_PARAM_ARG -# define YYPARSE_PARAM_DECL -#endif /* !YYPARSE_PARAM */ +#else /* ! YYPARSE_PARAM */ +b4_c_function_decl([yyparse], [int], b4_parse_param) +#endif /* ! YYPARSE_PARAM */ -/* Prevent warning if -Wstrict-prototypes. */ -#ifdef __GNUC__ -# ifdef YYPARSE_PARAM -int yyparse (void *); -# else -int yyparse (void); -# endif -#endif m4_divert_push([KILL])# ======================== M4 code. # b4_declare_parser_variables # --------------------------- # Declare the variables that are global, or local to YYPARSE if -# pure-parser +# pure-parser. m4_define([b4_declare_parser_variables], [/* The lookahead symbol. */ int yychar; @@ -774,7 +719,7 @@ int yychar; /* 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;]) @@ -784,9 +729,21 @@ m4_divert_pop([KILL])dnl# ====================== End of M4 code. b4_pure_if([], [b4_declare_parser_variables]) -int -yyparse (YYPARSE_PARAM_ARG) - YYPARSE_PARAM_DECL + +/*----------. +| yyparse. | +`----------*/ + +#ifdef YYPARSE_PARAM +# if defined (__STDC__) || defined (__cplusplus) +int yyparse (void *YYPARSE_PARAM) +# else +int yyparse (YYPARSE_PARAM) + void *YYPARSE_PARAM; +# endif +#else /* ! YYPARSE_PARAM */ +b4_c_function_def([yyparse], [int], b4_parse_param) +#endif {[ ]b4_pure_if([b4_declare_parser_variables])[ register int yystate; @@ -795,7 +752,7 @@ yyparse (YYPARSE_PARAM_ARG) /* 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, @@ -819,7 +776,8 @@ yyparse (YYPARSE_PARAM_ARG) [[ /* The location stack. */ YYLTYPE yylsa[YYINITDEPTH]; YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp;]])[ + YYLTYPE *yylsp; + YYLTYPE *yylerrsp;]])[ #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[) @@ -849,7 +807,17 @@ yyparse (YYPARSE_PARAM_ARG) yyssp = yyss; yyvsp = yyvs; ]b4_location_if([ yylsp = yyls;])[ - goto yysetstate; +]m4_ifdef([b4_initial_action], [ +m4_pushdef([b4_at_dollar], [(*yylsp)])dnl +m4_pushdef([b4_dollar_dollar], [(*yyvsp)])dnl + /* User initialization code. */ + b4_initial_action +m4_popdef([b4_dollar_dollar])dnl +m4_popdef([b4_at_dollar])dnl +/* Line __line__ of yacc.c. */ +b4_syncline([@oline@], [@ofile@])])dnl + +[ goto yysetstate; /*------------------------------------------------------------. | yynewstate -- Push a new state, which is found in yystate. | @@ -863,7 +831,7 @@ yyparse (YYPARSE_PARAM_ARG) yysetstate: *yyssp = yystate; - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) { /* Get the current used size of the three stacks, in elements. */ YYSIZE_T yysize = yyssp - yyss + 1; @@ -895,10 +863,10 @@ yyparse (YYPARSE_PARAM_ARG) goto yyoverflowlab; # else /* Extend the stack our own way. */ - if (yystacksize >= YYMAXDEPTH) + if (YYMAXDEPTH <= yystacksize) goto yyoverflowlab; yystacksize *= 2; - if (yystacksize > YYMAXDEPTH) + if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH; { @@ -924,7 +892,7 @@ yyparse (YYPARSE_PARAM_ARG) YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) yystacksize)); - if (yyssp >= yyss + yystacksize - 1) + if (yyss + yystacksize - 1 <= yyssp) YYABORT; } @@ -949,64 +917,43 @@ yybackup: /* 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. */ - + /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ if (yychar == YYEMPTY) { YYDPRINTF ((stderr, "Reading a token: ")); yychar = YYLEX; } - /* Convert token to internal form (in yychar1) for indexing tables with. */ - - if (yychar <= 0) /* This means end of input. */ + if (yychar <= YYEOF) { - yychar1 = 0; - yychar = YYEOF; /* Don't call YYLEX any more. */ - + yychar = yytoken = YYEOF; 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. */ - YYDPRINTF ((stderr, "Next token is ")); - YYDSYMPRINT ((stderr, yychar1, yylval]b4_location_if([, yyloc])[)); - YYDPRINTF ((stderr, "\n")); + yytoken = YYTRANSLATE (yychar); + YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); } - yyn += yychar1; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1) + /* If the proper action on seeing token YYTOKEN is to reduce or to + detect an error, take that action. */ + yyn += yytoken; + if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault; - yyn = yytable[yyn]; - - /* yyn is what to do for this token type in this state. - Negative => reduce, -yyn is rule number. - Positive => shift, yyn is new state. - New state is final state => don't bother to shift, - just return success. - 0, or most negative number => error. */ - - if (yyn < 0) + if (yyn <= 0) { - if (yyn == YYTABLE_NINF) + if (yyn == 0 || yyn == YYTABLE_NINF) goto yyerrlab; yyn = -yyn; goto yyreduce; } - else if (yyn == 0) - goto yyerrlab; if (yyn == YYFINAL) 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. */ if (yychar != YYEOF) @@ -1044,8 +991,8 @@ yyreduce: /* If YYLEN is nonzero, implement the default value of the action: `$$ = $1'. - Otherwise, the following line sets YYVAL to the semantic value of - the lookahead token. This behavior is undocumented and Bison + Otherwise, the following line sets YYVAL to garbage. + This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized. */ @@ -1053,46 +1000,21 @@ yyreduce: ]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]; yyrhs[yyi] >= 0; yyi++) - YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); - YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]); - } -#endif + YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);])[ + YY_REDUCE_PRINT (yyn); switch (yyn) ]{ b4_actions } -/* Line __line__ of __file__. */ -#line __oline__ "__ofile__" +/* Line __line__ of yacc.c. */ +b4_syncline([@oline@], [@ofile@]) [ 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;])[ @@ -1120,48 +1042,128 @@ yyerrlab: if (!yyerrstatus) { ++yynerrs; - yyreport_parse_error (yystate, yychar, yylval]b4_location_if([, yylloc])[); +#if YYERROR_VERBOSE + yyn = yypact[yystate]; + + if (YYPACT_NINF < yyn && yyn < YYLAST) + { + YYSIZE_T yysize = 0; + int yytype = YYTRANSLATE (yychar); + const char* yyprefix; + char *yymsg; + int yyx; + + /* Start YYX at -YYN if negative to avoid negative indexes in + YYCHECK. */ + int yyxbegin = yyn < 0 ? -yyn : 0; + + /* Stay within bounds of both yycheck and yytname. */ + int yychecklim = YYLAST - yyn; + int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; + int yycount = 0; + + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); + yycount += 1; + if (yycount == 5) + { + yysize = 0; + break; + } + } + yysize += (sizeof ("syntax error, unexpected ") + + yystrlen (yytname[yytype])); + yymsg = (char *) YYSTACK_ALLOC (yysize); + if (yymsg != 0) + { + char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); + yyp = yystpcpy (yyp, yytname[yytype]); + + if (yycount < 5) + { + yyprefix = ", expecting "; + for (yyx = yyxbegin; yyx < yyxend; ++yyx) + if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) + { + yyp = yystpcpy (yyp, yyprefix); + yyp = yystpcpy (yyp, yytname[yyx]); + yyprefix = " or "; + } + } + yyerror (]b4_yyerror_args[yymsg); + YYSTACK_FREE (yymsg); + } + else + yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted"); + } + else +#endif /* YYERROR_VERBOSE */ + yyerror (]b4_yyerror_args["syntax error"); } - goto yyerrlab1; +]b4_location_if([ yylerrsp = yylsp;])[ -/*----------------------------------------------------. -| yyerrlab1 -- error raised explicitly by an action. | -`----------------------------------------------------*/ -yyerrlab1: if (yyerrstatus == 3) { /* If just tried and failed to reuse lookahead token after an error, discard it. */ - /* Return failure if at end of input. */ - if (yychar == YYEOF) + if (yychar <= YYEOF) { - /* Pop the error token. */ - YYPOPSTACK; - /* Pop the rest of the stack. */ - while (yyssp > yyss) - { - YYDPRINTF ((stderr, "Error: popping ")); - YYDSYMPRINT ((stderr, - yystos[*yyssp], - *yyvsp]b4_location_if([, *yylsp])[)); - YYDPRINTF ((stderr, "\n")); - yydestruct (yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[); - YYPOPSTACK; - } - YYABORT; + /* If at end of input, pop the error token, + then the rest of the stack, then return failure. */ + if (yychar == YYEOF) + for (;;) + { + YYPOPSTACK; + if (yyssp == yyss) + YYABORT; + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[); + } } - - YYDPRINTF ((stderr, "Discarding token %d (%s).\n", - yychar, yytname[yychar1])); - yydestruct (yychar1, yylval]b4_location_if([, yylloc])[); - yychar = YYEMPTY; + else + { + YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); + yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[); + yychar = YYEMPTY; +]b4_location_if([ *++yylerrsp = yylloc;])[ + } } /* Else will try to reuse lookahead token after shifting the error token. */ + goto yyerrlab1; + +/*---------------------------------------------------. +| yyerrorlab -- error raised explicitly by YYERROR. | +`---------------------------------------------------*/ +yyerrorlab: + +#ifdef __GNUC__ + /* Pacify GCC when the user code never invokes YYERROR and the label + yyerrorlab therefore never appears in user code. */ + if (0) + goto yyerrorlab; +#endif + + yyvsp -= yylen; + yyssp -= yylen; + yystate = *yyssp; + ]b4_location_if([yylerrsp = yylsp; + *++yylerrsp = yyloc; + yylsp -= yylen; + ])[goto yyerrlab1; + + +/*-------------------------------------------------------------. +| yyerrlab1 -- common code for both syntax error and YYERROR. | +`-------------------------------------------------------------*/ +yyerrlab1: yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) @@ -1182,26 +1184,11 @@ yyerrlab1: 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])[); - 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 + YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); + yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[); + YYPOPSTACK; + yystate = *yyssp; + YY_STACK_PRINT (yyss, yyssp); } if (yyn == YYFINAL) @@ -1210,7 +1197,8 @@ yyerrlab1: YYDPRINTF ((stderr, "Shifting error token, ")); *++yyvsp = yylval; -]b4_location_if([ *++yylsp = yylloc;])[ +]b4_location_if([ YYLLOC_DEFAULT (yyloc, yylsp, yylerrsp - yylsp); + *++yylsp = yyloc;])[ yystate = yyn; goto yynewstate; @@ -1235,7 +1223,7 @@ yyabortlab: | yyoverflowlab -- parser overflow comes here. | `----------------------------------------------*/ yyoverflowlab: - yyerror ("parser stack overflow"); + yyerror (]b4_yyerror_args["parser stack overflow"); yyresult = 2; /* Fall through. */ #endif @@ -1251,42 +1239,47 @@ yyreturn: 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]) + [1984, 1989, 1990, 2000, 2001, 2002, 2003]) -#ifndef b4_header_guard -# define b4_header_guard +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ b4_token_defines(b4_tokens) -#ifndef YYSTYPE +#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) m4_ifdef([b4_stype], -[#line b4_stype_line "b4_filename" -typedef union b4_stype yystype; -/* Line __line__ of __file__. */ -#line __oline__ "__ofile__"], -[typedef int yystype;]) -# define YYSTYPE yystype +[b4_syncline([b4_stype_line], [b4_filename]) +typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; +/* Line __line__ of yacc.c. */ +b4_syncline([@oline@], [@ofile@])], +[typedef int YYSTYPE;]) +# define yystype YYSTYPE /* obsolescent; will be withdrawn */ +# define YYSTYPE_IS_DECLARED 1 +# define YYSTYPE_IS_TRIVIAL 1 #endif b4_pure_if([], [extern YYSTYPE b4_prefix[]lval;]) b4_location_if( -[#ifndef YYLTYPE -typedef struct yyltype +[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) +typedef struct YYLTYPE { int first_line; int first_column; int last_line; int last_column; -} yyltype; -# define YYLTYPE yyltype +} YYLTYPE; +# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ +# define YYLTYPE_IS_DECLARED 1 +# define YYLTYPE_IS_TRIVIAL 1 #endif m4_if(b4_pure, [0], [extern YYLTYPE b4_prefix[]lloc;]) ]) -#endif /* not b4_header_guard */ ])