1 2/* A Bison parser, made by GNU Bison 2.4.1. */ 3 4/* Skeleton implementation for Bison's Yacc-like parsers in C 5 6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 7 Free Software Foundation, Inc. 8 9 This program is free software: you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation, either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22/* As a special exception, you may create a larger work that contains 23 part or all of the Bison parser skeleton and distribute that work 24 under terms of your choice, so long as that work isn't itself a 25 parser generator using the skeleton or a modified version thereof 26 as a parser skeleton. Alternatively, if you modify or redistribute 27 the parser skeleton itself, you may (at your option) remove this 28 special exception, which will cause the skeleton and the resulting 29 Bison output files to be licensed under the GNU General Public 30 License without this special exception. 31 32 This special exception was added by the Free Software Foundation in 33 version 2.2 of Bison. */ 34 35/* C LALR(1) parser skeleton written by Richard Stallman, by 36 simplifying the original so-called "semantic" parser. */ 37 38/* All symbols defined below should begin with yy or YY, to avoid 39 infringing on user name space. This should be done even for local 40 variables, as they might otherwise be expanded by user macros. 41 There are some unavoidable exceptions within include files to 42 define necessary library symbols; they are noted "INFRINGES ON 43 USER NAME SPACE" below. */ 44 45/* Identify Bison output. */ 46#define YYBISON 1 47 48/* Bison version. */ 49#define YYBISON_VERSION "2.4.1" 50 51/* Skeleton name. */ 52#define YYSKELETON_NAME "yacc.c" 53 54/* Pure parsers. */ 55#define YYPURE 0 56 57/* Push parsers. */ 58#define YYPUSH 0 59 60/* Pull parsers. */ 61#define YYPULL 1 62 63/* Using locations. */ 64#define YYLSP_NEEDED 0 65 66 67 68/* Copy the first part of user declarations. */ 69 70/* Line 189 of yacc.c */ 71#line 9 "./parse.y" 72 73/*- 74 * Copyright (c) 1990 The Regents of the University of California. 75 * All rights reserved. 76 * 77 * This code is derived from software contributed to Berkeley by 78 * Vern Paxson. 79 * 80 * The United States Government has rights in this work pursuant 81 * to contract no. DE-AC03-76SF00098 between the United States 82 * Department of Energy and the University of California. 83 * 84 * Redistribution and use in source and binary forms with or without 85 * modification are permitted provided that: (1) source distributions retain 86 * this entire copyright notice and comment, and (2) distributions including 87 * binaries display the following acknowledgement: ``This product includes 88 * software developed by the University of California, Berkeley and its 89 * contributors'' in the documentation or other materials provided with the 90 * distribution and in all advertising materials mentioning features or use 91 * of this software. Neither the name of the University nor the names of 92 * its contributors may be used to endorse or promote products derived from 93 * this software without specific prior written permission. 94 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 95 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 96 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 97 */ 98 99/* $Header: /projects/cvsroot/src/router/flex/parse.y,v 1.1.1.1 2001/04/08 23:53:37 mhuang Exp $ */ 100 101 102/* Some versions of bison are broken in that they use alloca() but don't 103 * declare it properly. The following is the patented (just kidding!) 104 * #ifdef chud to fix the problem, courtesy of Francois Pinard. 105 */ 106#ifdef YYBISON 107/* AIX requires this to be the first thing in the file. What a piece. */ 108# ifdef _AIX 109 #pragma alloca 110# endif 111#endif 112 113#include "flexdef.h" 114 115/* The remainder of the alloca() cruft has to come after including flexdef.h, 116 * so HAVE_ALLOCA_H is (possibly) defined. 117 */ 118#ifdef YYBISON 119# ifdef __GNUC__ 120# ifndef alloca 121# define alloca __builtin_alloca 122# endif 123# else 124# if HAVE_ALLOCA_H 125# include <alloca.h> 126# else 127# ifdef __hpux 128void *alloca (); 129# else 130# ifdef __TURBOC__ 131# include <malloc.h> 132# else 133char *alloca (); 134# endif 135# endif 136# endif 137# endif 138#endif 139 140/* Bletch, ^^^^ that was ugly! */ 141 142 143int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen; 144int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule; 145 146int *scon_stk; 147int scon_stk_ptr; 148 149static int madeany = false; /* whether we've made the '.' character class */ 150int previous_continued_action; /* whether the previous rule's action was '|' */ 151 152/* Expand a POSIX character class expression. */ 153#define CCL_EXPR(func) \ 154 { \ 155 int c; \ 156 for ( c = 0; c < csize; ++c ) \ 157 if ( isascii(c) && func(c) ) \ 158 ccladd( currccl, c ); \ 159 } 160 161/* While POSIX defines isblank(), it's not ANSI C. */ 162#define IS_BLANK(c) ((c) == ' ' || (c) == '\t') 163 164/* On some over-ambitious machines, such as DEC Alpha's, the default 165 * token type is "long" instead of "int"; this leads to problems with 166 * declaring yylval in flexdef.h. But so far, all the yacc's I've seen 167 * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the 168 * following should ensure that the default token type is "int". 169 */ 170#define YYSTYPE int 171 172 173 174/* Line 189 of yacc.c */ 175#line 176 "y.tab.c" 176 177/* Enabling traces. */ 178#ifndef YYDEBUG 179# define YYDEBUG 0 180#endif 181 182/* Enabling verbose error messages. */ 183#ifdef YYERROR_VERBOSE 184# undef YYERROR_VERBOSE 185# define YYERROR_VERBOSE 1 186#else 187# define YYERROR_VERBOSE 0 188#endif 189 190/* Enabling the token table. */ 191#ifndef YYTOKEN_TABLE 192# define YYTOKEN_TABLE 0 193#endif 194 195 196/* Tokens. */ 197#ifndef YYTOKENTYPE 198# define YYTOKENTYPE 199 /* Put the tokens into the symbol table, so that GDB and other debuggers 200 know about them. */ 201 enum yytokentype { 202 CHAR = 258, 203 NUMBER = 259, 204 SECTEND = 260, 205 SCDECL = 261, 206 XSCDECL = 262, 207 NAME = 263, 208 PREVCCL = 264, 209 EOF_OP = 265, 210 OPTION_OP = 266, 211 OPT_OUTFILE = 267, 212 OPT_PREFIX = 268, 213 OPT_YYCLASS = 269, 214 CCE_ALNUM = 270, 215 CCE_ALPHA = 271, 216 CCE_BLANK = 272, 217 CCE_CNTRL = 273, 218 CCE_DIGIT = 274, 219 CCE_GRAPH = 275, 220 CCE_LOWER = 276, 221 CCE_PRINT = 277, 222 CCE_PUNCT = 278, 223 CCE_SPACE = 279, 224 CCE_UPPER = 280, 225 CCE_XDIGIT = 281 226 }; 227#endif 228/* Tokens. */ 229#define CHAR 258 230#define NUMBER 259 231#define SECTEND 260 232#define SCDECL 261 233#define XSCDECL 262 234#define NAME 263 235#define PREVCCL 264 236#define EOF_OP 265 237#define OPTION_OP 266 238#define OPT_OUTFILE 267 239#define OPT_PREFIX 268 240#define OPT_YYCLASS 269 241#define CCE_ALNUM 270 242#define CCE_ALPHA 271 243#define CCE_BLANK 272 244#define CCE_CNTRL 273 245#define CCE_DIGIT 274 246#define CCE_GRAPH 275 247#define CCE_LOWER 276 248#define CCE_PRINT 277 249#define CCE_PUNCT 278 250#define CCE_SPACE 279 251#define CCE_UPPER 280 252#define CCE_XDIGIT 281 253 254 255 256 257#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 258typedef int YYSTYPE; 259# define YYSTYPE_IS_TRIVIAL 1 260# define yystype YYSTYPE /* obsolescent; will be withdrawn */ 261# define YYSTYPE_IS_DECLARED 1 262#endif 263 264 265/* Copy the second part of user declarations. */ 266 267 268/* Line 264 of yacc.c */ 269#line 270 "y.tab.c" 270 271#ifdef short 272# undef short 273#endif 274 275#ifdef YYTYPE_UINT8 276typedef YYTYPE_UINT8 yytype_uint8; 277#else 278typedef unsigned char yytype_uint8; 279#endif 280 281#ifdef YYTYPE_INT8 282typedef YYTYPE_INT8 yytype_int8; 283#elif (defined __STDC__ || defined __C99__FUNC__ \ 284 || defined __cplusplus || defined _MSC_VER) 285typedef signed char yytype_int8; 286#else 287typedef short int yytype_int8; 288#endif 289 290#ifdef YYTYPE_UINT16 291typedef YYTYPE_UINT16 yytype_uint16; 292#else 293typedef unsigned short int yytype_uint16; 294#endif 295 296#ifdef YYTYPE_INT16 297typedef YYTYPE_INT16 yytype_int16; 298#else 299typedef short int yytype_int16; 300#endif 301 302#ifndef YYSIZE_T 303# ifdef __SIZE_TYPE__ 304# define YYSIZE_T __SIZE_TYPE__ 305# elif defined size_t 306# define YYSIZE_T size_t 307# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 308 || defined __cplusplus || defined _MSC_VER) 309# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 310# define YYSIZE_T size_t 311# else 312# define YYSIZE_T unsigned int 313# endif 314#endif 315 316#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 317 318#ifndef YY_ 319# if YYENABLE_NLS 320# if ENABLE_NLS 321# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 322# define YY_(msgid) dgettext ("bison-runtime", msgid) 323# endif 324# endif 325# ifndef YY_ 326# define YY_(msgid) msgid 327# endif 328#endif 329 330/* Suppress unused-variable warnings by "using" E. */ 331#if ! defined lint || defined __GNUC__ 332# define YYUSE(e) ((void) (e)) 333#else 334# define YYUSE(e) /* empty */ 335#endif 336 337/* Identity function, used to suppress warnings about constant conditions. */ 338#ifndef lint 339# define YYID(n) (n) 340#else 341#if (defined __STDC__ || defined __C99__FUNC__ \ 342 || defined __cplusplus || defined _MSC_VER) 343static int 344YYID (int yyi) 345#else 346static int 347YYID (yyi) 348 int yyi; 349#endif 350{ 351 return yyi; 352} 353#endif 354 355#if ! defined yyoverflow || YYERROR_VERBOSE 356 357/* The parser invokes alloca or malloc; define the necessary symbols. */ 358 359# ifdef YYSTACK_USE_ALLOCA 360# if YYSTACK_USE_ALLOCA 361# ifdef __GNUC__ 362# define YYSTACK_ALLOC __builtin_alloca 363# elif defined __BUILTIN_VA_ARG_INCR 364# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 365# elif defined _AIX 366# define YYSTACK_ALLOC __alloca 367# elif defined _MSC_VER 368# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 369# define alloca _alloca 370# else 371# define YYSTACK_ALLOC alloca 372# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 373 || defined __cplusplus || defined _MSC_VER) 374# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 375# ifndef _STDLIB_H 376# define _STDLIB_H 1 377# endif 378# endif 379# endif 380# endif 381# endif 382 383# ifdef YYSTACK_ALLOC 384 /* Pacify GCC's `empty if-body' warning. */ 385# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 386# ifndef YYSTACK_ALLOC_MAXIMUM 387 /* The OS might guarantee only one guard page at the bottom of the stack, 388 and a page size can be as small as 4096 bytes. So we cannot safely 389 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 390 to allow for a few compiler-allocated temporary stack slots. */ 391# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 392# endif 393# else 394# define YYSTACK_ALLOC YYMALLOC 395# define YYSTACK_FREE YYFREE 396# ifndef YYSTACK_ALLOC_MAXIMUM 397# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 398# endif 399# if (defined __cplusplus && ! defined _STDLIB_H \ 400 && ! ((defined YYMALLOC || defined malloc) \ 401 && (defined YYFREE || defined free))) 402# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 403# ifndef _STDLIB_H 404# define _STDLIB_H 1 405# endif 406# endif 407# ifndef YYMALLOC 408# define YYMALLOC malloc 409# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 410 || defined __cplusplus || defined _MSC_VER) 411void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 412# endif 413# endif 414# ifndef YYFREE 415# define YYFREE free 416# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 417 || defined __cplusplus || defined _MSC_VER) 418void free (void *); /* INFRINGES ON USER NAME SPACE */ 419# endif 420# endif 421# endif 422#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 423 424 425#if (! defined yyoverflow \ 426 && (! defined __cplusplus \ 427 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 428 429/* A type that is properly aligned for any stack member. */ 430union yyalloc 431{ 432 yytype_int16 yyss_alloc; 433 YYSTYPE yyvs_alloc; 434}; 435 436/* The size of the maximum gap between one aligned stack and the next. */ 437# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 438 439/* The size of an array large to enough to hold all stacks, each with 440 N elements. */ 441# define YYSTACK_BYTES(N) \ 442 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 443 + YYSTACK_GAP_MAXIMUM) 444 445/* Copy COUNT objects from FROM to TO. The source and destination do 446 not overlap. */ 447# ifndef YYCOPY 448# if defined __GNUC__ && 1 < __GNUC__ 449# define YYCOPY(To, From, Count) \ 450 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 451# else 452# define YYCOPY(To, From, Count) \ 453 do \ 454 { \ 455 YYSIZE_T yyi; \ 456 for (yyi = 0; yyi < (Count); yyi++) \ 457 (To)[yyi] = (From)[yyi]; \ 458 } \ 459 while (YYID (0)) 460# endif 461# endif 462 463/* Relocate STACK from its old location to the new one. The 464 local variables YYSIZE and YYSTACKSIZE give the old and new number of 465 elements in the stack, and YYPTR gives the new location of the 466 stack. Advance YYPTR to a properly aligned location for the next 467 stack. */ 468# define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 469 do \ 470 { \ 471 YYSIZE_T yynewbytes; \ 472 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 473 Stack = &yyptr->Stack_alloc; \ 474 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 475 yyptr += yynewbytes / sizeof (*yyptr); \ 476 } \ 477 while (YYID (0)) 478 479#endif 480 481/* YYFINAL -- State number of the termination state. */ 482#define YYFINAL 3 483/* YYLAST -- Last index in YYTABLE. */ 484#define YYLAST 110 485 486/* YYNTOKENS -- Number of terminals. */ 487#define YYNTOKENS 48 488/* YYNNTS -- Number of nonterminals. */ 489#define YYNNTS 26 490/* YYNRULES -- Number of rules. */ 491#define YYNRULES 76 492/* YYNRULES -- Number of states. */ 493#define YYNSTATES 107 494 495/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 496#define YYUNDEFTOK 2 497#define YYMAXUTOK 281 498 499#define YYTRANSLATE(YYX) \ 500 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 501 502/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 503static const yytype_uint8 yytranslate[] = 504{ 505 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 506 28, 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, 42, 2, 36, 2, 2, 2, 509 43, 44, 34, 39, 35, 47, 41, 38, 2, 2, 510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 511 32, 27, 33, 40, 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, 45, 2, 46, 31, 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, 29, 37, 30, 2, 2, 2, 2, 518 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 521 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 523 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 524 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 530 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 531 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 532 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 533 25, 26 534}; 535 536#if YYDEBUG 537/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 538 YYRHS. */ 539static const yytype_uint8 yyprhs[] = 540{ 541 0, 0, 3, 9, 10, 14, 17, 18, 20, 22, 542 24, 26, 29, 31, 33, 36, 39, 40, 44, 48, 543 52, 58, 64, 65, 66, 69, 71, 73, 75, 76, 544 81, 85, 86, 90, 92, 94, 96, 99, 103, 106, 545 108, 112, 114, 117, 120, 122, 125, 128, 131, 138, 546 144, 149, 151, 153, 155, 159, 163, 165, 169, 174, 547 179, 182, 185, 186, 188, 190, 192, 194, 196, 198, 548 200, 202, 204, 206, 208, 210, 213 549}; 550 551/* YYRHS -- A `-1'-separated list of the rules' RHS. */ 552static const yytype_int8 yyrhs[] = 553{ 554 49, 0, -1, 50, 51, 52, 58, 59, -1, -1, 555 51, 53, 54, -1, 51, 55, -1, -1, 1, -1, 556 5, -1, 6, -1, 7, -1, 54, 8, -1, 8, 557 -1, 1, -1, 11, 56, -1, 56, 57, -1, -1, 558 12, 27, 8, -1, 13, 27, 8, -1, 14, 27, 559 8, -1, 58, 62, 59, 60, 28, -1, 58, 62, 560 29, 58, 30, -1, -1, -1, 31, 65, -1, 65, 561 -1, 10, -1, 1, -1, -1, 32, 61, 63, 33, 562 -1, 32, 34, 33, -1, -1, 63, 35, 64, -1, 563 64, -1, 1, -1, 8, -1, 67, 66, -1, 67, 564 66, 36, -1, 66, 36, -1, 66, -1, 66, 37, 565 68, -1, 68, -1, 66, 38, -1, 68, 69, -1, 566 69, -1, 69, 34, -1, 69, 39, -1, 69, 40, 567 -1, 69, 29, 4, 35, 4, 30, -1, 69, 29, 568 4, 35, 30, -1, 69, 29, 4, 30, -1, 41, 569 -1, 70, -1, 9, -1, 42, 73, 42, -1, 43, 570 66, 44, -1, 3, -1, 45, 71, 46, -1, 45, 571 31, 71, 46, -1, 71, 3, 47, 3, -1, 71, 572 3, -1, 71, 72, -1, -1, 15, -1, 16, -1, 573 17, -1, 18, -1, 19, -1, 20, -1, 21, -1, 574 22, -1, 23, -1, 24, -1, 25, -1, 26, -1, 575 73, 3, -1, -1 576}; 577 578/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 579static const yytype_uint16 yyrline[] = 580{ 581 0, 112, 112, 142, 149, 150, 151, 152, 156, 164, 582 167, 171, 174, 177, 181, 184, 185, 188, 193, 195, 583 199, 201, 203, 207, 219, 255, 279, 302, 307, 310, 584 313, 331, 334, 336, 338, 342, 365, 420, 423, 466, 585 484, 490, 495, 522, 530, 534, 541, 547, 553, 581, 586 595, 614, 636, 654, 661, 664, 667, 678, 681, 688, 587 716, 727, 735, 742, 743, 744, 745, 746, 747, 748, 588 749, 750, 751, 752, 758, 761, 772 589}; 590#endif 591 592#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 593/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 594 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 595static const char *const yytname[] = 596{ 597 "$end", "error", "$undefined", "CHAR", "NUMBER", "SECTEND", "SCDECL", 598 "XSCDECL", "NAME", "PREVCCL", "EOF_OP", "OPTION_OP", "OPT_OUTFILE", 599 "OPT_PREFIX", "OPT_YYCLASS", "CCE_ALNUM", "CCE_ALPHA", "CCE_BLANK", 600 "CCE_CNTRL", "CCE_DIGIT", "CCE_GRAPH", "CCE_LOWER", "CCE_PRINT", 601 "CCE_PUNCT", "CCE_SPACE", "CCE_UPPER", "CCE_XDIGIT", "'='", "'\\n'", 602 "'{'", "'}'", "'^'", "'<'", "'>'", "'*'", "','", "'$'", "'|'", "'/'", 603 "'+'", "'?'", "'.'", "'\"'", "'('", "')'", "'['", "']'", "'-'", 604 "$accept", "goal", "initlex", "sect1", "sect1end", "startconddecl", 605 "namelist1", "options", "optionlist", "option", "sect2", "initforrule", 606 "flexrule", "scon_stk_ptr", "scon", "namelist2", "sconname", "rule", 607 "re", "re2", "series", "singleton", "fullccl", "ccl", "ccl_expr", 608 "string", 0 609}; 610#endif 611 612# ifdef YYPRINT 613/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 614 token YYLEX-NUM. */ 615static const yytype_uint16 yytoknum[] = 616{ 617 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 618 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 619 275, 276, 277, 278, 279, 280, 281, 61, 10, 123, 620 125, 94, 60, 62, 42, 44, 36, 124, 47, 43, 621 63, 46, 34, 40, 41, 91, 93, 45 622}; 623# endif 624 625/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 626static const yytype_uint8 yyr1[] = 627{ 628 0, 48, 49, 50, 51, 51, 51, 51, 52, 53, 629 53, 54, 54, 54, 55, 56, 56, 57, 57, 57, 630 58, 58, 58, 59, 60, 60, 60, 60, 61, 62, 631 62, 62, 63, 63, 63, 64, 65, 65, 65, 65, 632 66, 66, 67, 68, 68, 69, 69, 69, 69, 69, 633 69, 69, 69, 69, 69, 69, 69, 70, 70, 71, 634 71, 71, 71, 72, 72, 72, 72, 72, 72, 72, 635 72, 72, 72, 72, 72, 73, 73 636}; 637 638/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 639static const yytype_uint8 yyr2[] = 640{ 641 0, 2, 5, 0, 3, 2, 0, 1, 1, 1, 642 1, 2, 1, 1, 2, 2, 0, 3, 3, 3, 643 5, 5, 0, 0, 2, 1, 1, 1, 0, 4, 644 3, 0, 3, 1, 1, 1, 2, 3, 2, 1, 645 3, 1, 2, 2, 1, 2, 2, 2, 6, 5, 646 4, 1, 1, 1, 3, 3, 1, 3, 4, 4, 647 2, 2, 0, 1, 1, 1, 1, 1, 1, 1, 648 1, 1, 1, 1, 1, 2, 0 649}; 650 651/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 652 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 653 means the default is an error. */ 654static const yytype_uint8 yydefact[] = 655{ 656 3, 0, 0, 1, 7, 0, 8, 9, 10, 16, 657 22, 0, 5, 14, 31, 13, 12, 4, 0, 0, 658 0, 15, 28, 2, 23, 11, 0, 0, 0, 0, 659 0, 22, 0, 17, 18, 19, 30, 34, 35, 0, 660 33, 31, 27, 56, 53, 26, 0, 51, 76, 0, 661 62, 0, 25, 39, 0, 41, 44, 52, 29, 0, 662 21, 24, 0, 0, 62, 0, 20, 38, 0, 42, 663 36, 43, 0, 45, 46, 47, 32, 75, 54, 55, 664 0, 60, 63, 64, 65, 66, 67, 68, 69, 70, 665 71, 72, 73, 74, 57, 61, 40, 37, 0, 58, 666 0, 50, 0, 59, 0, 49, 48 667}; 668 669/* YYDEFGOTO[NTERM-NUM]. */ 670static const yytype_int8 yydefgoto[] = 671{ 672 -1, 1, 2, 5, 10, 11, 17, 12, 13, 21, 673 14, 23, 51, 30, 24, 39, 40, 52, 53, 54, 674 55, 56, 57, 65, 95, 62 675}; 676 677/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 678 STATE-NUM. */ 679#define YYPACT_NINF -52 680static const yytype_int8 yypact[] = 681{ 682 -52, 1, 78, -52, -52, 81, -52, -52, -52, -52, 683 -52, 6, -52, -2, 5, -52, -52, 20, -14, 9, 684 16, -52, 39, -52, 31, -52, 51, 74, 82, 61, 685 30, -52, -1, -52, -52, -52, -52, -52, -52, 58, 686 -52, 44, -52, -52, -52, -52, 24, -52, -52, 24, 687 66, 70, -52, 25, 24, 24, 41, -52, -52, 91, 688 -52, -52, 26, 27, -52, 0, -52, -52, 24, -52, 689 59, 41, 96, -52, -52, -52, -52, -52, -52, -52, 690 32, 54, -52, -52, -52, -52, -52, -52, -52, -52, 691 -52, -52, -52, -52, -52, -52, 24, -52, 4, -52, 692 99, -52, 2, -52, 73, -52, -52 693}; 694 695/* YYPGOTO[NTERM-NUM]. */ 696static const yytype_int8 yypgoto[] = 697{ 698 -52, -52, -52, -52, -52, -52, -52, -52, -52, -52, 699 75, 80, -52, -52, -52, -52, 46, 62, 23, -52, 700 42, -51, -52, 43, -52, -52 701}; 702 703/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 704 positive, shift that token. If negative, reduce the rule which 705 number is the opposite. If zero, do what YYDEFACT says. 706 If YYTABLE_NINF, syntax error. */ 707#define YYTABLE_NINF -24 708static const yytype_int8 yytable[] = 709{ 710 42, 3, 43, 81, 71, -23, 104, 15, 44, 45, 711 18, 19, 20, 26, 16, 82, 83, 84, 85, 86, 712 87, 88, 89, 90, 91, 92, 93, 43, 25, 77, 713 46, 37, 105, 44, 101, 81, 27, 22, 38, 102, 714 47, 48, 49, 28, 50, 71, 94, 82, 83, 84, 715 85, 86, 87, 88, 89, 90, 91, 92, 93, 33, 716 31, 67, 68, 69, 68, 47, 48, 49, 78, 50, 717 72, 79, 63, 29, 60, 73, 22, 70, 99, 4, 718 74, 75, 34, -6, -6, -6, 6, 7, 8, -6, 719 35, 58, 9, 59, 36, 97, 68, 64, 66, 38, 720 98, 100, 103, 106, 32, 76, 41, 80, 61, 0, 721 96 722}; 723 724static const yytype_int8 yycheck[] = 725{ 726 1, 0, 3, 3, 55, 0, 4, 1, 9, 10, 727 12, 13, 14, 27, 8, 15, 16, 17, 18, 19, 728 20, 21, 22, 23, 24, 25, 26, 3, 8, 3, 729 31, 1, 30, 9, 30, 3, 27, 32, 8, 35, 730 41, 42, 43, 27, 45, 96, 46, 15, 16, 17, 731 18, 19, 20, 21, 22, 23, 24, 25, 26, 8, 732 29, 36, 37, 38, 37, 41, 42, 43, 42, 45, 733 29, 44, 49, 34, 30, 34, 32, 54, 46, 1, 734 39, 40, 8, 5, 6, 7, 5, 6, 7, 11, 735 8, 33, 11, 35, 33, 36, 37, 31, 28, 8, 736 4, 47, 3, 30, 24, 59, 31, 64, 46, -1, 737 68 738}; 739 740/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 741 symbol of state STATE-NUM. */ 742static const yytype_uint8 yystos[] = 743{ 744 0, 49, 50, 0, 1, 51, 5, 6, 7, 11, 745 52, 53, 55, 56, 58, 1, 8, 54, 12, 13, 746 14, 57, 32, 59, 62, 8, 27, 27, 27, 34, 747 61, 29, 59, 8, 8, 8, 33, 1, 8, 63, 748 64, 58, 1, 3, 9, 10, 31, 41, 42, 43, 749 45, 60, 65, 66, 67, 68, 69, 70, 33, 35, 750 30, 65, 73, 66, 31, 71, 28, 36, 37, 38, 751 66, 69, 29, 34, 39, 40, 64, 3, 42, 44, 752 71, 3, 15, 16, 17, 18, 19, 20, 21, 22, 753 23, 24, 25, 26, 46, 72, 68, 36, 4, 46, 754 47, 30, 35, 3, 4, 30, 30 755}; 756 757#define yyerrok (yyerrstatus = 0) 758#define yyclearin (yychar = YYEMPTY) 759#define YYEMPTY (-2) 760#define YYEOF 0 761 762#define YYACCEPT goto yyacceptlab 763#define YYABORT goto yyabortlab 764#define YYERROR goto yyerrorlab 765 766 767/* Like YYERROR except do call yyerror. This remains here temporarily 768 to ease the transition to the new meaning of YYERROR, for GCC. 769 Once GCC version 2 has supplanted version 1, this can go. */ 770 771#define YYFAIL goto yyerrlab 772 773#define YYRECOVERING() (!!yyerrstatus) 774 775#define YYBACKUP(Token, Value) \ 776do \ 777 if (yychar == YYEMPTY && yylen == 1) \ 778 { \ 779 yychar = (Token); \ 780 yylval = (Value); \ 781 yytoken = YYTRANSLATE (yychar); \ 782 YYPOPSTACK (1); \ 783 goto yybackup; \ 784 } \ 785 else \ 786 { \ 787 yyerror (YY_("syntax error: cannot back up")); \ 788 YYERROR; \ 789 } \ 790while (YYID (0)) 791 792 793#define YYTERROR 1 794#define YYERRCODE 256 795 796 797/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 798 If N is 0, then set CURRENT to the empty location which ends 799 the previous symbol: RHS[0] (always defined). */ 800 801#define YYRHSLOC(Rhs, K) ((Rhs)[K]) 802#ifndef YYLLOC_DEFAULT 803# define YYLLOC_DEFAULT(Current, Rhs, N) \ 804 do \ 805 if (YYID (N)) \ 806 { \ 807 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 808 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 809 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 810 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 811 } \ 812 else \ 813 { \ 814 (Current).first_line = (Current).last_line = \ 815 YYRHSLOC (Rhs, 0).last_line; \ 816 (Current).first_column = (Current).last_column = \ 817 YYRHSLOC (Rhs, 0).last_column; \ 818 } \ 819 while (YYID (0)) 820#endif 821 822 823/* YY_LOCATION_PRINT -- Print the location on the stream. 824 This macro was not mandated originally: define only if we know 825 we won't break user code: when these are the locations we know. */ 826 827#ifndef YY_LOCATION_PRINT 828# if YYLTYPE_IS_TRIVIAL 829# define YY_LOCATION_PRINT(File, Loc) \ 830 fprintf (File, "%d.%d-%d.%d", \ 831 (Loc).first_line, (Loc).first_column, \ 832 (Loc).last_line, (Loc).last_column) 833# else 834# define YY_LOCATION_PRINT(File, Loc) ((void) 0) 835# endif 836#endif 837 838 839/* YYLEX -- calling `yylex' with the right arguments. */ 840 841#ifdef YYLEX_PARAM 842# define YYLEX yylex (YYLEX_PARAM) 843#else 844# define YYLEX yylex () 845#endif 846 847/* Enable debugging if requested. */ 848#if YYDEBUG 849 850# ifndef YYFPRINTF 851# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 852# define YYFPRINTF fprintf 853# endif 854 855# define YYDPRINTF(Args) \ 856do { \ 857 if (yydebug) \ 858 YYFPRINTF Args; \ 859} while (YYID (0)) 860 861# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 862do { \ 863 if (yydebug) \ 864 { \ 865 YYFPRINTF (stderr, "%s ", Title); \ 866 yy_symbol_print (stderr, \ 867 Type, Value); \ 868 YYFPRINTF (stderr, "\n"); \ 869 } \ 870} while (YYID (0)) 871 872 873/*--------------------------------. 874| Print this symbol on YYOUTPUT. | 875`--------------------------------*/ 876 877/*ARGSUSED*/ 878#if (defined __STDC__ || defined __C99__FUNC__ \ 879 || defined __cplusplus || defined _MSC_VER) 880static void 881yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 882#else 883static void 884yy_symbol_value_print (yyoutput, yytype, yyvaluep) 885 FILE *yyoutput; 886 int yytype; 887 YYSTYPE const * const yyvaluep; 888#endif 889{ 890 if (!yyvaluep) 891 return; 892# ifdef YYPRINT 893 if (yytype < YYNTOKENS) 894 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 895# else 896 YYUSE (yyoutput); 897# endif 898 switch (yytype) 899 { 900 default: 901 break; 902 } 903} 904 905 906/*--------------------------------. 907| Print this symbol on YYOUTPUT. | 908`--------------------------------*/ 909 910#if (defined __STDC__ || defined __C99__FUNC__ \ 911 || defined __cplusplus || defined _MSC_VER) 912static void 913yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 914#else 915static void 916yy_symbol_print (yyoutput, yytype, yyvaluep) 917 FILE *yyoutput; 918 int yytype; 919 YYSTYPE const * const yyvaluep; 920#endif 921{ 922 if (yytype < YYNTOKENS) 923 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 924 else 925 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 926 927 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 928 YYFPRINTF (yyoutput, ")"); 929} 930 931/*------------------------------------------------------------------. 932| yy_stack_print -- Print the state stack from its BOTTOM up to its | 933| TOP (included). | 934`------------------------------------------------------------------*/ 935 936#if (defined __STDC__ || defined __C99__FUNC__ \ 937 || defined __cplusplus || defined _MSC_VER) 938static void 939yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 940#else 941static void 942yy_stack_print (yybottom, yytop) 943 yytype_int16 *yybottom; 944 yytype_int16 *yytop; 945#endif 946{ 947 YYFPRINTF (stderr, "Stack now"); 948 for (; yybottom <= yytop; yybottom++) 949 { 950 int yybot = *yybottom; 951 YYFPRINTF (stderr, " %d", yybot); 952 } 953 YYFPRINTF (stderr, "\n"); 954} 955 956# define YY_STACK_PRINT(Bottom, Top) \ 957do { \ 958 if (yydebug) \ 959 yy_stack_print ((Bottom), (Top)); \ 960} while (YYID (0)) 961 962 963/*------------------------------------------------. 964| Report that the YYRULE is going to be reduced. | 965`------------------------------------------------*/ 966 967#if (defined __STDC__ || defined __C99__FUNC__ \ 968 || defined __cplusplus || defined _MSC_VER) 969static void 970yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 971#else 972static void 973yy_reduce_print (yyvsp, yyrule) 974 YYSTYPE *yyvsp; 975 int yyrule; 976#endif 977{ 978 int yynrhs = yyr2[yyrule]; 979 int yyi; 980 unsigned long int yylno = yyrline[yyrule]; 981 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 982 yyrule - 1, yylno); 983 /* The symbols being reduced. */ 984 for (yyi = 0; yyi < yynrhs; yyi++) 985 { 986 YYFPRINTF (stderr, " $%d = ", yyi + 1); 987 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 988 &(yyvsp[(yyi + 1) - (yynrhs)]) 989 ); 990 YYFPRINTF (stderr, "\n"); 991 } 992} 993 994# define YY_REDUCE_PRINT(Rule) \ 995do { \ 996 if (yydebug) \ 997 yy_reduce_print (yyvsp, Rule); \ 998} while (YYID (0)) 999 1000/* Nonzero means print parse trace. It is left uninitialized so that 1001 multiple parsers can coexist. */ 1002int yydebug; 1003#else /* !YYDEBUG */ 1004# define YYDPRINTF(Args) 1005# define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1006# define YY_STACK_PRINT(Bottom, Top) 1007# define YY_REDUCE_PRINT(Rule) 1008#endif /* !YYDEBUG */ 1009 1010 1011/* YYINITDEPTH -- initial size of the parser's stacks. */ 1012#ifndef YYINITDEPTH 1013# define YYINITDEPTH 200 1014#endif 1015 1016/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1017 if the built-in stack extension method is used). 1018 1019 Do not make this value too large; the results are undefined if 1020 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1021 evaluated with infinite-precision integer arithmetic. */ 1022 1023#ifndef YYMAXDEPTH 1024# define YYMAXDEPTH 10000 1025#endif 1026 1027 1028 1029#if YYERROR_VERBOSE 1030 1031# ifndef yystrlen 1032# if defined __GLIBC__ && defined _STRING_H 1033# define yystrlen strlen 1034# else 1035/* Return the length of YYSTR. */ 1036#if (defined __STDC__ || defined __C99__FUNC__ \ 1037 || defined __cplusplus || defined _MSC_VER) 1038static YYSIZE_T 1039yystrlen (const char *yystr) 1040#else 1041static YYSIZE_T 1042yystrlen (yystr) 1043 const char *yystr; 1044#endif 1045{ 1046 YYSIZE_T yylen; 1047 for (yylen = 0; yystr[yylen]; yylen++) 1048 continue; 1049 return yylen; 1050} 1051# endif 1052# endif 1053 1054# ifndef yystpcpy 1055# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 1056# define yystpcpy stpcpy 1057# else 1058/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1059 YYDEST. */ 1060#if (defined __STDC__ || defined __C99__FUNC__ \ 1061 || defined __cplusplus || defined _MSC_VER) 1062static char * 1063yystpcpy (char *yydest, const char *yysrc) 1064#else 1065static char * 1066yystpcpy (yydest, yysrc) 1067 char *yydest; 1068 const char *yysrc; 1069#endif 1070{ 1071 char *yyd = yydest; 1072 const char *yys = yysrc; 1073 1074 while ((*yyd++ = *yys++) != '\0') 1075 continue; 1076 1077 return yyd - 1; 1078} 1079# endif 1080# endif 1081 1082# ifndef yytnamerr 1083/* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1084 quotes and backslashes, so that it's suitable for yyerror. The 1085 heuristic is that double-quoting is unnecessary unless the string 1086 contains an apostrophe, a comma, or backslash (other than 1087 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1088 null, do not copy; instead, return the length of what the result 1089 would have been. */ 1090static YYSIZE_T 1091yytnamerr (char *yyres, const char *yystr) 1092{ 1093 if (*yystr == '"') 1094 { 1095 YYSIZE_T yyn = 0; 1096 char const *yyp = yystr; 1097 1098 for (;;) 1099 switch (*++yyp) 1100 { 1101 case '\'': 1102 case ',': 1103 goto do_not_strip_quotes; 1104 1105 case '\\': 1106 if (*++yyp != '\\') 1107 goto do_not_strip_quotes; 1108 /* Fall through. */ 1109 default: 1110 if (yyres) 1111 yyres[yyn] = *yyp; 1112 yyn++; 1113 break; 1114 1115 case '"': 1116 if (yyres) 1117 yyres[yyn] = '\0'; 1118 return yyn; 1119 } 1120 do_not_strip_quotes: ; 1121 } 1122 1123 if (! yyres) 1124 return yystrlen (yystr); 1125 1126 return yystpcpy (yyres, yystr) - yyres; 1127} 1128# endif 1129 1130/* Copy into YYRESULT an error message about the unexpected token 1131 YYCHAR while in state YYSTATE. Return the number of bytes copied, 1132 including the terminating null byte. If YYRESULT is null, do not 1133 copy anything; just return the number of bytes that would be 1134 copied. As a special case, return 0 if an ordinary "syntax error" 1135 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 1136 size calculation. */ 1137static YYSIZE_T 1138yysyntax_error (char *yyresult, int yystate, int yychar) 1139{ 1140 int yyn = yypact[yystate]; 1141 1142 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 1143 return 0; 1144 else 1145 { 1146 int yytype = YYTRANSLATE (yychar); 1147 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 1148 YYSIZE_T yysize = yysize0; 1149 YYSIZE_T yysize1; 1150 int yysize_overflow = 0; 1151 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 1152 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 1153 int yyx; 1154 1155# if 0 1156 /* This is so xgettext sees the translatable formats that are 1157 constructed on the fly. */ 1158 YY_("syntax error, unexpected %s"); 1159 YY_("syntax error, unexpected %s, expecting %s"); 1160 YY_("syntax error, unexpected %s, expecting %s or %s"); 1161 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 1162 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 1163# endif 1164 char *yyfmt; 1165 char const *yyf; 1166 static char const yyunexpected[] = "syntax error, unexpected %s"; 1167 static char const yyexpecting[] = ", expecting %s"; 1168 static char const yyor[] = " or %s"; 1169 char yyformat[sizeof yyunexpected 1170 + sizeof yyexpecting - 1 1171 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 1172 * (sizeof yyor - 1))]; 1173 char const *yyprefix = yyexpecting; 1174 1175 /* Start YYX at -YYN if negative to avoid negative indexes in 1176 YYCHECK. */ 1177 int yyxbegin = yyn < 0 ? -yyn : 0; 1178 1179 /* Stay within bounds of both yycheck and yytname. */ 1180 int yychecklim = YYLAST - yyn + 1; 1181 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 1182 int yycount = 1; 1183 1184 yyarg[0] = yytname[yytype]; 1185 yyfmt = yystpcpy (yyformat, yyunexpected); 1186 1187 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 1188 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 1189 { 1190 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 1191 { 1192 yycount = 1; 1193 yysize = yysize0; 1194 yyformat[sizeof yyunexpected - 1] = '\0'; 1195 break; 1196 } 1197 yyarg[yycount++] = yytname[yyx]; 1198 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 1199 yysize_overflow |= (yysize1 < yysize); 1200 yysize = yysize1; 1201 yyfmt = yystpcpy (yyfmt, yyprefix); 1202 yyprefix = yyor; 1203 } 1204 1205 yyf = YY_(yyformat); 1206 yysize1 = yysize + yystrlen (yyf); 1207 yysize_overflow |= (yysize1 < yysize); 1208 yysize = yysize1; 1209 1210 if (yysize_overflow) 1211 return YYSIZE_MAXIMUM; 1212 1213 if (yyresult) 1214 { 1215 /* Avoid sprintf, as that infringes on the user's name space. 1216 Don't have undefined behavior even if the translation 1217 produced a string with the wrong number of "%s"s. */ 1218 char *yyp = yyresult; 1219 int yyi = 0; 1220 while ((*yyp = *yyf) != '\0') 1221 { 1222 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 1223 { 1224 yyp += yytnamerr (yyp, yyarg[yyi++]); 1225 yyf += 2; 1226 } 1227 else 1228 { 1229 yyp++; 1230 yyf++; 1231 } 1232 } 1233 } 1234 return yysize; 1235 } 1236} 1237#endif /* YYERROR_VERBOSE */ 1238 1239 1240/*-----------------------------------------------. 1241| Release the memory associated to this symbol. | 1242`-----------------------------------------------*/ 1243 1244/*ARGSUSED*/ 1245#if (defined __STDC__ || defined __C99__FUNC__ \ 1246 || defined __cplusplus || defined _MSC_VER) 1247static void 1248yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1249#else 1250static void 1251yydestruct (yymsg, yytype, yyvaluep) 1252 const char *yymsg; 1253 int yytype; 1254 YYSTYPE *yyvaluep; 1255#endif 1256{ 1257 YYUSE (yyvaluep); 1258 1259 if (!yymsg) 1260 yymsg = "Deleting"; 1261 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1262 1263 switch (yytype) 1264 { 1265 1266 default: 1267 break; 1268 } 1269} 1270 1271/* Prevent warnings from -Wmissing-prototypes. */ 1272#ifdef YYPARSE_PARAM 1273#if defined __STDC__ || defined __cplusplus 1274int yyparse (void *YYPARSE_PARAM); 1275#else 1276int yyparse (); 1277#endif 1278#else /* ! YYPARSE_PARAM */ 1279#if defined __STDC__ || defined __cplusplus 1280int yyparse (void); 1281#else 1282int yyparse (); 1283#endif 1284#endif /* ! YYPARSE_PARAM */ 1285 1286 1287/* The lookahead symbol. */ 1288int yychar; 1289 1290/* The semantic value of the lookahead symbol. */ 1291YYSTYPE yylval; 1292 1293/* Number of syntax errors so far. */ 1294int yynerrs; 1295 1296 1297 1298/*-------------------------. 1299| yyparse or yypush_parse. | 1300`-------------------------*/ 1301 1302#ifdef YYPARSE_PARAM 1303#if (defined __STDC__ || defined __C99__FUNC__ \ 1304 || defined __cplusplus || defined _MSC_VER) 1305int 1306yyparse (void *YYPARSE_PARAM) 1307#else 1308int 1309yyparse (YYPARSE_PARAM) 1310 void *YYPARSE_PARAM; 1311#endif 1312#else /* ! YYPARSE_PARAM */ 1313#if (defined __STDC__ || defined __C99__FUNC__ \ 1314 || defined __cplusplus || defined _MSC_VER) 1315int 1316yyparse (void) 1317#else 1318int 1319yyparse () 1320 1321#endif 1322#endif 1323{ 1324 1325 1326 int yystate; 1327 /* Number of tokens to shift before error messages enabled. */ 1328 int yyerrstatus; 1329 1330 /* The stacks and their tools: 1331 `yyss': related to states. 1332 `yyvs': related to semantic values. 1333 1334 Refer to the stacks thru separate pointers, to allow yyoverflow 1335 to reallocate them elsewhere. */ 1336 1337 /* The state stack. */ 1338 yytype_int16 yyssa[YYINITDEPTH]; 1339 yytype_int16 *yyss; 1340 yytype_int16 *yyssp; 1341 1342 /* The semantic value stack. */ 1343 YYSTYPE yyvsa[YYINITDEPTH]; 1344 YYSTYPE *yyvs; 1345 YYSTYPE *yyvsp; 1346 1347 YYSIZE_T yystacksize; 1348 1349 int yyn; 1350 int yyresult; 1351 /* Lookahead token as an internal (translated) token number. */ 1352 int yytoken; 1353 /* The variables used to return semantic value and location from the 1354 action routines. */ 1355 YYSTYPE yyval; 1356 1357#if YYERROR_VERBOSE 1358 /* Buffer for error messages, and its allocated size. */ 1359 char yymsgbuf[128]; 1360 char *yymsg = yymsgbuf; 1361 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 1362#endif 1363 1364#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 1365 1366 /* The number of symbols on the RHS of the reduced rule. 1367 Keep to zero when no symbol should be popped. */ 1368 int yylen = 0; 1369 1370 yytoken = 0; 1371 yyss = yyssa; 1372 yyvs = yyvsa; 1373 yystacksize = YYINITDEPTH; 1374 1375 YYDPRINTF ((stderr, "Starting parse\n")); 1376 1377 yystate = 0; 1378 yyerrstatus = 0; 1379 yynerrs = 0; 1380 yychar = YYEMPTY; /* Cause a token to be read. */ 1381 1382 /* Initialize stack pointers. 1383 Waste one element of value and location stack 1384 so that they stay on the same level as the state stack. 1385 The wasted elements are never initialized. */ 1386 yyssp = yyss; 1387 yyvsp = yyvs; 1388 1389 goto yysetstate; 1390 1391/*------------------------------------------------------------. 1392| yynewstate -- Push a new state, which is found in yystate. | 1393`------------------------------------------------------------*/ 1394 yynewstate: 1395 /* In all cases, when you get here, the value and location stacks 1396 have just been pushed. So pushing a state here evens the stacks. */ 1397 yyssp++; 1398 1399 yysetstate: 1400 *yyssp = yystate; 1401 1402 if (yyss + yystacksize - 1 <= yyssp) 1403 { 1404 /* Get the current used size of the three stacks, in elements. */ 1405 YYSIZE_T yysize = yyssp - yyss + 1; 1406 1407#ifdef yyoverflow 1408 { 1409 /* Give user a chance to reallocate the stack. Use copies of 1410 these so that the &'s don't force the real ones into 1411 memory. */ 1412 YYSTYPE *yyvs1 = yyvs; 1413 yytype_int16 *yyss1 = yyss; 1414 1415 /* Each stack pointer address is followed by the size of the 1416 data in use in that stack, in bytes. This used to be a 1417 conditional around just the two extra args, but that might 1418 be undefined if yyoverflow is a macro. */ 1419 yyoverflow (YY_("memory exhausted"), 1420 &yyss1, yysize * sizeof (*yyssp), 1421 &yyvs1, yysize * sizeof (*yyvsp), 1422 &yystacksize); 1423 1424 yyss = yyss1; 1425 yyvs = yyvs1; 1426 } 1427#else /* no yyoverflow */ 1428# ifndef YYSTACK_RELOCATE 1429 goto yyexhaustedlab; 1430# else 1431 /* Extend the stack our own way. */ 1432 if (YYMAXDEPTH <= yystacksize) 1433 goto yyexhaustedlab; 1434 yystacksize *= 2; 1435 if (YYMAXDEPTH < yystacksize) 1436 yystacksize = YYMAXDEPTH; 1437 1438 { 1439 yytype_int16 *yyss1 = yyss; 1440 union yyalloc *yyptr = 1441 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1442 if (! yyptr) 1443 goto yyexhaustedlab; 1444 YYSTACK_RELOCATE (yyss_alloc, yyss); 1445 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 1446# undef YYSTACK_RELOCATE 1447 if (yyss1 != yyssa) 1448 YYSTACK_FREE (yyss1); 1449 } 1450# endif 1451#endif /* no yyoverflow */ 1452 1453 yyssp = yyss + yysize - 1; 1454 yyvsp = yyvs + yysize - 1; 1455 1456 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1457 (unsigned long int) yystacksize)); 1458 1459 if (yyss + yystacksize - 1 <= yyssp) 1460 YYABORT; 1461 } 1462 1463 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1464 1465 if (yystate == YYFINAL) 1466 YYACCEPT; 1467 1468 goto yybackup; 1469 1470/*-----------. 1471| yybackup. | 1472`-----------*/ 1473yybackup: 1474 1475 /* Do appropriate processing given the current state. Read a 1476 lookahead token if we need one and don't already have one. */ 1477 1478 /* First try to decide what to do without reference to lookahead token. */ 1479 yyn = yypact[yystate]; 1480 if (yyn == YYPACT_NINF) 1481 goto yydefault; 1482 1483 /* Not known => get a lookahead token if don't already have one. */ 1484 1485 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 1486 if (yychar == YYEMPTY) 1487 { 1488 YYDPRINTF ((stderr, "Reading a token: ")); 1489 yychar = YYLEX; 1490 } 1491 1492 if (yychar <= YYEOF) 1493 { 1494 yychar = yytoken = YYEOF; 1495 YYDPRINTF ((stderr, "Now at end of input.\n")); 1496 } 1497 else 1498 { 1499 yytoken = YYTRANSLATE (yychar); 1500 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1501 } 1502 1503 /* If the proper action on seeing token YYTOKEN is to reduce or to 1504 detect an error, take that action. */ 1505 yyn += yytoken; 1506 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1507 goto yydefault; 1508 yyn = yytable[yyn]; 1509 if (yyn <= 0) 1510 { 1511 if (yyn == 0 || yyn == YYTABLE_NINF) 1512 goto yyerrlab; 1513 yyn = -yyn; 1514 goto yyreduce; 1515 } 1516 1517 /* Count tokens shifted since error; after three, turn off error 1518 status. */ 1519 if (yyerrstatus) 1520 yyerrstatus--; 1521 1522 /* Shift the lookahead token. */ 1523 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1524 1525 /* Discard the shifted token. */ 1526 yychar = YYEMPTY; 1527 1528 yystate = yyn; 1529 *++yyvsp = yylval; 1530 1531 goto yynewstate; 1532 1533 1534/*-----------------------------------------------------------. 1535| yydefault -- do the default action for the current state. | 1536`-----------------------------------------------------------*/ 1537yydefault: 1538 yyn = yydefact[yystate]; 1539 if (yyn == 0) 1540 goto yyerrlab; 1541 goto yyreduce; 1542 1543 1544/*-----------------------------. 1545| yyreduce -- Do a reduction. | 1546`-----------------------------*/ 1547yyreduce: 1548 /* yyn is the number of a rule to reduce with. */ 1549 yylen = yyr2[yyn]; 1550 1551 /* If YYLEN is nonzero, implement the default value of the action: 1552 `$$ = $1'. 1553 1554 Otherwise, the following line sets YYVAL to garbage. 1555 This behavior is undocumented and Bison 1556 users should not rely upon it. Assigning to YYVAL 1557 unconditionally makes the parser a bit smaller, and it avoids a 1558 GCC warning that YYVAL may be used uninitialized. */ 1559 yyval = yyvsp[1-yylen]; 1560 1561 1562 YY_REDUCE_PRINT (yyn); 1563 switch (yyn) 1564 { 1565 case 2: 1566 1567/* Line 1455 of yacc.c */ 1568#line 113 "./parse.y" 1569 { /* add default rule */ 1570 int def_rule; 1571 1572 pat = cclinit(); 1573 cclnegate( pat ); 1574 1575 def_rule = mkstate( -pat ); 1576 1577 /* Remember the number of the default rule so we 1578 * don't generate "can't match" warnings for it. 1579 */ 1580 default_rule = num_rules; 1581 1582 finish_rule( def_rule, false, 0, 0 ); 1583 1584 for ( i = 1; i <= lastsc; ++i ) 1585 scset[i] = mkbranch( scset[i], def_rule ); 1586 1587 if ( spprdflt ) 1588 add_action( 1589 "YY_FATAL_ERROR( \"flex scanner jammed\" )" ); 1590 else 1591 add_action( "ECHO" ); 1592 1593 add_action( ";\n\tYY_BREAK\n" ); 1594 } 1595 break; 1596 1597 case 3: 1598 1599/* Line 1455 of yacc.c */ 1600#line 142 "./parse.y" 1601 { /* initialize for processing rules */ 1602 1603 /* Create default DFA start condition. */ 1604 scinstal( "INITIAL", false ); 1605 } 1606 break; 1607 1608 case 7: 1609 1610/* Line 1455 of yacc.c */ 1611#line 153 "./parse.y" 1612 { synerr( "unknown error processing section 1" ); } 1613 break; 1614 1615 case 8: 1616 1617/* Line 1455 of yacc.c */ 1618#line 157 "./parse.y" 1619 { 1620 check_options(); 1621 scon_stk = allocate_integer_array( lastsc + 1 ); 1622 scon_stk_ptr = 0; 1623 } 1624 break; 1625 1626 case 9: 1627 1628/* Line 1455 of yacc.c */ 1629#line 165 "./parse.y" 1630 { xcluflg = false; } 1631 break; 1632 1633 case 10: 1634 1635/* Line 1455 of yacc.c */ 1636#line 168 "./parse.y" 1637 { xcluflg = true; } 1638 break; 1639 1640 case 11: 1641 1642/* Line 1455 of yacc.c */ 1643#line 172 "./parse.y" 1644 { scinstal( nmstr, xcluflg ); } 1645 break; 1646 1647 case 12: 1648 1649/* Line 1455 of yacc.c */ 1650#line 175 "./parse.y" 1651 { scinstal( nmstr, xcluflg ); } 1652 break; 1653 1654 case 13: 1655 1656/* Line 1455 of yacc.c */ 1657#line 178 "./parse.y" 1658 { synerr( "bad start condition list" ); } 1659 break; 1660 1661 case 17: 1662 1663/* Line 1455 of yacc.c */ 1664#line 189 "./parse.y" 1665 { 1666 outfilename = copy_string( nmstr ); 1667 did_outfilename = 1; 1668 } 1669 break; 1670 1671 case 18: 1672 1673/* Line 1455 of yacc.c */ 1674#line 194 "./parse.y" 1675 { prefix = copy_string( nmstr ); } 1676 break; 1677 1678 case 19: 1679 1680/* Line 1455 of yacc.c */ 1681#line 196 "./parse.y" 1682 { yyclass = copy_string( nmstr ); } 1683 break; 1684 1685 case 20: 1686 1687/* Line 1455 of yacc.c */ 1688#line 200 "./parse.y" 1689 { scon_stk_ptr = (yyvsp[(2) - (5)]); } 1690 break; 1691 1692 case 21: 1693 1694/* Line 1455 of yacc.c */ 1695#line 202 "./parse.y" 1696 { scon_stk_ptr = (yyvsp[(2) - (5)]); } 1697 break; 1698 1699 case 23: 1700 1701/* Line 1455 of yacc.c */ 1702#line 207 "./parse.y" 1703 { 1704 /* Initialize for a parse of one rule. */ 1705 trlcontxt = variable_trail_rule = varlength = false; 1706 trailcnt = headcnt = rulelen = 0; 1707 current_state_type = STATE_NORMAL; 1708 previous_continued_action = continued_action; 1709 in_rule = true; 1710 1711 new_rule(); 1712 } 1713 break; 1714 1715 case 24: 1716 1717/* Line 1455 of yacc.c */ 1718#line 220 "./parse.y" 1719 { 1720 pat = (yyvsp[(2) - (2)]); 1721 finish_rule( pat, variable_trail_rule, 1722 headcnt, trailcnt ); 1723 1724 if ( scon_stk_ptr > 0 ) 1725 { 1726 for ( i = 1; i <= scon_stk_ptr; ++i ) 1727 scbol[scon_stk[i]] = 1728 mkbranch( scbol[scon_stk[i]], 1729 pat ); 1730 } 1731 1732 else 1733 { 1734 /* Add to all non-exclusive start conditions, 1735 * including the default (0) start condition. 1736 */ 1737 1738 for ( i = 1; i <= lastsc; ++i ) 1739 if ( ! scxclu[i] ) 1740 scbol[i] = mkbranch( scbol[i], 1741 pat ); 1742 } 1743 1744 if ( ! bol_needed ) 1745 { 1746 bol_needed = true; 1747 1748 if ( performance_report > 1 ) 1749 pinpoint_message( 1750 "'^' operator results in sub-optimal performance" ); 1751 } 1752 } 1753 break; 1754 1755 case 25: 1756 1757/* Line 1455 of yacc.c */ 1758#line 256 "./parse.y" 1759 { 1760 pat = (yyvsp[(1) - (1)]); 1761 finish_rule( pat, variable_trail_rule, 1762 headcnt, trailcnt ); 1763 1764 if ( scon_stk_ptr > 0 ) 1765 { 1766 for ( i = 1; i <= scon_stk_ptr; ++i ) 1767 scset[scon_stk[i]] = 1768 mkbranch( scset[scon_stk[i]], 1769 pat ); 1770 } 1771 1772 else 1773 { 1774 for ( i = 1; i <= lastsc; ++i ) 1775 if ( ! scxclu[i] ) 1776 scset[i] = 1777 mkbranch( scset[i], 1778 pat ); 1779 } 1780 } 1781 break; 1782 1783 case 26: 1784 1785/* Line 1455 of yacc.c */ 1786#line 280 "./parse.y" 1787 { 1788 if ( scon_stk_ptr > 0 ) 1789 build_eof_action(); 1790 1791 else 1792 { 1793 /* This EOF applies to all start conditions 1794 * which don't already have EOF actions. 1795 */ 1796 for ( i = 1; i <= lastsc; ++i ) 1797 if ( ! sceof[i] ) 1798 scon_stk[++scon_stk_ptr] = i; 1799 1800 if ( scon_stk_ptr == 0 ) 1801 warn( 1802 "all start conditions already have <<EOF>> rules" ); 1803 1804 else 1805 build_eof_action(); 1806 } 1807 } 1808 break; 1809 1810 case 27: 1811 1812/* Line 1455 of yacc.c */ 1813#line 303 "./parse.y" 1814 { synerr( "unrecognized rule" ); } 1815 break; 1816 1817 case 28: 1818 1819/* Line 1455 of yacc.c */ 1820#line 307 "./parse.y" 1821 { (yyval) = scon_stk_ptr; } 1822 break; 1823 1824 case 29: 1825 1826/* Line 1455 of yacc.c */ 1827#line 311 "./parse.y" 1828 { (yyval) = (yyvsp[(2) - (4)]); } 1829 break; 1830 1831 case 30: 1832 1833/* Line 1455 of yacc.c */ 1834#line 314 "./parse.y" 1835 { 1836 (yyval) = scon_stk_ptr; 1837 1838 for ( i = 1; i <= lastsc; ++i ) 1839 { 1840 int j; 1841 1842 for ( j = 1; j <= scon_stk_ptr; ++j ) 1843 if ( scon_stk[j] == i ) 1844 break; 1845 1846 if ( j > scon_stk_ptr ) 1847 scon_stk[++scon_stk_ptr] = i; 1848 } 1849 } 1850 break; 1851 1852 case 31: 1853 1854/* Line 1455 of yacc.c */ 1855#line 331 "./parse.y" 1856 { (yyval) = scon_stk_ptr; } 1857 break; 1858 1859 case 34: 1860 1861/* Line 1455 of yacc.c */ 1862#line 339 "./parse.y" 1863 { synerr( "bad start condition list" ); } 1864 break; 1865 1866 case 35: 1867 1868/* Line 1455 of yacc.c */ 1869#line 343 "./parse.y" 1870 { 1871 if ( (scnum = sclookup( nmstr )) == 0 ) 1872 format_pinpoint_message( 1873 "undeclared start condition %s", 1874 nmstr ); 1875 else 1876 { 1877 for ( i = 1; i <= scon_stk_ptr; ++i ) 1878 if ( scon_stk[i] == scnum ) 1879 { 1880 format_warn( 1881 "<%s> specified twice", 1882 scname[scnum] ); 1883 break; 1884 } 1885 1886 if ( i > scon_stk_ptr ) 1887 scon_stk[++scon_stk_ptr] = scnum; 1888 } 1889 } 1890 break; 1891 1892 case 36: 1893 1894/* Line 1455 of yacc.c */ 1895#line 366 "./parse.y" 1896 { 1897 if ( transchar[lastst[(yyvsp[(2) - (2)])]] != SYM_EPSILON ) 1898 /* Provide final transition \now/ so it 1899 * will be marked as a trailing context 1900 * state. 1901 */ 1902 (yyvsp[(2) - (2)]) = link_machines( (yyvsp[(2) - (2)]), 1903 mkstate( SYM_EPSILON ) ); 1904 1905 mark_beginning_as_normal( (yyvsp[(2) - (2)]) ); 1906 current_state_type = STATE_NORMAL; 1907 1908 if ( previous_continued_action ) 1909 { 1910 /* We need to treat this as variable trailing 1911 * context so that the backup does not happen 1912 * in the action but before the action switch 1913 * statement. If the backup happens in the 1914 * action, then the rules "falling into" this 1915 * one's action will *also* do the backup, 1916 * erroneously. 1917 */ 1918 if ( ! varlength || headcnt != 0 ) 1919 warn( 1920 "trailing context made variable due to preceding '|' action" ); 1921 1922 /* Mark as variable. */ 1923 varlength = true; 1924 headcnt = 0; 1925 } 1926 1927 if ( lex_compat || (varlength && headcnt == 0) ) 1928 { /* variable trailing context rule */ 1929 /* Mark the first part of the rule as the 1930 * accepting "head" part of a trailing 1931 * context rule. 1932 * 1933 * By the way, we didn't do this at the 1934 * beginning of this production because back 1935 * then current_state_type was set up for a 1936 * trail rule, and add_accept() can create 1937 * a new state ... 1938 */ 1939 add_accept( (yyvsp[(1) - (2)]), 1940 num_rules | YY_TRAILING_HEAD_MASK ); 1941 variable_trail_rule = true; 1942 } 1943 1944 else 1945 trailcnt = rulelen; 1946 1947 (yyval) = link_machines( (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]) ); 1948 } 1949 break; 1950 1951 case 37: 1952 1953/* Line 1455 of yacc.c */ 1954#line 421 "./parse.y" 1955 { synerr( "trailing context used twice" ); } 1956 break; 1957 1958 case 38: 1959 1960/* Line 1455 of yacc.c */ 1961#line 424 "./parse.y" 1962 { 1963 headcnt = 0; 1964 trailcnt = 1; 1965 rulelen = 1; 1966 varlength = false; 1967 1968 current_state_type = STATE_TRAILING_CONTEXT; 1969 1970 if ( trlcontxt ) 1971 { 1972 synerr( "trailing context used twice" ); 1973 (yyval) = mkstate( SYM_EPSILON ); 1974 } 1975 1976 else if ( previous_continued_action ) 1977 { 1978 /* See the comment in the rule for "re2 re" 1979 * above. 1980 */ 1981 warn( 1982 "trailing context made variable due to preceding '|' action" ); 1983 1984 varlength = true; 1985 } 1986 1987 if ( lex_compat || varlength ) 1988 { 1989 /* Again, see the comment in the rule for 1990 * "re2 re" above. 1991 */ 1992 add_accept( (yyvsp[(1) - (2)]), 1993 num_rules | YY_TRAILING_HEAD_MASK ); 1994 variable_trail_rule = true; 1995 } 1996 1997 trlcontxt = true; 1998 1999 eps = mkstate( SYM_EPSILON ); 2000 (yyval) = link_machines( (yyvsp[(1) - (2)]), 2001 link_machines( eps, mkstate( '\n' ) ) ); 2002 } 2003 break; 2004 2005 case 39: 2006 2007/* Line 1455 of yacc.c */ 2008#line 467 "./parse.y" 2009 { 2010 (yyval) = (yyvsp[(1) - (1)]); 2011 2012 if ( trlcontxt ) 2013 { 2014 if ( lex_compat || (varlength && headcnt == 0) ) 2015 /* Both head and trail are 2016 * variable-length. 2017 */ 2018 variable_trail_rule = true; 2019 else 2020 trailcnt = rulelen; 2021 } 2022 } 2023 break; 2024 2025 case 40: 2026 2027/* Line 1455 of yacc.c */ 2028#line 485 "./parse.y" 2029 { 2030 varlength = true; 2031 (yyval) = mkor( (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]) ); 2032 } 2033 break; 2034 2035 case 41: 2036 2037/* Line 1455 of yacc.c */ 2038#line 491 "./parse.y" 2039 { (yyval) = (yyvsp[(1) - (1)]); } 2040 break; 2041 2042 case 42: 2043 2044/* Line 1455 of yacc.c */ 2045#line 496 "./parse.y" 2046 { 2047 /* This rule is written separately so the 2048 * reduction will occur before the trailing 2049 * series is parsed. 2050 */ 2051 2052 if ( trlcontxt ) 2053 synerr( "trailing context used twice" ); 2054 else 2055 trlcontxt = true; 2056 2057 if ( varlength ) 2058 /* We hope the trailing context is 2059 * fixed-length. 2060 */ 2061 varlength = false; 2062 else 2063 headcnt = rulelen; 2064 2065 rulelen = 0; 2066 2067 current_state_type = STATE_TRAILING_CONTEXT; 2068 (yyval) = (yyvsp[(1) - (2)]); 2069 } 2070 break; 2071 2072 case 43: 2073 2074/* Line 1455 of yacc.c */ 2075#line 523 "./parse.y" 2076 { 2077 /* This is where concatenation of adjacent patterns 2078 * gets done. 2079 */ 2080 (yyval) = link_machines( (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]) ); 2081 } 2082 break; 2083 2084 case 44: 2085 2086/* Line 1455 of yacc.c */ 2087#line 531 "./parse.y" 2088 { (yyval) = (yyvsp[(1) - (1)]); } 2089 break; 2090 2091 case 45: 2092 2093/* Line 1455 of yacc.c */ 2094#line 535 "./parse.y" 2095 { 2096 varlength = true; 2097 2098 (yyval) = mkclos( (yyvsp[(1) - (2)]) ); 2099 } 2100 break; 2101 2102 case 46: 2103 2104/* Line 1455 of yacc.c */ 2105#line 542 "./parse.y" 2106 { 2107 varlength = true; 2108 (yyval) = mkposcl( (yyvsp[(1) - (2)]) ); 2109 } 2110 break; 2111 2112 case 47: 2113 2114/* Line 1455 of yacc.c */ 2115#line 548 "./parse.y" 2116 { 2117 varlength = true; 2118 (yyval) = mkopt( (yyvsp[(1) - (2)]) ); 2119 } 2120 break; 2121 2122 case 48: 2123 2124/* Line 1455 of yacc.c */ 2125#line 554 "./parse.y" 2126 { 2127 varlength = true; 2128 2129 if ( (yyvsp[(3) - (6)]) > (yyvsp[(5) - (6)]) || (yyvsp[(3) - (6)]) < 0 ) 2130 { 2131 synerr( "bad iteration values" ); 2132 (yyval) = (yyvsp[(1) - (6)]); 2133 } 2134 else 2135 { 2136 if ( (yyvsp[(3) - (6)]) == 0 ) 2137 { 2138 if ( (yyvsp[(5) - (6)]) <= 0 ) 2139 { 2140 synerr( 2141 "bad iteration values" ); 2142 (yyval) = (yyvsp[(1) - (6)]); 2143 } 2144 else 2145 (yyval) = mkopt( 2146 mkrep( (yyvsp[(1) - (6)]), 1, (yyvsp[(5) - (6)]) ) ); 2147 } 2148 else 2149 (yyval) = mkrep( (yyvsp[(1) - (6)]), (yyvsp[(3) - (6)]), (yyvsp[(5) - (6)]) ); 2150 } 2151 } 2152 break; 2153 2154 case 49: 2155 2156/* Line 1455 of yacc.c */ 2157#line 582 "./parse.y" 2158 { 2159 varlength = true; 2160 2161 if ( (yyvsp[(3) - (5)]) <= 0 ) 2162 { 2163 synerr( "iteration value must be positive" ); 2164 (yyval) = (yyvsp[(1) - (5)]); 2165 } 2166 2167 else 2168 (yyval) = mkrep( (yyvsp[(1) - (5)]), (yyvsp[(3) - (5)]), INFINITY ); 2169 } 2170 break; 2171 2172 case 50: 2173 2174/* Line 1455 of yacc.c */ 2175#line 596 "./parse.y" 2176 { 2177 /* The singleton could be something like "(foo)", 2178 * in which case we have no idea what its length 2179 * is, so we punt here. 2180 */ 2181 varlength = true; 2182 2183 if ( (yyvsp[(3) - (4)]) <= 0 ) 2184 { 2185 synerr( "iteration value must be positive" ); 2186 (yyval) = (yyvsp[(1) - (4)]); 2187 } 2188 2189 else 2190 (yyval) = link_machines( (yyvsp[(1) - (4)]), 2191 copysingl( (yyvsp[(1) - (4)]), (yyvsp[(3) - (4)]) - 1 ) ); 2192 } 2193 break; 2194 2195 case 51: 2196 2197/* Line 1455 of yacc.c */ 2198#line 615 "./parse.y" 2199 { 2200 if ( ! madeany ) 2201 { 2202 /* Create the '.' character class. */ 2203 anyccl = cclinit(); 2204 ccladd( anyccl, '\n' ); 2205 cclnegate( anyccl ); 2206 2207 if ( useecs ) 2208 mkeccl( ccltbl + cclmap[anyccl], 2209 ccllen[anyccl], nextecm, 2210 ecgroup, csize, csize ); 2211 2212 madeany = true; 2213 } 2214 2215 ++rulelen; 2216 2217 (yyval) = mkstate( -anyccl ); 2218 } 2219 break; 2220 2221 case 52: 2222 2223/* Line 1455 of yacc.c */ 2224#line 637 "./parse.y" 2225 { 2226 if ( ! cclsorted ) 2227 /* Sort characters for fast searching. We 2228 * use a shell sort since this list could 2229 * be large. 2230 */ 2231 cshell( ccltbl + cclmap[(yyvsp[(1) - (1)])], ccllen[(yyvsp[(1) - (1)])], true ); 2232 2233 if ( useecs ) 2234 mkeccl( ccltbl + cclmap[(yyvsp[(1) - (1)])], ccllen[(yyvsp[(1) - (1)])], 2235 nextecm, ecgroup, csize, csize ); 2236 2237 ++rulelen; 2238 2239 (yyval) = mkstate( -(yyvsp[(1) - (1)]) ); 2240 } 2241 break; 2242 2243 case 53: 2244 2245/* Line 1455 of yacc.c */ 2246#line 655 "./parse.y" 2247 { 2248 ++rulelen; 2249 2250 (yyval) = mkstate( -(yyvsp[(1) - (1)]) ); 2251 } 2252 break; 2253 2254 case 54: 2255 2256/* Line 1455 of yacc.c */ 2257#line 662 "./parse.y" 2258 { (yyval) = (yyvsp[(2) - (3)]); } 2259 break; 2260 2261 case 55: 2262 2263/* Line 1455 of yacc.c */ 2264#line 665 "./parse.y" 2265 { (yyval) = (yyvsp[(2) - (3)]); } 2266 break; 2267 2268 case 56: 2269 2270/* Line 1455 of yacc.c */ 2271#line 668 "./parse.y" 2272 { 2273 ++rulelen; 2274 2275 if ( caseins && (yyvsp[(1) - (1)]) >= 'A' && (yyvsp[(1) - (1)]) <= 'Z' ) 2276 (yyvsp[(1) - (1)]) = clower( (yyvsp[(1) - (1)]) ); 2277 2278 (yyval) = mkstate( (yyvsp[(1) - (1)]) ); 2279 } 2280 break; 2281 2282 case 57: 2283 2284/* Line 1455 of yacc.c */ 2285#line 679 "./parse.y" 2286 { (yyval) = (yyvsp[(2) - (3)]); } 2287 break; 2288 2289 case 58: 2290 2291/* Line 1455 of yacc.c */ 2292#line 682 "./parse.y" 2293 { 2294 cclnegate( (yyvsp[(3) - (4)]) ); 2295 (yyval) = (yyvsp[(3) - (4)]); 2296 } 2297 break; 2298 2299 case 59: 2300 2301/* Line 1455 of yacc.c */ 2302#line 689 "./parse.y" 2303 { 2304 if ( caseins ) 2305 { 2306 if ( (yyvsp[(2) - (4)]) >= 'A' && (yyvsp[(2) - (4)]) <= 'Z' ) 2307 (yyvsp[(2) - (4)]) = clower( (yyvsp[(2) - (4)]) ); 2308 if ( (yyvsp[(4) - (4)]) >= 'A' && (yyvsp[(4) - (4)]) <= 'Z' ) 2309 (yyvsp[(4) - (4)]) = clower( (yyvsp[(4) - (4)]) ); 2310 } 2311 2312 if ( (yyvsp[(2) - (4)]) > (yyvsp[(4) - (4)]) ) 2313 synerr( "negative range in character class" ); 2314 2315 else 2316 { 2317 for ( i = (yyvsp[(2) - (4)]); i <= (yyvsp[(4) - (4)]); ++i ) 2318 ccladd( (yyvsp[(1) - (4)]), i ); 2319 2320 /* Keep track if this ccl is staying in 2321 * alphabetical order. 2322 */ 2323 cclsorted = cclsorted && ((yyvsp[(2) - (4)]) > lastchar); 2324 lastchar = (yyvsp[(4) - (4)]); 2325 } 2326 2327 (yyval) = (yyvsp[(1) - (4)]); 2328 } 2329 break; 2330 2331 case 60: 2332 2333/* Line 1455 of yacc.c */ 2334#line 717 "./parse.y" 2335 { 2336 if ( caseins && (yyvsp[(2) - (2)]) >= 'A' && (yyvsp[(2) - (2)]) <= 'Z' ) 2337 (yyvsp[(2) - (2)]) = clower( (yyvsp[(2) - (2)]) ); 2338 2339 ccladd( (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]) ); 2340 cclsorted = cclsorted && ((yyvsp[(2) - (2)]) > lastchar); 2341 lastchar = (yyvsp[(2) - (2)]); 2342 (yyval) = (yyvsp[(1) - (2)]); 2343 } 2344 break; 2345 2346 case 61: 2347 2348/* Line 1455 of yacc.c */ 2349#line 728 "./parse.y" 2350 { 2351 /* Too hard to properly maintain cclsorted. */ 2352 cclsorted = false; 2353 (yyval) = (yyvsp[(1) - (2)]); 2354 } 2355 break; 2356 2357 case 62: 2358 2359/* Line 1455 of yacc.c */ 2360#line 735 "./parse.y" 2361 { 2362 cclsorted = true; 2363 lastchar = 0; 2364 currccl = (yyval) = cclinit(); 2365 } 2366 break; 2367 2368 case 63: 2369 2370/* Line 1455 of yacc.c */ 2371#line 742 "./parse.y" 2372 { CCL_EXPR(isalnum) } 2373 break; 2374 2375 case 64: 2376 2377/* Line 1455 of yacc.c */ 2378#line 743 "./parse.y" 2379 { CCL_EXPR(isalpha) } 2380 break; 2381 2382 case 65: 2383 2384/* Line 1455 of yacc.c */ 2385#line 744 "./parse.y" 2386 { CCL_EXPR(IS_BLANK) } 2387 break; 2388 2389 case 66: 2390 2391/* Line 1455 of yacc.c */ 2392#line 745 "./parse.y" 2393 { CCL_EXPR(iscntrl) } 2394 break; 2395 2396 case 67: 2397 2398/* Line 1455 of yacc.c */ 2399#line 746 "./parse.y" 2400 { CCL_EXPR(isdigit) } 2401 break; 2402 2403 case 68: 2404 2405/* Line 1455 of yacc.c */ 2406#line 747 "./parse.y" 2407 { CCL_EXPR(isgraph) } 2408 break; 2409 2410 case 69: 2411 2412/* Line 1455 of yacc.c */ 2413#line 748 "./parse.y" 2414 { CCL_EXPR(islower) } 2415 break; 2416 2417 case 70: 2418 2419/* Line 1455 of yacc.c */ 2420#line 749 "./parse.y" 2421 { CCL_EXPR(isprint) } 2422 break; 2423 2424 case 71: 2425 2426/* Line 1455 of yacc.c */ 2427#line 750 "./parse.y" 2428 { CCL_EXPR(ispunct) } 2429 break; 2430 2431 case 72: 2432 2433/* Line 1455 of yacc.c */ 2434#line 751 "./parse.y" 2435 { CCL_EXPR(isspace) } 2436 break; 2437 2438 case 73: 2439 2440/* Line 1455 of yacc.c */ 2441#line 752 "./parse.y" 2442 { 2443 if ( caseins ) 2444 CCL_EXPR(islower) 2445 else 2446 CCL_EXPR(isupper) 2447 } 2448 break; 2449 2450 case 74: 2451 2452/* Line 1455 of yacc.c */ 2453#line 758 "./parse.y" 2454 { CCL_EXPR(isxdigit) } 2455 break; 2456 2457 case 75: 2458 2459/* Line 1455 of yacc.c */ 2460#line 762 "./parse.y" 2461 { 2462 if ( caseins && (yyvsp[(2) - (2)]) >= 'A' && (yyvsp[(2) - (2)]) <= 'Z' ) 2463 (yyvsp[(2) - (2)]) = clower( (yyvsp[(2) - (2)]) ); 2464 2465 ++rulelen; 2466 2467 (yyval) = link_machines( (yyvsp[(1) - (2)]), mkstate( (yyvsp[(2) - (2)]) ) ); 2468 } 2469 break; 2470 2471 case 76: 2472 2473/* Line 1455 of yacc.c */ 2474#line 772 "./parse.y" 2475 { (yyval) = mkstate( SYM_EPSILON ); } 2476 break; 2477 2478 2479 2480/* Line 1455 of yacc.c */ 2481#line 2482 "y.tab.c" 2482 default: break; 2483 } 2484 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 2485 2486 YYPOPSTACK (yylen); 2487 yylen = 0; 2488 YY_STACK_PRINT (yyss, yyssp); 2489 2490 *++yyvsp = yyval; 2491 2492 /* Now `shift' the result of the reduction. Determine what state 2493 that goes to, based on the state we popped back to and the rule 2494 number reduced by. */ 2495 2496 yyn = yyr1[yyn]; 2497 2498 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2499 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2500 yystate = yytable[yystate]; 2501 else 2502 yystate = yydefgoto[yyn - YYNTOKENS]; 2503 2504 goto yynewstate; 2505 2506 2507/*------------------------------------. 2508| yyerrlab -- here on detecting error | 2509`------------------------------------*/ 2510yyerrlab: 2511 /* If not already recovering from an error, report this error. */ 2512 if (!yyerrstatus) 2513 { 2514 ++yynerrs; 2515#if ! YYERROR_VERBOSE 2516 yyerror (YY_("syntax error")); 2517#else 2518 { 2519 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 2520 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 2521 { 2522 YYSIZE_T yyalloc = 2 * yysize; 2523 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 2524 yyalloc = YYSTACK_ALLOC_MAXIMUM; 2525 if (yymsg != yymsgbuf) 2526 YYSTACK_FREE (yymsg); 2527 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 2528 if (yymsg) 2529 yymsg_alloc = yyalloc; 2530 else 2531 { 2532 yymsg = yymsgbuf; 2533 yymsg_alloc = sizeof yymsgbuf; 2534 } 2535 } 2536 2537 if (0 < yysize && yysize <= yymsg_alloc) 2538 { 2539 (void) yysyntax_error (yymsg, yystate, yychar); 2540 yyerror (yymsg); 2541 } 2542 else 2543 { 2544 yyerror (YY_("syntax error")); 2545 if (yysize != 0) 2546 goto yyexhaustedlab; 2547 } 2548 } 2549#endif 2550 } 2551 2552 2553 2554 if (yyerrstatus == 3) 2555 { 2556 /* If just tried and failed to reuse lookahead token after an 2557 error, discard it. */ 2558 2559 if (yychar <= YYEOF) 2560 { 2561 /* Return failure if at end of input. */ 2562 if (yychar == YYEOF) 2563 YYABORT; 2564 } 2565 else 2566 { 2567 yydestruct ("Error: discarding", 2568 yytoken, &yylval); 2569 yychar = YYEMPTY; 2570 } 2571 } 2572 2573 /* Else will try to reuse lookahead token after shifting the error 2574 token. */ 2575 goto yyerrlab1; 2576 2577 2578/*---------------------------------------------------. 2579| yyerrorlab -- error raised explicitly by YYERROR. | 2580`---------------------------------------------------*/ 2581yyerrorlab: 2582 2583 /* Pacify compilers like GCC when the user code never invokes 2584 YYERROR and the label yyerrorlab therefore never appears in user 2585 code. */ 2586 if (/*CONSTCOND*/ 0) 2587 goto yyerrorlab; 2588 2589 /* Do not reclaim the symbols of the rule which action triggered 2590 this YYERROR. */ 2591 YYPOPSTACK (yylen); 2592 yylen = 0; 2593 YY_STACK_PRINT (yyss, yyssp); 2594 yystate = *yyssp; 2595 goto yyerrlab1; 2596 2597 2598/*-------------------------------------------------------------. 2599| yyerrlab1 -- common code for both syntax error and YYERROR. | 2600`-------------------------------------------------------------*/ 2601yyerrlab1: 2602 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2603 2604 for (;;) 2605 { 2606 yyn = yypact[yystate]; 2607 if (yyn != YYPACT_NINF) 2608 { 2609 yyn += YYTERROR; 2610 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2611 { 2612 yyn = yytable[yyn]; 2613 if (0 < yyn) 2614 break; 2615 } 2616 } 2617 2618 /* Pop the current state because it cannot handle the error token. */ 2619 if (yyssp == yyss) 2620 YYABORT; 2621 2622 2623 yydestruct ("Error: popping", 2624 yystos[yystate], yyvsp); 2625 YYPOPSTACK (1); 2626 yystate = *yyssp; 2627 YY_STACK_PRINT (yyss, yyssp); 2628 } 2629 2630 *++yyvsp = yylval; 2631 2632 2633 /* Shift the error token. */ 2634 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2635 2636 yystate = yyn; 2637 goto yynewstate; 2638 2639 2640/*-------------------------------------. 2641| yyacceptlab -- YYACCEPT comes here. | 2642`-------------------------------------*/ 2643yyacceptlab: 2644 yyresult = 0; 2645 goto yyreturn; 2646 2647/*-----------------------------------. 2648| yyabortlab -- YYABORT comes here. | 2649`-----------------------------------*/ 2650yyabortlab: 2651 yyresult = 1; 2652 goto yyreturn; 2653 2654#if !defined(yyoverflow) || YYERROR_VERBOSE 2655/*-------------------------------------------------. 2656| yyexhaustedlab -- memory exhaustion comes here. | 2657`-------------------------------------------------*/ 2658yyexhaustedlab: 2659 yyerror (YY_("memory exhausted")); 2660 yyresult = 2; 2661 /* Fall through. */ 2662#endif 2663 2664yyreturn: 2665 if (yychar != YYEMPTY) 2666 yydestruct ("Cleanup: discarding lookahead", 2667 yytoken, &yylval); 2668 /* Do not reclaim the symbols of the rule which action triggered 2669 this YYABORT or YYACCEPT. */ 2670 YYPOPSTACK (yylen); 2671 YY_STACK_PRINT (yyss, yyssp); 2672 while (yyssp != yyss) 2673 { 2674 yydestruct ("Cleanup: popping", 2675 yystos[*yyssp], yyvsp); 2676 YYPOPSTACK (1); 2677 } 2678#ifndef yyoverflow 2679 if (yyss != yyssa) 2680 YYSTACK_FREE (yyss); 2681#endif 2682#if YYERROR_VERBOSE 2683 if (yymsg != yymsgbuf) 2684 YYSTACK_FREE (yymsg); 2685#endif 2686 /* Make sure YYID is used. */ 2687 return YYID (yyresult); 2688} 2689 2690 2691 2692/* Line 1675 of yacc.c */ 2693#line 775 "./parse.y" 2694 2695 2696 2697/* build_eof_action - build the "<<EOF>>" action for the active start 2698 * conditions 2699 */ 2700 2701void build_eof_action() 2702 { 2703 register int i; 2704 char action_text[MAXLINE]; 2705 2706 for ( i = 1; i <= scon_stk_ptr; ++i ) 2707 { 2708 if ( sceof[scon_stk[i]] ) 2709 format_pinpoint_message( 2710 "multiple <<EOF>> rules for start condition %s", 2711 scname[scon_stk[i]] ); 2712 2713 else 2714 { 2715 sceof[scon_stk[i]] = true; 2716 sprintf( action_text, "case YY_STATE_EOF(%s):\n", 2717 scname[scon_stk[i]] ); 2718 add_action( action_text ); 2719 } 2720 } 2721 2722 line_directive_out( (FILE *) 0, 1 ); 2723 2724 /* This isn't a normal rule after all - don't count it as 2725 * such, so we don't have any holes in the rule numbering 2726 * (which make generating "rule can never match" warnings 2727 * more difficult. 2728 */ 2729 --num_rules; 2730 ++num_eof_rules; 2731 } 2732 2733 2734/* format_synerr - write out formatted syntax error */ 2735 2736void format_synerr( msg, arg ) 2737char msg[], arg[]; 2738 { 2739 char errmsg[MAXLINE]; 2740 2741 (void) sprintf( errmsg, msg, arg ); 2742 synerr( errmsg ); 2743 } 2744 2745 2746/* synerr - report a syntax error */ 2747 2748void synerr( str ) 2749char str[]; 2750 { 2751 syntaxerror = true; 2752 pinpoint_message( str ); 2753 } 2754 2755 2756/* format_warn - write out formatted warning */ 2757 2758void format_warn( msg, arg ) 2759char msg[], arg[]; 2760 { 2761 char warn_msg[MAXLINE]; 2762 2763 (void) sprintf( warn_msg, msg, arg ); 2764 warn( warn_msg ); 2765 } 2766 2767 2768/* warn - report a warning, unless -w was given */ 2769 2770void warn( str ) 2771char str[]; 2772 { 2773 line_warning( str, linenum ); 2774 } 2775 2776/* format_pinpoint_message - write out a message formatted with one string, 2777 * pinpointing its location 2778 */ 2779 2780void format_pinpoint_message( msg, arg ) 2781char msg[], arg[]; 2782 { 2783 char errmsg[MAXLINE]; 2784 2785 (void) sprintf( errmsg, msg, arg ); 2786 pinpoint_message( errmsg ); 2787 } 2788 2789 2790/* pinpoint_message - write out a message, pinpointing its location */ 2791 2792void pinpoint_message( str ) 2793char str[]; 2794 { 2795 line_pinpoint( str, linenum ); 2796 } 2797 2798 2799/* line_warning - report a warning at a given line, unless -w was given */ 2800 2801void line_warning( str, line ) 2802char str[]; 2803int line; 2804 { 2805 char warning[MAXLINE]; 2806 2807 if ( ! nowarn ) 2808 { 2809 sprintf( warning, "warning, %s", str ); 2810 line_pinpoint( warning, line ); 2811 } 2812 } 2813 2814 2815/* line_pinpoint - write out a message, pinpointing it at the given line */ 2816 2817void line_pinpoint( str, line ) 2818char str[]; 2819int line; 2820 { 2821 fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str ); 2822 } 2823 2824 2825/* yyerror - eat up an error message from the parser; 2826 * currently, messages are ignore 2827 */ 2828 2829void yyerror( msg ) 2830char msg[]; 2831 { 2832 } 2833 2834