Go to:
Gentoo Home
Documentation
Forums
Lists
Bugs
Planet
Store
Wiki
Get Gentoo!
Gentoo's Bugzilla – Attachment 159562 Details for
Bug 230790
gnome-base/libbonobo-2.20.4 /usr/bin/m4:/usr/local/share/bison/yacc.c:23: cannot open `b4_pkgdatadir/c.m4': No such file or directory
Home
|
New
–
[Ex]
|
Browse
|
Search
|
Privacy Policy
|
[?]
|
Reports
|
Requests
|
Help
|
New Account
|
Log In
[x]
|
Forgot Password
Login:
[x]
/usr/local/share/bison/yacc.c
yacc.c (text/plain), 40.80 KB, created by
ksenija
on 2008-07-04 19:52:04 UTC
(
hide
)
Description:
/usr/local/share/bison/yacc.c
Filename:
MIME Type:
Creator:
ksenija
Created:
2008-07-04 19:52:04 UTC
Size:
40.80 KB
patch
obsolete
>m4_divert(-1) -*- C -*- > ># Yacc compatible skeleton for Bison > ># Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 ># Free Software Foundation, Inc. > ># This program is free software; you can redistribute it and/or modify ># it under the terms of the GNU General Public License as published by ># the Free Software Foundation; either version 2 of the License, or ># (at your option) any later version. > ># This program is distributed in the hope that it will be useful, ># but WITHOUT ANY WARRANTY; without even the implied warranty of ># MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ># GNU General Public License for more details. > ># You should have received a copy of the GNU General Public License ># along with this program; if not, write to the Free Software ># Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA ># 02110-1301 USA > >m4_include(b4_pkgdatadir/[c.m4]) > >## ---------------- ## >## Default values. ## >## ---------------- ## > ># Stack parameters. >m4_define_default([b4_stack_depth_max], [10000]) >m4_define_default([b4_stack_depth_init], [200]) > > >## ------------------------ ## >## Pure/impure interfaces. ## >## ------------------------ ## > > ># b4_yacc_pure_if(IF-TRUE, IF-FALSE) ># ---------------------------------- ># Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise. >m4_define([b4_yacc_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_yacc_pure_if([b4_locations_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_locations_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). Overwrite the version from c.m4, which ># uses only C89 types, so that the user can override the shorter ># types, and so that pre-C89 compilers are handled correctly. >m4_define([b4_int_type], >[m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8], > b4_ints_in($@, [-128], [127]), [1], [yytype_int8], > > b4_ints_in($@, [0], [65535]), [1], [yytype_uint16], > b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16], > > m4_eval([0 <= $1]), [1], [unsigned int], > > [int])]) > > >## ----------------- ## >## Semantic Values. ## >## ----------------- ## > > ># 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@{($2) - ($1)@}m4_ifval([$3], [.$3]))]) > > > >## ----------- ## >## Locations. ## >## ----------- ## > ># 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@{($2) - ($1)@})]) > > > >## --------------------------------------------------------- ## >## Defining symbol actions, e.g., printers and destructors. ## >## --------------------------------------------------------- ## > ># We do want M4 expansion after # for CPP macros. >m4_changecom() >m4_divert(0)dnl >@output @output_parser_name@ >b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl ' > [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])[ > >/* C LALR(1) parser skeleton 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. */ > >]b4_identification >m4_if(b4_prefix, [yy], [], >[/* Substitute the variable and function names. */ >#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 >b4_locations_if([#define yylloc b4_prefix[]lloc])])[ > >]b4_token_enums_defines(b4_tokens)[ > >/* Copy the first part of user declarations. */ >]b4_pre_prologue[ > >/* Enabling traces. */ >#ifndef YYDEBUG ># define YYDEBUG ]b4_debug_flag[ >#endif > >/* Enabling verbose error messages. */ >#ifdef YYERROR_VERBOSE ># undef YYERROR_VERBOSE ># define YYERROR_VERBOSE 1 >#else ># define YYERROR_VERBOSE ]b4_error_verbose_flag[ >#endif > >/* Enabling the token table. */ >#ifndef YYTOKEN_TABLE ># define YYTOKEN_TABLE ]b4_token_table[ >#endif > >#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED >]m4_ifdef([b4_stype], >[typedef union[]m4_bregexp(b4_stype, [^{], [ YYSTYPE]) >b4_stype >/* Line __line__ of yacc.c. */ >b4_syncline([@oline@], [@ofile@]) > YYSTYPE;], >[typedef int YYSTYPE;])[ ># define yystype YYSTYPE /* obsolescent; will be withdrawn */ ># define YYSTYPE_IS_DECLARED 1 ># define YYSTYPE_IS_TRIVIAL 1 >#endif > >]b4_locations_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 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 > >/* Line __line__ of yacc.c. */ >b4_syncline([@oline@], [@ofile@])[ > >#ifdef short ># undef short >#endif > >#ifdef YYTYPE_UINT8 >typedef YYTYPE_UINT8 yytype_uint8; >#else >typedef unsigned char yytype_uint8; >#endif > >#ifdef YYTYPE_INT8 >typedef YYTYPE_INT8 yytype_int8; >#elif ]b4_c_modern[ >typedef signed char yytype_int8; >#else >typedef short int yytype_int8; >#endif > >#ifdef YYTYPE_UINT16 >typedef YYTYPE_UINT16 yytype_uint16; >#else >typedef unsigned short int yytype_uint16; >#endif > >#ifdef YYTYPE_INT16 >typedef YYTYPE_INT16 yytype_int16; >#else >typedef short int yytype_int16; >#endif > >#ifndef YYSIZE_T ># ifdef __SIZE_TYPE__ ># define YYSIZE_T __SIZE_TYPE__ ># elif defined size_t ># define YYSIZE_T size_t ># elif ! defined YYSIZE_T && ]b4_c_modern[ ># include <stddef.h> /* INFRINGES ON USER NAME SPACE */ ># define YYSIZE_T size_t ># else ># define YYSIZE_T unsigned int ># endif >#endif > >#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) > >#ifndef YY_ ># if YYENABLE_NLS ># if ENABLE_NLS ># include <libintl.h> /* INFRINGES ON USER NAME SPACE */ ># define YY_(msgid) dgettext ("bison-runtime", msgid) ># endif ># endif ># ifndef YY_ ># define YY_(msgid) msgid ># endif >#endif > >/* Suppress unused-variable warnings by "using" E. */ >#if ! defined lint || defined __GNUC__ ># define YYUSE(e) ((void) (e)) >#else ># define YYUSE(e) /* empty */ >#endif > >/* Identity function, used to suppress warnings about constant conditions. */ >#ifndef lint ># define YYID(n) (n) >#else >]b4_c_function_def([YYID], [static int], [[int i], [i]])[ >{ > return i; >} >#endif > >#if ! defined yyoverflow || YYERROR_VERBOSE > >/* The parser invokes alloca or malloc; define the necessary symbols. */ > ># ifdef YYSTACK_USE_ALLOCA ># if YYSTACK_USE_ALLOCA ># ifdef __GNUC__ ># define YYSTACK_ALLOC __builtin_alloca ># elif defined __BUILTIN_VA_ARG_INCR ># include <alloca.h> /* INFRINGES ON USER NAME SPACE */ ># elif defined _AIX ># define YYSTACK_ALLOC __alloca ># elif defined _MSC_VER ># include <malloc.h> /* INFRINGES ON USER NAME SPACE */ ># define alloca _alloca ># else ># define YYSTACK_ALLOC alloca ># if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[ ># include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ ># ifndef _STDLIB_H ># define _STDLIB_H 1 ># endif ># endif ># endif ># endif ># endif > ># ifdef YYSTACK_ALLOC > /* Pacify GCC's `empty if-body' warning. */ ># define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) ># ifndef YYSTACK_ALLOC_MAXIMUM > /* The OS might guarantee only one guard page at the bottom of the stack, > and a page size can be as small as 4096 bytes. So we cannot safely > invoke alloca (N) if N exceeds 4096. Use a slightly smaller number > to allow for a few compiler-allocated temporary stack slots. */ ># define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ ># endif ># else ># define YYSTACK_ALLOC YYMALLOC ># define YYSTACK_FREE YYFREE ># ifndef YYSTACK_ALLOC_MAXIMUM ># define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM ># endif ># if (defined __cplusplus && ! defined _STDLIB_H \ > && ! ((defined YYMALLOC || defined malloc) \ > && (defined YYFREE || defined free))) ># include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ ># ifndef _STDLIB_H ># define _STDLIB_H 1 ># endif ># endif ># ifndef YYMALLOC ># define YYMALLOC malloc ># if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[ >void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ ># endif ># endif ># ifndef YYFREE ># define YYFREE free ># if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[ >void free (void *); /* INFRINGES ON USER NAME SPACE */ ># endif ># endif ># endif >#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ > > >#if (! defined yyoverflow \ > && (! defined __cplusplus \ > || (]b4_locations_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 >{ > yytype_int16 yyss; > YYSTYPE yyvs; > ]b4_locations_if([ YYLTYPE yyls; >])dnl >[}; > >/* The size of the maximum gap between one aligned stack and the next. */ ># 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_locations_if( >[# define YYSTACK_BYTES(N) \ > ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ > + 2 * YYSTACK_GAP_MAXIMUM)], >[# define YYSTACK_BYTES(N) \ > ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ > + YYSTACK_GAP_MAXIMUM)])[ > >/* Copy COUNT objects from FROM to TO. The source and destination do > not overlap. */ ># ifndef YYCOPY ># if defined __GNUC__ && 1 < __GNUC__ ># define YYCOPY(To, From, Count) \ > __builtin_memcpy (To, From, (Count) * sizeof (*(From))) ># else ># define YYCOPY(To, From, Count) \ > do \ > { \ > YYSIZE_T yyi; \ > for (yyi = 0; yyi < (Count); yyi++) \ > (To)[yyi] = (From)[yyi]; \ > } \ > while (YYID (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. */ ># define YYSTACK_RELOCATE(Stack) \ > do \ > { \ > YYSIZE_T yynewbytes; \ > YYCOPY (&yyptr->Stack, Stack, yysize); \ > Stack = &yyptr->Stack; \ > yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ > yyptr += yynewbytes / sizeof (*yyptr); \ > } \ > while (YYID (0)) > >#endif > >/* YYFINAL -- State number of the termination state. */ >#define YYFINAL ]b4_final_state_number[ >/* YYLAST -- Last index in YYTABLE. */ >#define YYLAST ]b4_last[ > >/* YYNTOKENS -- Number of terminals. */ >#define YYNTOKENS ]b4_tokens_number[ >/* YYNNTS -- Number of nonterminals. */ >#define YYNNTS ]b4_nterms_number[ >/* YYNRULES -- Number of rules. */ >#define YYNRULES ]b4_rules_number[ >/* YYNRULES -- Number of states. */ >#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 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[] = >{ > ]b4_translate[ >}; > >#if YYDEBUG >/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in > YYRHS. */ >static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = >{ > ]b4_prhs[ >}; > >/* YYRHS -- A `-1'-separated list of the rules' RHS. */ >static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = >{ > ]b4_rhs[ >}; > >/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ >static const ]b4_int_type_for([b4_rline])[ yyrline[] = >{ > ]b4_rline[ >}; >#endif > >#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE >/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. > First, the terminals, then, starting at YYNTOKENS, nonterminals. */ >static const char *const yytname[] = >{ > ]b4_tname[ >}; >#endif > ># ifdef YYPRINT >/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to > token YYLEX-NUM. */ >static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = >{ > ]b4_toknum[ >}; ># endif > >/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ >static const ]b4_int_type_for([b4_r1])[ yyr1[] = >{ > ]b4_r1[ >}; > >/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ >static const ]b4_int_type_for([b4_r2])[ yyr2[] = >{ > ]b4_r2[ >}; > >/* 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[] = >{ > ]b4_defact[ >}; > >/* YYDEFGOTO[NTERM-NUM]. */ >static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = >{ > ]b4_defgoto[ >}; > >/* 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[] = >{ > ]b4_pact[ >}; > >/* YYPGOTO[NTERM-NUM]. */ >static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = >{ > ]b4_pgoto[ >}; > >/* 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. > If YYTABLE_NINF, syntax error. */ >#define YYTABLE_NINF ]b4_table_ninf[ >static const ]b4_int_type_for([b4_table])[ yytable[] = >{ > ]b4_table[ >}; > >static const ]b4_int_type_for([b4_check])[ yycheck[] = >{ > ]b4_check[ >}; > >/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing > symbol of state STATE-NUM. */ >static const ]b4_int_type_for([b4_stos])[ yystos[] = >{ > ]b4_stos[ >}; > >#define yyerrok (yyerrstatus = 0) >#define yyclearin (yychar = YYEMPTY) >#define YYEMPTY (-2) >#define YYEOF 0 > >#define YYACCEPT goto yyacceptlab >#define YYABORT goto yyabortlab >#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. > Once GCC version 2 has supplanted version 1, this can go. */ > >#define YYFAIL goto yyerrlab > >#define YYRECOVERING() (!!yyerrstatus) > >#define YYBACKUP(Token, Value) \ >do \ > if (yychar == YYEMPTY && yylen == 1) \ > { \ > yychar = (Token); \ > yylval = (Value); \ > yytoken = YYTRANSLATE (yychar); \ > YYPOPSTACK (1); \ > goto yybackup; \ > } \ > else \ > { \ > yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ > YYERROR; \ > } \ >while (YYID (0)) > > >#define YYTERROR 1 >#define YYERRCODE 256 > > >/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. > If N is 0, then set CURRENT to the empty location which ends > the previous symbol: RHS[0] (always defined). */ > >#define YYRHSLOC(Rhs, K) ((Rhs)[K]) >#ifndef YYLLOC_DEFAULT ># define YYLLOC_DEFAULT(Current, Rhs, N) \ > do \ > if (YYID (N)) \ > { \ > (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ > (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ > (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ > (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ > } \ > else \ > { \ > (Current).first_line = (Current).last_line = \ > YYRHSLOC (Rhs, 0).last_line; \ > (Current).first_column = (Current).last_column = \ > YYRHSLOC (Rhs, 0).last_column; \ > } \ > while (YYID (0)) >#endif > > >/* YY_LOCATION_PRINT -- Print the location on the stream. > This macro was not mandated originally: define only if we know > we won't break user code: when these are the locations we know. */ > >#ifndef YY_LOCATION_PRINT ># if YYLTYPE_IS_TRIVIAL ># define YY_LOCATION_PRINT(File, Loc) \ > fprintf (File, "%d.%d-%d.%d", \ > (Loc).first_line, (Loc).first_column, \ > (Loc).last_line, (Loc).last_column) ># else ># define YY_LOCATION_PRINT(File, Loc) ((void) 0) ># endif >#endif > > >/* YYLEX -- calling `yylex' with the right arguments. */ > >#ifdef YYLEX_PARAM ># define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM) >#else ># define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ >#endif > >/* Enable debugging if requested. */ >#if YYDEBUG > ># ifndef YYFPRINTF ># include <stdio.h> /* INFRINGES ON USER NAME SPACE */ ># define YYFPRINTF fprintf ># endif > ># define YYDPRINTF(Args) \ >do { \ > if (yydebug) \ > YYFPRINTF Args; \ >} while (YYID (0)) > ># define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ >do { \ > if (yydebug) \ > { \ > YYFPRINTF (stderr, "%s ", Title); \ > yy_symbol_print (stderr, \ > Type, Value]b4_locations_if([, Location])[]b4_user_args[); \ > YYFPRINTF (stderr, "\n"); \ > } \ >} while (YYID (0)) > >]b4_yy_symbol_print_generate([b4_c_function_def])[ > >/*------------------------------------------------------------------. >| yy_stack_print -- Print the state stack from its BOTTOM up to its | >| TOP (included). | >`------------------------------------------------------------------*/ > >]b4_c_function_def([yy_stack_print], [static void], > [[yytype_int16 *bottom], [bottom]], > [[yytype_int16 *top], [top]])[ >{ > YYFPRINTF (stderr, "Stack now"); > for (; 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 (YYID (0)) > > >/*------------------------------------------------. >| Report that the YYRULE is going to be reduced. | >`------------------------------------------------*/ > >]b4_c_function_def([yy_reduce_print], [static void], > [[YYSTYPE *yyvsp], [yyvsp]], > b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], > ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, > ])b4_parse_param)[ >{ > int yynrhs = yyr2[yyrule]; > int yyi; > unsigned long int yylno = yyrline[yyrule]; > YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", > yyrule - 1, yylno); > /* The symbols being reduced. */ > for (yyi = 0; yyi < yynrhs; yyi++) > { > fprintf (stderr, " $%d = ", yyi + 1); > yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], > &]b4_rhs_value(yynrhs, yyi + 1)[ > ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl > b4_user_args[); > fprintf (stderr, "\n"); > } >} > ># define YY_REDUCE_PRINT(Rule) \ >do { \ > if (yydebug) \ > yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ >} while (YYID (0)) > >/* Nonzero means print parse trace. It is left uninitialized so that > multiple parsers can coexist. */ >int yydebug; >#else /* !YYDEBUG */ ># define YYDPRINTF(Args) ># define YY_SYMBOL_PRINT(Title, Type, 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_stack_depth_init[ >#endif > >/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only > if the built-in stack extension method is used). > > Do not make this value too large; the results are undefined if > YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) > evaluated with infinite-precision integer arithmetic. */ > >#ifndef YYMAXDEPTH ># define YYMAXDEPTH ]b4_stack_depth_max[ >#endif > > > >#if YYERROR_VERBOSE > ># ifndef yystrlen ># if defined __GLIBC__ && defined _STRING_H ># define yystrlen strlen ># else >/* Return the length of YYSTR. */ >]b4_c_function_def([yystrlen], [static YYSIZE_T], > [[const char *yystr], [yystr]])[ >{ > YYSIZE_T yylen; > for (yylen = 0; yystr[yylen]; yylen++) > continue; > return yylen; >} ># endif ># endif > ># ifndef yystpcpy ># if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE ># define yystpcpy stpcpy ># else >/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in > YYDEST. */ >]b4_c_function_def([yystpcpy], [static char *], > [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[ >{ > char *yyd = yydest; > const char *yys = yysrc; > > while ((*yyd++ = *yys++) != '\0') > continue; > > return yyd - 1; >} ># endif ># endif > ># ifndef yytnamerr >/* Copy to YYRES the contents of YYSTR after stripping away unnecessary > quotes and backslashes, so that it's suitable for yyerror. The > heuristic is that double-quoting is unnecessary unless the string > contains an apostrophe, a comma, or backslash (other than > backslash-backslash). YYSTR is taken from yytname. If YYRES is > null, do not copy; instead, return the length of what the result > would have been. */ >static YYSIZE_T >yytnamerr (char *yyres, const char *yystr) >{ > if (*yystr == '"') > { > YYSIZE_T yyn = 0; > char const *yyp = yystr; > > for (;;) > switch (*++yyp) > { > case '\'': > case ',': > goto do_not_strip_quotes; > > case '\\': > if (*++yyp != '\\') > goto do_not_strip_quotes; > /* Fall through. */ > default: > if (yyres) > yyres[yyn] = *yyp; > yyn++; > break; > > case '"': > if (yyres) > yyres[yyn] = '\0'; > return yyn; > } > do_not_strip_quotes: ; > } > > if (! yyres) > return yystrlen (yystr); > > return yystpcpy (yyres, yystr) - yyres; >} ># endif > >/* Copy into YYRESULT an error message about the unexpected token > YYCHAR while in state YYSTATE. Return the number of bytes copied, > including the terminating null byte. If YYRESULT is null, do not > copy anything; just return the number of bytes that would be > copied. As a special case, return 0 if an ordinary "syntax error" > message will do. Return YYSIZE_MAXIMUM if overflow occurs during > size calculation. */ >static YYSIZE_T >yysyntax_error (char *yyresult, int yystate, int yychar) >{ > int yyn = yypact[yystate]; > > if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) > return 0; > else > { > int yytype = YYTRANSLATE (yychar); > YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); > YYSIZE_T yysize = yysize0; > YYSIZE_T yysize1; > int yysize_overflow = 0; > enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; > char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; > int yyx; > ># if 0 > /* This is so xgettext sees the translatable formats that are > constructed on the fly. */ > YY_("syntax error, unexpected %s"); > YY_("syntax error, unexpected %s, expecting %s"); > YY_("syntax error, unexpected %s, expecting %s or %s"); > YY_("syntax error, unexpected %s, expecting %s or %s or %s"); > YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); ># endif > char *yyfmt; > char const *yyf; > static char const yyunexpected[] = "syntax error, unexpected %s"; > static char const yyexpecting[] = ", expecting %s"; > static char const yyor[] = " or %s"; > char yyformat[sizeof yyunexpected > + sizeof yyexpecting - 1 > + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) > * (sizeof yyor - 1))]; > char const *yyprefix = yyexpecting; > > /* 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 + 1; > int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; > int yycount = 1; > > yyarg[0] = yytname[yytype]; > yyfmt = yystpcpy (yyformat, yyunexpected); > > for (yyx = yyxbegin; yyx < yyxend; ++yyx) > if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) > { > if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) > { > yycount = 1; > yysize = yysize0; > yyformat[sizeof yyunexpected - 1] = '\0'; > break; > } > yyarg[yycount++] = yytname[yyx]; > yysize1 = yysize + yytnamerr (0, yytname[yyx]); > yysize_overflow |= (yysize1 < yysize); > yysize = yysize1; > yyfmt = yystpcpy (yyfmt, yyprefix); > yyprefix = yyor; > } > > yyf = YY_(yyformat); > yysize1 = yysize + yystrlen (yyf); > yysize_overflow |= (yysize1 < yysize); > yysize = yysize1; > > if (yysize_overflow) > return YYSIZE_MAXIMUM; > > if (yyresult) > { > /* Avoid sprintf, as that infringes on the user's name space. > Don't have undefined behavior even if the translation > produced a string with the wrong number of "%s"s. */ > char *yyp = yyresult; > int yyi = 0; > while ((*yyp = *yyf) != '\0') > { > if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) > { > yyp += yytnamerr (yyp, yyarg[yyi++]); > yyf += 2; > } > else > { > yyp++; > yyf++; > } > } > } > return yysize; > } >} >#endif /* YYERROR_VERBOSE */ > > >]b4_yydestruct_generate([b4_c_function_def])[ > > >/* Prevent warnings from -Wmissing-prototypes. */ > >#ifdef YYPARSE_PARAM >]b4_c_function_decl([yyparse], [int], > [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ >#else /* ! YYPARSE_PARAM */ >]b4_c_function_decl([yyparse], [int], b4_parse_param)[ >#endif /* ! YYPARSE_PARAM */ > > >]m4_divert_push([KILL])# ======================== M4 code. ># b4_declare_parser_variables ># --------------------------- ># Declare the variables that are global, or local to YYPARSE if ># pure-parser. >m4_define([b4_declare_parser_variables], >[/* The look-ahead symbol. */ >int yychar; > >/* The semantic value of the look-ahead symbol. */ >YYSTYPE yylval; > >/* Number of syntax errors so far. */ >int yynerrs;b4_locations_if([ >/* Location data for the look-ahead symbol. */ >YYLTYPE yylloc;]) >]) >m4_divert_pop([KILL])dnl# ====================== End of M4 code. > >b4_pure_if([], > [b4_declare_parser_variables]) > > >/*----------. >| yyparse. | >`----------*/ > >#ifdef YYPARSE_PARAM >b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]]) >#else /* ! YYPARSE_PARAM */ >b4_c_function_def([yyparse], [int], b4_parse_param) >#endif >{[ > ]b4_pure_if([b4_declare_parser_variables])[ > int yystate; > int yyn; > int yyresult; > /* Number of tokens to shift before error messages enabled. */ > int yyerrstatus; > /* Look-ahead token as an internal (translated) token number. */ > int yytoken = 0; >#if YYERROR_VERBOSE > /* Buffer for error messages, and its allocated size. */ > char yymsgbuf[128]; > char *yymsg = yymsgbuf; > YYSIZE_T yymsg_alloc = sizeof yymsgbuf; >#endif > > /* Three stacks and their tools: > `yyss': related to states, > `yyvs': related to semantic values, > `yyls': related to locations. > > Refer to the stacks thru separate pointers, to allow yyoverflow > to reallocate them elsewhere. */ > > /* The state stack. */ > yytype_int16 yyssa[YYINITDEPTH]; > yytype_int16 *yyss = yyssa; > yytype_int16 *yyssp; > > /* The semantic value stack. */ > YYSTYPE yyvsa[YYINITDEPTH]; > YYSTYPE *yyvs = yyvsa; > YYSTYPE *yyvsp; > >]b4_locations_if( >[[ /* The location stack. */ > YYLTYPE yylsa[YYINITDEPTH]; > YYLTYPE *yyls = yylsa; > YYLTYPE *yylsp; > /* The locations where the error started and ended. */ > YYLTYPE yyerror_range[2];]])[ > >#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[) > > YYSIZE_T yystacksize = YYINITDEPTH; > > /* The variables used to return semantic value and location from the > action routines. */ > YYSTYPE yyval; >]b4_locations_if([ YYLTYPE yyloc;])[ > > /* The number of symbols on the RHS of the reduced rule. > Keep to zero when no symbol should be popped. */ > int yylen = 0; > > YYDPRINTF ((stderr, "Starting parse\n")); > > yystate = 0; > yyerrstatus = 0; > yynerrs = 0; > yychar = YYEMPTY; /* Cause a token to be read. */ > > /* Initialize stack pointers. > Waste one element of value and location stack > so that they stay on the same level as the state stack. > The wasted elements are never initialized. */ > > yyssp = yyss; > yyvsp = yyvs; >]b4_locations_if([[ yylsp = yyls; >#if YYLTYPE_IS_TRIVIAL > /* Initialize the default location before parsing starts. */ > yylloc.first_line = yylloc.last_line = 1; > yylloc.first_column = yylloc.last_column = 0; >#endif >]]) >m4_ifdef([b4_initial_action], [ >m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl >m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl > /* 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 >m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; >]])dnl >m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; >]])dnl >[ goto yysetstate; > >/*------------------------------------------------------------. >| yynewstate -- Push a new state, which is found in yystate. | >`------------------------------------------------------------*/ > yynewstate: > /* In all cases, when you get here, the value and location stacks > have just been pushed. So pushing a state here evens the stacks. */ > yyssp++; > > yysetstate: > *yyssp = yystate; > > if (yyss + yystacksize - 1 <= yyssp) > { > /* Get the current used size of the three stacks, in elements. */ > YYSIZE_T yysize = yyssp - yyss + 1; > >#ifdef yyoverflow > { > /* Give user a chance to reallocate the stack. Use copies of > these so that the &'s don't force the real ones into > memory. */ > YYSTYPE *yyvs1 = yyvs; > yytype_int16 *yyss1 = yyss; >]b4_locations_if([ YYLTYPE *yyls1 = yyls;])[ > > /* Each stack pointer address is followed by the size of the > data in use in that stack, in bytes. This used to be a > conditional around just the two extra args, but that might > be undefined if yyoverflow is a macro. */ > yyoverflow (YY_("memory exhausted"), > &yyss1, yysize * sizeof (*yyssp), > &yyvs1, yysize * sizeof (*yyvsp), >]b4_locations_if([ &yyls1, yysize * sizeof (*yylsp),])[ > &yystacksize); >]b4_locations_if([ yyls = yyls1;])[ > yyss = yyss1; > yyvs = yyvs1; > } >#else /* no yyoverflow */ ># ifndef YYSTACK_RELOCATE > goto yyexhaustedlab; ># else > /* Extend the stack our own way. */ > if (YYMAXDEPTH <= yystacksize) > goto yyexhaustedlab; > yystacksize *= 2; > if (YYMAXDEPTH < yystacksize) > yystacksize = YYMAXDEPTH; > > { > yytype_int16 *yyss1 = yyss; > union yyalloc *yyptr = > (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); > if (! yyptr) > goto yyexhaustedlab; > YYSTACK_RELOCATE (yyss); > YYSTACK_RELOCATE (yyvs); >]b4_locations_if([ YYSTACK_RELOCATE (yyls);])[ ># undef YYSTACK_RELOCATE > if (yyss1 != yyssa) > YYSTACK_FREE (yyss1); > } ># endif >#endif /* no yyoverflow */ > > yyssp = yyss + yysize - 1; > yyvsp = yyvs + yysize - 1; >]b4_locations_if([ yylsp = yyls + yysize - 1;])[ > > YYDPRINTF ((stderr, "Stack size increased to %lu\n", > (unsigned long int) yystacksize)); > > if (yyss + yystacksize - 1 <= yyssp) > YYABORT; > } > > YYDPRINTF ((stderr, "Entering state %d\n", yystate)); > > goto yybackup; > >/*-----------. >| yybackup. | >`-----------*/ >yybackup: > > /* Do appropriate processing given the current state. Read a > look-ahead token if we need one and don't already have one. */ > > /* First try to decide what to do without reference to look-ahead token. */ > yyn = yypact[yystate]; > if (yyn == YYPACT_NINF) > goto yydefault; > > /* Not known => get a look-ahead token if don't already have one. */ > > /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ > if (yychar == YYEMPTY) > { > YYDPRINTF ((stderr, "Reading a token: ")); > yychar = YYLEX; > } > > if (yychar <= YYEOF) > { > yychar = yytoken = YYEOF; > YYDPRINTF ((stderr, "Now at end of input.\n")); > } > else > { > yytoken = YYTRANSLATE (yychar); > YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); > } > > /* 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]; > if (yyn <= 0) > { > if (yyn == 0 || yyn == YYTABLE_NINF) > goto yyerrlab; > yyn = -yyn; > goto yyreduce; > } > > if (yyn == YYFINAL) > YYACCEPT; > > /* Count tokens shifted since error; after three, turn off error > status. */ > if (yyerrstatus) > yyerrstatus--; > > /* Shift the look-ahead token. */ > YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); > > /* Discard the shifted token unless it is eof. */ > if (yychar != YYEOF) > yychar = YYEMPTY; > > yystate = yyn; > *++yyvsp = yylval; >]b4_locations_if([ *++yylsp = yylloc;])[ > goto yynewstate; > > >/*-----------------------------------------------------------. >| yydefault -- do the default action for the current state. | >`-----------------------------------------------------------*/ >yydefault: > yyn = yydefact[yystate]; > if (yyn == 0) > goto yyerrlab; > goto yyreduce; > > >/*-----------------------------. >| yyreduce -- Do a reduction. | >`-----------------------------*/ >yyreduce: > /* yyn is the number of a rule to reduce with. */ > yylen = yyr2[yyn]; > > /* If YYLEN is nonzero, implement the default value of the action: > `$$ = $1'. > > 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. */ > yyval = yyvsp[1-yylen]; > >]b4_locations_if( >[[ /* Default location. */ > YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[ > YY_REDUCE_PRINT (yyn); > switch (yyn) > { > ]b4_actions >/* Line __line__ of yacc.c. */ >b4_syncline([@oline@], [@ofile@])[ > default: break; > } > YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); > > YYPOPSTACK (yylen); > yylen = 0; > YY_STACK_PRINT (yyss, yyssp); > > *++yyvsp = yyval; >]b4_locations_if([ *++yylsp = yyloc;])[ > > /* Now `shift' the result of the reduction. Determine what state > that goes to, based on the state we popped back to and the rule > number reduced by. */ > > yyn = yyr1[yyn]; > > yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; > if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) > yystate = yytable[yystate]; > else > yystate = yydefgoto[yyn - YYNTOKENS]; > > goto yynewstate; > > >/*------------------------------------. >| yyerrlab -- here on detecting error | >`------------------------------------*/ >yyerrlab: > /* If not already recovering from an error, report this error. */ > if (!yyerrstatus) > { > ++yynerrs; >#if ! YYERROR_VERBOSE > yyerror (]b4_yyerror_args[YY_("syntax error")); >#else > { > YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); > if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) > { > YYSIZE_T yyalloc = 2 * yysize; > if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) > yyalloc = YYSTACK_ALLOC_MAXIMUM; > if (yymsg != yymsgbuf) > YYSTACK_FREE (yymsg); > yymsg = (char *) YYSTACK_ALLOC (yyalloc); > if (yymsg) > yymsg_alloc = yyalloc; > else > { > yymsg = yymsgbuf; > yymsg_alloc = sizeof yymsgbuf; > } > } > > if (0 < yysize && yysize <= yymsg_alloc) > { > (void) yysyntax_error (yymsg, yystate, yychar); > yyerror (]b4_yyerror_args[yymsg); > } > else > { > yyerror (]b4_yyerror_args[YY_("syntax error")); > if (yysize != 0) > goto yyexhaustedlab; > } > } >#endif > } > >]b4_locations_if([[ yyerror_range[0] = yylloc;]])[ > > if (yyerrstatus == 3) > { > /* If just tried and failed to reuse look-ahead token after an > error, discard it. */ > > if (yychar <= YYEOF) > { > /* Return failure if at end of input. */ > if (yychar == YYEOF) > YYABORT; > } > else > { > yydestruct ("Error: discarding", > yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); > yychar = YYEMPTY; > } > } > > /* Else will try to reuse look-ahead token after shifting the error > token. */ > goto yyerrlab1; > > >/*---------------------------------------------------. >| yyerrorlab -- error raised explicitly by YYERROR. | >`---------------------------------------------------*/ >yyerrorlab: > > /* Pacify compilers like GCC when the user code never invokes > YYERROR and the label yyerrorlab therefore never appears in user > code. */ > if (/*CONSTCOND*/ 0) > goto yyerrorlab; > >]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen]; >]])[ /* Do not reclaim the symbols of the rule which action triggered > this YYERROR. */ > YYPOPSTACK (yylen); > yylen = 0; > YY_STACK_PRINT (yyss, yyssp); > yystate = *yyssp; > goto yyerrlab1; > > >/*-------------------------------------------------------------. >| yyerrlab1 -- common code for both syntax error and YYERROR. | >`-------------------------------------------------------------*/ >yyerrlab1: > yyerrstatus = 3; /* Each real token shifted decrements this. */ > > for (;;) > { > yyn = yypact[yystate]; > if (yyn != YYPACT_NINF) > { > yyn += YYTERROR; > if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) > { > yyn = yytable[yyn]; > if (0 < yyn) > break; > } > } > > /* Pop the current state because it cannot handle the error token. */ > if (yyssp == yyss) > YYABORT; > >]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[ > yydestruct ("Error: popping", > yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); > YYPOPSTACK (1); > yystate = *yyssp; > YY_STACK_PRINT (yyss, yyssp); > } > > if (yyn == YYFINAL) > YYACCEPT; > > *++yyvsp = yylval; >]b4_locations_if([[ > yyerror_range[1] = yylloc; > /* Using YYLLOC is tempting, but would change the location of > the look-ahead. YYLOC is available though. */ > YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); > *++yylsp = yyloc;]])[ > > /* Shift the error token. */ > YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); > > yystate = yyn; > goto yynewstate; > > >/*-------------------------------------. >| yyacceptlab -- YYACCEPT comes here. | >`-------------------------------------*/ >yyacceptlab: > yyresult = 0; > goto yyreturn; > >/*-----------------------------------. >| yyabortlab -- YYABORT comes here. | >`-----------------------------------*/ >yyabortlab: > yyresult = 1; > goto yyreturn; > >#ifndef yyoverflow >/*-------------------------------------------------. >| yyexhaustedlab -- memory exhaustion comes here. | >`-------------------------------------------------*/ >yyexhaustedlab: > yyerror (]b4_yyerror_args[YY_("memory exhausted")); > yyresult = 2; > /* Fall through. */ >#endif > >yyreturn: > if (yychar != YYEOF && yychar != YYEMPTY) > yydestruct ("Cleanup: discarding lookahead", > yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); > /* Do not reclaim the symbols of the rule which action triggered > this YYABORT or YYACCEPT. */ > YYPOPSTACK (yylen); > YY_STACK_PRINT (yyss, yyssp); > while (yyssp != yyss) > { > yydestruct ("Cleanup: popping", > yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[); > YYPOPSTACK (1); > } >#ifndef yyoverflow > if (yyss != yyssa) > YYSTACK_FREE (yyss); >#endif >#if YYERROR_VERBOSE > if (yymsg != yymsgbuf) > YYSTACK_FREE (yymsg); >#endif > /* Make sure YYID is used. */ > return YYID (yyresult); >]} > > >b4_epilogue >b4_defines_if( >[@output @output_header_name@ >b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl ' > [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006]) > >b4_token_enums_defines(b4_tokens) > >#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED >m4_ifdef([b4_stype], >[typedef union[]m4_bregexp(b4_stype, [^{], [ YYSTYPE]) >b4_stype >/* Line __line__ of yacc.c. */ >b4_syncline([@oline@], [@ofile@]) > YYSTYPE;], >[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_locations_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 YYLTYPE /* obsolescent; will be withdrawn */ ># define YYLTYPE_IS_DECLARED 1 ># define YYLTYPE_IS_TRIVIAL 1 >#endif > >b4_pure_if([], > [extern YYLTYPE b4_prefix[]lloc;]) >])dnl b4_locations_if >])dnl b4_defines_if
You cannot view the attachment while viewing its details because your browser does not support IFRAMEs.
View the attachment on a separate page
.
View Attachment As Raw
Actions:
View
Attachments on
bug 230790
:
159558
|
159560
| 159562