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 COMMENT = 258, 70 DOMAIN = 259, 71 JUNK = 260, 72 PREV_MSGCTXT = 261, 73 PREV_MSGID = 262, 74 PREV_MSGID_PLURAL = 263, 75 PREV_STRING = 264, 76 MSGCTXT = 265, 77 MSGID = 266, 78 MSGID_PLURAL = 267, 79 MSGSTR = 268, 80 NAME = 269, 81 NUMBER = 270, 82 STRING = 271 83 }; 84#endif 85/* Tokens. */ 86#define COMMENT 258 87#define DOMAIN 259 88#define JUNK 260 89#define PREV_MSGCTXT 261 90#define PREV_MSGID 262 91#define PREV_MSGID_PLURAL 263 92#define PREV_STRING 264 93#define MSGCTXT 265 94#define MSGID 266 95#define MSGID_PLURAL 267 96#define MSGSTR 268 97#define NAME 269 98#define NUMBER 270 99#define STRING 271 100 101 102 103 104/* Copy the first part of user declarations. */ 105#line 19 "po-gram-gen.y" 106 107#ifdef HAVE_CONFIG_H 108# include "config.h" 109#endif 110 111/* Specification. */ 112#include "po-gram.h" 113 114#include <stdbool.h> 115#include <stdio.h> 116#include <stdlib.h> 117#include <string.h> 118 119#include "str-list.h" 120#include "po-lex.h" 121#include "po-charset.h" 122#include "error.h" 123#include "xalloc.h" 124#include "gettext.h" 125#include "read-catalog-abstract.h" 126 127#define _(str) gettext (str) 128 129/* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), 130 as well as gratuitiously global symbol names, so we can have multiple 131 yacc generated parsers in the same program. Note that these are only 132 the variables produced by yacc. If other parser generators (bison, 133 byacc, etc) produce additional global names that conflict at link time, 134 then those parser generators need to be fixed instead of adding those 135 names to this list. */ 136 137#define yymaxdepth po_gram_maxdepth 138#define yyparse po_gram_parse 139#define yylex po_gram_lex 140#define yyerror po_gram_error 141#define yylval po_gram_lval 142#define yychar po_gram_char 143#define yydebug po_gram_debug 144#define yypact po_gram_pact 145#define yyr1 po_gram_r1 146#define yyr2 po_gram_r2 147#define yydef po_gram_def 148#define yychk po_gram_chk 149#define yypgo po_gram_pgo 150#define yyact po_gram_act 151#define yyexca po_gram_exca 152#define yyerrflag po_gram_errflag 153#define yynerrs po_gram_nerrs 154#define yyps po_gram_ps 155#define yypv po_gram_pv 156#define yys po_gram_s 157#define yy_yys po_gram_yys 158#define yystate po_gram_state 159#define yytmp po_gram_tmp 160#define yyv po_gram_v 161#define yy_yyv po_gram_yyv 162#define yyval po_gram_val 163#define yylloc po_gram_lloc 164#define yyreds po_gram_reds /* With YYDEBUG defined */ 165#define yytoks po_gram_toks /* With YYDEBUG defined */ 166#define yylhs po_gram_yylhs 167#define yylen po_gram_yylen 168#define yydefred po_gram_yydefred 169#define yydgoto po_gram_yydgoto 170#define yysindex po_gram_yysindex 171#define yyrindex po_gram_yyrindex 172#define yygindex po_gram_yygindex 173#define yytable po_gram_yytable 174#define yycheck po_gram_yycheck 175 176static long plural_counter; 177 178#define check_obsolete(value1,value2) \ 179 if ((value1).obsolete != (value2).obsolete) \ 180 po_gram_error_at_line (&(value2).pos, _("inconsistent use of #~")); 181 182static inline void 183do_callback_message (char *msgctxt, 184 char *msgid, lex_pos_ty *msgid_pos, char *msgid_plural, 185 char *msgstr, size_t msgstr_len, lex_pos_ty *msgstr_pos, 186 char *prev_msgctxt, 187 char *prev_msgid, char *prev_msgid_plural, 188 bool obsolete) 189{ 190 /* Test for header entry. Ignore fuzziness of the header entry. */ 191 if (msgctxt == NULL && msgid[0] == '\0' && !obsolete) 192 po_lex_charset_set (msgstr, gram_pos.file_name); 193 194 po_callback_message (msgctxt, 195 msgid, msgid_pos, msgid_plural, 196 msgstr, msgstr_len, msgstr_pos, 197 prev_msgctxt, prev_msgid, prev_msgid_plural, 198 false, obsolete); 199} 200 201#define free_message_intro(value) \ 202 if ((value).prev_ctxt != NULL) \ 203 free ((value).prev_ctxt); \ 204 if ((value).prev_id != NULL) \ 205 free ((value).prev_id); \ 206 if ((value).prev_id_plural != NULL) \ 207 free ((value).prev_id_plural); \ 208 if ((value).ctxt != NULL) \ 209 free ((value).ctxt); 210 211 212 213/* Enabling traces. */ 214#ifndef YYDEBUG 215# define YYDEBUG 0 216#endif 217 218/* Enabling verbose error messages. */ 219#ifdef YYERROR_VERBOSE 220# undef YYERROR_VERBOSE 221# define YYERROR_VERBOSE 1 222#else 223# define YYERROR_VERBOSE 0 224#endif 225 226/* Enabling the token table. */ 227#ifndef YYTOKEN_TABLE 228# define YYTOKEN_TABLE 0 229#endif 230 231#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 232typedef union YYSTYPE 233#line 143 "po-gram-gen.y" 234{ 235 struct { char *string; lex_pos_ty pos; bool obsolete; } string; 236 struct { string_list_ty stringlist; lex_pos_ty pos; bool obsolete; } stringlist; 237 struct { long number; lex_pos_ty pos; bool obsolete; } number; 238 struct { lex_pos_ty pos; bool obsolete; } pos; 239 struct { char *ctxt; char *id; char *id_plural; lex_pos_ty pos; bool obsolete; } prev; 240 struct { char *prev_ctxt; char *prev_id; char *prev_id_plural; char *ctxt; lex_pos_ty pos; bool obsolete; } message_intro; 241 struct { struct msgstr_def rhs; lex_pos_ty pos; bool obsolete; } rhs; 242} 243/* Line 187 of yacc.c. */ 244#line 245 "po-gram-gen.c" 245 YYSTYPE; 246# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 247# define YYSTYPE_IS_DECLARED 1 248# define YYSTYPE_IS_TRIVIAL 1 249#endif 250 251 252 253/* Copy the second part of user declarations. */ 254 255 256/* Line 216 of yacc.c. */ 257#line 258 "po-gram-gen.c" 258 259#ifdef short 260# undef short 261#endif 262 263#ifdef YYTYPE_UINT8 264typedef YYTYPE_UINT8 yytype_uint8; 265#else 266typedef unsigned char yytype_uint8; 267#endif 268 269#ifdef YYTYPE_INT8 270typedef YYTYPE_INT8 yytype_int8; 271#elif (defined __STDC__ || defined __C99__FUNC__ \ 272 || defined __cplusplus || defined _MSC_VER) 273typedef signed char yytype_int8; 274#else 275typedef short int yytype_int8; 276#endif 277 278#ifdef YYTYPE_UINT16 279typedef YYTYPE_UINT16 yytype_uint16; 280#else 281typedef unsigned short int yytype_uint16; 282#endif 283 284#ifdef YYTYPE_INT16 285typedef YYTYPE_INT16 yytype_int16; 286#else 287typedef short int yytype_int16; 288#endif 289 290#ifndef YYSIZE_T 291# ifdef __SIZE_TYPE__ 292# define YYSIZE_T __SIZE_TYPE__ 293# elif defined size_t 294# define YYSIZE_T size_t 295# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 296 || defined __cplusplus || defined _MSC_VER) 297# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 298# define YYSIZE_T size_t 299# else 300# define YYSIZE_T unsigned int 301# endif 302#endif 303 304#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 305 306#ifndef YY_ 307# if YYENABLE_NLS 308# if ENABLE_NLS 309# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 310# define YY_(msgid) dgettext ("bison-runtime", msgid) 311# endif 312# endif 313# ifndef YY_ 314# define YY_(msgid) msgid 315# endif 316#endif 317 318/* Suppress unused-variable warnings by "using" E. */ 319#if ! defined lint || defined __GNUC__ 320# define YYUSE(e) ((void) (e)) 321#else 322# define YYUSE(e) /* empty */ 323#endif 324 325/* Identity function, used to suppress warnings about constant conditions. */ 326#ifndef lint 327# define YYID(n) (n) 328#else 329#if (defined __STDC__ || defined __C99__FUNC__ \ 330 || defined __cplusplus || defined _MSC_VER) 331static int 332YYID (int i) 333#else 334static int 335YYID (i) 336 int i; 337#endif 338{ 339 return i; 340} 341#endif 342 343#if ! defined yyoverflow || YYERROR_VERBOSE 344 345/* The parser invokes alloca or malloc; define the necessary symbols. */ 346 347# ifdef YYSTACK_USE_ALLOCA 348# if YYSTACK_USE_ALLOCA 349# ifdef __GNUC__ 350# define YYSTACK_ALLOC __builtin_alloca 351# elif defined __BUILTIN_VA_ARG_INCR 352# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 353# elif defined _AIX 354# define YYSTACK_ALLOC __alloca 355# elif defined _MSC_VER 356# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 357# define alloca _alloca 358# else 359# define YYSTACK_ALLOC alloca 360# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 361 || defined __cplusplus || defined _MSC_VER) 362# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 363# ifndef _STDLIB_H 364# define _STDLIB_H 1 365# endif 366# endif 367# endif 368# endif 369# endif 370 371# ifdef YYSTACK_ALLOC 372 /* Pacify GCC's `empty if-body' warning. */ 373# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 374# ifndef YYSTACK_ALLOC_MAXIMUM 375 /* The OS might guarantee only one guard page at the bottom of the stack, 376 and a page size can be as small as 4096 bytes. So we cannot safely 377 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 378 to allow for a few compiler-allocated temporary stack slots. */ 379# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 380# endif 381# else 382# define YYSTACK_ALLOC YYMALLOC 383# define YYSTACK_FREE YYFREE 384# ifndef YYSTACK_ALLOC_MAXIMUM 385# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 386# endif 387# if (defined __cplusplus && ! defined _STDLIB_H \ 388 && ! ((defined YYMALLOC || defined malloc) \ 389 && (defined YYFREE || defined free))) 390# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 391# ifndef _STDLIB_H 392# define _STDLIB_H 1 393# endif 394# endif 395# ifndef YYMALLOC 396# define YYMALLOC malloc 397# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 398 || defined __cplusplus || defined _MSC_VER) 399void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 400# endif 401# endif 402# ifndef YYFREE 403# define YYFREE free 404# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 405 || defined __cplusplus || defined _MSC_VER) 406void free (void *); /* INFRINGES ON USER NAME SPACE */ 407# endif 408# endif 409# endif 410#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 411 412 413#if (! defined yyoverflow \ 414 && (! defined __cplusplus \ 415 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 416 417/* A type that is properly aligned for any stack member. */ 418union yyalloc 419{ 420 yytype_int16 yyss; 421 YYSTYPE yyvs; 422 }; 423 424/* The size of the maximum gap between one aligned stack and the next. */ 425# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 426 427/* The size of an array large to enough to hold all stacks, each with 428 N elements. */ 429# define YYSTACK_BYTES(N) \ 430 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 431 + YYSTACK_GAP_MAXIMUM) 432 433/* Copy COUNT objects from FROM to TO. The source and destination do 434 not overlap. */ 435# ifndef YYCOPY 436# if defined __GNUC__ && 1 < __GNUC__ 437# define YYCOPY(To, From, Count) \ 438 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 439# else 440# define YYCOPY(To, From, Count) \ 441 do \ 442 { \ 443 YYSIZE_T yyi; \ 444 for (yyi = 0; yyi < (Count); yyi++) \ 445 (To)[yyi] = (From)[yyi]; \ 446 } \ 447 while (YYID (0)) 448# endif 449# endif 450 451/* Relocate STACK from its old location to the new one. The 452 local variables YYSIZE and YYSTACKSIZE give the old and new number of 453 elements in the stack, and YYPTR gives the new location of the 454 stack. Advance YYPTR to a properly aligned location for the next 455 stack. */ 456# define YYSTACK_RELOCATE(Stack) \ 457 do \ 458 { \ 459 YYSIZE_T yynewbytes; \ 460 YYCOPY (&yyptr->Stack, Stack, yysize); \ 461 Stack = &yyptr->Stack; \ 462 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 463 yyptr += yynewbytes / sizeof (*yyptr); \ 464 } \ 465 while (YYID (0)) 466 467#endif 468 469/* YYFINAL -- State number of the termination state. */ 470#define YYFINAL 2 471/* YYLAST -- Last index in YYTABLE. */ 472#define YYLAST 40 473 474/* YYNTOKENS -- Number of terminals. */ 475#define YYNTOKENS 19 476/* YYNNTS -- Number of nonterminals. */ 477#define YYNNTS 15 478/* YYNRULES -- Number of rules. */ 479#define YYNRULES 30 480/* YYNRULES -- Number of states. */ 481#define YYNSTATES 46 482 483/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 484#define YYUNDEFTOK 2 485#define YYMAXUTOK 271 486 487#define YYTRANSLATE(YYX) \ 488 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 489 490/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 491static const yytype_uint8 yytranslate[] = 492{ 493 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 502 2, 15, 2, 16, 2, 2, 2, 2, 2, 2, 503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 504 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 505 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 506 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 507 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 508 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 509 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 511 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 512 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 513 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 514 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 515 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 518 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 519 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 520 17, 18 521}; 522 523#if YYDEBUG 524/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 525 YYRHS. */ 526static const yytype_uint8 yyprhs[] = 527{ 528 0, 0, 3, 4, 7, 10, 13, 16, 18, 21, 529 26, 31, 35, 39, 42, 44, 47, 50, 54, 56, 530 60, 62, 66, 69, 72, 74, 77, 83, 85, 88, 531 90 532}; 533 534/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 535static const yytype_int8 yyrhs[] = 536{ 537 20, 0, -1, -1, 20, 21, -1, 20, 22, -1, 538 20, 23, -1, 20, 1, -1, 3, -1, 4, 18, 539 -1, 24, 32, 13, 32, -1, 24, 32, 28, 30, 540 -1, 24, 32, 28, -1, 24, 32, 30, -1, 24, 541 32, -1, 26, -1, 25, 26, -1, 27, 33, -1, 542 27, 33, 29, -1, 11, -1, 10, 32, 11, -1, 543 7, -1, 6, 33, 7, -1, 12, 32, -1, 8, 544 33, -1, 31, -1, 30, 31, -1, 13, 15, 17, 545 16, 32, -1, 18, -1, 32, 18, -1, 9, -1, 546 33, 9, -1 547}; 548 549/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 550static const yytype_uint16 yyrline[] = 551{ 552 0, 168, 168, 170, 171, 172, 173, 178, 186, 194, 553 215, 236, 245, 254, 265, 274, 288, 297, 311, 317, 554 328, 334, 346, 357, 368, 372, 387, 410, 417, 428, 555 435 556}; 557#endif 558 559#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 560/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 561 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 562static const char *const yytname[] = 563{ 564 "$end", "error", "$undefined", "COMMENT", "DOMAIN", "JUNK", 565 "PREV_MSGCTXT", "PREV_MSGID", "PREV_MSGID_PLURAL", "PREV_STRING", 566 "MSGCTXT", "MSGID", "MSGID_PLURAL", "MSGSTR", "NAME", "'['", "']'", 567 "NUMBER", "STRING", "$accept", "po_file", "comment", "domain", "message", 568 "message_intro", "prev", "msg_intro", "prev_msg_intro", 569 "msgid_pluralform", "prev_msgid_pluralform", "pluralform_list", 570 "pluralform", "string_list", "prev_string_list", 0 571}; 572#endif 573 574# ifdef YYPRINT 575/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 576 token YYLEX-NUM. */ 577static const yytype_uint16 yytoknum[] = 578{ 579 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 580 265, 266, 267, 268, 269, 91, 93, 270, 271 581}; 582# endif 583 584/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 585static const yytype_uint8 yyr1[] = 586{ 587 0, 19, 20, 20, 20, 20, 20, 21, 22, 23, 588 23, 23, 23, 23, 24, 24, 25, 25, 26, 26, 589 27, 27, 28, 29, 30, 30, 31, 32, 32, 33, 590 33 591}; 592 593/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 594static const yytype_uint8 yyr2[] = 595{ 596 0, 2, 0, 2, 2, 2, 2, 1, 2, 4, 597 4, 3, 3, 2, 1, 2, 2, 3, 1, 3, 598 1, 3, 2, 2, 1, 2, 5, 1, 2, 1, 599 2 600}; 601 602/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 603 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 604 means the default is an error. */ 605static const yytype_uint8 yydefact[] = 606{ 607 2, 0, 1, 6, 7, 0, 0, 20, 0, 18, 608 3, 4, 5, 0, 0, 14, 0, 8, 29, 0, 609 27, 0, 13, 15, 16, 21, 30, 19, 28, 0, 610 0, 11, 12, 24, 0, 17, 22, 0, 9, 0, 611 10, 25, 23, 0, 0, 26 612}; 613 614/* YYDEFGOTO[NTERM-NUM]. */ 615static const yytype_int8 yydefgoto[] = 616{ 617 -1, 1, 10, 11, 12, 13, 14, 15, 16, 31, 618 35, 32, 33, 21, 19 619}; 620 621/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 622 STATE-NUM. */ 623#define YYPACT_NINF -26 624static const yytype_int8 yypact[] = 625{ 626 -26, 2, -26, -26, -26, -8, 5, -26, 0, -26, 627 -26, -26, -26, 0, 13, -26, 5, -26, -26, 20, 628 -26, -7, 8, -26, 24, -26, -26, -26, -26, 0, 629 7, 15, 15, -26, 5, -26, 12, 17, 12, 21, 630 15, -26, 26, 22, 0, 12 631}; 632 633/* YYPGOTO[NTERM-NUM]. */ 634static const yytype_int8 yypgoto[] = 635{ 636 -26, -26, -26, -26, -26, -26, -26, 23, -26, -26, 637 -26, 9, -25, -13, -15 638}; 639 640/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 641 positive, shift that token. If negative, reduce the rule which 642 number is the opposite. If zero, do what YYDEFACT says. 643 If YYTABLE_NINF, syntax error. */ 644#define YYTABLE_NINF -1 645static const yytype_uint8 yytable[] = 646{ 647 22, 24, 2, 3, 27, 4, 5, 41, 6, 7, 648 17, 28, 8, 9, 18, 41, 36, 38, 20, 42, 649 29, 30, 37, 8, 9, 20, 28, 25, 39, 26, 650 28, 45, 34, 26, 43, 26, 37, 23, 44, 0, 651 40 652}; 653 654static const yytype_int8 yycheck[] = 655{ 656 13, 16, 0, 1, 11, 3, 4, 32, 6, 7, 657 18, 18, 10, 11, 9, 40, 29, 30, 18, 34, 658 12, 13, 15, 10, 11, 18, 18, 7, 13, 9, 659 18, 44, 8, 9, 17, 9, 15, 14, 16, -1, 660 31 661}; 662 663/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 664 symbol of state STATE-NUM. */ 665static const yytype_uint8 yystos[] = 666{ 667 0, 20, 0, 1, 3, 4, 6, 7, 10, 11, 668 21, 22, 23, 24, 25, 26, 27, 18, 9, 33, 669 18, 32, 32, 26, 33, 7, 9, 11, 18, 12, 670 13, 28, 30, 31, 8, 29, 32, 15, 32, 13, 671 30, 31, 33, 17, 16, 32 672}; 673 674#define yyerrok (yyerrstatus = 0) 675#define yyclearin (yychar = YYEMPTY) 676#define YYEMPTY (-2) 677#define YYEOF 0 678 679#define YYACCEPT goto yyacceptlab 680#define YYABORT goto yyabortlab 681#define YYERROR goto yyerrorlab 682 683 684/* Like YYERROR except do call yyerror. This remains here temporarily 685 to ease the transition to the new meaning of YYERROR, for GCC. 686 Once GCC version 2 has supplanted version 1, this can go. */ 687 688#define YYFAIL goto yyerrlab 689 690#define YYRECOVERING() (!!yyerrstatus) 691 692#define YYBACKUP(Token, Value) \ 693do \ 694 if (yychar == YYEMPTY && yylen == 1) \ 695 { \ 696 yychar = (Token); \ 697 yylval = (Value); \ 698 yytoken = YYTRANSLATE (yychar); \ 699 YYPOPSTACK (1); \ 700 goto yybackup; \ 701 } \ 702 else \ 703 { \ 704 yyerror (YY_("syntax error: cannot back up")); \ 705 YYERROR; \ 706 } \ 707while (YYID (0)) 708 709 710#define YYTERROR 1 711#define YYERRCODE 256 712 713 714/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 715 If N is 0, then set CURRENT to the empty location which ends 716 the previous symbol: RHS[0] (always defined). */ 717 718#define YYRHSLOC(Rhs, K) ((Rhs)[K]) 719#ifndef YYLLOC_DEFAULT 720# define YYLLOC_DEFAULT(Current, Rhs, N) \ 721 do \ 722 if (YYID (N)) \ 723 { \ 724 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 725 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 726 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 727 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 728 } \ 729 else \ 730 { \ 731 (Current).first_line = (Current).last_line = \ 732 YYRHSLOC (Rhs, 0).last_line; \ 733 (Current).first_column = (Current).last_column = \ 734 YYRHSLOC (Rhs, 0).last_column; \ 735 } \ 736 while (YYID (0)) 737#endif 738 739 740/* YY_LOCATION_PRINT -- Print the location on the stream. 741 This macro was not mandated originally: define only if we know 742 we won't break user code: when these are the locations we know. */ 743 744#ifndef YY_LOCATION_PRINT 745# if YYLTYPE_IS_TRIVIAL 746# define YY_LOCATION_PRINT(File, Loc) \ 747 fprintf (File, "%d.%d-%d.%d", \ 748 (Loc).first_line, (Loc).first_column, \ 749 (Loc).last_line, (Loc).last_column) 750# else 751# define YY_LOCATION_PRINT(File, Loc) ((void) 0) 752# endif 753#endif 754 755 756/* YYLEX -- calling `yylex' with the right arguments. */ 757 758#ifdef YYLEX_PARAM 759# define YYLEX yylex (YYLEX_PARAM) 760#else 761# define YYLEX yylex () 762#endif 763 764/* Enable debugging if requested. */ 765#if YYDEBUG 766 767# ifndef YYFPRINTF 768# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 769# define YYFPRINTF fprintf 770# endif 771 772# define YYDPRINTF(Args) \ 773do { \ 774 if (yydebug) \ 775 YYFPRINTF Args; \ 776} while (YYID (0)) 777 778# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 779do { \ 780 if (yydebug) \ 781 { \ 782 YYFPRINTF (stderr, "%s ", Title); \ 783 yy_symbol_print (stderr, \ 784 Type, Value); \ 785 YYFPRINTF (stderr, "\n"); \ 786 } \ 787} while (YYID (0)) 788 789 790/*--------------------------------. 791| Print this symbol on YYOUTPUT. | 792`--------------------------------*/ 793 794/*ARGSUSED*/ 795#if (defined __STDC__ || defined __C99__FUNC__ \ 796 || defined __cplusplus || defined _MSC_VER) 797static void 798yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 799#else 800static void 801yy_symbol_value_print (yyoutput, yytype, yyvaluep) 802 FILE *yyoutput; 803 int yytype; 804 YYSTYPE const * const yyvaluep; 805#endif 806{ 807 if (!yyvaluep) 808 return; 809# ifdef YYPRINT 810 if (yytype < YYNTOKENS) 811 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 812# else 813 YYUSE (yyoutput); 814# endif 815 switch (yytype) 816 { 817 default: 818 break; 819 } 820} 821 822 823/*--------------------------------. 824| Print this symbol on YYOUTPUT. | 825`--------------------------------*/ 826 827#if (defined __STDC__ || defined __C99__FUNC__ \ 828 || defined __cplusplus || defined _MSC_VER) 829static void 830yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 831#else 832static void 833yy_symbol_print (yyoutput, yytype, yyvaluep) 834 FILE *yyoutput; 835 int yytype; 836 YYSTYPE const * const yyvaluep; 837#endif 838{ 839 if (yytype < YYNTOKENS) 840 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 841 else 842 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 843 844 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 845 YYFPRINTF (yyoutput, ")"); 846} 847 848/*------------------------------------------------------------------. 849| yy_stack_print -- Print the state stack from its BOTTOM up to its | 850| TOP (included). | 851`------------------------------------------------------------------*/ 852 853#if (defined __STDC__ || defined __C99__FUNC__ \ 854 || defined __cplusplus || defined _MSC_VER) 855static void 856yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) 857#else 858static void 859yy_stack_print (bottom, top) 860 yytype_int16 *bottom; 861 yytype_int16 *top; 862#endif 863{ 864 YYFPRINTF (stderr, "Stack now"); 865 for (; bottom <= top; ++bottom) 866 YYFPRINTF (stderr, " %d", *bottom); 867 YYFPRINTF (stderr, "\n"); 868} 869 870# define YY_STACK_PRINT(Bottom, Top) \ 871do { \ 872 if (yydebug) \ 873 yy_stack_print ((Bottom), (Top)); \ 874} while (YYID (0)) 875 876 877/*------------------------------------------------. 878| Report that the YYRULE is going to be reduced. | 879`------------------------------------------------*/ 880 881#if (defined __STDC__ || defined __C99__FUNC__ \ 882 || defined __cplusplus || defined _MSC_VER) 883static void 884yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 885#else 886static void 887yy_reduce_print (yyvsp, yyrule) 888 YYSTYPE *yyvsp; 889 int yyrule; 890#endif 891{ 892 int yynrhs = yyr2[yyrule]; 893 int yyi; 894 unsigned long int yylno = yyrline[yyrule]; 895 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 896 yyrule - 1, yylno); 897 /* The symbols being reduced. */ 898 for (yyi = 0; yyi < yynrhs; yyi++) 899 { 900 fprintf (stderr, " $%d = ", yyi + 1); 901 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 902 &(yyvsp[(yyi + 1) - (yynrhs)]) 903 ); 904 fprintf (stderr, "\n"); 905 } 906} 907 908# define YY_REDUCE_PRINT(Rule) \ 909do { \ 910 if (yydebug) \ 911 yy_reduce_print (yyvsp, Rule); \ 912} while (YYID (0)) 913 914/* Nonzero means print parse trace. It is left uninitialized so that 915 multiple parsers can coexist. */ 916int yydebug; 917#else /* !YYDEBUG */ 918# define YYDPRINTF(Args) 919# define YY_SYMBOL_PRINT(Title, Type, Value, Location) 920# define YY_STACK_PRINT(Bottom, Top) 921# define YY_REDUCE_PRINT(Rule) 922#endif /* !YYDEBUG */ 923 924 925/* YYINITDEPTH -- initial size of the parser's stacks. */ 926#ifndef YYINITDEPTH 927# define YYINITDEPTH 200 928#endif 929 930/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 931 if the built-in stack extension method is used). 932 933 Do not make this value too large; the results are undefined if 934 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 935 evaluated with infinite-precision integer arithmetic. */ 936 937#ifndef YYMAXDEPTH 938# define YYMAXDEPTH 10000 939#endif 940 941 942 943#if YYERROR_VERBOSE 944 945# ifndef yystrlen 946# if defined __GLIBC__ && defined _STRING_H 947# define yystrlen strlen 948# else 949/* Return the length of YYSTR. */ 950#if (defined __STDC__ || defined __C99__FUNC__ \ 951 || defined __cplusplus || defined _MSC_VER) 952static YYSIZE_T 953yystrlen (const char *yystr) 954#else 955static YYSIZE_T 956yystrlen (yystr) 957 const char *yystr; 958#endif 959{ 960 YYSIZE_T yylen; 961 for (yylen = 0; yystr[yylen]; yylen++) 962 continue; 963 return yylen; 964} 965# endif 966# endif 967 968# ifndef yystpcpy 969# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 970# define yystpcpy stpcpy 971# else 972/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 973 YYDEST. */ 974#if (defined __STDC__ || defined __C99__FUNC__ \ 975 || defined __cplusplus || defined _MSC_VER) 976static char * 977yystpcpy (char *yydest, const char *yysrc) 978#else 979static char * 980yystpcpy (yydest, yysrc) 981 char *yydest; 982 const char *yysrc; 983#endif 984{ 985 char *yyd = yydest; 986 const char *yys = yysrc; 987 988 while ((*yyd++ = *yys++) != '\0') 989 continue; 990 991 return yyd - 1; 992} 993# endif 994# endif 995 996# ifndef yytnamerr 997/* Copy to YYRES the contents of YYSTR after stripping away unnecessary 998 quotes and backslashes, so that it's suitable for yyerror. The 999 heuristic is that double-quoting is unnecessary unless the string 1000 contains an apostrophe, a comma, or backslash (other than 1001 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1002 null, do not copy; instead, return the length of what the result 1003 would have been. */ 1004static YYSIZE_T 1005yytnamerr (char *yyres, const char *yystr) 1006{ 1007 if (*yystr == '"') 1008 { 1009 YYSIZE_T yyn = 0; 1010 char const *yyp = yystr; 1011 1012 for (;;) 1013 switch (*++yyp) 1014 { 1015 case '\'': 1016 case ',': 1017 goto do_not_strip_quotes; 1018 1019 case '\\': 1020 if (*++yyp != '\\') 1021 goto do_not_strip_quotes; 1022 /* Fall through. */ 1023 default: 1024 if (yyres) 1025 yyres[yyn] = *yyp; 1026 yyn++; 1027 break; 1028 1029 case '"': 1030 if (yyres) 1031 yyres[yyn] = '\0'; 1032 return yyn; 1033 } 1034 do_not_strip_quotes: ; 1035 } 1036 1037 if (! yyres) 1038 return yystrlen (yystr); 1039 1040 return yystpcpy (yyres, yystr) - yyres; 1041} 1042# endif 1043 1044/* Copy into YYRESULT an error message about the unexpected token 1045 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1046 including the terminating null byte. If YYRESULT is null, do not 1047 copy anything; just return the number of bytes that would be 1048 copied. As a special case, return 0 if an ordinary "syntax error" 1049 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1050 size calculation. */ 1051static YYSIZE_T 1052yysyntax_error (char *yyresult, int yystate, int yychar) 1053{ 1054 int yyn = yypact[yystate]; 1055 1056 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1057 return 0; 1058 else 1059 { 1060 int yytype = YYTRANSLATE (yychar); 1061 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1062 YYSIZE_T yysize = yysize0; 1063 YYSIZE_T yysize1; 1064 int yysize_overflow = 0; 1065 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1066 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1067 int yyx; 1068 1069# if 0 1070 /* This is so xgettext sees the translatable formats that are 1071 constructed on the fly. */ 1072 YY_("syntax error, unexpected %s"); 1073 YY_("syntax error, unexpected %s, expecting %s"); 1074 YY_("syntax error, unexpected %s, expecting %s or %s"); 1075 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1076 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1077# endif 1078 char *yyfmt; 1079 char const *yyf; 1080 static char const yyunexpected[] = "syntax error, unexpected %s"; 1081 static char const yyexpecting[] = ", expecting %s"; 1082 static char const yyor[] = " or %s"; 1083 char yyformat[sizeof yyunexpected 1084 + sizeof yyexpecting - 1 1085 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1086 * (sizeof yyor - 1))]; 1087 char const *yyprefix = yyexpecting; 1088 1089 /* Start YYX at -YYN if negative to avoid negative indexes in 1090 YYCHECK. */ 1091 int yyxbegin = yyn < 0 ? -yyn : 0; 1092 1093 /* Stay within bounds of both yycheck and yytname. */ 1094 int yychecklim = YYLAST - yyn + 1; 1095 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1096 int yycount = 1; 1097 1098 yyarg[0] = yytname[yytype]; 1099 yyfmt = yystpcpy (yyformat, yyunexpected); 1100 1101 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1102 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1103 { 1104 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1105 { 1106 yycount = 1; 1107 yysize = yysize0; 1108 yyformat[sizeof yyunexpected - 1] = '\0'; 1109 break; 1110 } 1111 yyarg[yycount++] = yytname[yyx]; 1112 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1113 yysize_overflow |= (yysize1 < yysize); 1114 yysize = yysize1; 1115 yyfmt = yystpcpy (yyfmt, yyprefix); 1116 yyprefix = yyor; 1117 } 1118 1119 yyf = YY_(yyformat); 1120 yysize1 = yysize + yystrlen (yyf); 1121 yysize_overflow |= (yysize1 < yysize); 1122 yysize = yysize1; 1123 1124 if (yysize_overflow) 1125 return YYSIZE_MAXIMUM; 1126 1127 if (yyresult) 1128 { 1129 /* Avoid sprintf, as that infringes on the user's name space. 1130 Don't have undefined behavior even if the translation 1131 produced a string with the wrong number of "%s"s. */ 1132 char *yyp = yyresult; 1133 int yyi = 0; 1134 while ((*yyp = *yyf) != '\0') 1135 { 1136 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1137 { 1138 yyp += yytnamerr (yyp, yyarg[yyi++]); 1139 yyf += 2; 1140 } 1141 else 1142 { 1143 yyp++; 1144 yyf++; 1145 } 1146 } 1147 } 1148 return yysize; 1149 } 1150} 1151#endif /* YYERROR_VERBOSE */ 1152 1153 1154/*-----------------------------------------------. 1155| Release the memory associated to this symbol. | 1156`-----------------------------------------------*/ 1157 1158/*ARGSUSED*/ 1159#if (defined __STDC__ || defined __C99__FUNC__ \ 1160 || defined __cplusplus || defined _MSC_VER) 1161static void 1162yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1163#else 1164static void 1165yydestruct (yymsg, yytype, yyvaluep) 1166 const char *yymsg; 1167 int yytype; 1168 YYSTYPE *yyvaluep; 1169#endif 1170{ 1171 YYUSE (yyvaluep); 1172 1173 if (!yymsg) 1174 yymsg = "Deleting"; 1175 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1176 1177 switch (yytype) 1178 { 1179 1180 default: 1181 break; 1182 } 1183} 1184 1185 1186/* Prevent warnings from -Wmissing-prototypes. */ 1187 1188#ifdef YYPARSE_PARAM 1189#if defined __STDC__ || defined __cplusplus 1190int yyparse (void *YYPARSE_PARAM); 1191#else 1192int yyparse (); 1193#endif 1194#else /* ! YYPARSE_PARAM */ 1195#if defined __STDC__ || defined __cplusplus 1196int yyparse (void); 1197#else 1198int yyparse (); 1199#endif 1200#endif /* ! YYPARSE_PARAM */ 1201 1202 1203 1204/* The look-ahead symbol. */ 1205int yychar; 1206 1207/* The semantic value of the look-ahead symbol. */ 1208YYSTYPE yylval; 1209 1210/* Number of syntax errors so far. */ 1211int yynerrs; 1212 1213 1214 1215/*----------. 1216| yyparse. | 1217`----------*/ 1218 1219#ifdef YYPARSE_PARAM 1220#if (defined __STDC__ || defined __C99__FUNC__ \ 1221 || defined __cplusplus || defined _MSC_VER) 1222int 1223yyparse (void *YYPARSE_PARAM) 1224#else 1225int 1226yyparse (YYPARSE_PARAM) 1227 void *YYPARSE_PARAM; 1228#endif 1229#else /* ! YYPARSE_PARAM */ 1230#if (defined __STDC__ || defined __C99__FUNC__ \ 1231 || defined __cplusplus || defined _MSC_VER) 1232int 1233yyparse (void) 1234#else 1235int 1236yyparse () 1237 1238#endif 1239#endif 1240{ 1241 1242 int yystate; 1243 int yyn; 1244 int yyresult; 1245 /* Number of tokens to shift before error messages enabled. */ 1246 int yyerrstatus; 1247 /* Look-ahead token as an internal (translated) token number. */ 1248 int yytoken = 0; 1249#if YYERROR_VERBOSE 1250 /* Buffer for error messages, and its allocated size. */ 1251 char yymsgbuf[128]; 1252 char *yymsg = yymsgbuf; 1253 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1254#endif 1255 1256 /* Three stacks and their tools: 1257 `yyss': related to states, 1258 `yyvs': related to semantic values, 1259 `yyls': related to locations. 1260 1261 Refer to the stacks thru separate pointers, to allow yyoverflow 1262 to reallocate them elsewhere. */ 1263 1264 /* The state stack. */ 1265 yytype_int16 yyssa[YYINITDEPTH]; 1266 yytype_int16 *yyss = yyssa; 1267 yytype_int16 *yyssp; 1268 1269 /* The semantic value stack. */ 1270 YYSTYPE yyvsa[YYINITDEPTH]; 1271 YYSTYPE *yyvs = yyvsa; 1272 YYSTYPE *yyvsp; 1273 1274 1275 1276#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1277 1278 YYSIZE_T yystacksize = YYINITDEPTH; 1279 1280 /* The variables used to return semantic value and location from the 1281 action routines. */ 1282 YYSTYPE yyval; 1283 1284 1285 /* The number of symbols on the RHS of the reduced rule. 1286 Keep to zero when no symbol should be popped. */ 1287 int yylen = 0; 1288 1289 YYDPRINTF ((stderr, "Starting parse\n")); 1290 1291 yystate = 0; 1292 yyerrstatus = 0; 1293 yynerrs = 0; 1294 yychar = YYEMPTY; /* Cause a token to be read. */ 1295 1296 /* Initialize stack pointers. 1297 Waste one element of value and location stack 1298 so that they stay on the same level as the state stack. 1299 The wasted elements are never initialized. */ 1300 1301 yyssp = yyss; 1302 yyvsp = yyvs; 1303 1304 goto yysetstate; 1305 1306/*------------------------------------------------------------. 1307| yynewstate -- Push a new state, which is found in yystate. | 1308`------------------------------------------------------------*/ 1309 yynewstate: 1310 /* In all cases, when you get here, the value and location stacks 1311 have just been pushed. So pushing a state here evens the stacks. */ 1312 yyssp++; 1313 1314 yysetstate: 1315 *yyssp = yystate; 1316 1317 if (yyss + yystacksize - 1 <= yyssp) 1318 { 1319 /* Get the current used size of the three stacks, in elements. */ 1320 YYSIZE_T yysize = yyssp - yyss + 1; 1321 1322#ifdef yyoverflow 1323 { 1324 /* Give user a chance to reallocate the stack. Use copies of 1325 these so that the &'s don't force the real ones into 1326 memory. */ 1327 YYSTYPE *yyvs1 = yyvs; 1328 yytype_int16 *yyss1 = yyss; 1329 1330 1331 /* Each stack pointer address is followed by the size of the 1332 data in use in that stack, in bytes. This used to be a 1333 conditional around just the two extra args, but that might 1334 be undefined if yyoverflow is a macro. */ 1335 yyoverflow (YY_("memory exhausted"), 1336 &yyss1, yysize * sizeof (*yyssp), 1337 &yyvs1, yysize * sizeof (*yyvsp), 1338 1339 &yystacksize); 1340 1341 yyss = yyss1; 1342 yyvs = yyvs1; 1343 } 1344#else /* no yyoverflow */ 1345# ifndef YYSTACK_RELOCATE 1346 goto yyexhaustedlab; 1347# else 1348 /* Extend the stack our own way. */ 1349 if (YYMAXDEPTH <= yystacksize) 1350 goto yyexhaustedlab; 1351 yystacksize *= 2; 1352 if (YYMAXDEPTH < yystacksize) 1353 yystacksize = YYMAXDEPTH; 1354 1355 { 1356 yytype_int16 *yyss1 = yyss; 1357 union yyalloc *yyptr = 1358 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1359 if (! yyptr) 1360 goto yyexhaustedlab; 1361 YYSTACK_RELOCATE (yyss); 1362 YYSTACK_RELOCATE (yyvs); 1363 1364# undef YYSTACK_RELOCATE 1365 if (yyss1 != yyssa) 1366 YYSTACK_FREE (yyss1); 1367 } 1368# endif 1369#endif /* no yyoverflow */ 1370 1371 yyssp = yyss + yysize - 1; 1372 yyvsp = yyvs + yysize - 1; 1373 1374 1375 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1376 (unsigned long int) yystacksize)); 1377 1378 if (yyss + yystacksize - 1 <= yyssp) 1379 YYABORT; 1380 } 1381 1382 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1383 1384 goto yybackup; 1385 1386/*-----------. 1387| yybackup. | 1388`-----------*/ 1389yybackup: 1390 1391 /* Do appropriate processing given the current state. Read a 1392 look-ahead token if we need one and don't already have one. */ 1393 1394 /* First try to decide what to do without reference to look-ahead token. */ 1395 yyn = yypact[yystate]; 1396 if (yyn == YYPACT_NINF) 1397 goto yydefault; 1398 1399 /* Not known => get a look-ahead token if don't already have one. */ 1400 1401 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1402 if (yychar == YYEMPTY) 1403 { 1404 YYDPRINTF ((stderr, "Reading a token: ")); 1405 yychar = YYLEX; 1406 } 1407 1408 if (yychar <= YYEOF) 1409 { 1410 yychar = yytoken = YYEOF; 1411 YYDPRINTF ((stderr, "Now at end of input.\n")); 1412 } 1413 else 1414 { 1415 yytoken = YYTRANSLATE (yychar); 1416 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1417 } 1418 1419 /* If the proper action on seeing token YYTOKEN is to reduce or to 1420 detect an error, take that action. */ 1421 yyn += yytoken; 1422 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1423 goto yydefault; 1424 yyn = yytable[yyn]; 1425 if (yyn <= 0) 1426 { 1427 if (yyn == 0 || yyn == YYTABLE_NINF) 1428 goto yyerrlab; 1429 yyn = -yyn; 1430 goto yyreduce; 1431 } 1432 1433 if (yyn == YYFINAL) 1434 YYACCEPT; 1435 1436 /* Count tokens shifted since error; after three, turn off error 1437 status. */ 1438 if (yyerrstatus) 1439 yyerrstatus--; 1440 1441 /* Shift the look-ahead token. */ 1442 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1443 1444 /* Discard the shifted token unless it is eof. */ 1445 if (yychar != YYEOF) 1446 yychar = YYEMPTY; 1447 1448 yystate = yyn; 1449 *++yyvsp = yylval; 1450 1451 goto yynewstate; 1452 1453 1454/*-----------------------------------------------------------. 1455| yydefault -- do the default action for the current state. | 1456`-----------------------------------------------------------*/ 1457yydefault: 1458 yyn = yydefact[yystate]; 1459 if (yyn == 0) 1460 goto yyerrlab; 1461 goto yyreduce; 1462 1463 1464/*-----------------------------. 1465| yyreduce -- Do a reduction. | 1466`-----------------------------*/ 1467yyreduce: 1468 /* yyn is the number of a rule to reduce with. */ 1469 yylen = yyr2[yyn]; 1470 1471 /* If YYLEN is nonzero, implement the default value of the action: 1472 `$$ = $1'. 1473 1474 Otherwise, the following line sets YYVAL to garbage. 1475 This behavior is undocumented and Bison 1476 users should not rely upon it. Assigning to YYVAL 1477 unconditionally makes the parser a bit smaller, and it avoids a 1478 GCC warning that YYVAL may be used uninitialized. */ 1479 yyval = yyvsp[1-yylen]; 1480 1481 1482 YY_REDUCE_PRINT (yyn); 1483 switch (yyn) 1484 { 1485 case 7: 1486#line 179 "po-gram-gen.y" 1487 { 1488 po_callback_comment_dispatcher ((yyvsp[(1) - (1)].string).string); 1489 } 1490 break; 1491 1492 case 8: 1493#line 187 "po-gram-gen.y" 1494 { 1495 po_callback_domain ((yyvsp[(2) - (2)].string).string); 1496 } 1497 break; 1498 1499 case 9: 1500#line 195 "po-gram-gen.y" 1501 { 1502 char *string2 = string_list_concat_destroy (&(yyvsp[(2) - (4)].stringlist).stringlist); 1503 char *string4 = string_list_concat_destroy (&(yyvsp[(4) - (4)].stringlist).stringlist); 1504 1505 check_obsolete ((yyvsp[(1) - (4)].message_intro), (yyvsp[(2) - (4)].stringlist)); 1506 check_obsolete ((yyvsp[(1) - (4)].message_intro), (yyvsp[(3) - (4)].pos)); 1507 check_obsolete ((yyvsp[(1) - (4)].message_intro), (yyvsp[(4) - (4)].stringlist)); 1508 if (!(yyvsp[(1) - (4)].message_intro).obsolete || pass_obsolete_entries) 1509 do_callback_message ((yyvsp[(1) - (4)].message_intro).ctxt, string2, &(yyvsp[(1) - (4)].message_intro).pos, NULL, 1510 string4, strlen (string4) + 1, &(yyvsp[(3) - (4)].pos).pos, 1511 (yyvsp[(1) - (4)].message_intro).prev_ctxt, 1512 (yyvsp[(1) - (4)].message_intro).prev_id, (yyvsp[(1) - (4)].message_intro).prev_id_plural, 1513 (yyvsp[(1) - (4)].message_intro).obsolete); 1514 else 1515 { 1516 free_message_intro ((yyvsp[(1) - (4)].message_intro)); 1517 free (string2); 1518 free (string4); 1519 } 1520 } 1521 break; 1522 1523 case 10: 1524#line 216 "po-gram-gen.y" 1525 { 1526 char *string2 = string_list_concat_destroy (&(yyvsp[(2) - (4)].stringlist).stringlist); 1527 1528 check_obsolete ((yyvsp[(1) - (4)].message_intro), (yyvsp[(2) - (4)].stringlist)); 1529 check_obsolete ((yyvsp[(1) - (4)].message_intro), (yyvsp[(3) - (4)].string)); 1530 check_obsolete ((yyvsp[(1) - (4)].message_intro), (yyvsp[(4) - (4)].rhs)); 1531 if (!(yyvsp[(1) - (4)].message_intro).obsolete || pass_obsolete_entries) 1532 do_callback_message ((yyvsp[(1) - (4)].message_intro).ctxt, string2, &(yyvsp[(1) - (4)].message_intro).pos, (yyvsp[(3) - (4)].string).string, 1533 (yyvsp[(4) - (4)].rhs).rhs.msgstr, (yyvsp[(4) - (4)].rhs).rhs.msgstr_len, &(yyvsp[(4) - (4)].rhs).pos, 1534 (yyvsp[(1) - (4)].message_intro).prev_ctxt, 1535 (yyvsp[(1) - (4)].message_intro).prev_id, (yyvsp[(1) - (4)].message_intro).prev_id_plural, 1536 (yyvsp[(1) - (4)].message_intro).obsolete); 1537 else 1538 { 1539 free_message_intro ((yyvsp[(1) - (4)].message_intro)); 1540 free (string2); 1541 free ((yyvsp[(3) - (4)].string).string); 1542 free ((yyvsp[(4) - (4)].rhs).rhs.msgstr); 1543 } 1544 } 1545 break; 1546 1547 case 11: 1548#line 237 "po-gram-gen.y" 1549 { 1550 check_obsolete ((yyvsp[(1) - (3)].message_intro), (yyvsp[(2) - (3)].stringlist)); 1551 check_obsolete ((yyvsp[(1) - (3)].message_intro), (yyvsp[(3) - (3)].string)); 1552 po_gram_error_at_line (&(yyvsp[(1) - (3)].message_intro).pos, _("missing `msgstr[]' section")); 1553 free_message_intro ((yyvsp[(1) - (3)].message_intro)); 1554 string_list_destroy (&(yyvsp[(2) - (3)].stringlist).stringlist); 1555 free ((yyvsp[(3) - (3)].string).string); 1556 } 1557 break; 1558 1559 case 12: 1560#line 246 "po-gram-gen.y" 1561 { 1562 check_obsolete ((yyvsp[(1) - (3)].message_intro), (yyvsp[(2) - (3)].stringlist)); 1563 check_obsolete ((yyvsp[(1) - (3)].message_intro), (yyvsp[(3) - (3)].rhs)); 1564 po_gram_error_at_line (&(yyvsp[(1) - (3)].message_intro).pos, _("missing `msgid_plural' section")); 1565 free_message_intro ((yyvsp[(1) - (3)].message_intro)); 1566 string_list_destroy (&(yyvsp[(2) - (3)].stringlist).stringlist); 1567 free ((yyvsp[(3) - (3)].rhs).rhs.msgstr); 1568 } 1569 break; 1570 1571 case 13: 1572#line 255 "po-gram-gen.y" 1573 { 1574 check_obsolete ((yyvsp[(1) - (2)].message_intro), (yyvsp[(2) - (2)].stringlist)); 1575 po_gram_error_at_line (&(yyvsp[(1) - (2)].message_intro).pos, _("missing `msgstr' section")); 1576 free_message_intro ((yyvsp[(1) - (2)].message_intro)); 1577 string_list_destroy (&(yyvsp[(2) - (2)].stringlist).stringlist); 1578 } 1579 break; 1580 1581 case 14: 1582#line 266 "po-gram-gen.y" 1583 { 1584 (yyval.message_intro).prev_ctxt = NULL; 1585 (yyval.message_intro).prev_id = NULL; 1586 (yyval.message_intro).prev_id_plural = NULL; 1587 (yyval.message_intro).ctxt = (yyvsp[(1) - (1)].string).string; 1588 (yyval.message_intro).pos = (yyvsp[(1) - (1)].string).pos; 1589 (yyval.message_intro).obsolete = (yyvsp[(1) - (1)].string).obsolete; 1590 } 1591 break; 1592 1593 case 15: 1594#line 275 "po-gram-gen.y" 1595 { 1596 check_obsolete ((yyvsp[(1) - (2)].prev), (yyvsp[(2) - (2)].string)); 1597 (yyval.message_intro).prev_ctxt = (yyvsp[(1) - (2)].prev).ctxt; 1598 (yyval.message_intro).prev_id = (yyvsp[(1) - (2)].prev).id; 1599 (yyval.message_intro).prev_id_plural = (yyvsp[(1) - (2)].prev).id_plural; 1600 (yyval.message_intro).ctxt = (yyvsp[(2) - (2)].string).string; 1601 (yyval.message_intro).pos = (yyvsp[(2) - (2)].string).pos; 1602 (yyval.message_intro).obsolete = (yyvsp[(2) - (2)].string).obsolete; 1603 } 1604 break; 1605 1606 case 16: 1607#line 289 "po-gram-gen.y" 1608 { 1609 check_obsolete ((yyvsp[(1) - (2)].string), (yyvsp[(2) - (2)].stringlist)); 1610 (yyval.prev).ctxt = (yyvsp[(1) - (2)].string).string; 1611 (yyval.prev).id = string_list_concat_destroy (&(yyvsp[(2) - (2)].stringlist).stringlist); 1612 (yyval.prev).id_plural = NULL; 1613 (yyval.prev).pos = (yyvsp[(1) - (2)].string).pos; 1614 (yyval.prev).obsolete = (yyvsp[(1) - (2)].string).obsolete; 1615 } 1616 break; 1617 1618 case 17: 1619#line 298 "po-gram-gen.y" 1620 { 1621 check_obsolete ((yyvsp[(1) - (3)].string), (yyvsp[(2) - (3)].stringlist)); 1622 check_obsolete ((yyvsp[(1) - (3)].string), (yyvsp[(3) - (3)].string)); 1623 (yyval.prev).ctxt = (yyvsp[(1) - (3)].string).string; 1624 (yyval.prev).id = string_list_concat_destroy (&(yyvsp[(2) - (3)].stringlist).stringlist); 1625 (yyval.prev).id_plural = (yyvsp[(3) - (3)].string).string; 1626 (yyval.prev).pos = (yyvsp[(1) - (3)].string).pos; 1627 (yyval.prev).obsolete = (yyvsp[(1) - (3)].string).obsolete; 1628 } 1629 break; 1630 1631 case 18: 1632#line 312 "po-gram-gen.y" 1633 { 1634 (yyval.string).string = NULL; 1635 (yyval.string).pos = (yyvsp[(1) - (1)].pos).pos; 1636 (yyval.string).obsolete = (yyvsp[(1) - (1)].pos).obsolete; 1637 } 1638 break; 1639 1640 case 19: 1641#line 318 "po-gram-gen.y" 1642 { 1643 check_obsolete ((yyvsp[(1) - (3)].pos), (yyvsp[(2) - (3)].stringlist)); 1644 check_obsolete ((yyvsp[(1) - (3)].pos), (yyvsp[(3) - (3)].pos)); 1645 (yyval.string).string = string_list_concat_destroy (&(yyvsp[(2) - (3)].stringlist).stringlist); 1646 (yyval.string).pos = (yyvsp[(3) - (3)].pos).pos; 1647 (yyval.string).obsolete = (yyvsp[(3) - (3)].pos).obsolete; 1648 } 1649 break; 1650 1651 case 20: 1652#line 329 "po-gram-gen.y" 1653 { 1654 (yyval.string).string = NULL; 1655 (yyval.string).pos = (yyvsp[(1) - (1)].pos).pos; 1656 (yyval.string).obsolete = (yyvsp[(1) - (1)].pos).obsolete; 1657 } 1658 break; 1659 1660 case 21: 1661#line 335 "po-gram-gen.y" 1662 { 1663 check_obsolete ((yyvsp[(1) - (3)].pos), (yyvsp[(2) - (3)].stringlist)); 1664 check_obsolete ((yyvsp[(1) - (3)].pos), (yyvsp[(3) - (3)].pos)); 1665 (yyval.string).string = string_list_concat_destroy (&(yyvsp[(2) - (3)].stringlist).stringlist); 1666 (yyval.string).pos = (yyvsp[(3) - (3)].pos).pos; 1667 (yyval.string).obsolete = (yyvsp[(3) - (3)].pos).obsolete; 1668 } 1669 break; 1670 1671 case 22: 1672#line 347 "po-gram-gen.y" 1673 { 1674 check_obsolete ((yyvsp[(1) - (2)].pos), (yyvsp[(2) - (2)].stringlist)); 1675 plural_counter = 0; 1676 (yyval.string).string = string_list_concat_destroy (&(yyvsp[(2) - (2)].stringlist).stringlist); 1677 (yyval.string).pos = (yyvsp[(1) - (2)].pos).pos; 1678 (yyval.string).obsolete = (yyvsp[(1) - (2)].pos).obsolete; 1679 } 1680 break; 1681 1682 case 23: 1683#line 358 "po-gram-gen.y" 1684 { 1685 check_obsolete ((yyvsp[(1) - (2)].pos), (yyvsp[(2) - (2)].stringlist)); 1686 (yyval.string).string = string_list_concat_destroy (&(yyvsp[(2) - (2)].stringlist).stringlist); 1687 (yyval.string).pos = (yyvsp[(1) - (2)].pos).pos; 1688 (yyval.string).obsolete = (yyvsp[(1) - (2)].pos).obsolete; 1689 } 1690 break; 1691 1692 case 24: 1693#line 369 "po-gram-gen.y" 1694 { 1695 (yyval.rhs) = (yyvsp[(1) - (1)].rhs); 1696 } 1697 break; 1698 1699 case 25: 1700#line 373 "po-gram-gen.y" 1701 { 1702 check_obsolete ((yyvsp[(1) - (2)].rhs), (yyvsp[(2) - (2)].rhs)); 1703 (yyval.rhs).rhs.msgstr = XNMALLOC ((yyvsp[(1) - (2)].rhs).rhs.msgstr_len + (yyvsp[(2) - (2)].rhs).rhs.msgstr_len, char); 1704 memcpy ((yyval.rhs).rhs.msgstr, (yyvsp[(1) - (2)].rhs).rhs.msgstr, (yyvsp[(1) - (2)].rhs).rhs.msgstr_len); 1705 memcpy ((yyval.rhs).rhs.msgstr + (yyvsp[(1) - (2)].rhs).rhs.msgstr_len, (yyvsp[(2) - (2)].rhs).rhs.msgstr, (yyvsp[(2) - (2)].rhs).rhs.msgstr_len); 1706 (yyval.rhs).rhs.msgstr_len = (yyvsp[(1) - (2)].rhs).rhs.msgstr_len + (yyvsp[(2) - (2)].rhs).rhs.msgstr_len; 1707 free ((yyvsp[(1) - (2)].rhs).rhs.msgstr); 1708 free ((yyvsp[(2) - (2)].rhs).rhs.msgstr); 1709 (yyval.rhs).pos = (yyvsp[(1) - (2)].rhs).pos; 1710 (yyval.rhs).obsolete = (yyvsp[(1) - (2)].rhs).obsolete; 1711 } 1712 break; 1713 1714 case 26: 1715#line 388 "po-gram-gen.y" 1716 { 1717 check_obsolete ((yyvsp[(1) - (5)].pos), (yyvsp[(2) - (5)].pos)); 1718 check_obsolete ((yyvsp[(1) - (5)].pos), (yyvsp[(3) - (5)].number)); 1719 check_obsolete ((yyvsp[(1) - (5)].pos), (yyvsp[(4) - (5)].pos)); 1720 check_obsolete ((yyvsp[(1) - (5)].pos), (yyvsp[(5) - (5)].stringlist)); 1721 if ((yyvsp[(3) - (5)].number).number != plural_counter) 1722 { 1723 if (plural_counter == 0) 1724 po_gram_error_at_line (&(yyvsp[(1) - (5)].pos).pos, _("first plural form has nonzero index")); 1725 else 1726 po_gram_error_at_line (&(yyvsp[(1) - (5)].pos).pos, _("plural form has wrong index")); 1727 } 1728 plural_counter++; 1729 (yyval.rhs).rhs.msgstr = string_list_concat_destroy (&(yyvsp[(5) - (5)].stringlist).stringlist); 1730 (yyval.rhs).rhs.msgstr_len = strlen ((yyval.rhs).rhs.msgstr) + 1; 1731 (yyval.rhs).pos = (yyvsp[(1) - (5)].pos).pos; 1732 (yyval.rhs).obsolete = (yyvsp[(1) - (5)].pos).obsolete; 1733 } 1734 break; 1735 1736 case 27: 1737#line 411 "po-gram-gen.y" 1738 { 1739 string_list_init (&(yyval.stringlist).stringlist); 1740 string_list_append (&(yyval.stringlist).stringlist, (yyvsp[(1) - (1)].string).string); 1741 (yyval.stringlist).pos = (yyvsp[(1) - (1)].string).pos; 1742 (yyval.stringlist).obsolete = (yyvsp[(1) - (1)].string).obsolete; 1743 } 1744 break; 1745 1746 case 28: 1747#line 418 "po-gram-gen.y" 1748 { 1749 check_obsolete ((yyvsp[(1) - (2)].stringlist), (yyvsp[(2) - (2)].string)); 1750 (yyval.stringlist).stringlist = (yyvsp[(1) - (2)].stringlist).stringlist; 1751 string_list_append (&(yyval.stringlist).stringlist, (yyvsp[(2) - (2)].string).string); 1752 (yyval.stringlist).pos = (yyvsp[(1) - (2)].stringlist).pos; 1753 (yyval.stringlist).obsolete = (yyvsp[(1) - (2)].stringlist).obsolete; 1754 } 1755 break; 1756 1757 case 29: 1758#line 429 "po-gram-gen.y" 1759 { 1760 string_list_init (&(yyval.stringlist).stringlist); 1761 string_list_append (&(yyval.stringlist).stringlist, (yyvsp[(1) - (1)].string).string); 1762 (yyval.stringlist).pos = (yyvsp[(1) - (1)].string).pos; 1763 (yyval.stringlist).obsolete = (yyvsp[(1) - (1)].string).obsolete; 1764 } 1765 break; 1766 1767 case 30: 1768#line 436 "po-gram-gen.y" 1769 { 1770 check_obsolete ((yyvsp[(1) - (2)].stringlist), (yyvsp[(2) - (2)].string)); 1771 (yyval.stringlist).stringlist = (yyvsp[(1) - (2)].stringlist).stringlist; 1772 string_list_append (&(yyval.stringlist).stringlist, (yyvsp[(2) - (2)].string).string); 1773 (yyval.stringlist).pos = (yyvsp[(1) - (2)].stringlist).pos; 1774 (yyval.stringlist).obsolete = (yyvsp[(1) - (2)].stringlist).obsolete; 1775 } 1776 break; 1777 1778 1779/* Line 1267 of yacc.c. */ 1780#line 1781 "po-gram-gen.c" 1781 default: break; 1782 } 1783 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 1784 1785 YYPOPSTACK (yylen); 1786 yylen = 0; 1787 YY_STACK_PRINT (yyss, yyssp); 1788 1789 *++yyvsp = yyval; 1790 1791 1792 /* Now `shift' the result of the reduction. Determine what state 1793 that goes to, based on the state we popped back to and the rule 1794 number reduced by. */ 1795 1796 yyn = yyr1[yyn]; 1797 1798 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 1799 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 1800 yystate = yytable[yystate]; 1801 else 1802 yystate = yydefgoto[yyn - YYNTOKENS]; 1803 1804 goto yynewstate; 1805 1806 1807/*------------------------------------. 1808| yyerrlab -- here on detecting error | 1809`------------------------------------*/ 1810yyerrlab: 1811 /* If not already recovering from an error, report this error. */ 1812 if (!yyerrstatus) 1813 { 1814 ++yynerrs; 1815#if ! YYERROR_VERBOSE 1816 yyerror (YY_("syntax error")); 1817#else 1818 { 1819 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 1820 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 1821 { 1822 YYSIZE_T yyalloc = 2 * yysize; 1823 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 1824 yyalloc = YYSTACK_ALLOC_MAXIMUM; 1825 if (yymsg != yymsgbuf) 1826 YYSTACK_FREE (yymsg); 1827 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 1828 if (yymsg) 1829 yymsg_alloc = yyalloc; 1830 else 1831 { 1832 yymsg = yymsgbuf; 1833 yymsg_alloc = sizeof yymsgbuf; 1834 } 1835 } 1836 1837 if (0 < yysize && yysize <= yymsg_alloc) 1838 { 1839 (void) yysyntax_error (yymsg, yystate, yychar); 1840 yyerror (yymsg); 1841 } 1842 else 1843 { 1844 yyerror (YY_("syntax error")); 1845 if (yysize != 0) 1846 goto yyexhaustedlab; 1847 } 1848 } 1849#endif 1850 } 1851 1852 1853 1854 if (yyerrstatus == 3) 1855 { 1856 /* If just tried and failed to reuse look-ahead token after an 1857 error, discard it. */ 1858 1859 if (yychar <= YYEOF) 1860 { 1861 /* Return failure if at end of input. */ 1862 if (yychar == YYEOF) 1863 YYABORT; 1864 } 1865 else 1866 { 1867 yydestruct ("Error: discarding", 1868 yytoken, &yylval); 1869 yychar = YYEMPTY; 1870 } 1871 } 1872 1873 /* Else will try to reuse look-ahead token after shifting the error 1874 token. */ 1875 goto yyerrlab1; 1876 1877 1878/*---------------------------------------------------. 1879| yyerrorlab -- error raised explicitly by YYERROR. | 1880`---------------------------------------------------*/ 1881yyerrorlab: 1882 1883 /* Pacify compilers like GCC when the user code never invokes 1884 YYERROR and the label yyerrorlab therefore never appears in user 1885 code. */ 1886 if (/*CONSTCOND*/ 0) 1887 goto yyerrorlab; 1888 1889 /* Do not reclaim the symbols of the rule which action triggered 1890 this YYERROR. */ 1891 YYPOPSTACK (yylen); 1892 yylen = 0; 1893 YY_STACK_PRINT (yyss, yyssp); 1894 yystate = *yyssp; 1895 goto yyerrlab1; 1896 1897 1898/*-------------------------------------------------------------. 1899| yyerrlab1 -- common code for both syntax error and YYERROR. | 1900`-------------------------------------------------------------*/ 1901yyerrlab1: 1902 yyerrstatus = 3; /* Each real token shifted decrements this. */ 1903 1904 for (;;) 1905 { 1906 yyn = yypact[yystate]; 1907 if (yyn != YYPACT_NINF) 1908 { 1909 yyn += YYTERROR; 1910 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 1911 { 1912 yyn = yytable[yyn]; 1913 if (0 < yyn) 1914 break; 1915 } 1916 } 1917 1918 /* Pop the current state because it cannot handle the error token. */ 1919 if (yyssp == yyss) 1920 YYABORT; 1921 1922 1923 yydestruct ("Error: popping", 1924 yystos[yystate], yyvsp); 1925 YYPOPSTACK (1); 1926 yystate = *yyssp; 1927 YY_STACK_PRINT (yyss, yyssp); 1928 } 1929 1930 if (yyn == YYFINAL) 1931 YYACCEPT; 1932 1933 *++yyvsp = yylval; 1934 1935 1936 /* Shift the error token. */ 1937 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 1938 1939 yystate = yyn; 1940 goto yynewstate; 1941 1942 1943/*-------------------------------------. 1944| yyacceptlab -- YYACCEPT comes here. | 1945`-------------------------------------*/ 1946yyacceptlab: 1947 yyresult = 0; 1948 goto yyreturn; 1949 1950/*-----------------------------------. 1951| yyabortlab -- YYABORT comes here. | 1952`-----------------------------------*/ 1953yyabortlab: 1954 yyresult = 1; 1955 goto yyreturn; 1956 1957#ifndef yyoverflow 1958/*-------------------------------------------------. 1959| yyexhaustedlab -- memory exhaustion comes here. | 1960`-------------------------------------------------*/ 1961yyexhaustedlab: 1962 yyerror (YY_("memory exhausted")); 1963 yyresult = 2; 1964 /* Fall through. */ 1965#endif 1966 1967yyreturn: 1968 if (yychar != YYEOF && yychar != YYEMPTY) 1969 yydestruct ("Cleanup: discarding lookahead", 1970 yytoken, &yylval); 1971 /* Do not reclaim the symbols of the rule which action triggered 1972 this YYABORT or YYACCEPT. */ 1973 YYPOPSTACK (yylen); 1974 YY_STACK_PRINT (yyss, yyssp); 1975 while (yyssp != yyss) 1976 { 1977 yydestruct ("Cleanup: popping", 1978 yystos[*yyssp], yyvsp); 1979 YYPOPSTACK (1); 1980 } 1981#ifndef yyoverflow 1982 if (yyss != yyssa) 1983 YYSTACK_FREE (yyss); 1984#endif 1985#if YYERROR_VERBOSE 1986 if (yymsg != yymsgbuf) 1987 YYSTACK_FREE (yymsg); 1988#endif 1989 /* Make sure YYID is used. */ 1990 return YYID (yyresult); 1991} 1992 1993 1994 1995