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