OLD | NEW |
(Empty) | |
| 1 -*- C -*- |
| 2 |
| 3 # Yacc compatible skeleton for Bison |
| 4 |
| 5 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, |
| 6 # 2007, 2008 Free Software Foundation, Inc. |
| 7 |
| 8 # This program is free software: you can redistribute it and/or modify |
| 9 # it under the terms of the GNU General Public License as published by |
| 10 # the Free Software Foundation, either version 3 of the License, or |
| 11 # (at your option) any later version. |
| 12 # |
| 13 # This program is distributed in the hope that it will be useful, |
| 14 # but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| 16 # GNU General Public License for more details. |
| 17 # |
| 18 # You should have received a copy of the GNU General Public License |
| 19 # along with this program. If not, see <http://www.gnu.org/licenses/>. |
| 20 |
| 21 # Check the value of %define api.push_pull. |
| 22 b4_percent_define_default([[api.push_pull]], [[pull]]) |
| 23 b4_percent_define_check_values([[[[api.push_pull]], |
| 24 [[pull]], [[push]], [[both]]]]) |
| 25 b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]]) |
| 26 b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]]) |
| 27 m4_case(b4_percent_define_get([[api.push_pull]]), |
| 28 [pull], [m4_define([b4_push_flag], [[0]])], |
| 29 [push], [m4_define([b4_pull_flag], [[0]])]) |
| 30 |
| 31 # Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing |
| 32 # tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's |
| 33 # behavior at all when push parsing is already requested. |
| 34 b4_define_flag_if([use_push_for_pull]) |
| 35 b4_use_push_for_pull_if([ |
| 36 b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])], |
| 37 [m4_define([b4_push_flag], [[1]])])]) |
| 38 |
| 39 m4_include(b4_pkgdatadir/[c.m4]) |
| 40 |
| 41 ## ---------------- ## |
| 42 ## Default values. ## |
| 43 ## ---------------- ## |
| 44 |
| 45 # Stack parameters. |
| 46 m4_define_default([b4_stack_depth_max], [10000]) |
| 47 m4_define_default([b4_stack_depth_init], [200]) |
| 48 |
| 49 |
| 50 ## ------------------------ ## |
| 51 ## Pure/impure interfaces. ## |
| 52 ## ------------------------ ## |
| 53 |
| 54 b4_percent_define_default([[api.pure]], [[false]]) |
| 55 b4_define_flag_if([pure]) |
| 56 m4_define([b4_pure_flag], |
| 57 [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])]) |
| 58 |
| 59 # b4_yacc_pure_if(IF-TRUE, IF-FALSE) |
| 60 # ---------------------------------- |
| 61 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise. |
| 62 m4_define([b4_yacc_pure_if], |
| 63 [b4_pure_if([m4_ifset([b4_parse_param], |
| 64 [$1], [$2])], |
| 65 [$2])]) |
| 66 |
| 67 |
| 68 # b4_yyerror_args |
| 69 # --------------- |
| 70 # Arguments passed to yyerror: user args plus yylloc. |
| 71 m4_define([b4_yyerror_args], |
| 72 [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl |
| 73 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) |
| 74 |
| 75 |
| 76 # b4_lex_param |
| 77 # ------------ |
| 78 # Accumulate in b4_lex_param all the yylex arguments. |
| 79 # b4_lex_param arrives quoted twice, but we want to keep only one level. |
| 80 m4_define([b4_lex_param], |
| 81 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl |
| 82 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl |
| 83 m4_ifdef([b4_lex_param], b4_lex_param))) |
| 84 |
| 85 |
| 86 ## ------------ ## |
| 87 ## Data Types. ## |
| 88 ## ------------ ## |
| 89 |
| 90 # b4_int_type(MIN, MAX) |
| 91 # --------------------- |
| 92 # Return the smallest int type able to handle numbers ranging from |
| 93 # MIN to MAX (included). Overwrite the version from c.m4, which |
| 94 # uses only C89 types, so that the user can override the shorter |
| 95 # types, and so that pre-C89 compilers are handled correctly. |
| 96 m4_define([b4_int_type], |
| 97 [m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8], |
| 98 b4_ints_in($@, [-128], [127]), [1], [yytype_int8], |
| 99 |
| 100 b4_ints_in($@, [0], [65535]), [1], [yytype_uint16], |
| 101 b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16], |
| 102 |
| 103 m4_eval([0 <= $1]), [1], [unsigned int], |
| 104 |
| 105 [int])]) |
| 106 |
| 107 |
| 108 ## ----------------- ## |
| 109 ## Semantic Values. ## |
| 110 ## ----------------- ## |
| 111 |
| 112 |
| 113 # b4_lhs_value([TYPE]) |
| 114 # -------------------- |
| 115 # Expansion of $<TYPE>$. |
| 116 m4_define([b4_lhs_value], |
| 117 [(yyval[]m4_ifval([$1], [.$1]))]) |
| 118 |
| 119 |
| 120 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) |
| 121 # -------------------------------------- |
| 122 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH |
| 123 # symbols on RHS. |
| 124 m4_define([b4_rhs_value], |
| 125 [(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))]) |
| 126 |
| 127 |
| 128 |
| 129 ## ----------- ## |
| 130 ## Locations. ## |
| 131 ## ----------- ## |
| 132 |
| 133 # b4_lhs_location() |
| 134 # ----------------- |
| 135 # Expansion of @$. |
| 136 m4_define([b4_lhs_location], |
| 137 [(yyloc)]) |
| 138 |
| 139 |
| 140 # b4_rhs_location(RULE-LENGTH, NUM) |
| 141 # --------------------------------- |
| 142 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols |
| 143 # on RHS. |
| 144 m4_define([b4_rhs_location], |
| 145 [(yylsp@{($2) - ($1)@})]) |
| 146 |
| 147 |
| 148 |
| 149 ## --------------------------------------------------------- ## |
| 150 ## Defining symbol actions, e.g., printers and destructors. ## |
| 151 ## --------------------------------------------------------- ## |
| 152 |
| 153 # We do want M4 expansion after # for CPP macros. |
| 154 m4_changecom() |
| 155 m4_divert_push(0)dnl |
| 156 @output(b4_parser_file_name@) |
| 157 b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl ' |
| 158 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])[ |
| 159 |
| 160 /* C LALR(1) parser skeleton written by Richard Stallman, by |
| 161 simplifying the original so-called "semantic" parser. */ |
| 162 |
| 163 /* All symbols defined below should begin with yy or YY, to avoid |
| 164 infringing on user name space. This should be done even for local |
| 165 variables, as they might otherwise be expanded by user macros. |
| 166 There are some unavoidable exceptions within include files to |
| 167 define necessary library symbols; they are noted "INFRINGES ON |
| 168 USER NAME SPACE" below. */ |
| 169 |
| 170 ]b4_identification |
| 171 b4_percent_code_get([[top]])[]dnl |
| 172 m4_if(b4_prefix, [yy], [], |
| 173 [[/* Substitute the variable and function names. */ |
| 174 ]b4_pull_if([[#define yyparse ]b4_prefix[parse |
| 175 ]])b4_push_if([[#define yypush_parse ]b4_prefix[push_parse |
| 176 ]b4_pull_if([[#define yypull_parse ]b4_prefix[pull_parse |
| 177 ]])[#define yypstate_new ]b4_prefix[pstate_new |
| 178 #define yypstate_delete ]b4_prefix[pstate_delete |
| 179 #define yypstate ]b4_prefix[pstate |
| 180 ]])[#define yylex ]b4_prefix[lex |
| 181 #define yyerror ]b4_prefix[error |
| 182 #define yylval ]b4_prefix[lval |
| 183 #define yychar ]b4_prefix[char |
| 184 #define yydebug ]b4_prefix[debug |
| 185 #define yynerrs ]b4_prefix[nerrs |
| 186 ]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[ |
| 187 |
| 188 /* Copy the first part of user declarations. */ |
| 189 ]b4_user_pre_prologue[ |
| 190 |
| 191 /* Enabling traces. */ |
| 192 #ifndef YYDEBUG |
| 193 # define YYDEBUG ]b4_debug_flag[ |
| 194 #endif |
| 195 |
| 196 /* Enabling verbose error messages. */ |
| 197 #ifdef YYERROR_VERBOSE |
| 198 # undef YYERROR_VERBOSE |
| 199 # define YYERROR_VERBOSE 1 |
| 200 #else |
| 201 # define YYERROR_VERBOSE ]b4_error_verbose_flag[ |
| 202 #endif |
| 203 |
| 204 /* Enabling the token table. */ |
| 205 #ifndef YYTOKEN_TABLE |
| 206 # define YYTOKEN_TABLE ]b4_token_table[ |
| 207 #endif |
| 208 |
| 209 ]b4_percent_code_get([[requires]])[]dnl |
| 210 |
| 211 b4_token_enums_defines(b4_tokens)[ |
| 212 |
| 213 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED |
| 214 ]m4_ifdef([b4_stype], |
| 215 [[typedef union ]b4_union_name[ |
| 216 { |
| 217 ]b4_user_stype[ |
| 218 } YYSTYPE; |
| 219 # define YYSTYPE_IS_TRIVIAL 1]], |
| 220 [m4_if(b4_tag_seen_flag, 0, |
| 221 [[typedef int YYSTYPE; |
| 222 # define YYSTYPE_IS_TRIVIAL 1]])])[ |
| 223 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
| 224 # define YYSTYPE_IS_DECLARED 1 |
| 225 #endif]b4_locations_if([[ |
| 226 |
| 227 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED |
| 228 typedef struct YYLTYPE |
| 229 { |
| 230 int first_line; |
| 231 int first_column; |
| 232 int last_line; |
| 233 int last_column; |
| 234 } YYLTYPE; |
| 235 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ |
| 236 # define YYLTYPE_IS_DECLARED 1 |
| 237 # define YYLTYPE_IS_TRIVIAL 1 |
| 238 #endif]])b4_push_if([[ |
| 239 |
| 240 #ifndef YYPUSH_DECLS |
| 241 # define YYPUSH_DECLS |
| 242 struct yypstate; |
| 243 typedef struct yypstate yypstate; |
| 244 enum { YYPUSH_MORE = 4 }; |
| 245 |
| 246 ]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param) |
| 247 ])b4_c_function_decl([[yypush_parse]], [[int]], |
| 248 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, |
| 249 [[[int yypushed_char]], [[yypushed_char]]], |
| 250 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, |
| 251 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_para
m], [, |
| 252 b4_parse_param])) |
| 253 b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]], |
| 254 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, |
| 255 b4_parse_param]))]) |
| 256 b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []]) |
| 257 b4_c_function_decl([[yypstate_delete]], [[void]], |
| 258 [[[yypstate *yyps]], [[yyps]]])[ |
| 259 #endif]]) |
| 260 |
| 261 b4_percent_code_get([[provides]])[]dnl |
| 262 |
| 263 [/* Copy the second part of user declarations. */ |
| 264 ]b4_user_post_prologue |
| 265 b4_percent_code_get[]dnl |
| 266 |
| 267 [#ifdef short |
| 268 # undef short |
| 269 #endif |
| 270 |
| 271 #ifdef YYTYPE_UINT8 |
| 272 typedef YYTYPE_UINT8 yytype_uint8; |
| 273 #else |
| 274 typedef unsigned char yytype_uint8; |
| 275 #endif |
| 276 |
| 277 #ifdef YYTYPE_INT8 |
| 278 typedef YYTYPE_INT8 yytype_int8; |
| 279 #elif ]b4_c_modern[ |
| 280 typedef signed char yytype_int8; |
| 281 #else |
| 282 typedef short int yytype_int8; |
| 283 #endif |
| 284 |
| 285 #ifdef YYTYPE_UINT16 |
| 286 typedef YYTYPE_UINT16 yytype_uint16; |
| 287 #else |
| 288 typedef unsigned short int yytype_uint16; |
| 289 #endif |
| 290 |
| 291 #ifdef YYTYPE_INT16 |
| 292 typedef YYTYPE_INT16 yytype_int16; |
| 293 #else |
| 294 typedef short int yytype_int16; |
| 295 #endif |
| 296 |
| 297 #ifndef YYSIZE_T |
| 298 # ifdef __SIZE_TYPE__ |
| 299 # define YYSIZE_T __SIZE_TYPE__ |
| 300 # elif defined size_t |
| 301 # define YYSIZE_T size_t |
| 302 # elif ! defined YYSIZE_T && ]b4_c_modern[ |
| 303 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
| 304 # define YYSIZE_T size_t |
| 305 # else |
| 306 # define YYSIZE_T unsigned int |
| 307 # endif |
| 308 #endif |
| 309 |
| 310 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
| 311 |
| 312 #ifndef YY_ |
| 313 # if YYENABLE_NLS |
| 314 # if ENABLE_NLS |
| 315 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ |
| 316 # define YY_(msgid) dgettext ("bison-runtime", msgid) |
| 317 # endif |
| 318 # endif |
| 319 # ifndef YY_ |
| 320 # define YY_(msgid) msgid |
| 321 # endif |
| 322 #endif |
| 323 |
| 324 /* Suppress unused-variable warnings by "using" E. */ |
| 325 #if ! defined lint || defined __GNUC__ |
| 326 # define YYUSE(e) ((void) (e)) |
| 327 #else |
| 328 # define YYUSE(e) /* empty */ |
| 329 #endif |
| 330 |
| 331 /* Identity function, used to suppress warnings about constant conditions. */ |
| 332 #ifndef lint |
| 333 # define YYID(n) (n) |
| 334 #else |
| 335 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[ |
| 336 { |
| 337 return yyi; |
| 338 } |
| 339 #endif |
| 340 |
| 341 #if ! defined yyoverflow || YYERROR_VERBOSE |
| 342 |
| 343 ]b4_push_if([], |
| 344 [[/* The parser invokes alloca or malloc; define the necessary symbols. */ |
| 345 |
| 346 # ifdef YYSTACK_USE_ALLOCA |
| 347 # if YYSTACK_USE_ALLOCA |
| 348 # ifdef __GNUC__ |
| 349 # define YYSTACK_ALLOC __builtin_alloca |
| 350 # elif defined __BUILTIN_VA_ARG_INCR |
| 351 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ |
| 352 # elif defined _AIX |
| 353 # define YYSTACK_ALLOC __alloca |
| 354 # elif defined _MSC_VER |
| 355 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ |
| 356 # define alloca _alloca |
| 357 # else |
| 358 # define YYSTACK_ALLOC alloca |
| 359 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[ |
| 360 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
| 361 # ifndef _STDLIB_H |
| 362 # define _STDLIB_H 1 |
| 363 # endif |
| 364 # endif |
| 365 # endif |
| 366 # endif |
| 367 # endif |
| 368 |
| 369 ]])dnl |
| 370 [# ifdef YYSTACK_ALLOC |
| 371 /* Pacify GCC's `empty if-body' warning. */ |
| 372 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) |
| 373 # ifndef YYSTACK_ALLOC_MAXIMUM |
| 374 /* The OS might guarantee only one guard page at the bottom of the stack, |
| 375 and a page size can be as small as 4096 bytes. So we cannot safely |
| 376 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number |
| 377 to allow for a few compiler-allocated temporary stack slots. */ |
| 378 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ |
| 379 # endif |
| 380 # else |
| 381 # define YYSTACK_ALLOC YYMALLOC |
| 382 # define YYSTACK_FREE YYFREE |
| 383 # ifndef YYSTACK_ALLOC_MAXIMUM |
| 384 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
| 385 # endif |
| 386 # if (defined __cplusplus && ! defined _STDLIB_H \ |
| 387 && ! ((defined YYMALLOC || defined malloc) \ |
| 388 && (defined YYFREE || defined free))) |
| 389 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
| 390 # ifndef _STDLIB_H |
| 391 # define _STDLIB_H 1 |
| 392 # endif |
| 393 # endif |
| 394 # ifndef YYMALLOC |
| 395 # define YYMALLOC malloc |
| 396 # if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[ |
| 397 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ |
| 398 # endif |
| 399 # endif |
| 400 # ifndef YYFREE |
| 401 # define YYFREE free |
| 402 # if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[ |
| 403 void free (void *); /* INFRINGES ON USER NAME SPACE */ |
| 404 # endif |
| 405 # endif |
| 406 # endif |
| 407 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ |
| 408 |
| 409 |
| 410 #if (! defined yyoverflow \ |
| 411 && (! defined __cplusplus \ |
| 412 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
\ |
| 413 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) |
| 414 |
| 415 /* A type that is properly aligned for any stack member. */ |
| 416 union yyalloc |
| 417 { |
| 418 yytype_int16 yyss_alloc; |
| 419 YYSTYPE yyvs_alloc;]b4_locations_if([ |
| 420 YYLTYPE yyls_alloc;])[ |
| 421 }; |
| 422 |
| 423 /* The size of the maximum gap between one aligned stack and the next. */ |
| 424 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
| 425 |
| 426 /* The size of an array large to enough to hold all stacks, each with |
| 427 N elements. */ |
| 428 ]b4_locations_if( |
| 429 [# define YYSTACK_BYTES(N) \ |
| 430 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ |
| 431 + 2 * YYSTACK_GAP_MAXIMUM)], |
| 432 [# define YYSTACK_BYTES(N) \ |
| 433 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ |
| 434 + YYSTACK_GAP_MAXIMUM)])[ |
| 435 |
| 436 /* Copy COUNT objects from FROM to TO. The source and destination do |
| 437 not overlap. */ |
| 438 # ifndef YYCOPY |
| 439 # if defined __GNUC__ && 1 < __GNUC__ |
| 440 # define YYCOPY(To, From, Count) \ |
| 441 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) |
| 442 # else |
| 443 # define YYCOPY(To, From, Count) \ |
| 444 do \ |
| 445 { \ |
| 446 YYSIZE_T yyi; \ |
| 447 for (yyi = 0; yyi < (Count); yyi++) \ |
| 448 (To)[yyi] = (From)[yyi]; \ |
| 449 } \ |
| 450 while (YYID (0)) |
| 451 # endif |
| 452 # endif |
| 453 |
| 454 /* Relocate STACK from its old location to the new one. The |
| 455 local variables YYSIZE and YYSTACKSIZE give the old and new number of |
| 456 elements in the stack, and YYPTR gives the new location of the |
| 457 stack. Advance YYPTR to a properly aligned location for the next |
| 458 stack. */ |
| 459 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ |
| 460 do \ |
| 461 { \ |
| 462 YYSIZE_T yynewbytes; \ |
| 463 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ |
| 464 Stack = &yyptr->Stack_alloc; \ |
| 465 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
| 466 yyptr += yynewbytes / sizeof (*yyptr); \ |
| 467 } \ |
| 468 while (YYID (0)) |
| 469 |
| 470 #endif |
| 471 |
| 472 /* YYFINAL -- State number of the termination state. */ |
| 473 #define YYFINAL ]b4_final_state_number[ |
| 474 /* YYLAST -- Last index in YYTABLE. */ |
| 475 #define YYLAST ]b4_last[ |
| 476 |
| 477 /* YYNTOKENS -- Number of terminals. */ |
| 478 #define YYNTOKENS ]b4_tokens_number[ |
| 479 /* YYNNTS -- Number of nonterminals. */ |
| 480 #define YYNNTS ]b4_nterms_number[ |
| 481 /* YYNRULES -- Number of rules. */ |
| 482 #define YYNRULES ]b4_rules_number[ |
| 483 /* YYNRULES -- Number of states. */ |
| 484 #define YYNSTATES ]b4_states_number[ |
| 485 |
| 486 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
| 487 #define YYUNDEFTOK ]b4_undef_token_number[ |
| 488 #define YYMAXUTOK ]b4_user_token_number_max[ |
| 489 |
| 490 #define YYTRANSLATE(YYX) \ |
| 491 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
| 492 |
| 493 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
| 494 static const ]b4_int_type_for([b4_translate])[ yytranslate[] = |
| 495 { |
| 496 ]b4_translate[ |
| 497 }; |
| 498 |
| 499 #if YYDEBUG |
| 500 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
| 501 YYRHS. */ |
| 502 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = |
| 503 { |
| 504 ]b4_prhs[ |
| 505 }; |
| 506 |
| 507 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
| 508 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = |
| 509 { |
| 510 ]b4_rhs[ |
| 511 }; |
| 512 |
| 513 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
| 514 static const ]b4_int_type_for([b4_rline])[ yyrline[] = |
| 515 { |
| 516 ]b4_rline[ |
| 517 }; |
| 518 #endif |
| 519 |
| 520 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
| 521 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
| 522 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
| 523 static const char *const yytname[] = |
| 524 { |
| 525 ]b4_tname[ |
| 526 }; |
| 527 #endif |
| 528 |
| 529 # ifdef YYPRINT |
| 530 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
| 531 token YYLEX-NUM. */ |
| 532 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = |
| 533 { |
| 534 ]b4_toknum[ |
| 535 }; |
| 536 # endif |
| 537 |
| 538 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
| 539 static const ]b4_int_type_for([b4_r1])[ yyr1[] = |
| 540 { |
| 541 ]b4_r1[ |
| 542 }; |
| 543 |
| 544 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
| 545 static const ]b4_int_type_for([b4_r2])[ yyr2[] = |
| 546 { |
| 547 ]b4_r2[ |
| 548 }; |
| 549 |
| 550 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state |
| 551 STATE-NUM when YYTABLE doesn't specify something else to do. Zero |
| 552 means the default is an error. */ |
| 553 static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
| 554 { |
| 555 ]b4_defact[ |
| 556 }; |
| 557 |
| 558 /* YYDEFGOTO[NTERM-NUM]. */ |
| 559 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = |
| 560 { |
| 561 ]b4_defgoto[ |
| 562 }; |
| 563 |
| 564 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
| 565 STATE-NUM. */ |
| 566 #define YYPACT_NINF ]b4_pact_ninf[ |
| 567 static const ]b4_int_type_for([b4_pact])[ yypact[] = |
| 568 { |
| 569 ]b4_pact[ |
| 570 }; |
| 571 |
| 572 /* YYPGOTO[NTERM-NUM]. */ |
| 573 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = |
| 574 { |
| 575 ]b4_pgoto[ |
| 576 }; |
| 577 |
| 578 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
| 579 positive, shift that token. If negative, reduce the rule which |
| 580 number is the opposite. If zero, do what YYDEFACT says. |
| 581 If YYTABLE_NINF, syntax error. */ |
| 582 #define YYTABLE_NINF ]b4_table_ninf[ |
| 583 static const ]b4_int_type_for([b4_table])[ yytable[] = |
| 584 { |
| 585 ]b4_table[ |
| 586 }; |
| 587 |
| 588 static const ]b4_int_type_for([b4_check])[ yycheck[] = |
| 589 { |
| 590 ]b4_check[ |
| 591 }; |
| 592 |
| 593 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
| 594 symbol of state STATE-NUM. */ |
| 595 static const ]b4_int_type_for([b4_stos])[ yystos[] = |
| 596 { |
| 597 ]b4_stos[ |
| 598 }; |
| 599 |
| 600 #define yyerrok (yyerrstatus = 0) |
| 601 #define yyclearin (yychar = YYEMPTY) |
| 602 #define YYEMPTY (-2) |
| 603 #define YYEOF 0 |
| 604 |
| 605 #define YYACCEPT goto yyacceptlab |
| 606 #define YYABORT goto yyabortlab |
| 607 #define YYERROR goto yyerrorlab |
| 608 |
| 609 |
| 610 /* Like YYERROR except do call yyerror. This remains here temporarily |
| 611 to ease the transition to the new meaning of YYERROR, for GCC. |
| 612 Once GCC version 2 has supplanted version 1, this can go. */ |
| 613 |
| 614 #define YYFAIL goto yyerrlab |
| 615 |
| 616 #define YYRECOVERING() (!!yyerrstatus) |
| 617 |
| 618 #define YYBACKUP(Token, Value) \ |
| 619 do \ |
| 620 if (yychar == YYEMPTY && yylen == 1) \ |
| 621 { \ |
| 622 yychar = (Token); \ |
| 623 yylval = (Value); \ |
| 624 yytoken = YYTRANSLATE (yychar); \ |
| 625 YYPOPSTACK (1); \ |
| 626 goto yybackup; \ |
| 627 } \ |
| 628 else \ |
| 629 { \ |
| 630 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \ |
| 631 YYERROR; \ |
| 632 } \ |
| 633 while (YYID (0)) |
| 634 |
| 635 |
| 636 #define YYTERROR 1 |
| 637 #define YYERRCODE 256 |
| 638 |
| 639 |
| 640 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
| 641 If N is 0, then set CURRENT to the empty location which ends |
| 642 the previous symbol: RHS[0] (always defined). */ |
| 643 |
| 644 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) |
| 645 #ifndef YYLLOC_DEFAULT |
| 646 # define YYLLOC_DEFAULT(Current, Rhs, N) \ |
| 647 do \ |
| 648 if (YYID (N)) \ |
| 649 { \ |
| 650 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
| 651 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ |
| 652 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ |
| 653 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ |
| 654 } \ |
| 655 else \ |
| 656 { \ |
| 657 (Current).first_line = (Current).last_line = \ |
| 658 YYRHSLOC (Rhs, 0).last_line; \ |
| 659 (Current).first_column = (Current).last_column = \ |
| 660 YYRHSLOC (Rhs, 0).last_column; \ |
| 661 } \ |
| 662 while (YYID (0)) |
| 663 #endif |
| 664 |
| 665 |
| 666 /* YY_LOCATION_PRINT -- Print the location on the stream. |
| 667 This macro was not mandated originally: define only if we know |
| 668 we won't break user code: when these are the locations we know. */ |
| 669 |
| 670 #ifndef YY_LOCATION_PRINT |
| 671 # if YYLTYPE_IS_TRIVIAL |
| 672 # define YY_LOCATION_PRINT(File, Loc) \ |
| 673 fprintf (File, "%d.%d-%d.%d", \ |
| 674 (Loc).first_line, (Loc).first_column, \ |
| 675 (Loc).last_line, (Loc).last_column) |
| 676 # else |
| 677 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
| 678 # endif |
| 679 #endif |
| 680 |
| 681 |
| 682 /* YYLEX -- calling `yylex' with the right arguments. */ |
| 683 |
| 684 #ifdef YYLEX_PARAM |
| 685 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYL
EX_PARAM) |
| 686 #else |
| 687 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ |
| 688 #endif |
| 689 |
| 690 /* Enable debugging if requested. */ |
| 691 #if YYDEBUG |
| 692 |
| 693 # ifndef YYFPRINTF |
| 694 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
| 695 # define YYFPRINTF fprintf |
| 696 # endif |
| 697 |
| 698 # define YYDPRINTF(Args) \ |
| 699 do { \ |
| 700 if (yydebug) \ |
| 701 YYFPRINTF Args; \ |
| 702 } while (YYID (0)) |
| 703 |
| 704 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
| 705 do { \ |
| 706 if (yydebug) \ |
| 707 { \ |
| 708 YYFPRINTF (stderr, "%s ", Title); \ |
| 709 yy_symbol_print (stderr, \ |
| 710 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \ |
| 711 YYFPRINTF (stderr, "\n"); \ |
| 712 } \ |
| 713 } while (YYID (0)) |
| 714 |
| 715 ]b4_yy_symbol_print_generate([b4_c_function_def])[ |
| 716 |
| 717 /*------------------------------------------------------------------. |
| 718 | yy_stack_print -- Print the state stack from its BOTTOM up to its | |
| 719 | TOP (included). | |
| 720 `------------------------------------------------------------------*/ |
| 721 |
| 722 ]b4_c_function_def([yy_stack_print], [static void], |
| 723 [[yytype_int16 *yybottom], [yybottom]], |
| 724 [[yytype_int16 *yytop], [yytop]])[ |
| 725 { |
| 726 YYFPRINTF (stderr, "Stack now"); |
| 727 for (; yybottom <= yytop; yybottom++) |
| 728 { |
| 729 int yybot = *yybottom; |
| 730 YYFPRINTF (stderr, " %d", yybot); |
| 731 } |
| 732 YYFPRINTF (stderr, "\n"); |
| 733 } |
| 734 |
| 735 # define YY_STACK_PRINT(Bottom, Top) \ |
| 736 do { \ |
| 737 if (yydebug) \ |
| 738 yy_stack_print ((Bottom), (Top)); \ |
| 739 } while (YYID (0)) |
| 740 |
| 741 |
| 742 /*------------------------------------------------. |
| 743 | Report that the YYRULE is going to be reduced. | |
| 744 `------------------------------------------------*/ |
| 745 |
| 746 ]b4_c_function_def([yy_reduce_print], [static void], |
| 747 [[YYSTYPE *yyvsp], [yyvsp]], |
| 748 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]], |
| 749 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [, |
| 750 b4_parse_param]))[ |
| 751 { |
| 752 int yynrhs = yyr2[yyrule]; |
| 753 int yyi; |
| 754 unsigned long int yylno = yyrline[yyrule]; |
| 755 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", |
| 756 yyrule - 1, yylno); |
| 757 /* The symbols being reduced. */ |
| 758 for (yyi = 0; yyi < yynrhs; yyi++) |
| 759 { |
| 760 YYFPRINTF (stderr, " $%d = ", yyi + 1); |
| 761 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
| 762 &]b4_rhs_value(yynrhs, yyi + 1)[ |
| 763 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]
dnl |
| 764 b4_user_args[); |
| 765 YYFPRINTF (stderr, "\n"); |
| 766 } |
| 767 } |
| 768 |
| 769 # define YY_REDUCE_PRINT(Rule) \ |
| 770 do { \ |
| 771 if (yydebug) \ |
| 772 yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \ |
| 773 } while (YYID (0)) |
| 774 |
| 775 /* Nonzero means print parse trace. It is left uninitialized so that |
| 776 multiple parsers can coexist. */ |
| 777 int yydebug; |
| 778 #else /* !YYDEBUG */ |
| 779 # define YYDPRINTF(Args) |
| 780 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) |
| 781 # define YY_STACK_PRINT(Bottom, Top) |
| 782 # define YY_REDUCE_PRINT(Rule) |
| 783 #endif /* !YYDEBUG */ |
| 784 |
| 785 |
| 786 /* YYINITDEPTH -- initial size of the parser's stacks. */ |
| 787 #ifndef YYINITDEPTH |
| 788 # define YYINITDEPTH ]b4_stack_depth_init[ |
| 789 #endif |
| 790 |
| 791 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
| 792 if the built-in stack extension method is used). |
| 793 |
| 794 Do not make this value too large; the results are undefined if |
| 795 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) |
| 796 evaluated with infinite-precision integer arithmetic. */ |
| 797 |
| 798 #ifndef YYMAXDEPTH |
| 799 # define YYMAXDEPTH ]b4_stack_depth_max[ |
| 800 #endif |
| 801 |
| 802 |
| 803 |
| 804 #if YYERROR_VERBOSE |
| 805 |
| 806 # ifndef yystrlen |
| 807 # if defined __GLIBC__ && defined _STRING_H |
| 808 # define yystrlen strlen |
| 809 # else |
| 810 /* Return the length of YYSTR. */ |
| 811 ]b4_c_function_def([yystrlen], [static YYSIZE_T], |
| 812 [[const char *yystr], [yystr]])[ |
| 813 { |
| 814 YYSIZE_T yylen; |
| 815 for (yylen = 0; yystr[yylen]; yylen++) |
| 816 continue; |
| 817 return yylen; |
| 818 } |
| 819 # endif |
| 820 # endif |
| 821 |
| 822 # ifndef yystpcpy |
| 823 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE |
| 824 # define yystpcpy stpcpy |
| 825 # else |
| 826 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in |
| 827 YYDEST. */ |
| 828 ]b4_c_function_def([yystpcpy], [static char *], |
| 829 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[ |
| 830 { |
| 831 char *yyd = yydest; |
| 832 const char *yys = yysrc; |
| 833 |
| 834 while ((*yyd++ = *yys++) != '\0') |
| 835 continue; |
| 836 |
| 837 return yyd - 1; |
| 838 } |
| 839 # endif |
| 840 # endif |
| 841 |
| 842 # ifndef yytnamerr |
| 843 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary |
| 844 quotes and backslashes, so that it's suitable for yyerror. The |
| 845 heuristic is that double-quoting is unnecessary unless the string |
| 846 contains an apostrophe, a comma, or backslash (other than |
| 847 backslash-backslash). YYSTR is taken from yytname. If YYRES is |
| 848 null, do not copy; instead, return the length of what the result |
| 849 would have been. */ |
| 850 static YYSIZE_T |
| 851 yytnamerr (char *yyres, const char *yystr) |
| 852 { |
| 853 if (*yystr == '"') |
| 854 { |
| 855 YYSIZE_T yyn = 0; |
| 856 char const *yyp = yystr; |
| 857 |
| 858 for (;;) |
| 859 switch (*++yyp) |
| 860 { |
| 861 case '\'': |
| 862 case ',': |
| 863 goto do_not_strip_quotes; |
| 864 |
| 865 case '\\': |
| 866 if (*++yyp != '\\') |
| 867 goto do_not_strip_quotes; |
| 868 /* Fall through. */ |
| 869 default: |
| 870 if (yyres) |
| 871 yyres[yyn] = *yyp; |
| 872 yyn++; |
| 873 break; |
| 874 |
| 875 case '"': |
| 876 if (yyres) |
| 877 yyres[yyn] = '\0'; |
| 878 return yyn; |
| 879 } |
| 880 do_not_strip_quotes: ; |
| 881 } |
| 882 |
| 883 if (! yyres) |
| 884 return yystrlen (yystr); |
| 885 |
| 886 return yystpcpy (yyres, yystr) - yyres; |
| 887 } |
| 888 # endif |
| 889 |
| 890 /* Copy into YYRESULT an error message about the unexpected token |
| 891 YYCHAR while in state YYSTATE. Return the number of bytes copied, |
| 892 including the terminating null byte. If YYRESULT is null, do not |
| 893 copy anything; just return the number of bytes that would be |
| 894 copied. As a special case, return 0 if an ordinary "syntax error" |
| 895 message will do. Return YYSIZE_MAXIMUM if overflow occurs during |
| 896 size calculation. */ |
| 897 static YYSIZE_T |
| 898 yysyntax_error (char *yyresult, int yystate, int yychar) |
| 899 { |
| 900 int yyn = yypact[yystate]; |
| 901 |
| 902 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) |
| 903 return 0; |
| 904 else |
| 905 { |
| 906 int yytype = YYTRANSLATE (yychar); |
| 907 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); |
| 908 YYSIZE_T yysize = yysize0; |
| 909 YYSIZE_T yysize1; |
| 910 int yysize_overflow = 0; |
| 911 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; |
| 912 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; |
| 913 int yyx; |
| 914 |
| 915 # if 0 |
| 916 /* This is so xgettext sees the translatable formats that are |
| 917 constructed on the fly. */ |
| 918 YY_("syntax error, unexpected %s"); |
| 919 YY_("syntax error, unexpected %s, expecting %s"); |
| 920 YY_("syntax error, unexpected %s, expecting %s or %s"); |
| 921 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); |
| 922 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); |
| 923 # endif |
| 924 char *yyfmt; |
| 925 char const *yyf; |
| 926 static char const yyunexpected[] = "syntax error, unexpected %s"; |
| 927 static char const yyexpecting[] = ", expecting %s"; |
| 928 static char const yyor[] = " or %s"; |
| 929 char yyformat[sizeof yyunexpected |
| 930 + sizeof yyexpecting - 1 |
| 931 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) |
| 932 * (sizeof yyor - 1))]; |
| 933 char const *yyprefix = yyexpecting; |
| 934 |
| 935 /* Start YYX at -YYN if negative to avoid negative indexes in |
| 936 YYCHECK. */ |
| 937 int yyxbegin = yyn < 0 ? -yyn : 0; |
| 938 |
| 939 /* Stay within bounds of both yycheck and yytname. */ |
| 940 int yychecklim = YYLAST - yyn + 1; |
| 941 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
| 942 int yycount = 1; |
| 943 |
| 944 yyarg[0] = yytname[yytype]; |
| 945 yyfmt = yystpcpy (yyformat, yyunexpected); |
| 946 |
| 947 for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
| 948 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
| 949 { |
| 950 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
| 951 { |
| 952 yycount = 1; |
| 953 yysize = yysize0; |
| 954 yyformat[sizeof yyunexpected - 1] = '\0'; |
| 955 break; |
| 956 } |
| 957 yyarg[yycount++] = yytname[yyx]; |
| 958 yysize1 = yysize + yytnamerr (0, yytname[yyx]); |
| 959 yysize_overflow |= (yysize1 < yysize); |
| 960 yysize = yysize1; |
| 961 yyfmt = yystpcpy (yyfmt, yyprefix); |
| 962 yyprefix = yyor; |
| 963 } |
| 964 |
| 965 yyf = YY_(yyformat); |
| 966 yysize1 = yysize + yystrlen (yyf); |
| 967 yysize_overflow |= (yysize1 < yysize); |
| 968 yysize = yysize1; |
| 969 |
| 970 if (yysize_overflow) |
| 971 return YYSIZE_MAXIMUM; |
| 972 |
| 973 if (yyresult) |
| 974 { |
| 975 /* Avoid sprintf, as that infringes on the user's name space. |
| 976 Don't have undefined behavior even if the translation |
| 977 produced a string with the wrong number of "%s"s. */ |
| 978 char *yyp = yyresult; |
| 979 int yyi = 0; |
| 980 while ((*yyp = *yyf) != '\0') |
| 981 { |
| 982 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
| 983 { |
| 984 yyp += yytnamerr (yyp, yyarg[yyi++]); |
| 985 yyf += 2; |
| 986 } |
| 987 else |
| 988 { |
| 989 yyp++; |
| 990 yyf++; |
| 991 } |
| 992 } |
| 993 } |
| 994 return yysize; |
| 995 } |
| 996 } |
| 997 #endif /* YYERROR_VERBOSE */ |
| 998 |
| 999 |
| 1000 ]b4_yydestruct_generate([b4_c_function_def])[ |
| 1001 |
| 1002 ]b4_push_if([], |
| 1003 [[/* Prevent warnings from -Wmissing-prototypes. */ |
| 1004 #ifdef YYPARSE_PARAM |
| 1005 ]b4_c_function_decl([yyparse], [int], |
| 1006 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[ |
| 1007 #else /* ! YYPARSE_PARAM */ |
| 1008 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[ |
| 1009 #endif /* ! YYPARSE_PARAM */]]) |
| 1010 |
| 1011 m4_divert_push([KILL])# ======================== M4 code. |
| 1012 # b4_declare_scanner_communication_variables |
| 1013 # ------------------------------------------ |
| 1014 # Declare the variables that are global, or local to YYPARSE if |
| 1015 # pure-parser. |
| 1016 m4_define([b4_declare_scanner_communication_variables], |
| 1017 [[/* The lookahead symbol. */ |
| 1018 int yychar; |
| 1019 |
| 1020 /* The semantic value of the lookahead symbol. */ |
| 1021 YYSTYPE yylval; |
| 1022 ]b4_locations_if([[ |
| 1023 /* Location data for the lookahead symbol. */ |
| 1024 YYLTYPE yylloc; |
| 1025 ]])b4_pure_if([], [[ |
| 1026 /* Number of syntax errors so far. */ |
| 1027 int yynerrs; |
| 1028 ]])]) |
| 1029 |
| 1030 # b4_declare_parser_state_variables |
| 1031 # --------------------------------- |
| 1032 # Declare all the variables that are needed to maintain the parser state |
| 1033 # between calls to yypush_parse. |
| 1034 m4_define([b4_declare_parser_state_variables], |
| 1035 [b4_pure_if([[ /* Number of syntax errors so far. */ |
| 1036 int yynerrs; |
| 1037 ]])[ |
| 1038 int yystate; |
| 1039 /* Number of tokens to shift before error messages enabled. */ |
| 1040 int yyerrstatus; |
| 1041 |
| 1042 /* The stacks and their tools: |
| 1043 `yyss': related to states. |
| 1044 `yyvs': related to semantic values.]b4_locations_if([[ |
| 1045 `yyls': related to locations.]])[ |
| 1046 |
| 1047 Refer to the stacks thru separate pointers, to allow yyoverflow |
| 1048 to reallocate them elsewhere. */ |
| 1049 |
| 1050 /* The state stack. */ |
| 1051 yytype_int16 yyssa[YYINITDEPTH]; |
| 1052 yytype_int16 *yyss; |
| 1053 yytype_int16 *yyssp; |
| 1054 |
| 1055 /* The semantic value stack. */ |
| 1056 YYSTYPE yyvsa[YYINITDEPTH]; |
| 1057 YYSTYPE *yyvs; |
| 1058 YYSTYPE *yyvsp; |
| 1059 ]b4_locations_if([[ |
| 1060 /* The location stack. */ |
| 1061 YYLTYPE yylsa[YYINITDEPTH]; |
| 1062 YYLTYPE *yyls; |
| 1063 YYLTYPE *yylsp; |
| 1064 |
| 1065 /* The locations where the error started and ended. */ |
| 1066 YYLTYPE yyerror_range[2]; |
| 1067 ]])[ |
| 1068 YYSIZE_T yystacksize; |
| 1069 ]]) |
| 1070 |
| 1071 m4_divert_pop([KILL])dnl# ====================== End of M4 code. |
| 1072 |
| 1073 b4_pure_if([], [b4_declare_scanner_communication_variables]) |
| 1074 |
| 1075 b4_push_if( |
| 1076 [[struct yypstate |
| 1077 { |
| 1078 ]b4_declare_parser_state_variables[ |
| 1079 /* Used to determine if this is the first time this instance has |
| 1080 been used. */ |
| 1081 int yynew; |
| 1082 };]b4_pure_if([], [[ |
| 1083 |
| 1084 static char yypstate_allocated = 0;]])b4_pull_if([ |
| 1085 |
| 1086 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[ |
| 1087 { |
| 1088 return yypull_parse (0]m4_ifset([b4_parse_param], |
| 1089 [[, ]b4_c_args(b4_parse_param)])[); |
| 1090 } |
| 1091 |
| 1092 ]b4_c_function_def([[yypull_parse]], [[int]], |
| 1093 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, |
| 1094 b4_parse_param]))[ |
| 1095 { |
| 1096 int yystatus; |
| 1097 yypstate *yyps_local;]b4_pure_if([[ |
| 1098 int yychar; |
| 1099 YYSTYPE yylval;]b4_locations_if([[ |
| 1100 YYLTYPE yylloc;]])])[ |
| 1101 if (yyps == 0) |
| 1102 { |
| 1103 yyps_local = yypstate_new (); |
| 1104 if (!yyps_local) |
| 1105 {]b4_pure_if([[ |
| 1106 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[ |
| 1107 if (!yypstate_allocated) |
| 1108 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[ |
| 1109 return 2; |
| 1110 } |
| 1111 } |
| 1112 else |
| 1113 yyps_local = yyps; |
| 1114 do { |
| 1115 yychar = YYLEX; |
| 1116 yystatus = |
| 1117 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[
, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[); |
| 1118 } while (yystatus == YYPUSH_MORE); |
| 1119 if (yyps == 0) |
| 1120 yypstate_delete (yyps_local); |
| 1121 return yystatus; |
| 1122 }]])[ |
| 1123 |
| 1124 /* Initialize the parser data structure. */ |
| 1125 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[ |
| 1126 { |
| 1127 yypstate *yyps;]b4_pure_if([], [[ |
| 1128 if (yypstate_allocated) |
| 1129 return 0;]])[ |
| 1130 yyps = (yypstate *) malloc (sizeof *yyps); |
| 1131 if (!yyps) |
| 1132 return 0; |
| 1133 yyps->yynew = 1;]b4_pure_if([], [[ |
| 1134 yypstate_allocated = 1;]])[ |
| 1135 return yyps; |
| 1136 } |
| 1137 |
| 1138 ]b4_c_function_def([[yypstate_delete]], [[void]], |
| 1139 [[[yypstate *yyps]], [[yyps]]])[ |
| 1140 { |
| 1141 #ifndef yyoverflow |
| 1142 /* If the stack was reallocated but the parse did not complete, then the |
| 1143 stack still needs to be freed. */ |
| 1144 if (!yyps->yynew && yyps->yyss != yyps->yyssa) |
| 1145 YYSTACK_FREE (yyps->yyss); |
| 1146 #endif |
| 1147 free (yyps);]b4_pure_if([], [[ |
| 1148 yypstate_allocated = 0;]])[ |
| 1149 } |
| 1150 |
| 1151 ]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs |
| 1152 ]])[#define yystate yyps->yystate |
| 1153 #define yyerrstatus yyps->yyerrstatus |
| 1154 #define yyssa yyps->yyssa |
| 1155 #define yyss yyps->yyss |
| 1156 #define yyssp yyps->yyssp |
| 1157 #define yyvsa yyps->yyvsa |
| 1158 #define yyvs yyps->yyvs |
| 1159 #define yyvsp yyps->yyvsp |
| 1160 ]b4_locations_if([[#define yylsa yyps->yylsa |
| 1161 #define yyls yyps->yyls |
| 1162 #define yylsp yyps->yylsp |
| 1163 #define yyerror_range yyps->yyerror_range |
| 1164 ]])[#define yystacksize yyps->yystacksize |
| 1165 ]])[ |
| 1166 /*-------------------------. |
| 1167 | yyparse or yypush_parse. | |
| 1168 `-------------------------*/ |
| 1169 ]b4_push_if([ |
| 1170 b4_c_function_def([[yypush_parse]], [[int]], |
| 1171 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([, |
| 1172 [[[int yypushed_char]], [[yypushed_char]]], |
| 1173 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, |
| 1174 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_para
m], [, |
| 1175 b4_parse_param]))], [ |
| 1176 #ifdef YYPARSE_PARAM |
| 1177 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]]) |
| 1178 #else /* ! YYPARSE_PARAM */ |
| 1179 b4_c_function_def([yyparse], [int], b4_parse_param) |
| 1180 #endif])[ |
| 1181 { |
| 1182 ]b4_pure_if([b4_declare_scanner_communication_variables]) |
| 1183 b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar; |
| 1184 YYSTYPE yypushed_val = yylval; |
| 1185 ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc; |
| 1186 ]])])], |
| 1187 [b4_declare_parser_state_variables])[ |
| 1188 int yyn; |
| 1189 int yyresult; |
| 1190 /* Lookahead token as an internal (translated) token number. */ |
| 1191 int yytoken; |
| 1192 /* The variables used to return semantic value and location from the |
| 1193 action routines. */ |
| 1194 YYSTYPE yyval;]b4_locations_if([[ |
| 1195 YYLTYPE yyloc;]])[ |
| 1196 |
| 1197 #if YYERROR_VERBOSE |
| 1198 /* Buffer for error messages, and its allocated size. */ |
| 1199 char yymsgbuf[128]; |
| 1200 char *yymsg = yymsgbuf; |
| 1201 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; |
| 1202 #endif |
| 1203 |
| 1204 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -=
(N)])[) |
| 1205 |
| 1206 /* The number of symbols on the RHS of the reduced rule. |
| 1207 Keep to zero when no symbol should be popped. */ |
| 1208 int yylen = 0;]b4_push_if([[ |
| 1209 |
| 1210 if (!yyps->yynew) |
| 1211 { |
| 1212 yyn = yypact[yystate]; |
| 1213 goto yyread_pushed_token; |
| 1214 }]])[ |
| 1215 |
| 1216 yytoken = 0; |
| 1217 yyss = yyssa; |
| 1218 yyvs = yyvsa;]b4_locations_if([[ |
| 1219 yyls = yylsa;]])[ |
| 1220 yystacksize = YYINITDEPTH; |
| 1221 |
| 1222 YYDPRINTF ((stderr, "Starting parse\n")); |
| 1223 |
| 1224 yystate = 0; |
| 1225 yyerrstatus = 0; |
| 1226 yynerrs = 0; |
| 1227 yychar = YYEMPTY; /* Cause a token to be read. */ |
| 1228 |
| 1229 /* Initialize stack pointers. |
| 1230 Waste one element of value and location stack |
| 1231 so that they stay on the same level as the state stack. |
| 1232 The wasted elements are never initialized. */ |
| 1233 yyssp = yyss; |
| 1234 yyvsp = yyvs;]b4_locations_if([[ |
| 1235 yylsp = yyls; |
| 1236 |
| 1237 #if YYLTYPE_IS_TRIVIAL |
| 1238 /* Initialize the default location before parsing starts. */ |
| 1239 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[; |
| 1240 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[; |
| 1241 #endif]]) |
| 1242 m4_ifdef([b4_initial_action],[ |
| 1243 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl |
| 1244 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl |
| 1245 /* User initialization code. */ |
| 1246 b4_user_initial_action |
| 1247 m4_popdef([b4_dollar_dollar])dnl |
| 1248 m4_popdef([b4_at_dollar])])dnl |
| 1249 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval; |
| 1250 ]])dnl |
| 1251 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc; |
| 1252 ]])[ |
| 1253 goto yysetstate; |
| 1254 |
| 1255 /*------------------------------------------------------------. |
| 1256 | yynewstate -- Push a new state, which is found in yystate. | |
| 1257 `------------------------------------------------------------*/ |
| 1258 yynewstate: |
| 1259 /* In all cases, when you get here, the value and location stacks |
| 1260 have just been pushed. So pushing a state here evens the stacks. */ |
| 1261 yyssp++; |
| 1262 |
| 1263 yysetstate: |
| 1264 *yyssp = yystate; |
| 1265 |
| 1266 if (yyss + yystacksize - 1 <= yyssp) |
| 1267 { |
| 1268 /* Get the current used size of the three stacks, in elements. */ |
| 1269 YYSIZE_T yysize = yyssp - yyss + 1; |
| 1270 |
| 1271 #ifdef yyoverflow |
| 1272 { |
| 1273 /* Give user a chance to reallocate the stack. Use copies of |
| 1274 these so that the &'s don't force the real ones into |
| 1275 memory. */ |
| 1276 YYSTYPE *yyvs1 = yyvs; |
| 1277 yytype_int16 *yyss1 = yyss;]b4_locations_if([ |
| 1278 YYLTYPE *yyls1 = yyls;])[ |
| 1279 |
| 1280 /* Each stack pointer address is followed by the size of the |
| 1281 data in use in that stack, in bytes. This used to be a |
| 1282 conditional around just the two extra args, but that might |
| 1283 be undefined if yyoverflow is a macro. */ |
| 1284 yyoverflow (YY_("memory exhausted"), |
| 1285 &yyss1, yysize * sizeof (*yyssp), |
| 1286 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([ |
| 1287 &yyls1, yysize * sizeof (*yylsp),])[ |
| 1288 &yystacksize); |
| 1289 ]b4_locations_if([ |
| 1290 yyls = yyls1;])[ |
| 1291 yyss = yyss1; |
| 1292 yyvs = yyvs1; |
| 1293 } |
| 1294 #else /* no yyoverflow */ |
| 1295 # ifndef YYSTACK_RELOCATE |
| 1296 goto yyexhaustedlab; |
| 1297 # else |
| 1298 /* Extend the stack our own way. */ |
| 1299 if (YYMAXDEPTH <= yystacksize) |
| 1300 goto yyexhaustedlab; |
| 1301 yystacksize *= 2; |
| 1302 if (YYMAXDEPTH < yystacksize) |
| 1303 yystacksize = YYMAXDEPTH; |
| 1304 |
| 1305 { |
| 1306 yytype_int16 *yyss1 = yyss; |
| 1307 union yyalloc *yyptr = |
| 1308 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
| 1309 if (! yyptr) |
| 1310 goto yyexhaustedlab; |
| 1311 YYSTACK_RELOCATE (yyss_alloc, yyss); |
| 1312 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([ |
| 1313 YYSTACK_RELOCATE (yyls_alloc, yyls);])[ |
| 1314 # undef YYSTACK_RELOCATE |
| 1315 if (yyss1 != yyssa) |
| 1316 YYSTACK_FREE (yyss1); |
| 1317 } |
| 1318 # endif |
| 1319 #endif /* no yyoverflow */ |
| 1320 |
| 1321 yyssp = yyss + yysize - 1; |
| 1322 yyvsp = yyvs + yysize - 1;]b4_locations_if([ |
| 1323 yylsp = yyls + yysize - 1;])[ |
| 1324 |
| 1325 YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
| 1326 (unsigned long int) yystacksize)); |
| 1327 |
| 1328 if (yyss + yystacksize - 1 <= yyssp) |
| 1329 YYABORT; |
| 1330 } |
| 1331 |
| 1332 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
| 1333 |
| 1334 if (yystate == YYFINAL) |
| 1335 YYACCEPT; |
| 1336 |
| 1337 goto yybackup; |
| 1338 |
| 1339 /*-----------. |
| 1340 | yybackup. | |
| 1341 `-----------*/ |
| 1342 yybackup: |
| 1343 |
| 1344 /* Do appropriate processing given the current state. Read a |
| 1345 lookahead token if we need one and don't already have one. */ |
| 1346 |
| 1347 /* First try to decide what to do without reference to lookahead token. */ |
| 1348 yyn = yypact[yystate]; |
| 1349 if (yyn == YYPACT_NINF) |
| 1350 goto yydefault; |
| 1351 |
| 1352 /* Not known => get a lookahead token if don't already have one. */ |
| 1353 |
| 1354 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ |
| 1355 if (yychar == YYEMPTY) |
| 1356 {]b4_push_if([[ |
| 1357 if (!yyps->yynew) |
| 1358 {]b4_use_push_for_pull_if([], [[ |
| 1359 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[ |
| 1360 yyresult = YYPUSH_MORE; |
| 1361 goto yypushreturn; |
| 1362 } |
| 1363 yyps->yynew = 0;]b4_pure_if([], [[ |
| 1364 /* Restoring the pushed token is only necessary for the first |
| 1365 yypush_parse invocation since subsequent invocations don't overwrite |
| 1366 it before jumping to yyread_pushed_token. */ |
| 1367 yychar = yypushed_char; |
| 1368 yylval = yypushed_val;]b4_locations_if([[ |
| 1369 yylloc = yypushed_loc;]])])[ |
| 1370 yyread_pushed_token:]])[ |
| 1371 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[ |
| 1372 yychar = yypushed_char; |
| 1373 if (yypushed_val) |
| 1374 yylval = *yypushed_val;]b4_locations_if([[ |
| 1375 if (yypushed_loc) |
| 1376 yylloc = *yypushed_loc;]])])], [[ |
| 1377 yychar = YYLEX;]])[ |
| 1378 } |
| 1379 |
| 1380 if (yychar <= YYEOF) |
| 1381 { |
| 1382 yychar = yytoken = YYEOF; |
| 1383 YYDPRINTF ((stderr, "Now at end of input.\n")); |
| 1384 } |
| 1385 else |
| 1386 { |
| 1387 yytoken = YYTRANSLATE (yychar); |
| 1388 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
| 1389 } |
| 1390 |
| 1391 /* If the proper action on seeing token YYTOKEN is to reduce or to |
| 1392 detect an error, take that action. */ |
| 1393 yyn += yytoken; |
| 1394 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) |
| 1395 goto yydefault; |
| 1396 yyn = yytable[yyn]; |
| 1397 if (yyn <= 0) |
| 1398 { |
| 1399 if (yyn == 0 || yyn == YYTABLE_NINF) |
| 1400 goto yyerrlab; |
| 1401 yyn = -yyn; |
| 1402 goto yyreduce; |
| 1403 } |
| 1404 |
| 1405 /* Count tokens shifted since error; after three, turn off error |
| 1406 status. */ |
| 1407 if (yyerrstatus) |
| 1408 yyerrstatus--; |
| 1409 |
| 1410 /* Shift the lookahead token. */ |
| 1411 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
| 1412 |
| 1413 /* Discard the shifted token. */ |
| 1414 yychar = YYEMPTY; |
| 1415 |
| 1416 yystate = yyn; |
| 1417 *++yyvsp = yylval; |
| 1418 ]b4_locations_if([ *++yylsp = yylloc;])[ |
| 1419 goto yynewstate; |
| 1420 |
| 1421 |
| 1422 /*-----------------------------------------------------------. |
| 1423 | yydefault -- do the default action for the current state. | |
| 1424 `-----------------------------------------------------------*/ |
| 1425 yydefault: |
| 1426 yyn = yydefact[yystate]; |
| 1427 if (yyn == 0) |
| 1428 goto yyerrlab; |
| 1429 goto yyreduce; |
| 1430 |
| 1431 |
| 1432 /*-----------------------------. |
| 1433 | yyreduce -- Do a reduction. | |
| 1434 `-----------------------------*/ |
| 1435 yyreduce: |
| 1436 /* yyn is the number of a rule to reduce with. */ |
| 1437 yylen = yyr2[yyn]; |
| 1438 |
| 1439 /* If YYLEN is nonzero, implement the default value of the action: |
| 1440 `$$ = $1'. |
| 1441 |
| 1442 Otherwise, the following line sets YYVAL to garbage. |
| 1443 This behavior is undocumented and Bison |
| 1444 users should not rely upon it. Assigning to YYVAL |
| 1445 unconditionally makes the parser a bit smaller, and it avoids a |
| 1446 GCC warning that YYVAL may be used uninitialized. */ |
| 1447 yyval = yyvsp[1-yylen]; |
| 1448 |
| 1449 ]b4_locations_if( |
| 1450 [[ /* Default location. */ |
| 1451 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[ |
| 1452 YY_REDUCE_PRINT (yyn); |
| 1453 switch (yyn) |
| 1454 { |
| 1455 ]b4_user_actions[ |
| 1456 default: break; |
| 1457 } |
| 1458 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); |
| 1459 |
| 1460 YYPOPSTACK (yylen); |
| 1461 yylen = 0; |
| 1462 YY_STACK_PRINT (yyss, yyssp); |
| 1463 |
| 1464 *++yyvsp = yyval;]b4_locations_if([ |
| 1465 *++yylsp = yyloc;])[ |
| 1466 |
| 1467 /* Now `shift' the result of the reduction. Determine what state |
| 1468 that goes to, based on the state we popped back to and the rule |
| 1469 number reduced by. */ |
| 1470 |
| 1471 yyn = yyr1[yyn]; |
| 1472 |
| 1473 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; |
| 1474 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
| 1475 yystate = yytable[yystate]; |
| 1476 else |
| 1477 yystate = yydefgoto[yyn - YYNTOKENS]; |
| 1478 |
| 1479 goto yynewstate; |
| 1480 |
| 1481 |
| 1482 /*------------------------------------. |
| 1483 | yyerrlab -- here on detecting error | |
| 1484 `------------------------------------*/ |
| 1485 yyerrlab: |
| 1486 /* If not already recovering from an error, report this error. */ |
| 1487 if (!yyerrstatus) |
| 1488 { |
| 1489 ++yynerrs; |
| 1490 #if ! YYERROR_VERBOSE |
| 1491 yyerror (]b4_yyerror_args[YY_("syntax error")); |
| 1492 #else |
| 1493 { |
| 1494 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); |
| 1495 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) |
| 1496 { |
| 1497 YYSIZE_T yyalloc = 2 * yysize; |
| 1498 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) |
| 1499 yyalloc = YYSTACK_ALLOC_MAXIMUM; |
| 1500 if (yymsg != yymsgbuf) |
| 1501 YYSTACK_FREE (yymsg); |
| 1502 yymsg = (char *) YYSTACK_ALLOC (yyalloc); |
| 1503 if (yymsg) |
| 1504 yymsg_alloc = yyalloc; |
| 1505 else |
| 1506 { |
| 1507 yymsg = yymsgbuf; |
| 1508 yymsg_alloc = sizeof yymsgbuf; |
| 1509 } |
| 1510 } |
| 1511 |
| 1512 if (0 < yysize && yysize <= yymsg_alloc) |
| 1513 { |
| 1514 (void) yysyntax_error (yymsg, yystate, yychar); |
| 1515 yyerror (]b4_yyerror_args[yymsg); |
| 1516 } |
| 1517 else |
| 1518 { |
| 1519 yyerror (]b4_yyerror_args[YY_("syntax error")); |
| 1520 if (yysize != 0) |
| 1521 goto yyexhaustedlab; |
| 1522 } |
| 1523 } |
| 1524 #endif |
| 1525 } |
| 1526 |
| 1527 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[ |
| 1528 |
| 1529 if (yyerrstatus == 3) |
| 1530 { |
| 1531 /* If just tried and failed to reuse lookahead token after an |
| 1532 error, discard it. */ |
| 1533 |
| 1534 if (yychar <= YYEOF) |
| 1535 { |
| 1536 /* Return failure if at end of input. */ |
| 1537 if (yychar == YYEOF) |
| 1538 YYABORT; |
| 1539 } |
| 1540 else |
| 1541 { |
| 1542 yydestruct ("Error: discarding", |
| 1543 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_arg
s[); |
| 1544 yychar = YYEMPTY; |
| 1545 } |
| 1546 } |
| 1547 |
| 1548 /* Else will try to reuse lookahead token after shifting the error |
| 1549 token. */ |
| 1550 goto yyerrlab1; |
| 1551 |
| 1552 |
| 1553 /*---------------------------------------------------. |
| 1554 | yyerrorlab -- error raised explicitly by YYERROR. | |
| 1555 `---------------------------------------------------*/ |
| 1556 yyerrorlab: |
| 1557 |
| 1558 /* Pacify compilers like GCC when the user code never invokes |
| 1559 YYERROR and the label yyerrorlab therefore never appears in user |
| 1560 code. */ |
| 1561 if (/*CONSTCOND*/ 0) |
| 1562 goto yyerrorlab; |
| 1563 |
| 1564 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen]; |
| 1565 ]])[ /* Do not reclaim the symbols of the rule which action triggered |
| 1566 this YYERROR. */ |
| 1567 YYPOPSTACK (yylen); |
| 1568 yylen = 0; |
| 1569 YY_STACK_PRINT (yyss, yyssp); |
| 1570 yystate = *yyssp; |
| 1571 goto yyerrlab1; |
| 1572 |
| 1573 |
| 1574 /*-------------------------------------------------------------. |
| 1575 | yyerrlab1 -- common code for both syntax error and YYERROR. | |
| 1576 `-------------------------------------------------------------*/ |
| 1577 yyerrlab1: |
| 1578 yyerrstatus = 3; /* Each real token shifted decrements this. */ |
| 1579 |
| 1580 for (;;) |
| 1581 { |
| 1582 yyn = yypact[yystate]; |
| 1583 if (yyn != YYPACT_NINF) |
| 1584 { |
| 1585 yyn += YYTERROR; |
| 1586 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
| 1587 { |
| 1588 yyn = yytable[yyn]; |
| 1589 if (0 < yyn) |
| 1590 break; |
| 1591 } |
| 1592 } |
| 1593 |
| 1594 /* Pop the current state because it cannot handle the error token. */ |
| 1595 if (yyssp == yyss) |
| 1596 YYABORT; |
| 1597 |
| 1598 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[ |
| 1599 yydestruct ("Error: popping", |
| 1600 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_arg
s[); |
| 1601 YYPOPSTACK (1); |
| 1602 yystate = *yyssp; |
| 1603 YY_STACK_PRINT (yyss, yyssp); |
| 1604 } |
| 1605 |
| 1606 *++yyvsp = yylval; |
| 1607 ]b4_locations_if([[ |
| 1608 yyerror_range[1] = yylloc; |
| 1609 /* Using YYLLOC is tempting, but would change the location of |
| 1610 the lookahead. YYLOC is available though. */ |
| 1611 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2); |
| 1612 *++yylsp = yyloc;]])[ |
| 1613 |
| 1614 /* Shift the error token. */ |
| 1615 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); |
| 1616 |
| 1617 yystate = yyn; |
| 1618 goto yynewstate; |
| 1619 |
| 1620 |
| 1621 /*-------------------------------------. |
| 1622 | yyacceptlab -- YYACCEPT comes here. | |
| 1623 `-------------------------------------*/ |
| 1624 yyacceptlab: |
| 1625 yyresult = 0; |
| 1626 goto yyreturn; |
| 1627 |
| 1628 /*-----------------------------------. |
| 1629 | yyabortlab -- YYABORT comes here. | |
| 1630 `-----------------------------------*/ |
| 1631 yyabortlab: |
| 1632 yyresult = 1; |
| 1633 goto yyreturn; |
| 1634 |
| 1635 #if !defined(yyoverflow) || YYERROR_VERBOSE |
| 1636 /*-------------------------------------------------. |
| 1637 | yyexhaustedlab -- memory exhaustion comes here. | |
| 1638 `-------------------------------------------------*/ |
| 1639 yyexhaustedlab: |
| 1640 yyerror (]b4_yyerror_args[YY_("memory exhausted")); |
| 1641 yyresult = 2; |
| 1642 /* Fall through. */ |
| 1643 #endif |
| 1644 |
| 1645 yyreturn: |
| 1646 if (yychar != YYEMPTY) |
| 1647 yydestruct ("Cleanup: discarding lookahead", |
| 1648 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[); |
| 1649 /* Do not reclaim the symbols of the rule which action triggered |
| 1650 this YYABORT or YYACCEPT. */ |
| 1651 YYPOPSTACK (yylen); |
| 1652 YY_STACK_PRINT (yyss, yyssp); |
| 1653 while (yyssp != yyss) |
| 1654 { |
| 1655 yydestruct ("Cleanup: popping", |
| 1656 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args
[); |
| 1657 YYPOPSTACK (1); |
| 1658 } |
| 1659 #ifndef yyoverflow |
| 1660 if (yyss != yyssa) |
| 1661 YYSTACK_FREE (yyss); |
| 1662 #endif |
| 1663 ]b4_push_if([[ yyps->yynew = 1; |
| 1664 |
| 1665 yypushreturn: |
| 1666 ]])[#if YYERROR_VERBOSE |
| 1667 if (yymsg != yymsgbuf) |
| 1668 YYSTACK_FREE (yymsg); |
| 1669 #endif |
| 1670 /* Make sure YYID is used. */ |
| 1671 return YYID (yyresult); |
| 1672 } |
| 1673 |
| 1674 |
| 1675 ]b4_epilogue |
| 1676 b4_defines_if( |
| 1677 [@output(b4_spec_defines_file@) |
| 1678 b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl ' |
| 1679 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006]) |
| 1680 |
| 1681 b4_percent_code_get([[requires]])[]dnl |
| 1682 |
| 1683 b4_token_enums_defines(b4_tokens) |
| 1684 |
| 1685 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED |
| 1686 ]m4_ifdef([b4_stype], |
| 1687 [[typedef union ]b4_union_name[ |
| 1688 { |
| 1689 ]b4_user_stype[ |
| 1690 } YYSTYPE; |
| 1691 # define YYSTYPE_IS_TRIVIAL 1]], |
| 1692 [m4_if(b4_tag_seen_flag, 0, |
| 1693 [[typedef int YYSTYPE; |
| 1694 # define YYSTYPE_IS_TRIVIAL 1]])])[ |
| 1695 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
| 1696 # define YYSTYPE_IS_DECLARED 1 |
| 1697 #endif |
| 1698 |
| 1699 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]]) |
| 1700 |
| 1701 b4_locations_if( |
| 1702 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED |
| 1703 typedef struct YYLTYPE |
| 1704 { |
| 1705 int first_line; |
| 1706 int first_column; |
| 1707 int last_line; |
| 1708 int last_column; |
| 1709 } YYLTYPE; |
| 1710 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */ |
| 1711 # define YYLTYPE_IS_DECLARED 1 |
| 1712 # define YYLTYPE_IS_TRIVIAL 1 |
| 1713 #endif |
| 1714 |
| 1715 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]]) |
| 1716 )dnl b4_locations_if |
| 1717 b4_push_if([[ |
| 1718 #ifndef YYPUSH_DECLS |
| 1719 # define YYPUSH_DECLS |
| 1720 struct ]b4_prefix[pstate; |
| 1721 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate; |
| 1722 enum { YYPUSH_MORE = 4 }; |
| 1723 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param) |
| 1724 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]], |
| 1725 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([, |
| 1726 [[[int yypushed_char]], [[yypushed_char]]], |
| 1727 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([, |
| 1728 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_para
m], [, |
| 1729 b4_parse_param])) |
| 1730 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]], |
| 1731 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [, |
| 1732 b4_parse_param]))]) |
| 1733 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]], |
| 1734 [[[void]], []]) |
| 1735 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]], |
| 1736 [[b4_prefix[pstate *yyps]], [[yyps]]])[ |
| 1737 #endif |
| 1738 ]]) |
| 1739 b4_percent_code_get([[provides]])[]dnl |
| 1740 ])dnl b4_defines_if |
| 1741 m4_divert_pop(0) |
OLD | NEW |