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