1 /* A Bison parser, made by GNU Bison 2.1. */ 2 3 /* Skeleton parser for Yacc-like parsing with Bison, 4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street, Fifth Floor, 19 Boston, MA 02110-1301, USA. */ 20 21 /* As a special exception, when this file is copied by Bison into a 22 Bison output file, you may use that output file without restriction. 23 This special exception was added by the Free Software Foundation 24 in version 1.24 of Bison. */ 25 26 /* Written by Richard Stallman by simplifying the original so called 27 ``semantic'' parser. */ 28 29 /* All symbols defined below should begin with yy or YY, to avoid 30 infringing on user name space. This should be done even for local 31 variables, as they might otherwise be expanded by user macros. 32 There are some unavoidable exceptions within include files to 33 define necessary library symbols; they are noted "INFRINGES ON 34 USER NAME SPACE" below. */ 35 36 /* Identify Bison output. */ 37 #define YYBISON 1 38 39 /* Bison version. */ 40 #define YYBISON_VERSION "2.1" 41 42 /* Skeleton name. */ 43 #define YYSKELETON_NAME "yacc.c" 44 45 /* Pure parsers. */ 46 #define YYPURE 0 47 48 /* Using locations. */ 49 #define YYLSP_NEEDED 0 50 51 /* Substitute the variable and function names. */ 52 #define yyparse pcap_parse 53 #define yylex pcap_lex 54 #define yyerror pcap_error 55 #define yylval pcap_lval 56 #define yychar pcap_char 57 #define yydebug pcap_debug 58 #define yynerrs pcap_nerrs 59 60 61 /* Tokens. */ 62 #ifndef YYTOKENTYPE 63 # define YYTOKENTYPE 64 /* Put the tokens into the symbol table, so that GDB and other debuggers 65 know about them. */ 66 enum yytokentype { 67 DST = 258, 68 SRC = 259, 69 HOST = 260, 70 GATEWAY = 261, 71 NET = 262, 72 NETMASK = 263, 73 PORT = 264, 74 PORTRANGE = 265, 75 LESS = 266, 76 GREATER = 267, 77 PROTO = 268, 78 PROTOCHAIN = 269, 79 CBYTE = 270, 80 ARP = 271, 81 RARP = 272, 82 IP = 273, 83 SCTP = 274, 84 TCP = 275, 85 UDP = 276, 86 ICMP = 277, 87 IGMP = 278, 88 IGRP = 279, 89 PIM = 280, 90 VRRP = 281, 91 ATALK = 282, 92 AARP = 283, 93 DECNET = 284, 94 LAT = 285, 95 SCA = 286, 96 MOPRC = 287, 97 MOPDL = 288, 98 TK_BROADCAST = 289, 99 TK_MULTICAST = 290, 100 NUM = 291, 101 INBOUND = 292, 102 OUTBOUND = 293, 103 PF_IFNAME = 294, 104 PF_RSET = 295, 105 PF_RNR = 296, 106 PF_SRNR = 297, 107 PF_REASON = 298, 108 PF_ACTION = 299, 109 LINK = 300, 110 GEQ = 301, 111 LEQ = 302, 112 NEQ = 303, 113 ID = 304, 114 EID = 305, 115 HID = 306, 116 HID6 = 307, 117 AID = 308, 118 LSH = 309, 119 RSH = 310, 120 LEN = 311, 121 IPV6 = 312, 122 ICMPV6 = 313, 123 AH = 314, 124 ESP = 315, 125 VLAN = 316, 126 MPLS = 317, 127 PPPOED = 318, 128 PPPOES = 319, 129 ISO = 320, 130 ESIS = 321, 131 CLNP = 322, 132 ISIS = 323, 133 L1 = 324, 134 L2 = 325, 135 IIH = 326, 136 LSP = 327, 137 SNP = 328, 138 CSNP = 329, 139 PSNP = 330, 140 STP = 331, 141 IPX = 332, 142 NETBEUI = 333, 143 LANE = 334, 144 LLC = 335, 145 METAC = 336, 146 BCC = 337, 147 SC = 338, 148 ILMIC = 339, 149 OAMF4EC = 340, 150 OAMF4SC = 341, 151 OAM = 342, 152 OAMF4 = 343, 153 CONNECTMSG = 344, 154 METACONNECT = 345, 155 VPI = 346, 156 VCI = 347, 157 RADIO = 348, 158 FISU = 349, 159 LSSU = 350, 160 MSU = 351, 161 SIO = 352, 162 OPC = 353, 163 DPC = 354, 164 SLS = 355, 165 AND = 356, 166 OR = 357, 167 UMINUS = 358 168 }; 169 #endif 170 /* Tokens. */ 171 #define DST 258 172 #define SRC 259 173 #define HOST 260 174 #define GATEWAY 261 175 #define NET 262 176 #define NETMASK 263 177 #define PORT 264 178 #define PORTRANGE 265 179 #define LESS 266 180 #define GREATER 267 181 #define PROTO 268 182 #define PROTOCHAIN 269 183 #define CBYTE 270 184 #define ARP 271 185 #define RARP 272 186 #define IP 273 187 #define SCTP 274 188 #define TCP 275 189 #define UDP 276 190 #define ICMP 277 191 #define IGMP 278 192 #define IGRP 279 193 #define PIM 280 194 #define VRRP 281 195 #define ATALK 282 196 #define AARP 283 197 #define DECNET 284 198 #define LAT 285 199 #define SCA 286 200 #define MOPRC 287 201 #define MOPDL 288 202 #define TK_BROADCAST 289 203 #define TK_MULTICAST 290 204 #define NUM 291 205 #define INBOUND 292 206 #define OUTBOUND 293 207 #define PF_IFNAME 294 208 #define PF_RSET 295 209 #define PF_RNR 296 210 #define PF_SRNR 297 211 #define PF_REASON 298 212 #define PF_ACTION 299 213 #define LINK 300 214 #define GEQ 301 215 #define LEQ 302 216 #define NEQ 303 217 #define ID 304 218 #define EID 305 219 #define HID 306 220 #define HID6 307 221 #define AID 308 222 #define LSH 309 223 #define RSH 310 224 #define LEN 311 225 #define IPV6 312 226 #define ICMPV6 313 227 #define AH 314 228 #define ESP 315 229 #define VLAN 316 230 #define MPLS 317 231 #define PPPOED 318 232 #define PPPOES 319 233 #define ISO 320 234 #define ESIS 321 235 #define CLNP 322 236 #define ISIS 323 237 #define L1 324 238 #define L2 325 239 #define IIH 326 240 #define LSP 327 241 #define SNP 328 242 #define CSNP 329 243 #define PSNP 330 244 #define STP 331 245 #define IPX 332 246 #define NETBEUI 333 247 #define LANE 334 248 #define LLC 335 249 #define METAC 336 250 #define BCC 337 251 #define SC 338 252 #define ILMIC 339 253 #define OAMF4EC 340 254 #define OAMF4SC 341 255 #define OAM 342 256 #define OAMF4 343 257 #define CONNECTMSG 344 258 #define METACONNECT 345 259 #define VPI 346 260 #define VCI 347 261 #define RADIO 348 262 #define FISU 349 263 #define LSSU 350 264 #define MSU 351 265 #define SIO 352 266 #define OPC 353 267 #define DPC 354 268 #define SLS 355 269 #define AND 356 270 #define OR 357 271 #define UMINUS 358 272 273 274 275 276 /* Copy the first part of user declarations. */ 277 #line 1 "grammar.y" 278 279 /* 280 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996 281 * The Regents of the University of California. All rights reserved. 282 * 283 * Redistribution and use in source and binary forms, with or without 284 * modification, are permitted provided that: (1) source code distributions 285 * retain the above copyright notice and this paragraph in its entirety, (2) 286 * distributions including binary code include the above copyright notice and 287 * this paragraph in its entirety in the documentation or other materials 288 * provided with the distribution, and (3) all advertising materials mentioning 289 * features or use of this software display the following acknowledgement: 290 * ``This product includes software developed by the University of California, 291 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of 292 * the University nor the names of its contributors may be used to endorse 293 * or promote products derived from this software without specific prior 294 * written permission. 295 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 296 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 297 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 298 * 299 */ 300 #ifndef lint 301 static const char rcsid[] _U_ = 302 "@(#) $Header: /tcpdump/master/libpcap/grammar.y,v 1.86.2.9 2007/09/12 19:17:25 guy Exp $ (LBL)"; 303 #endif 304 305 #ifdef HAVE_CONFIG_H 306 #include "config.h" 307 #endif 308 309 #ifdef WIN32 310 #include <pcap-stdinc.h> 311 #else /* WIN32 */ 312 #include <sys/types.h> 313 #include <sys/socket.h> 314 #endif /* WIN32 */ 315 316 #include <stdlib.h> 317 318 #ifndef WIN32 319 #if __STDC__ 320 struct mbuf; 321 struct rtentry; 322 #endif 323 324 #include <netinet/in.h> 325 #endif /* WIN32 */ 326 327 #include <stdio.h> 328 329 #include "pcap-int.h" 330 331 #include "gencode.h" 332 #ifdef HAVE_NET_PFVAR_H 333 #include <net/if.h> 334 #include <net/pfvar.h> 335 #include <net/if_pflog.h> 336 #endif 337 #include <pcap-namedb.h> 338 339 #ifdef HAVE_OS_PROTO_H 340 #include "os-proto.h" 341 #endif 342 343 #define QSET(q, p, d, a) (q).proto = (p),\ 344 (q).dir = (d),\ 345 (q).addr = (a) 346 347 int n_errors = 0; 348 349 static struct qual qerr = { Q_UNDEF, Q_UNDEF, Q_UNDEF, Q_UNDEF }; 350 351 static void 352 yyerror(const char *msg) 353 { 354 ++n_errors; 355 bpf_error("%s", msg); 356 /* NOTREACHED */ 357 } 358 359 #ifndef YYBISON 360 int yyparse(void); 361 362 int 363 pcap_parse() 364 { 365 return (yyparse()); 366 } 367 #endif 368 369 #ifdef HAVE_NET_PFVAR_H 370 static int 371 pfreason_to_num(const char *reason) 372 { 373 const char *reasons[] = PFRES_NAMES; 374 int i; 375 376 for (i = 0; reasons[i]; i++) { 377 if (pcap_strcasecmp(reason, reasons[i]) == 0) 378 return (i); 379 } 380 bpf_error("unknown PF reason"); 381 /*NOTREACHED*/ 382 } 383 384 static int 385 pfaction_to_num(const char *action) 386 { 387 if (pcap_strcasecmp(action, "pass") == 0 || 388 pcap_strcasecmp(action, "accept") == 0) 389 return (PF_PASS); 390 else if (pcap_strcasecmp(action, "drop") == 0 || 391 pcap_strcasecmp(action, "block") == 0) 392 return (PF_DROP); 393 else { 394 bpf_error("unknown PF action"); 395 /*NOTREACHED*/ 396 } 397 } 398 #else /* !HAVE_NET_PFVAR_H */ 399 static int 400 pfreason_to_num(const char *reason) 401 { 402 bpf_error("libpcap was compiled on a machine without pf support"); 403 /*NOTREACHED*/ 404 } 405 406 static int 407 pfaction_to_num(const char *action) 408 { 409 bpf_error("libpcap was compiled on a machine without pf support"); 410 /*NOTREACHED*/ 411 } 412 #endif /* HAVE_NET_PFVAR_H */ 413 414 415 /* Enabling traces. */ 416 #ifndef YYDEBUG 417 # define YYDEBUG 0 418 #endif 419 420 /* Enabling verbose error messages. */ 421 #ifdef YYERROR_VERBOSE 422 # undef YYERROR_VERBOSE 423 # define YYERROR_VERBOSE 1 424 #else 425 # define YYERROR_VERBOSE 0 426 #endif 427 428 /* Enabling the token table. */ 429 #ifndef YYTOKEN_TABLE 430 # define YYTOKEN_TABLE 0 431 #endif 432 433 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) 434 #line 138 "grammar.y" 435 typedef union YYSTYPE { 436 int i; 437 bpf_u_int32 h; 438 u_char *e; 439 char *s; 440 struct stmt *stmt; 441 struct arth *a; 442 struct { 443 struct qual q; 444 int atmfieldtype; 445 int mtp3fieldtype; 446 struct block *b; 447 } blk; 448 struct block *rblk; 449 } YYSTYPE; 450 /* Line 196 of yacc.c. */ 451 #line 452 "y.tab.c" 452 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 453 # define YYSTYPE_IS_DECLARED 1 454 # define YYSTYPE_IS_TRIVIAL 1 455 #endif 456 457 458 459 /* Copy the second part of user declarations. */ 460 461 462 /* Line 219 of yacc.c. */ 463 #line 464 "y.tab.c" 464 465 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) 466 # define YYSIZE_T __SIZE_TYPE__ 467 #endif 468 #if ! defined (YYSIZE_T) && defined (size_t) 469 # define YYSIZE_T size_t 470 #endif 471 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus)) 472 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 473 # define YYSIZE_T size_t 474 #endif 475 #if ! defined (YYSIZE_T) 476 # define YYSIZE_T unsigned int 477 #endif 478 479 #ifndef YY_ 480 # if YYENABLE_NLS 481 # if ENABLE_NLS 482 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 483 # define YY_(msgid) dgettext ("bison-runtime", msgid) 484 # endif 485 # endif 486 # ifndef YY_ 487 # define YY_(msgid) msgid 488 # endif 489 #endif 490 491 #if ! defined (yyoverflow) || YYERROR_VERBOSE 492 493 /* The parser invokes alloca or malloc; define the necessary symbols. */ 494 495 # ifdef YYSTACK_USE_ALLOCA 496 # if YYSTACK_USE_ALLOCA 497 # ifdef __GNUC__ 498 # define YYSTACK_ALLOC __builtin_alloca 499 # else 500 # define YYSTACK_ALLOC alloca 501 # if defined (__STDC__) || defined (__cplusplus) 502 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 503 # define YYINCLUDED_STDLIB_H 504 # endif 505 # endif 506 # endif 507 # endif 508 509 # ifdef YYSTACK_ALLOC 510 /* Pacify GCC's `empty if-body' warning. */ 511 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) 512 # ifndef YYSTACK_ALLOC_MAXIMUM 513 /* The OS might guarantee only one guard page at the bottom of the stack, 514 and a page size can be as small as 4096 bytes. So we cannot safely 515 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 516 to allow for a few compiler-allocated temporary stack slots. */ 517 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */ 518 # endif 519 # else 520 # define YYSTACK_ALLOC YYMALLOC 521 # define YYSTACK_FREE YYFREE 522 # ifndef YYSTACK_ALLOC_MAXIMUM 523 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1) 524 # endif 525 # ifdef __cplusplus 526 extern "C" { 527 # endif 528 # ifndef YYMALLOC 529 # define YYMALLOC malloc 530 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \ 531 && (defined (__STDC__) || defined (__cplusplus))) 532 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 533 # endif 534 # endif 535 # ifndef YYFREE 536 # define YYFREE free 537 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \ 538 && (defined (__STDC__) || defined (__cplusplus))) 539 void free (void *); /* INFRINGES ON USER NAME SPACE */ 540 # endif 541 # endif 542 # ifdef __cplusplus 543 } 544 # endif 545 # endif 546 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ 547 548 549 #if (! defined (yyoverflow) \ 550 && (! defined (__cplusplus) \ 551 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) 552 553 /* A type that is properly aligned for any stack member. */ 554 union yyalloc 555 { 556 short int yyss; 557 YYSTYPE yyvs; 558 }; 559 560 /* The size of the maximum gap between one aligned stack and the next. */ 561 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 562 563 /* The size of an array large to enough to hold all stacks, each with 564 N elements. */ 565 # define YYSTACK_BYTES(N) \ 566 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \ 567 + YYSTACK_GAP_MAXIMUM) 568 569 /* Copy COUNT objects from FROM to TO. The source and destination do 570 not overlap. */ 571 # ifndef YYCOPY 572 # if defined (__GNUC__) && 1 < __GNUC__ 573 # define YYCOPY(To, From, Count) \ 574 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 575 # else 576 # define YYCOPY(To, From, Count) \ 577 do \ 578 { \ 579 YYSIZE_T yyi; \ 580 for (yyi = 0; yyi < (Count); yyi++) \ 581 (To)[yyi] = (From)[yyi]; \ 582 } \ 583 while (0) 584 # endif 585 # endif 586 587 /* Relocate STACK from its old location to the new one. The 588 local variables YYSIZE and YYSTACKSIZE give the old and new number of 589 elements in the stack, and YYPTR gives the new location of the 590 stack. Advance YYPTR to a properly aligned location for the next 591 stack. */ 592 # define YYSTACK_RELOCATE(Stack) \ 593 do \ 594 { \ 595 YYSIZE_T yynewbytes; \ 596 YYCOPY (&yyptr->Stack, Stack, yysize); \ 597 Stack = &yyptr->Stack; \ 598 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 599 yyptr += yynewbytes / sizeof (*yyptr); \ 600 } \ 601 while (0) 602 603 #endif 604 605 #if defined (__STDC__) || defined (__cplusplus) 606 typedef signed char yysigned_char; 607 #else 608 typedef short int yysigned_char; 609 #endif 610 611 /* YYFINAL -- State number of the termination state. */ 612 #define YYFINAL 3 613 /* YYLAST -- Last index in YYTABLE. */ 614 #define YYLAST 605 615 616 /* YYNTOKENS -- Number of terminals. */ 617 #define YYNTOKENS 119 618 /* YYNNTS -- Number of nonterminals. */ 619 #define YYNNTS 41 620 /* YYNRULES -- Number of rules. */ 621 #define YYNRULES 186 622 /* YYNRULES -- Number of states. */ 623 #define YYNSTATES 254 624 625 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 626 #define YYUNDEFTOK 2 627 #define YYMAXUTOK 358 628 629 #define YYTRANSLATE(YYX) \ 630 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 631 632 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 633 static const unsigned char yytranslate[] = 634 { 635 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 636 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 637 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 638 2, 2, 2, 103, 2, 2, 2, 2, 105, 2, 639 112, 111, 108, 106, 2, 107, 2, 109, 2, 2, 640 2, 2, 2, 2, 2, 2, 2, 2, 118, 2, 641 115, 114, 113, 2, 2, 2, 2, 2, 2, 2, 642 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 643 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 644 2, 116, 2, 117, 2, 2, 2, 2, 2, 2, 645 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 646 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 647 2, 2, 2, 2, 104, 2, 2, 2, 2, 2, 648 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 649 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 650 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 651 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 652 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 653 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 654 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 655 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 656 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 657 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 658 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 659 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 660 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 661 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 662 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 663 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 664 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 665 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 666 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 667 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 668 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 669 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 670 95, 96, 97, 98, 99, 100, 101, 102, 110 671 }; 672 673 #if YYDEBUG 674 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 675 YYRHS. */ 676 static const unsigned short int yyprhs[] = 677 { 678 0, 0, 3, 6, 8, 9, 11, 15, 19, 23, 679 27, 29, 31, 33, 35, 39, 41, 45, 49, 51, 680 55, 57, 59, 61, 64, 66, 68, 70, 74, 78, 681 80, 82, 84, 87, 91, 94, 97, 100, 103, 106, 682 109, 113, 115, 119, 123, 125, 127, 129, 132, 134, 683 137, 139, 140, 142, 144, 148, 152, 156, 160, 162, 684 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 685 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 686 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 687 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 688 244, 246, 249, 252, 255, 258, 263, 265, 267, 270, 689 272, 275, 277, 279, 281, 283, 286, 289, 292, 295, 690 298, 301, 303, 305, 307, 309, 311, 313, 315, 317, 691 319, 321, 323, 328, 335, 339, 343, 347, 351, 355, 692 359, 363, 367, 370, 374, 376, 378, 380, 382, 384, 693 386, 388, 392, 394, 396, 398, 400, 402, 404, 406, 694 408, 410, 412, 414, 416, 418, 420, 422, 425, 428, 695 432, 434, 436, 440, 442, 444, 446, 448, 450, 452, 696 454, 456, 459, 462, 466, 468, 470 697 }; 698 699 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 700 static const short int yyrhs[] = 701 { 702 120, 0, -1, 121, 122, -1, 121, -1, -1, 131, 703 -1, 122, 123, 131, -1, 122, 123, 125, -1, 122, 704 124, 131, -1, 122, 124, 125, -1, 101, -1, 102, 705 -1, 126, -1, 148, -1, 128, 129, 111, -1, 49, 706 -1, 51, 109, 36, -1, 51, 8, 51, -1, 51, 707 -1, 52, 109, 36, -1, 52, -1, 50, -1, 53, 708 -1, 127, 125, -1, 103, -1, 112, -1, 126, -1, 709 130, 123, 125, -1, 130, 124, 125, -1, 148, -1, 710 129, -1, 133, -1, 127, 131, -1, 134, 135, 136, 711 -1, 134, 135, -1, 134, 136, -1, 134, 13, -1, 712 134, 14, -1, 134, 137, -1, 132, 125, -1, 128, 713 122, 111, -1, 138, -1, 145, 143, 145, -1, 145, 714 144, 145, -1, 139, -1, 149, -1, 150, -1, 151, 715 152, -1, 155, -1, 156, 157, -1, 138, -1, -1, 716 4, -1, 3, -1, 4, 102, 3, -1, 3, 102, 717 4, -1, 4, 101, 3, -1, 3, 101, 4, -1, 718 5, -1, 7, -1, 9, -1, 10, -1, 6, -1, 719 45, -1, 18, -1, 16, -1, 17, -1, 19, -1, 720 20, -1, 21, -1, 22, -1, 23, -1, 24, -1, 721 25, -1, 26, -1, 27, -1, 28, -1, 29, -1, 722 30, -1, 31, -1, 33, -1, 32, -1, 57, -1, 723 58, -1, 59, -1, 60, -1, 65, -1, 66, -1, 724 68, -1, 69, -1, 70, -1, 71, -1, 72, -1, 725 73, -1, 75, -1, 74, -1, 67, -1, 76, -1, 726 77, -1, 78, -1, 93, -1, 134, 34, -1, 134, 727 35, -1, 11, 36, -1, 12, 36, -1, 15, 36, 728 147, 36, -1, 37, -1, 38, -1, 61, 148, -1, 729 61, -1, 62, 148, -1, 62, -1, 63, -1, 64, 730 -1, 140, -1, 39, 49, -1, 40, 49, -1, 41, 731 36, -1, 42, 36, -1, 43, 141, -1, 44, 142, 732 -1, 36, -1, 49, -1, 49, -1, 113, -1, 46, 733 -1, 114, -1, 47, -1, 115, -1, 48, -1, 148, 734 -1, 146, -1, 138, 116, 145, 117, -1, 138, 116, 735 145, 118, 36, 117, -1, 145, 106, 145, -1, 145, 736 107, 145, -1, 145, 108, 145, -1, 145, 109, 145, 737 -1, 145, 105, 145, -1, 145, 104, 145, -1, 145, 738 54, 145, -1, 145, 55, 145, -1, 107, 145, -1, 739 128, 146, 111, -1, 56, -1, 105, -1, 104, -1, 740 115, -1, 113, -1, 114, -1, 36, -1, 128, 148, 741 111, -1, 79, -1, 80, -1, 81, -1, 82, -1, 742 85, -1, 86, -1, 83, -1, 84, -1, 87, -1, 743 88, -1, 89, -1, 90, -1, 91, -1, 92, -1, 744 153, -1, 143, 36, -1, 144, 36, -1, 128, 154, 745 111, -1, 36, -1, 153, -1, 154, 124, 153, -1, 746 94, -1, 95, -1, 96, -1, 97, -1, 98, -1, 747 99, -1, 100, -1, 158, -1, 143, 36, -1, 144, 748 36, -1, 128, 159, 111, -1, 36, -1, 158, -1, 749 159, 124, 158, -1 750 }; 751 752 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 753 static const unsigned short int yyrline[] = 754 { 755 0, 210, 210, 214, 216, 218, 219, 220, 221, 222, 756 224, 226, 228, 229, 231, 233, 234, 236, 238, 243, 757 252, 261, 270, 279, 281, 283, 285, 286, 287, 289, 758 291, 293, 294, 296, 297, 298, 299, 300, 301, 303, 759 304, 305, 306, 308, 310, 311, 312, 313, 314, 315, 760 318, 319, 322, 323, 324, 325, 326, 327, 330, 331, 761 332, 333, 336, 338, 339, 340, 341, 342, 343, 344, 762 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 763 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 764 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 765 375, 377, 378, 379, 380, 381, 382, 383, 384, 385, 766 386, 387, 388, 389, 390, 393, 394, 395, 396, 397, 767 398, 401, 402, 405, 408, 409, 410, 412, 413, 414, 768 416, 417, 419, 420, 421, 422, 423, 424, 425, 426, 769 427, 428, 429, 430, 431, 433, 434, 435, 436, 437, 770 439, 440, 442, 443, 444, 445, 446, 447, 448, 449, 771 451, 452, 453, 454, 457, 458, 460, 461, 462, 463, 772 465, 472, 473, 476, 477, 478, 481, 482, 483, 484, 773 486, 487, 488, 489, 491, 500, 501 774 }; 775 #endif 776 777 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 778 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 779 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 780 static const char *const yytname[] = 781 { 782 "$end", "error", "$undefined", "DST", "SRC", "HOST", "GATEWAY", "NET", 783 "NETMASK", "PORT", "PORTRANGE", "LESS", "GREATER", "PROTO", "PROTOCHAIN", 784 "CBYTE", "ARP", "RARP", "IP", "SCTP", "TCP", "UDP", "ICMP", "IGMP", 785 "IGRP", "PIM", "VRRP", "ATALK", "AARP", "DECNET", "LAT", "SCA", "MOPRC", 786 "MOPDL", "TK_BROADCAST", "TK_MULTICAST", "NUM", "INBOUND", "OUTBOUND", 787 "PF_IFNAME", "PF_RSET", "PF_RNR", "PF_SRNR", "PF_REASON", "PF_ACTION", 788 "LINK", "GEQ", "LEQ", "NEQ", "ID", "EID", "HID", "HID6", "AID", "LSH", 789 "RSH", "LEN", "IPV6", "ICMPV6", "AH", "ESP", "VLAN", "MPLS", "PPPOED", 790 "PPPOES", "ISO", "ESIS", "CLNP", "ISIS", "L1", "L2", "IIH", "LSP", "SNP", 791 "CSNP", "PSNP", "STP", "IPX", "NETBEUI", "LANE", "LLC", "METAC", "BCC", 792 "SC", "ILMIC", "OAMF4EC", "OAMF4SC", "OAM", "OAMF4", "CONNECTMSG", 793 "METACONNECT", "VPI", "VCI", "RADIO", "FISU", "LSSU", "MSU", "SIO", 794 "OPC", "DPC", "SLS", "AND", "OR", "'!'", "'|'", "'&'", "'+'", "'-'", 795 "'*'", "'/'", "UMINUS", "')'", "'('", "'>'", "'='", "'<'", "'['", "']'", 796 "':'", "$accept", "prog", "null", "expr", "and", "or", "id", "nid", 797 "not", "paren", "pid", "qid", "term", "head", "rterm", "pqual", "dqual", 798 "aqual", "ndaqual", "pname", "other", "pfvar", "reason", "action", 799 "relop", "irelop", "arth", "narth", "byteop", "pnum", "atmtype", 800 "atmmultitype", "atmfield", "atmvalue", "atmfieldvalue", "atmlistvalue", 801 "mtp2type", "mtp3field", "mtp3value", "mtp3fieldvalue", "mtp3listvalue", 0 802 }; 803 #endif 804 805 # ifdef YYPRINT 806 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 807 token YYLEX-NUM. */ 808 static const unsigned short int yytoknum[] = 809 { 810 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 811 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 812 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 813 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 814 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 815 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 816 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 817 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 818 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 819 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 820 355, 356, 357, 33, 124, 38, 43, 45, 42, 47, 821 358, 41, 40, 62, 61, 60, 91, 93, 58 822 }; 823 # endif 824 825 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 826 static const unsigned char yyr1[] = 827 { 828 0, 119, 120, 120, 121, 122, 122, 122, 122, 122, 829 123, 124, 125, 125, 125, 126, 126, 126, 126, 126, 830 126, 126, 126, 126, 127, 128, 129, 129, 129, 130, 831 130, 131, 131, 132, 132, 132, 132, 132, 132, 133, 832 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 833 134, 134, 135, 135, 135, 135, 135, 135, 136, 136, 834 136, 136, 137, 138, 138, 138, 138, 138, 138, 138, 835 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 836 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 837 138, 138, 138, 138, 138, 138, 138, 138, 138, 138, 838 138, 139, 139, 139, 139, 139, 139, 139, 139, 139, 839 139, 139, 139, 139, 139, 140, 140, 140, 140, 140, 840 140, 141, 141, 142, 143, 143, 143, 144, 144, 144, 841 145, 145, 146, 146, 146, 146, 146, 146, 146, 146, 842 146, 146, 146, 146, 146, 147, 147, 147, 147, 147, 843 148, 148, 149, 149, 149, 149, 149, 149, 149, 149, 844 150, 150, 150, 150, 151, 151, 152, 152, 152, 152, 845 153, 154, 154, 155, 155, 155, 156, 156, 156, 156, 846 157, 157, 157, 157, 158, 159, 159 847 }; 848 849 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 850 static const unsigned char yyr2[] = 851 { 852 0, 2, 2, 1, 0, 1, 3, 3, 3, 3, 853 1, 1, 1, 1, 3, 1, 3, 3, 1, 3, 854 1, 1, 1, 2, 1, 1, 1, 3, 3, 1, 855 1, 1, 2, 3, 2, 2, 2, 2, 2, 2, 856 3, 1, 3, 3, 1, 1, 1, 2, 1, 2, 857 1, 0, 1, 1, 3, 3, 3, 3, 1, 1, 858 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 859 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 860 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 861 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 862 1, 2, 2, 2, 2, 4, 1, 1, 2, 1, 863 2, 1, 1, 1, 1, 2, 2, 2, 2, 2, 864 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 865 1, 1, 4, 6, 3, 3, 3, 3, 3, 3, 866 3, 3, 2, 3, 1, 1, 1, 1, 1, 1, 867 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 868 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 869 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 870 1, 2, 2, 3, 1, 1, 3 871 }; 872 873 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 874 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 875 means the default is an error. */ 876 static const unsigned char yydefact[] = 877 { 878 4, 0, 51, 1, 0, 0, 0, 65, 66, 64, 879 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 880 77, 78, 79, 81, 80, 150, 106, 107, 0, 0, 881 0, 0, 0, 0, 63, 144, 82, 83, 84, 85, 882 109, 111, 112, 113, 86, 87, 96, 88, 89, 90, 883 91, 92, 93, 95, 94, 97, 98, 99, 152, 153, 884 154, 155, 158, 159, 156, 157, 160, 161, 162, 163, 885 164, 165, 100, 173, 174, 175, 176, 177, 178, 179, 886 24, 0, 25, 2, 51, 51, 5, 0, 31, 0, 887 50, 44, 114, 0, 131, 130, 45, 46, 0, 48, 888 0, 103, 104, 0, 115, 116, 117, 118, 121, 122, 889 119, 123, 120, 0, 108, 110, 0, 0, 142, 10, 890 11, 51, 51, 32, 0, 131, 130, 15, 21, 18, 891 20, 22, 39, 12, 0, 0, 13, 53, 52, 58, 892 62, 59, 60, 61, 36, 37, 101, 102, 34, 35, 893 38, 0, 125, 127, 129, 0, 0, 0, 0, 0, 894 0, 0, 0, 124, 126, 128, 0, 0, 170, 0, 895 0, 0, 47, 166, 184, 0, 0, 0, 49, 180, 896 146, 145, 148, 149, 147, 0, 0, 0, 7, 51, 897 51, 6, 130, 9, 8, 40, 143, 151, 0, 0, 898 0, 23, 26, 30, 0, 29, 0, 0, 0, 0, 899 33, 0, 140, 141, 139, 138, 134, 135, 136, 137, 900 42, 43, 171, 0, 167, 168, 185, 0, 181, 182, 901 105, 130, 17, 16, 19, 14, 0, 0, 57, 55, 902 56, 54, 132, 0, 169, 0, 183, 0, 27, 28, 903 0, 172, 186, 133 904 }; 905 906 /* YYDEFGOTO[NTERM-NUM]. */ 907 static const short int yydefgoto[] = 908 { 909 -1, 1, 2, 124, 121, 122, 201, 133, 134, 116, 910 203, 204, 86, 87, 88, 89, 148, 149, 150, 117, 911 91, 92, 110, 112, 166, 167, 93, 94, 185, 95, 912 96, 97, 98, 172, 173, 223, 99, 100, 178, 179, 913 227 914 }; 915 916 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 917 STATE-NUM. */ 918 #define YYPACT_NINF -181 919 static const short int yypact[] = 920 { 921 -181, 19, 200, -181, -3, 1, 15, -181, -181, -181, 922 -181, -181, -181, -181, -181, -181, -181, -181, -181, -181, 923 -181, -181, -181, -181, -181, -181, -181, -181, 13, 20, 924 18, 44, -26, 35, -181, -181, -181, -181, -181, -181, 925 -19, -19, -181, -181, -181, -181, -181, -181, -181, -181, 926 -181, -181, -181, -181, -181, -181, -181, -181, -181, -181, 927 -181, -181, -181, -181, -181, -181, -181, -181, -181, -181, 928 -181, -181, -181, -181, -181, -181, -181, -181, -181, -181, 929 -181, 493, -181, 41, 396, 396, -181, -24, -181, 155, 930 2, -181, -181, 488, -181, -181, -181, -181, 9, -181, 931 134, -181, -181, 62, -181, -181, -181, -181, -181, -181, 932 -181, -181, -181, -19, -181, -181, 493, -9, -181, -181, 933 -181, 298, 298, -181, -53, -14, -1, -181, -181, 0, 934 3, -181, -181, -181, -24, -24, -181, 77, 82, -181, 935 -181, -181, -181, -181, -181, -181, -181, -181, 437, -181, 936 -181, 493, -181, -181, -181, 493, 493, 493, 493, 493, 937 493, 493, 493, -181, -181, -181, 493, 493, -181, 78, 938 81, 89, -181, -181, -181, 95, 108, 113, -181, -181, 939 -181, -181, -181, -181, -181, 120, -1, -34, -181, 298, 940 298, -181, 4, -181, -181, -181, -181, -181, 112, 149, 941 150, -181, -181, 80, 41, -1, 188, 189, 205, 206, 942 -181, -41, 65, 65, 98, 144, -93, -93, -181, -181, 943 -34, -34, -181, -80, -181, -181, -181, -58, -181, -181, 944 -181, 46, -181, -181, -181, -181, -24, -24, -181, -181, 945 -181, -181, -181, 174, -181, 78, -181, 95, -181, -181, 946 96, -181, -181, -181 947 }; 948 949 /* YYPGOTO[NTERM-NUM]. */ 950 static const short int yypgoto[] = 951 { 952 -181, -181, -181, 212, 50, -180, -86, -89, 5, -2, 953 -181, -181, -81, -181, -181, -181, -181, 107, -181, 7, 954 -181, -181, -181, -181, -66, -39, -21, -74, -181, -35, 955 -181, -181, -181, -181, -151, -181, -181, -181, -181, -145, 956 -181 957 }; 958 959 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 960 positive, shift that token. If negative, reduce the rule which 961 number is the opposite. If zero, do what YYDEFACT says. 962 If YYTABLE_NINF, syntax error. */ 963 #define YYTABLE_NINF -42 964 static const short int yytable[] = 965 { 966 85, 132, -41, 123, -13, 114, 115, 84, 198, 90, 967 108, 125, 25, 155, 156, 161, 162, 25, 222, 3, 968 155, 156, 120, 109, 237, 127, 128, 129, 130, 131, 969 226, 244, 170, 101, 176, 188, 193, 102, 113, 113, 970 191, 194, 125, 245, 120, 168, 202, 247, 119, 120, 971 126, 103, 136, 246, 106, 152, 153, 154, 195, 171, 972 118, 177, 104, 157, 158, 159, 160, 161, 162, 105, 973 157, 158, 159, 160, 161, 162, 242, 243, 186, 80, 974 107, 126, 85, 85, 111, 135, 192, 192, 82, 84, 975 84, 90, 90, 82, 251, 187, 169, 196, 175, 136, 976 205, 202, 252, -41, -41, -13, -13, 151, 123, 199, 977 197, 113, 200, -41, 168, -13, 125, 224, 151, 190, 978 190, 82, 163, 164, 165, 225, 189, 189, 90, 90, 979 211, 174, 135, 113, 212, 213, 214, 215, 216, 217, 980 218, 219, 119, 120, 228, 220, 221, -29, -29, 229, 981 248, 249, 155, 156, 192, 231, 230, 197, 137, 138, 982 139, 140, 141, 232, 142, 143, 180, 181, 144, 145, 983 174, 159, 160, 161, 162, 182, 183, 184, 206, 207, 984 152, 153, 154, 208, 209, 233, 234, 190, 85, 146, 985 147, 235, 238, 239, 189, 189, 90, 90, 155, 156, 986 -3, 136, 136, 158, 159, 160, 161, 162, 240, 241, 987 250, 4, 5, 253, 83, 6, 7, 8, 9, 10, 988 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 989 21, 22, 23, 24, 135, 135, 25, 26, 27, 28, 990 29, 30, 31, 32, 33, 34, 82, 163, 164, 165, 991 159, 160, 161, 162, 236, 210, 35, 36, 37, 38, 992 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 993 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 994 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 995 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 996 79, 0, 0, 80, 0, 0, 0, 81, 0, 4, 997 5, 0, 82, 6, 7, 8, 9, 10, 11, 12, 998 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 999 23, 24, 0, 0, 25, 26, 27, 28, 29, 30, 1000 31, 32, 33, 34, 0, 0, 0, 127, 128, 129, 1001 130, 131, 0, 0, 35, 36, 37, 38, 39, 40, 1002 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 1003 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 1004 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 1005 71, 72, 73, 74, 75, 76, 77, 78, 79, 0, 1006 0, 80, 0, 0, 0, 81, 0, 4, 5, 0, 1007 82, 6, 7, 8, 9, 10, 11, 12, 13, 14, 1008 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 1009 0, 0, 25, 26, 27, 28, 29, 30, 31, 32, 1010 33, 34, 139, 0, 141, 0, 142, 143, 0, 0, 1011 0, 0, 35, 36, 37, 38, 39, 40, 41, 42, 1012 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 1013 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 1014 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 1015 73, 74, 75, 76, 77, 78, 79, 0, 0, 80, 1016 0, 0, 0, 81, 0, 0, 0, 0, 82, 7, 1017 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 1018 18, 19, 20, 21, 22, 23, 24, 0, 0, 25, 1019 0, 0, 0, 0, 152, 153, 154, 0, 34, 0, 1020 0, 0, 155, 156, 0, 0, 0, 0, 0, 35, 1021 36, 37, 38, 39, 0, 0, 0, 0, 44, 45, 1022 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 1023 56, 57, 0, 0, 0, 0, 0, 0, 0, 0, 1024 0, 0, 0, 0, 0, 0, 72, 0, 0, 0, 1025 0, 0, 157, 158, 159, 160, 161, 162, 0, 0, 1026 81, 163, 164, 165, 0, 82 1027 }; 1028 1029 static const short int yycheck[] = 1030 { 1031 2, 87, 0, 84, 0, 40, 41, 2, 8, 2, 1032 36, 85, 36, 54, 55, 108, 109, 36, 169, 0, 1033 54, 55, 102, 49, 204, 49, 50, 51, 52, 53, 1034 175, 111, 98, 36, 100, 121, 122, 36, 40, 41, 1035 121, 122, 116, 223, 102, 36, 135, 227, 101, 102, 1036 85, 36, 87, 111, 36, 46, 47, 48, 111, 98, 1037 81, 100, 49, 104, 105, 106, 107, 108, 109, 49, 1038 104, 105, 106, 107, 108, 109, 117, 118, 113, 103, 1039 36, 116, 84, 85, 49, 87, 121, 122, 112, 84, 1040 85, 84, 85, 112, 245, 116, 98, 111, 100, 134, 1041 135, 190, 247, 101, 102, 101, 102, 116, 189, 109, 1042 111, 113, 109, 111, 36, 111, 190, 36, 116, 121, 1043 122, 112, 113, 114, 115, 36, 121, 122, 121, 122, 1044 151, 36, 134, 135, 155, 156, 157, 158, 159, 160, 1045 161, 162, 101, 102, 36, 166, 167, 101, 102, 36, 1046 236, 237, 54, 55, 189, 190, 36, 111, 3, 4, 1047 5, 6, 7, 51, 9, 10, 104, 105, 13, 14, 1048 36, 106, 107, 108, 109, 113, 114, 115, 101, 102, 1049 46, 47, 48, 101, 102, 36, 36, 189, 190, 34, 1050 35, 111, 4, 4, 189, 190, 189, 190, 54, 55, 1051 0, 236, 237, 105, 106, 107, 108, 109, 3, 3, 1052 36, 11, 12, 117, 2, 15, 16, 17, 18, 19, 1053 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 1054 30, 31, 32, 33, 236, 237, 36, 37, 38, 39, 1055 40, 41, 42, 43, 44, 45, 112, 113, 114, 115, 1056 106, 107, 108, 109, 204, 148, 56, 57, 58, 59, 1057 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 1058 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 1059 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 1060 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 1061 100, -1, -1, 103, -1, -1, -1, 107, -1, 11, 1062 12, -1, 112, 15, 16, 17, 18, 19, 20, 21, 1063 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 1064 32, 33, -1, -1, 36, 37, 38, 39, 40, 41, 1065 42, 43, 44, 45, -1, -1, -1, 49, 50, 51, 1066 52, 53, -1, -1, 56, 57, 58, 59, 60, 61, 1067 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 1068 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 1069 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 1070 92, 93, 94, 95, 96, 97, 98, 99, 100, -1, 1071 -1, 103, -1, -1, -1, 107, -1, 11, 12, -1, 1072 112, 15, 16, 17, 18, 19, 20, 21, 22, 23, 1073 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 1074 -1, -1, 36, 37, 38, 39, 40, 41, 42, 43, 1075 44, 45, 5, -1, 7, -1, 9, 10, -1, -1, 1076 -1, -1, 56, 57, 58, 59, 60, 61, 62, 63, 1077 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 1078 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 1079 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 1080 94, 95, 96, 97, 98, 99, 100, -1, -1, 103, 1081 -1, -1, -1, 107, -1, -1, -1, -1, 112, 16, 1082 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 1083 27, 28, 29, 30, 31, 32, 33, -1, -1, 36, 1084 -1, -1, -1, -1, 46, 47, 48, -1, 45, -1, 1085 -1, -1, 54, 55, -1, -1, -1, -1, -1, 56, 1086 57, 58, 59, 60, -1, -1, -1, -1, 65, 66, 1087 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 1088 77, 78, -1, -1, -1, -1, -1, -1, -1, -1, 1089 -1, -1, -1, -1, -1, -1, 93, -1, -1, -1, 1090 -1, -1, 104, 105, 106, 107, 108, 109, -1, -1, 1091 107, 113, 114, 115, -1, 112 1092 }; 1093 1094 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 1095 symbol of state STATE-NUM. */ 1096 static const unsigned char yystos[] = 1097 { 1098 0, 120, 121, 0, 11, 12, 15, 16, 17, 18, 1099 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 1100 29, 30, 31, 32, 33, 36, 37, 38, 39, 40, 1101 41, 42, 43, 44, 45, 56, 57, 58, 59, 60, 1102 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 1103 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 1104 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 1105 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 1106 103, 107, 112, 122, 127, 128, 131, 132, 133, 134, 1107 138, 139, 140, 145, 146, 148, 149, 150, 151, 155, 1108 156, 36, 36, 36, 49, 49, 36, 36, 36, 49, 1109 141, 49, 142, 128, 148, 148, 128, 138, 145, 101, 1110 102, 123, 124, 131, 122, 146, 148, 49, 50, 51, 1111 52, 53, 125, 126, 127, 128, 148, 3, 4, 5, 1112 6, 7, 9, 10, 13, 14, 34, 35, 135, 136, 1113 137, 116, 46, 47, 48, 54, 55, 104, 105, 106, 1114 107, 108, 109, 113, 114, 115, 143, 144, 36, 128, 1115 143, 144, 152, 153, 36, 128, 143, 144, 157, 158, 1116 104, 105, 113, 114, 115, 147, 148, 145, 125, 127, 1117 128, 131, 148, 125, 131, 111, 111, 111, 8, 109, 1118 109, 125, 126, 129, 130, 148, 101, 102, 101, 102, 1119 136, 145, 145, 145, 145, 145, 145, 145, 145, 145, 1120 145, 145, 153, 154, 36, 36, 158, 159, 36, 36, 1121 36, 148, 51, 36, 36, 111, 123, 124, 4, 4, 1122 3, 3, 117, 118, 111, 124, 111, 124, 125, 125, 1123 36, 153, 158, 117 1124 }; 1125 1126 #define yyerrok (yyerrstatus = 0) 1127 #define yyclearin (yychar = YYEMPTY) 1128 #define YYEMPTY (-2) 1129 #define YYEOF 0 1130 1131 #define YYACCEPT goto yyacceptlab 1132 #define YYABORT goto yyabortlab 1133 #define YYERROR goto yyerrorlab 1134 1135 1136 /* Like YYERROR except do call yyerror. This remains here temporarily 1137 to ease the transition to the new meaning of YYERROR, for GCC. 1138 Once GCC version 2 has supplanted version 1, this can go. */ 1139 1140 #define YYFAIL goto yyerrlab 1141 1142 #define YYRECOVERING() (!!yyerrstatus) 1143 1144 #define YYBACKUP(Token, Value) \ 1145 do \ 1146 if (yychar == YYEMPTY && yylen == 1) \ 1147 { \ 1148 yychar = (Token); \ 1149 yylval = (Value); \ 1150 yytoken = YYTRANSLATE (yychar); \ 1151 YYPOPSTACK; \ 1152 goto yybackup; \ 1153 } \ 1154 else \ 1155 { \ 1156 yyerror (YY_("syntax error: cannot back up")); \ 1157 YYERROR; \ 1158 } \ 1159 while (0) 1160 1161 1162 #define YYTERROR 1 1163 #define YYERRCODE 256 1164 1165 1166 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 1167 If N is 0, then set CURRENT to the empty location which ends 1168 the previous symbol: RHS[0] (always defined). */ 1169 1170 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 1171 #ifndef YYLLOC_DEFAULT 1172 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 1173 do \ 1174 if (N) \ 1175 { \ 1176 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 1177 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 1178 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 1179 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 1180 } \ 1181 else \ 1182 { \ 1183 (Current).first_line = (Current).last_line = \ 1184 YYRHSLOC (Rhs, 0).last_line; \ 1185 (Current).first_column = (Current).last_column = \ 1186 YYRHSLOC (Rhs, 0).last_column; \ 1187 } \ 1188 while (0) 1189 #endif 1190 1191 1192 /* YY_LOCATION_PRINT -- Print the location on the stream. 1193 This macro was not mandated originally: define only if we know 1194 we won't break user code: when these are the locations we know. */ 1195 1196 #ifndef YY_LOCATION_PRINT 1197 # if YYLTYPE_IS_TRIVIAL 1198 # define YY_LOCATION_PRINT(File, Loc) \ 1199 fprintf (File, "%d.%d-%d.%d", \ 1200 (Loc).first_line, (Loc).first_column, \ 1201 (Loc).last_line, (Loc).last_column) 1202 # else 1203 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 1204 # endif 1205 #endif 1206 1207 1208 /* YYLEX -- calling `yylex' with the right arguments. */ 1209 1210 #ifdef YYLEX_PARAM 1211 # define YYLEX yylex (YYLEX_PARAM) 1212 #else 1213 # define YYLEX yylex () 1214 #endif 1215 1216 /* Enable debugging if requested. */ 1217 #if YYDEBUG 1218 1219 # ifndef YYFPRINTF 1220 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 1221 # define YYFPRINTF fprintf 1222 # endif 1223 1224 # define YYDPRINTF(Args) \ 1225 do { \ 1226 if (yydebug) \ 1227 YYFPRINTF Args; \ 1228 } while (0) 1229 1230 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 1231 do { \ 1232 if (yydebug) \ 1233 { \ 1234 YYFPRINTF (stderr, "%s ", Title); \ 1235 yysymprint (stderr, \ 1236 Type, Value); \ 1237 YYFPRINTF (stderr, "\n"); \ 1238 } \ 1239 } while (0) 1240 1241 /*------------------------------------------------------------------. 1242 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 1243 | TOP (included). | 1244 `------------------------------------------------------------------*/ 1245 1246 #if defined (__STDC__) || defined (__cplusplus) 1247 static void 1248 yy_stack_print (short int *bottom, short int *top) 1249 #else 1250 static void 1251 yy_stack_print (bottom, top) 1252 short int *bottom; 1253 short int *top; 1254 #endif 1255 { 1256 YYFPRINTF (stderr, "Stack now"); 1257 for (/* Nothing. */; bottom <= top; ++bottom) 1258 YYFPRINTF (stderr, " %d", *bottom); 1259 YYFPRINTF (stderr, "\n"); 1260 } 1261 1262 # define YY_STACK_PRINT(Bottom, Top) \ 1263 do { \ 1264 if (yydebug) \ 1265 yy_stack_print ((Bottom), (Top)); \ 1266 } while (0) 1267 1268 1269 /*------------------------------------------------. 1270 | Report that the YYRULE is going to be reduced. | 1271 `------------------------------------------------*/ 1272 1273 #if defined (__STDC__) || defined (__cplusplus) 1274 static void 1275 yy_reduce_print (int yyrule) 1276 #else 1277 static void 1278 yy_reduce_print (yyrule) 1279 int yyrule; 1280 #endif 1281 { 1282 int yyi; 1283 unsigned long int yylno = yyrline[yyrule]; 1284 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ", 1285 yyrule - 1, yylno); 1286 /* Print the symbols being reduced, and their result. */ 1287 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) 1288 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]); 1289 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]); 1290 } 1291 1292 # define YY_REDUCE_PRINT(Rule) \ 1293 do { \ 1294 if (yydebug) \ 1295 yy_reduce_print (Rule); \ 1296 } while (0) 1297 1298 /* Nonzero means print parse trace. It is left uninitialized so that 1299 multiple parsers can coexist. */ 1300 int yydebug; 1301 #else /* !YYDEBUG */ 1302 # define YYDPRINTF(Args) 1303 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 1304 # define YY_STACK_PRINT(Bottom, Top) 1305 # define YY_REDUCE_PRINT(Rule) 1306 #endif /* !YYDEBUG */ 1307 1308 1309 /* YYINITDEPTH -- initial size of the parser's stacks. */ 1310 #ifndef YYINITDEPTH 1311 # define YYINITDEPTH 200 1312 #endif 1313 1314 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 1315 if the built-in stack extension method is used). 1316 1317 Do not make this value too large; the results are undefined if 1318 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 1319 evaluated with infinite-precision integer arithmetic. */ 1320 1321 #ifndef YYMAXDEPTH 1322 # define YYMAXDEPTH 10000 1323 #endif 1324 1325 1326 1328 #if YYERROR_VERBOSE 1329 1330 # ifndef yystrlen 1331 # if defined (__GLIBC__) && defined (_STRING_H) 1332 # define yystrlen strlen 1333 # else 1334 /* Return the length of YYSTR. */ 1335 static YYSIZE_T 1336 # if defined (__STDC__) || defined (__cplusplus) 1337 yystrlen (const char *yystr) 1338 # else 1339 yystrlen (yystr) 1340 const char *yystr; 1341 # endif 1342 { 1343 const char *yys = yystr; 1344 1345 while (*yys++ != '\0') 1346 continue; 1347 1348 return yys - yystr - 1; 1349 } 1350 # endif 1351 # endif 1352 1353 # ifndef yystpcpy 1354 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) 1355 # define yystpcpy stpcpy 1356 # else 1357 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 1358 YYDEST. */ 1359 static char * 1360 # if defined (__STDC__) || defined (__cplusplus) 1361 yystpcpy (char *yydest, const char *yysrc) 1362 # else 1363 yystpcpy (yydest, yysrc) 1364 char *yydest; 1365 const char *yysrc; 1366 # endif 1367 { 1368 char *yyd = yydest; 1369 const char *yys = yysrc; 1370 1371 while ((*yyd++ = *yys++) != '\0') 1372 continue; 1373 1374 return yyd - 1; 1375 } 1376 # endif 1377 # endif 1378 1379 # ifndef yytnamerr 1380 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 1381 quotes and backslashes, so that it's suitable for yyerror. The 1382 heuristic is that double-quoting is unnecessary unless the string 1383 contains an apostrophe, a comma, or backslash (other than 1384 backslash-backslash). YYSTR is taken from yytname. If YYRES is 1385 null, do not copy; instead, return the length of what the result 1386 would have been. */ 1387 static YYSIZE_T 1388 yytnamerr (char *yyres, const char *yystr) 1389 { 1390 if (*yystr == '"') 1391 { 1392 size_t yyn = 0; 1393 char const *yyp = yystr; 1394 1395 for (;;) 1396 switch (*++yyp) 1397 { 1398 case '\'': 1399 case ',': 1400 goto do_not_strip_quotes; 1401 1402 case '\\': 1403 if (*++yyp != '\\') 1404 goto do_not_strip_quotes; 1405 /* Fall through. */ 1406 default: 1407 if (yyres) 1408 yyres[yyn] = *yyp; 1409 yyn++; 1410 break; 1411 1412 case '"': 1413 if (yyres) 1414 yyres[yyn] = '\0'; 1415 return yyn; 1416 } 1417 do_not_strip_quotes: ; 1418 } 1419 1420 if (! yyres) 1421 return yystrlen (yystr); 1422 1423 return yystpcpy (yyres, yystr) - yyres; 1424 } 1425 # endif 1426 1427 #endif /* YYERROR_VERBOSE */ 1428 1429 1430 1432 #if YYDEBUG 1433 /*--------------------------------. 1434 | Print this symbol on YYOUTPUT. | 1435 `--------------------------------*/ 1436 1437 #if defined (__STDC__) || defined (__cplusplus) 1438 static void 1439 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) 1440 #else 1441 static void 1442 yysymprint (yyoutput, yytype, yyvaluep) 1443 FILE *yyoutput; 1444 int yytype; 1445 YYSTYPE *yyvaluep; 1446 #endif 1447 { 1448 /* Pacify ``unused variable'' warnings. */ 1449 (void) yyvaluep; 1450 1451 if (yytype < YYNTOKENS) 1452 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 1453 else 1454 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 1455 1456 1457 # ifdef YYPRINT 1458 if (yytype < YYNTOKENS) 1459 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 1460 # endif 1461 switch (yytype) 1462 { 1463 default: 1464 break; 1465 } 1466 YYFPRINTF (yyoutput, ")"); 1467 } 1468 1469 #endif /* ! YYDEBUG */ 1470 /*-----------------------------------------------. 1471 | Release the memory associated to this symbol. | 1472 `-----------------------------------------------*/ 1473 1474 #if defined (__STDC__) || defined (__cplusplus) 1475 static void 1476 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 1477 #else 1478 static void 1479 yydestruct (yymsg, yytype, yyvaluep) 1480 const char *yymsg; 1481 int yytype; 1482 YYSTYPE *yyvaluep; 1483 #endif 1484 { 1485 /* Pacify ``unused variable'' warnings. */ 1486 (void) yyvaluep; 1487 1488 if (!yymsg) 1489 yymsg = "Deleting"; 1490 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 1491 1492 switch (yytype) 1493 { 1494 1495 default: 1496 break; 1497 } 1498 } 1499 1500 1502 /* Prevent warnings from -Wmissing-prototypes. */ 1503 1504 #ifdef YYPARSE_PARAM 1505 # if defined (__STDC__) || defined (__cplusplus) 1506 int yyparse (void *YYPARSE_PARAM); 1507 # else 1508 int yyparse (); 1509 # endif 1510 #else /* ! YYPARSE_PARAM */ 1511 #if defined (__STDC__) || defined (__cplusplus) 1512 int yyparse (void); 1513 #else 1514 int yyparse (); 1515 #endif 1516 #endif /* ! YYPARSE_PARAM */ 1517 1518 1519 1520 /* The look-ahead symbol. */ 1521 int yychar; 1522 1523 /* The semantic value of the look-ahead symbol. */ 1524 YYSTYPE yylval; 1525 1526 /* Number of syntax errors so far. */ 1527 int yynerrs; 1528 1529 1530 1531 /*----------. 1532 | yyparse. | 1533 `----------*/ 1534 1535 #ifdef YYPARSE_PARAM 1536 # if defined (__STDC__) || defined (__cplusplus) 1537 int yyparse (void *YYPARSE_PARAM) 1538 # else 1539 int yyparse (YYPARSE_PARAM) 1540 void *YYPARSE_PARAM; 1541 # endif 1542 #else /* ! YYPARSE_PARAM */ 1543 #if defined (__STDC__) || defined (__cplusplus) 1544 int 1545 yyparse (void) 1546 #else 1547 int 1548 yyparse () 1549 ; 1550 #endif 1551 #endif 1552 { 1553 1554 int yystate; 1555 int yyn; 1556 int yyresult; 1557 /* Number of tokens to shift before error messages enabled. */ 1558 int yyerrstatus; 1559 /* Look-ahead token as an internal (translated) token number. */ 1560 int yytoken = 0; 1561 1562 /* Three stacks and their tools: 1563 `yyss': related to states, 1564 `yyvs': related to semantic values, 1565 `yyls': related to locations. 1566 1567 Refer to the stacks thru separate pointers, to allow yyoverflow 1568 to reallocate them elsewhere. */ 1569 1570 /* The state stack. */ 1571 short int yyssa[YYINITDEPTH]; 1572 short int *yyss = yyssa; 1573 short int *yyssp; 1574 1575 /* The semantic value stack. */ 1576 YYSTYPE yyvsa[YYINITDEPTH]; 1577 YYSTYPE *yyvs = yyvsa; 1578 YYSTYPE *yyvsp; 1579 1580 1581 1582 #define YYPOPSTACK (yyvsp--, yyssp--) 1583 1584 YYSIZE_T yystacksize = YYINITDEPTH; 1585 1586 /* The variables used to return semantic value and location from the 1587 action routines. */ 1588 YYSTYPE yyval; 1589 1590 1591 /* When reducing, the number of symbols on the RHS of the reduced 1592 rule. */ 1593 int yylen; 1594 1595 YYDPRINTF ((stderr, "Starting parse\n")); 1596 1597 yystate = 0; 1598 yyerrstatus = 0; 1599 yynerrs = 0; 1600 yychar = YYEMPTY; /* Cause a token to be read. */ 1601 1602 /* Initialize stack pointers. 1603 Waste one element of value and location stack 1604 so that they stay on the same level as the state stack. 1605 The wasted elements are never initialized. */ 1606 1607 yyssp = yyss; 1608 yyvsp = yyvs; 1609 1610 goto yysetstate; 1611 1612 /*------------------------------------------------------------. 1613 | yynewstate -- Push a new state, which is found in yystate. | 1614 `------------------------------------------------------------*/ 1615 yynewstate: 1616 /* In all cases, when you get here, the value and location stacks 1617 have just been pushed. so pushing a state here evens the stacks. 1618 */ 1619 yyssp++; 1620 1621 yysetstate: 1622 *yyssp = yystate; 1623 1624 if (yyss + yystacksize - 1 <= yyssp) 1625 { 1626 /* Get the current used size of the three stacks, in elements. */ 1627 YYSIZE_T yysize = yyssp - yyss + 1; 1628 1629 #ifdef yyoverflow 1630 { 1631 /* Give user a chance to reallocate the stack. Use copies of 1632 these so that the &'s don't force the real ones into 1633 memory. */ 1634 YYSTYPE *yyvs1 = yyvs; 1635 short int *yyss1 = yyss; 1636 1637 1638 /* Each stack pointer address is followed by the size of the 1639 data in use in that stack, in bytes. This used to be a 1640 conditional around just the two extra args, but that might 1641 be undefined if yyoverflow is a macro. */ 1642 yyoverflow (YY_("memory exhausted"), 1643 &yyss1, yysize * sizeof (*yyssp), 1644 &yyvs1, yysize * sizeof (*yyvsp), 1645 1646 &yystacksize); 1647 1648 yyss = yyss1; 1649 yyvs = yyvs1; 1650 } 1651 #else /* no yyoverflow */ 1652 # ifndef YYSTACK_RELOCATE 1653 goto yyexhaustedlab; 1654 # else 1655 /* Extend the stack our own way. */ 1656 if (YYMAXDEPTH <= yystacksize) 1657 goto yyexhaustedlab; 1658 yystacksize *= 2; 1659 if (YYMAXDEPTH < yystacksize) 1660 yystacksize = YYMAXDEPTH; 1661 1662 { 1663 short int *yyss1 = yyss; 1664 union yyalloc *yyptr = 1665 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 1666 if (! yyptr) 1667 goto yyexhaustedlab; 1668 YYSTACK_RELOCATE (yyss); 1669 YYSTACK_RELOCATE (yyvs); 1670 1671 # undef YYSTACK_RELOCATE 1672 if (yyss1 != yyssa) 1673 YYSTACK_FREE (yyss1); 1674 } 1675 # endif 1676 #endif /* no yyoverflow */ 1677 1678 yyssp = yyss + yysize - 1; 1679 yyvsp = yyvs + yysize - 1; 1680 1681 1682 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 1683 (unsigned long int) yystacksize)); 1684 1685 if (yyss + yystacksize - 1 <= yyssp) 1686 YYABORT; 1687 } 1688 1689 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 1690 1691 goto yybackup; 1692 1693 /*-----------. 1694 | yybackup. | 1695 `-----------*/ 1696 yybackup: 1697 1698 /* Do appropriate processing given the current state. */ 1699 /* Read a look-ahead token if we need one and don't already have one. */ 1700 /* yyresume: */ 1701 1702 /* First try to decide what to do without reference to look-ahead token. */ 1703 1704 yyn = yypact[yystate]; 1705 if (yyn == YYPACT_NINF) 1706 goto yydefault; 1707 1708 /* Not known => get a look-ahead token if don't already have one. */ 1709 1710 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ 1711 if (yychar == YYEMPTY) 1712 { 1713 YYDPRINTF ((stderr, "Reading a token: ")); 1714 yychar = YYLEX; 1715 } 1716 1717 if (yychar <= YYEOF) 1718 { 1719 yychar = yytoken = YYEOF; 1720 YYDPRINTF ((stderr, "Now at end of input.\n")); 1721 } 1722 else 1723 { 1724 yytoken = YYTRANSLATE (yychar); 1725 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 1726 } 1727 1728 /* If the proper action on seeing token YYTOKEN is to reduce or to 1729 detect an error, take that action. */ 1730 yyn += yytoken; 1731 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 1732 goto yydefault; 1733 yyn = yytable[yyn]; 1734 if (yyn <= 0) 1735 { 1736 if (yyn == 0 || yyn == YYTABLE_NINF) 1737 goto yyerrlab; 1738 yyn = -yyn; 1739 goto yyreduce; 1740 } 1741 1742 if (yyn == YYFINAL) 1743 YYACCEPT; 1744 1745 /* Shift the look-ahead token. */ 1746 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 1747 1748 /* Discard the token being shifted unless it is eof. */ 1749 if (yychar != YYEOF) 1750 yychar = YYEMPTY; 1751 1752 *++yyvsp = yylval; 1753 1754 1755 /* Count tokens shifted since error; after three, turn off error 1756 status. */ 1757 if (yyerrstatus) 1758 yyerrstatus--; 1759 1760 yystate = yyn; 1761 goto yynewstate; 1762 1763 1764 /*-----------------------------------------------------------. 1765 | yydefault -- do the default action for the current state. | 1766 `-----------------------------------------------------------*/ 1767 yydefault: 1768 yyn = yydefact[yystate]; 1769 if (yyn == 0) 1770 goto yyerrlab; 1771 goto yyreduce; 1772 1773 1774 /*-----------------------------. 1775 | yyreduce -- Do a reduction. | 1776 `-----------------------------*/ 1777 yyreduce: 1778 /* yyn is the number of a rule to reduce with. */ 1779 yylen = yyr2[yyn]; 1780 1781 /* If YYLEN is nonzero, implement the default value of the action: 1782 `$$ = $1'. 1783 1784 Otherwise, the following line sets YYVAL to garbage. 1785 This behavior is undocumented and Bison 1786 users should not rely upon it. Assigning to YYVAL 1787 unconditionally makes the parser a bit smaller, and it avoids a 1788 GCC warning that YYVAL may be used uninitialized. */ 1789 yyval = yyvsp[1-yylen]; 1790 1791 1792 YY_REDUCE_PRINT (yyn); 1793 switch (yyn) 1794 { 1795 case 2: 1796 #line 211 "grammar.y" 1797 { 1798 finish_parse((yyvsp[0].blk).b); 1799 } 1800 break; 1801 1802 case 4: 1803 #line 216 "grammar.y" 1804 { (yyval.blk).q = qerr; } 1805 break; 1806 1807 case 6: 1808 #line 219 "grammar.y" 1809 { gen_and((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1810 break; 1811 1812 case 7: 1813 #line 220 "grammar.y" 1814 { gen_and((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1815 break; 1816 1817 case 8: 1818 #line 221 "grammar.y" 1819 { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1820 break; 1821 1822 case 9: 1823 #line 222 "grammar.y" 1824 { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1825 break; 1826 1827 case 10: 1828 #line 224 "grammar.y" 1829 { (yyval.blk) = (yyvsp[-1].blk); } 1830 break; 1831 1832 case 11: 1833 #line 226 "grammar.y" 1834 { (yyval.blk) = (yyvsp[-1].blk); } 1835 break; 1836 1837 case 13: 1838 #line 229 "grammar.y" 1839 { (yyval.blk).b = gen_ncode(NULL, (bpf_u_int32)(yyvsp[0].i), 1840 (yyval.blk).q = (yyvsp[-1].blk).q); } 1841 break; 1842 1843 case 14: 1844 #line 231 "grammar.y" 1845 { (yyval.blk) = (yyvsp[-1].blk); } 1846 break; 1847 1848 case 15: 1849 #line 233 "grammar.y" 1850 { (yyval.blk).b = gen_scode((yyvsp[0].s), (yyval.blk).q = (yyvsp[-1].blk).q); } 1851 break; 1852 1853 case 16: 1854 #line 234 "grammar.y" 1855 { (yyval.blk).b = gen_mcode((yyvsp[-2].s), NULL, (yyvsp[0].i), 1856 (yyval.blk).q = (yyvsp[-3].blk).q); } 1857 break; 1858 1859 case 17: 1860 #line 236 "grammar.y" 1861 { (yyval.blk).b = gen_mcode((yyvsp[-2].s), (yyvsp[0].s), 0, 1862 (yyval.blk).q = (yyvsp[-3].blk).q); } 1863 break; 1864 1865 case 18: 1866 #line 238 "grammar.y" 1867 { 1868 /* Decide how to parse HID based on proto */ 1869 (yyval.blk).q = (yyvsp[-1].blk).q; 1870 (yyval.blk).b = gen_ncode((yyvsp[0].s), 0, (yyval.blk).q); 1871 } 1872 break; 1873 1874 case 19: 1875 #line 243 "grammar.y" 1876 { 1877 #ifdef INET6 1878 (yyval.blk).b = gen_mcode6((yyvsp[-2].s), NULL, (yyvsp[0].i), 1879 (yyval.blk).q = (yyvsp[-3].blk).q); 1880 #else 1881 bpf_error("'ip6addr/prefixlen' not supported " 1882 "in this configuration"); 1883 #endif /*INET6*/ 1884 } 1885 break; 1886 1887 case 20: 1888 #line 252 "grammar.y" 1889 { 1890 #ifdef INET6 1891 (yyval.blk).b = gen_mcode6((yyvsp[0].s), 0, 128, 1892 (yyval.blk).q = (yyvsp[-1].blk).q); 1893 #else 1894 bpf_error("'ip6addr' not supported " 1895 "in this configuration"); 1896 #endif /*INET6*/ 1897 } 1898 break; 1899 1900 case 21: 1901 #line 261 "grammar.y" 1902 { 1903 (yyval.blk).b = gen_ecode((yyvsp[0].e), (yyval.blk).q = (yyvsp[-1].blk).q); 1904 /* 1905 * $1 was allocated by "pcap_ether_aton()", 1906 * so we must free it now that we're done 1907 * with it. 1908 */ 1909 free((yyvsp[0].e)); 1910 } 1911 break; 1912 1913 case 22: 1914 #line 270 "grammar.y" 1915 { 1916 (yyval.blk).b = gen_acode((yyvsp[0].e), (yyval.blk).q = (yyvsp[-1].blk).q); 1917 /* 1918 * $1 was allocated by "pcap_ether_aton()", 1919 * so we must free it now that we're done 1920 * with it. 1921 */ 1922 free((yyvsp[0].e)); 1923 } 1924 break; 1925 1926 case 23: 1927 #line 279 "grammar.y" 1928 { gen_not((yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1929 break; 1930 1931 case 24: 1932 #line 281 "grammar.y" 1933 { (yyval.blk) = (yyvsp[-1].blk); } 1934 break; 1935 1936 case 25: 1937 #line 283 "grammar.y" 1938 { (yyval.blk) = (yyvsp[-1].blk); } 1939 break; 1940 1941 case 27: 1942 #line 286 "grammar.y" 1943 { gen_and((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1944 break; 1945 1946 case 28: 1947 #line 287 "grammar.y" 1948 { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1949 break; 1950 1951 case 29: 1952 #line 289 "grammar.y" 1953 { (yyval.blk).b = gen_ncode(NULL, (bpf_u_int32)(yyvsp[0].i), 1954 (yyval.blk).q = (yyvsp[-1].blk).q); } 1955 break; 1956 1957 case 32: 1958 #line 294 "grammar.y" 1959 { gen_not((yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 1960 break; 1961 1962 case 33: 1963 #line 296 "grammar.y" 1964 { QSET((yyval.blk).q, (yyvsp[-2].i), (yyvsp[-1].i), (yyvsp[0].i)); } 1965 break; 1966 1967 case 34: 1968 #line 297 "grammar.y" 1969 { QSET((yyval.blk).q, (yyvsp[-1].i), (yyvsp[0].i), Q_DEFAULT); } 1970 break; 1971 1972 case 35: 1973 #line 298 "grammar.y" 1974 { QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, (yyvsp[0].i)); } 1975 break; 1976 1977 case 36: 1978 #line 299 "grammar.y" 1979 { QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, Q_PROTO); } 1980 break; 1981 1982 case 37: 1983 #line 300 "grammar.y" 1984 { QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, Q_PROTOCHAIN); } 1985 break; 1986 1987 case 38: 1988 #line 301 "grammar.y" 1989 { QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, (yyvsp[0].i)); } 1990 break; 1991 1992 case 39: 1993 #line 303 "grammar.y" 1994 { (yyval.blk) = (yyvsp[0].blk); } 1995 break; 1996 1997 case 40: 1998 #line 304 "grammar.y" 1999 { (yyval.blk).b = (yyvsp[-1].blk).b; (yyval.blk).q = (yyvsp[-2].blk).q; } 2000 break; 2001 2002 case 41: 2003 #line 305 "grammar.y" 2004 { (yyval.blk).b = gen_proto_abbrev((yyvsp[0].i)); (yyval.blk).q = qerr; } 2005 break; 2006 2007 case 42: 2008 #line 306 "grammar.y" 2009 { (yyval.blk).b = gen_relation((yyvsp[-1].i), (yyvsp[-2].a), (yyvsp[0].a), 0); 2010 (yyval.blk).q = qerr; } 2011 break; 2012 2013 case 43: 2014 #line 308 "grammar.y" 2015 { (yyval.blk).b = gen_relation((yyvsp[-1].i), (yyvsp[-2].a), (yyvsp[0].a), 1); 2016 (yyval.blk).q = qerr; } 2017 break; 2018 2019 case 44: 2020 #line 310 "grammar.y" 2021 { (yyval.blk).b = (yyvsp[0].rblk); (yyval.blk).q = qerr; } 2022 break; 2023 2024 case 45: 2025 #line 311 "grammar.y" 2026 { (yyval.blk).b = gen_atmtype_abbrev((yyvsp[0].i)); (yyval.blk).q = qerr; } 2027 break; 2028 2029 case 46: 2030 #line 312 "grammar.y" 2031 { (yyval.blk).b = gen_atmmulti_abbrev((yyvsp[0].i)); (yyval.blk).q = qerr; } 2032 break; 2033 2034 case 47: 2035 #line 313 "grammar.y" 2036 { (yyval.blk).b = (yyvsp[0].blk).b; (yyval.blk).q = qerr; } 2037 break; 2038 2039 case 48: 2040 #line 314 "grammar.y" 2041 { (yyval.blk).b = gen_mtp2type_abbrev((yyvsp[0].i)); (yyval.blk).q = qerr; } 2042 break; 2043 2044 case 49: 2045 #line 315 "grammar.y" 2046 { (yyval.blk).b = (yyvsp[0].blk).b; (yyval.blk).q = qerr; } 2047 break; 2048 2049 case 51: 2050 #line 319 "grammar.y" 2051 { (yyval.i) = Q_DEFAULT; } 2052 break; 2053 2054 case 52: 2055 #line 322 "grammar.y" 2056 { (yyval.i) = Q_SRC; } 2057 break; 2058 2059 case 53: 2060 #line 323 "grammar.y" 2061 { (yyval.i) = Q_DST; } 2062 break; 2063 2064 case 54: 2065 #line 324 "grammar.y" 2066 { (yyval.i) = Q_OR; } 2067 break; 2068 2069 case 55: 2070 #line 325 "grammar.y" 2071 { (yyval.i) = Q_OR; } 2072 break; 2073 2074 case 56: 2075 #line 326 "grammar.y" 2076 { (yyval.i) = Q_AND; } 2077 break; 2078 2079 case 57: 2080 #line 327 "grammar.y" 2081 { (yyval.i) = Q_AND; } 2082 break; 2083 2084 case 58: 2085 #line 330 "grammar.y" 2086 { (yyval.i) = Q_HOST; } 2087 break; 2088 2089 case 59: 2090 #line 331 "grammar.y" 2091 { (yyval.i) = Q_NET; } 2092 break; 2093 2094 case 60: 2095 #line 332 "grammar.y" 2096 { (yyval.i) = Q_PORT; } 2097 break; 2098 2099 case 61: 2100 #line 333 "grammar.y" 2101 { (yyval.i) = Q_PORTRANGE; } 2102 break; 2103 2104 case 62: 2105 #line 336 "grammar.y" 2106 { (yyval.i) = Q_GATEWAY; } 2107 break; 2108 2109 case 63: 2110 #line 338 "grammar.y" 2111 { (yyval.i) = Q_LINK; } 2112 break; 2113 2114 case 64: 2115 #line 339 "grammar.y" 2116 { (yyval.i) = Q_IP; } 2117 break; 2118 2119 case 65: 2120 #line 340 "grammar.y" 2121 { (yyval.i) = Q_ARP; } 2122 break; 2123 2124 case 66: 2125 #line 341 "grammar.y" 2126 { (yyval.i) = Q_RARP; } 2127 break; 2128 2129 case 67: 2130 #line 342 "grammar.y" 2131 { (yyval.i) = Q_SCTP; } 2132 break; 2133 2134 case 68: 2135 #line 343 "grammar.y" 2136 { (yyval.i) = Q_TCP; } 2137 break; 2138 2139 case 69: 2140 #line 344 "grammar.y" 2141 { (yyval.i) = Q_UDP; } 2142 break; 2143 2144 case 70: 2145 #line 345 "grammar.y" 2146 { (yyval.i) = Q_ICMP; } 2147 break; 2148 2149 case 71: 2150 #line 346 "grammar.y" 2151 { (yyval.i) = Q_IGMP; } 2152 break; 2153 2154 case 72: 2155 #line 347 "grammar.y" 2156 { (yyval.i) = Q_IGRP; } 2157 break; 2158 2159 case 73: 2160 #line 348 "grammar.y" 2161 { (yyval.i) = Q_PIM; } 2162 break; 2163 2164 case 74: 2165 #line 349 "grammar.y" 2166 { (yyval.i) = Q_VRRP; } 2167 break; 2168 2169 case 75: 2170 #line 350 "grammar.y" 2171 { (yyval.i) = Q_ATALK; } 2172 break; 2173 2174 case 76: 2175 #line 351 "grammar.y" 2176 { (yyval.i) = Q_AARP; } 2177 break; 2178 2179 case 77: 2180 #line 352 "grammar.y" 2181 { (yyval.i) = Q_DECNET; } 2182 break; 2183 2184 case 78: 2185 #line 353 "grammar.y" 2186 { (yyval.i) = Q_LAT; } 2187 break; 2188 2189 case 79: 2190 #line 354 "grammar.y" 2191 { (yyval.i) = Q_SCA; } 2192 break; 2193 2194 case 80: 2195 #line 355 "grammar.y" 2196 { (yyval.i) = Q_MOPDL; } 2197 break; 2198 2199 case 81: 2200 #line 356 "grammar.y" 2201 { (yyval.i) = Q_MOPRC; } 2202 break; 2203 2204 case 82: 2205 #line 357 "grammar.y" 2206 { (yyval.i) = Q_IPV6; } 2207 break; 2208 2209 case 83: 2210 #line 358 "grammar.y" 2211 { (yyval.i) = Q_ICMPV6; } 2212 break; 2213 2214 case 84: 2215 #line 359 "grammar.y" 2216 { (yyval.i) = Q_AH; } 2217 break; 2218 2219 case 85: 2220 #line 360 "grammar.y" 2221 { (yyval.i) = Q_ESP; } 2222 break; 2223 2224 case 86: 2225 #line 361 "grammar.y" 2226 { (yyval.i) = Q_ISO; } 2227 break; 2228 2229 case 87: 2230 #line 362 "grammar.y" 2231 { (yyval.i) = Q_ESIS; } 2232 break; 2233 2234 case 88: 2235 #line 363 "grammar.y" 2236 { (yyval.i) = Q_ISIS; } 2237 break; 2238 2239 case 89: 2240 #line 364 "grammar.y" 2241 { (yyval.i) = Q_ISIS_L1; } 2242 break; 2243 2244 case 90: 2245 #line 365 "grammar.y" 2246 { (yyval.i) = Q_ISIS_L2; } 2247 break; 2248 2249 case 91: 2250 #line 366 "grammar.y" 2251 { (yyval.i) = Q_ISIS_IIH; } 2252 break; 2253 2254 case 92: 2255 #line 367 "grammar.y" 2256 { (yyval.i) = Q_ISIS_LSP; } 2257 break; 2258 2259 case 93: 2260 #line 368 "grammar.y" 2261 { (yyval.i) = Q_ISIS_SNP; } 2262 break; 2263 2264 case 94: 2265 #line 369 "grammar.y" 2266 { (yyval.i) = Q_ISIS_PSNP; } 2267 break; 2268 2269 case 95: 2270 #line 370 "grammar.y" 2271 { (yyval.i) = Q_ISIS_CSNP; } 2272 break; 2273 2274 case 96: 2275 #line 371 "grammar.y" 2276 { (yyval.i) = Q_CLNP; } 2277 break; 2278 2279 case 97: 2280 #line 372 "grammar.y" 2281 { (yyval.i) = Q_STP; } 2282 break; 2283 2284 case 98: 2285 #line 373 "grammar.y" 2286 { (yyval.i) = Q_IPX; } 2287 break; 2288 2289 case 99: 2290 #line 374 "grammar.y" 2291 { (yyval.i) = Q_NETBEUI; } 2292 break; 2293 2294 case 100: 2295 #line 375 "grammar.y" 2296 { (yyval.i) = Q_RADIO; } 2297 break; 2298 2299 case 101: 2300 #line 377 "grammar.y" 2301 { (yyval.rblk) = gen_broadcast((yyvsp[-1].i)); } 2302 break; 2303 2304 case 102: 2305 #line 378 "grammar.y" 2306 { (yyval.rblk) = gen_multicast((yyvsp[-1].i)); } 2307 break; 2308 2309 case 103: 2310 #line 379 "grammar.y" 2311 { (yyval.rblk) = gen_less((yyvsp[0].i)); } 2312 break; 2313 2314 case 104: 2315 #line 380 "grammar.y" 2316 { (yyval.rblk) = gen_greater((yyvsp[0].i)); } 2317 break; 2318 2319 case 105: 2320 #line 381 "grammar.y" 2321 { (yyval.rblk) = gen_byteop((yyvsp[-1].i), (yyvsp[-2].i), (yyvsp[0].i)); } 2322 break; 2323 2324 case 106: 2325 #line 382 "grammar.y" 2326 { (yyval.rblk) = gen_inbound(0); } 2327 break; 2328 2329 case 107: 2330 #line 383 "grammar.y" 2331 { (yyval.rblk) = gen_inbound(1); } 2332 break; 2333 2334 case 108: 2335 #line 384 "grammar.y" 2336 { (yyval.rblk) = gen_vlan((yyvsp[0].i)); } 2337 break; 2338 2339 case 109: 2340 #line 385 "grammar.y" 2341 { (yyval.rblk) = gen_vlan(-1); } 2342 break; 2343 2344 case 110: 2345 #line 386 "grammar.y" 2346 { (yyval.rblk) = gen_mpls((yyvsp[0].i)); } 2347 break; 2348 2349 case 111: 2350 #line 387 "grammar.y" 2351 { (yyval.rblk) = gen_mpls(-1); } 2352 break; 2353 2354 case 112: 2355 #line 388 "grammar.y" 2356 { (yyval.rblk) = gen_pppoed(); } 2357 break; 2358 2359 case 113: 2360 #line 389 "grammar.y" 2361 { (yyval.rblk) = gen_pppoes(); } 2362 break; 2363 2364 case 114: 2365 #line 390 "grammar.y" 2366 { (yyval.rblk) = (yyvsp[0].rblk); } 2367 break; 2368 2369 case 115: 2370 #line 393 "grammar.y" 2371 { (yyval.rblk) = gen_pf_ifname((yyvsp[0].s)); } 2372 break; 2373 2374 case 116: 2375 #line 394 "grammar.y" 2376 { (yyval.rblk) = gen_pf_ruleset((yyvsp[0].s)); } 2377 break; 2378 2379 case 117: 2380 #line 395 "grammar.y" 2381 { (yyval.rblk) = gen_pf_rnr((yyvsp[0].i)); } 2382 break; 2383 2384 case 118: 2385 #line 396 "grammar.y" 2386 { (yyval.rblk) = gen_pf_srnr((yyvsp[0].i)); } 2387 break; 2388 2389 case 119: 2390 #line 397 "grammar.y" 2391 { (yyval.rblk) = gen_pf_reason((yyvsp[0].i)); } 2392 break; 2393 2394 case 120: 2395 #line 398 "grammar.y" 2396 { (yyval.rblk) = gen_pf_action((yyvsp[0].i)); } 2397 break; 2398 2399 case 121: 2400 #line 401 "grammar.y" 2401 { (yyval.i) = (yyvsp[0].i); } 2402 break; 2403 2404 case 122: 2405 #line 402 "grammar.y" 2406 { (yyval.i) = pfreason_to_num((yyvsp[0].s)); } 2407 break; 2408 2409 case 123: 2410 #line 405 "grammar.y" 2411 { (yyval.i) = pfaction_to_num((yyvsp[0].s)); } 2412 break; 2413 2414 case 124: 2415 #line 408 "grammar.y" 2416 { (yyval.i) = BPF_JGT; } 2417 break; 2418 2419 case 125: 2420 #line 409 "grammar.y" 2421 { (yyval.i) = BPF_JGE; } 2422 break; 2423 2424 case 126: 2425 #line 410 "grammar.y" 2426 { (yyval.i) = BPF_JEQ; } 2427 break; 2428 2429 case 127: 2430 #line 412 "grammar.y" 2431 { (yyval.i) = BPF_JGT; } 2432 break; 2433 2434 case 128: 2435 #line 413 "grammar.y" 2436 { (yyval.i) = BPF_JGE; } 2437 break; 2438 2439 case 129: 2440 #line 414 "grammar.y" 2441 { (yyval.i) = BPF_JEQ; } 2442 break; 2443 2444 case 130: 2445 #line 416 "grammar.y" 2446 { (yyval.a) = gen_loadi((yyvsp[0].i)); } 2447 break; 2448 2449 case 132: 2450 #line 419 "grammar.y" 2451 { (yyval.a) = gen_load((yyvsp[-3].i), (yyvsp[-1].a), 1); } 2452 break; 2453 2454 case 133: 2455 #line 420 "grammar.y" 2456 { (yyval.a) = gen_load((yyvsp[-5].i), (yyvsp[-3].a), (yyvsp[-1].i)); } 2457 break; 2458 2459 case 134: 2460 #line 421 "grammar.y" 2461 { (yyval.a) = gen_arth(BPF_ADD, (yyvsp[-2].a), (yyvsp[0].a)); } 2462 break; 2463 2464 case 135: 2465 #line 422 "grammar.y" 2466 { (yyval.a) = gen_arth(BPF_SUB, (yyvsp[-2].a), (yyvsp[0].a)); } 2467 break; 2468 2469 case 136: 2470 #line 423 "grammar.y" 2471 { (yyval.a) = gen_arth(BPF_MUL, (yyvsp[-2].a), (yyvsp[0].a)); } 2472 break; 2473 2474 case 137: 2475 #line 424 "grammar.y" 2476 { (yyval.a) = gen_arth(BPF_DIV, (yyvsp[-2].a), (yyvsp[0].a)); } 2477 break; 2478 2479 case 138: 2480 #line 425 "grammar.y" 2481 { (yyval.a) = gen_arth(BPF_AND, (yyvsp[-2].a), (yyvsp[0].a)); } 2482 break; 2483 2484 case 139: 2485 #line 426 "grammar.y" 2486 { (yyval.a) = gen_arth(BPF_OR, (yyvsp[-2].a), (yyvsp[0].a)); } 2487 break; 2488 2489 case 140: 2490 #line 427 "grammar.y" 2491 { (yyval.a) = gen_arth(BPF_LSH, (yyvsp[-2].a), (yyvsp[0].a)); } 2492 break; 2493 2494 case 141: 2495 #line 428 "grammar.y" 2496 { (yyval.a) = gen_arth(BPF_RSH, (yyvsp[-2].a), (yyvsp[0].a)); } 2497 break; 2498 2499 case 142: 2500 #line 429 "grammar.y" 2501 { (yyval.a) = gen_neg((yyvsp[0].a)); } 2502 break; 2503 2504 case 143: 2505 #line 430 "grammar.y" 2506 { (yyval.a) = (yyvsp[-1].a); } 2507 break; 2508 2509 case 144: 2510 #line 431 "grammar.y" 2511 { (yyval.a) = gen_loadlen(); } 2512 break; 2513 2514 case 145: 2515 #line 433 "grammar.y" 2516 { (yyval.i) = '&'; } 2517 break; 2518 2519 case 146: 2520 #line 434 "grammar.y" 2521 { (yyval.i) = '|'; } 2522 break; 2523 2524 case 147: 2525 #line 435 "grammar.y" 2526 { (yyval.i) = '<'; } 2527 break; 2528 2529 case 148: 2530 #line 436 "grammar.y" 2531 { (yyval.i) = '>'; } 2532 break; 2533 2534 case 149: 2535 #line 437 "grammar.y" 2536 { (yyval.i) = '='; } 2537 break; 2538 2539 case 151: 2540 #line 440 "grammar.y" 2541 { (yyval.i) = (yyvsp[-1].i); } 2542 break; 2543 2544 case 152: 2545 #line 442 "grammar.y" 2546 { (yyval.i) = A_LANE; } 2547 break; 2548 2549 case 153: 2550 #line 443 "grammar.y" 2551 { (yyval.i) = A_LLC; } 2552 break; 2553 2554 case 154: 2555 #line 444 "grammar.y" 2556 { (yyval.i) = A_METAC; } 2557 break; 2558 2559 case 155: 2560 #line 445 "grammar.y" 2561 { (yyval.i) = A_BCC; } 2562 break; 2563 2564 case 156: 2565 #line 446 "grammar.y" 2566 { (yyval.i) = A_OAMF4EC; } 2567 break; 2568 2569 case 157: 2570 #line 447 "grammar.y" 2571 { (yyval.i) = A_OAMF4SC; } 2572 break; 2573 2574 case 158: 2575 #line 448 "grammar.y" 2576 { (yyval.i) = A_SC; } 2577 break; 2578 2579 case 159: 2580 #line 449 "grammar.y" 2581 { (yyval.i) = A_ILMIC; } 2582 break; 2583 2584 case 160: 2585 #line 451 "grammar.y" 2586 { (yyval.i) = A_OAM; } 2587 break; 2588 2589 case 161: 2590 #line 452 "grammar.y" 2591 { (yyval.i) = A_OAMF4; } 2592 break; 2593 2594 case 162: 2595 #line 453 "grammar.y" 2596 { (yyval.i) = A_CONNECTMSG; } 2597 break; 2598 2599 case 163: 2600 #line 454 "grammar.y" 2601 { (yyval.i) = A_METACONNECT; } 2602 break; 2603 2604 case 164: 2605 #line 457 "grammar.y" 2606 { (yyval.blk).atmfieldtype = A_VPI; } 2607 break; 2608 2609 case 165: 2610 #line 458 "grammar.y" 2611 { (yyval.blk).atmfieldtype = A_VCI; } 2612 break; 2613 2614 case 167: 2615 #line 461 "grammar.y" 2616 { (yyval.blk).b = gen_atmfield_code((yyvsp[-2].blk).atmfieldtype, (bpf_int32)(yyvsp[0].i), (bpf_u_int32)(yyvsp[-1].i), 0); } 2617 break; 2618 2619 case 168: 2620 #line 462 "grammar.y" 2621 { (yyval.blk).b = gen_atmfield_code((yyvsp[-2].blk).atmfieldtype, (bpf_int32)(yyvsp[0].i), (bpf_u_int32)(yyvsp[-1].i), 1); } 2622 break; 2623 2624 case 169: 2625 #line 463 "grammar.y" 2626 { (yyval.blk).b = (yyvsp[-1].blk).b; (yyval.blk).q = qerr; } 2627 break; 2628 2629 case 170: 2630 #line 465 "grammar.y" 2631 { 2632 (yyval.blk).atmfieldtype = (yyvsp[-1].blk).atmfieldtype; 2633 if ((yyval.blk).atmfieldtype == A_VPI || 2634 (yyval.blk).atmfieldtype == A_VCI) 2635 (yyval.blk).b = gen_atmfield_code((yyval.blk).atmfieldtype, (bpf_int32) (yyvsp[0].i), BPF_JEQ, 0); 2636 } 2637 break; 2638 2639 case 172: 2640 #line 473 "grammar.y" 2641 { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 2642 break; 2643 2644 case 173: 2645 #line 476 "grammar.y" 2646 { (yyval.i) = M_FISU; } 2647 break; 2648 2649 case 174: 2650 #line 477 "grammar.y" 2651 { (yyval.i) = M_LSSU; } 2652 break; 2653 2654 case 175: 2655 #line 478 "grammar.y" 2656 { (yyval.i) = M_MSU; } 2657 break; 2658 2659 case 176: 2660 #line 481 "grammar.y" 2661 { (yyval.blk).mtp3fieldtype = M_SIO; } 2662 break; 2663 2664 case 177: 2665 #line 482 "grammar.y" 2666 { (yyval.blk).mtp3fieldtype = M_OPC; } 2667 break; 2668 2669 case 178: 2670 #line 483 "grammar.y" 2671 { (yyval.blk).mtp3fieldtype = M_DPC; } 2672 break; 2673 2674 case 179: 2675 #line 484 "grammar.y" 2676 { (yyval.blk).mtp3fieldtype = M_SLS; } 2677 break; 2678 2679 case 181: 2680 #line 487 "grammar.y" 2681 { (yyval.blk).b = gen_mtp3field_code((yyvsp[-2].blk).mtp3fieldtype, (u_int)(yyvsp[0].i), (u_int)(yyvsp[-1].i), 0); } 2682 break; 2683 2684 case 182: 2685 #line 488 "grammar.y" 2686 { (yyval.blk).b = gen_mtp3field_code((yyvsp[-2].blk).mtp3fieldtype, (u_int)(yyvsp[0].i), (u_int)(yyvsp[-1].i), 1); } 2687 break; 2688 2689 case 183: 2690 #line 489 "grammar.y" 2691 { (yyval.blk).b = (yyvsp[-1].blk).b; (yyval.blk).q = qerr; } 2692 break; 2693 2694 case 184: 2695 #line 491 "grammar.y" 2696 { 2697 (yyval.blk).mtp3fieldtype = (yyvsp[-1].blk).mtp3fieldtype; 2698 if ((yyval.blk).mtp3fieldtype == M_SIO || 2699 (yyval.blk).mtp3fieldtype == M_OPC || 2700 (yyval.blk).mtp3fieldtype == M_DPC || 2701 (yyval.blk).mtp3fieldtype == M_SLS ) 2702 (yyval.blk).b = gen_mtp3field_code((yyval.blk).mtp3fieldtype, (u_int) (yyvsp[0].i), BPF_JEQ, 0); 2703 } 2704 break; 2705 2706 case 186: 2707 #line 501 "grammar.y" 2708 { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); } 2709 break; 2710 2711 2712 default: break; 2713 } 2714 2715 /* Line 1126 of yacc.c. */ 2716 #line 2714 "y.tab.c" 2717 2718 yyvsp -= yylen; 2720 yyssp -= yylen; 2721 2722 2723 YY_STACK_PRINT (yyss, yyssp); 2724 2725 *++yyvsp = yyval; 2726 2727 2728 /* Now `shift' the result of the reduction. Determine what state 2729 that goes to, based on the state we popped back to and the rule 2730 number reduced by. */ 2731 2732 yyn = yyr1[yyn]; 2733 2734 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 2735 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 2736 yystate = yytable[yystate]; 2737 else 2738 yystate = yydefgoto[yyn - YYNTOKENS]; 2739 2740 goto yynewstate; 2741 2742 2743 /*------------------------------------. 2744 | yyerrlab -- here on detecting error | 2745 `------------------------------------*/ 2746 yyerrlab: 2747 /* If not already recovering from an error, report this error. */ 2748 if (!yyerrstatus) 2749 { 2750 ++yynerrs; 2751 #if YYERROR_VERBOSE 2752 yyn = yypact[yystate]; 2753 2754 if (YYPACT_NINF < yyn && yyn < YYLAST) 2755 { 2756 int yytype = YYTRANSLATE (yychar); 2757 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 2758 YYSIZE_T yysize = yysize0; 2759 YYSIZE_T yysize1; 2760 int yysize_overflow = 0; 2761 char *yymsg = 0; 2762 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5 2763 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 2764 int yyx; 2765 2766 #if 0 2767 /* This is so xgettext sees the translatable formats that are 2768 constructed on the fly. */ 2769 YY_("syntax error, unexpected %s"); 2770 YY_("syntax error, unexpected %s, expecting %s"); 2771 YY_("syntax error, unexpected %s, expecting %s or %s"); 2772 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 2773 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 2774 #endif 2775 char *yyfmt; 2776 char const *yyf; 2777 static char const yyunexpected[] = "syntax error, unexpected %s"; 2778 static char const yyexpecting[] = ", expecting %s"; 2779 static char const yyor[] = " or %s"; 2780 char yyformat[sizeof yyunexpected 2781 + sizeof yyexpecting - 1 2782 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 2783 * (sizeof yyor - 1))]; 2784 char const *yyprefix = yyexpecting; 2785 2786 /* Start YYX at -YYN if negative to avoid negative indexes in 2787 YYCHECK. */ 2788 int yyxbegin = yyn < 0 ? -yyn : 0; 2789 2790 /* Stay within bounds of both yycheck and yytname. */ 2791 int yychecklim = YYLAST - yyn; 2792 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 2793 int yycount = 1; 2794 2795 yyarg[0] = yytname[yytype]; 2796 yyfmt = yystpcpy (yyformat, yyunexpected); 2797 2798 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 2799 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 2800 { 2801 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 2802 { 2803 yycount = 1; 2804 yysize = yysize0; 2805 yyformat[sizeof yyunexpected - 1] = '\0'; 2806 break; 2807 } 2808 yyarg[yycount++] = yytname[yyx]; 2809 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 2810 yysize_overflow |= yysize1 < yysize; 2811 yysize = yysize1; 2812 yyfmt = yystpcpy (yyfmt, yyprefix); 2813 yyprefix = yyor; 2814 } 2815 2816 yyf = YY_(yyformat); 2817 yysize1 = yysize + yystrlen (yyf); 2818 yysize_overflow |= yysize1 < yysize; 2819 yysize = yysize1; 2820 2821 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM) 2822 yymsg = (char *) YYSTACK_ALLOC (yysize); 2823 if (yymsg) 2824 { 2825 /* Avoid sprintf, as that infringes on the user's name space. 2826 Don't have undefined behavior even if the translation 2827 produced a string with the wrong number of "%s"s. */ 2828 char *yyp = yymsg; 2829 int yyi = 0; 2830 while ((*yyp = *yyf)) 2831 { 2832 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 2833 { 2834 yyp += yytnamerr (yyp, yyarg[yyi++]); 2835 yyf += 2; 2836 } 2837 else 2838 { 2839 yyp++; 2840 yyf++; 2841 } 2842 } 2843 yyerror (yymsg); 2844 YYSTACK_FREE (yymsg); 2845 } 2846 else 2847 { 2848 yyerror (YY_("syntax error")); 2849 goto yyexhaustedlab; 2850 } 2851 } 2852 else 2853 #endif /* YYERROR_VERBOSE */ 2854 yyerror (YY_("syntax error")); 2855 } 2856 2857 2858 2859 if (yyerrstatus == 3) 2860 { 2861 /* If just tried and failed to reuse look-ahead token after an 2862 error, discard it. */ 2863 2864 if (yychar <= YYEOF) 2865 { 2866 /* Return failure if at end of input. */ 2867 if (yychar == YYEOF) 2868 YYABORT; 2869 } 2870 else 2871 { 2872 yydestruct ("Error: discarding", yytoken, &yylval); 2873 yychar = YYEMPTY; 2874 } 2875 } 2876 2877 /* Else will try to reuse look-ahead token after shifting the error 2878 token. */ 2879 goto yyerrlab1; 2880 2881 2882 /*---------------------------------------------------. 2883 | yyerrorlab -- error raised explicitly by YYERROR. | 2884 `---------------------------------------------------*/ 2885 yyerrorlab: 2886 2887 /* Pacify compilers like GCC when the user code never invokes 2888 YYERROR and the label yyerrorlab therefore never appears in user 2889 code. */ 2890 if (0) 2891 goto yyerrorlab; 2892 2893 yyvsp -= yylen; 2894 yyssp -= yylen; 2895 yystate = *yyssp; 2896 goto yyerrlab1; 2897 2898 2899 /*-------------------------------------------------------------. 2900 | yyerrlab1 -- common code for both syntax error and YYERROR. | 2901 `-------------------------------------------------------------*/ 2902 yyerrlab1: 2903 yyerrstatus = 3; /* Each real token shifted decrements this. */ 2904 2905 for (;;) 2906 { 2907 yyn = yypact[yystate]; 2908 if (yyn != YYPACT_NINF) 2909 { 2910 yyn += YYTERROR; 2911 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 2912 { 2913 yyn = yytable[yyn]; 2914 if (0 < yyn) 2915 break; 2916 } 2917 } 2918 2919 /* Pop the current state because it cannot handle the error token. */ 2920 if (yyssp == yyss) 2921 YYABORT; 2922 2923 2924 yydestruct ("Error: popping", yystos[yystate], yyvsp); 2925 YYPOPSTACK; 2926 yystate = *yyssp; 2927 YY_STACK_PRINT (yyss, yyssp); 2928 } 2929 2930 if (yyn == YYFINAL) 2931 YYACCEPT; 2932 2933 *++yyvsp = yylval; 2934 2935 2936 /* Shift the error token. */ 2937 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 2938 2939 yystate = yyn; 2940 goto yynewstate; 2941 2942 2943 /*-------------------------------------. 2944 | yyacceptlab -- YYACCEPT comes here. | 2945 `-------------------------------------*/ 2946 yyacceptlab: 2947 yyresult = 0; 2948 goto yyreturn; 2949 2950 /*-----------------------------------. 2951 | yyabortlab -- YYABORT comes here. | 2952 `-----------------------------------*/ 2953 yyabortlab: 2954 yyresult = 1; 2955 goto yyreturn; 2956 2957 #ifndef yyoverflow 2958 /*-------------------------------------------------. 2959 | yyexhaustedlab -- memory exhaustion comes here. | 2960 `-------------------------------------------------*/ 2961 yyexhaustedlab: 2962 yyerror (YY_("memory exhausted")); 2963 yyresult = 2; 2964 /* Fall through. */ 2965 #endif 2966 2967 yyreturn: 2968 if (yychar != YYEOF && yychar != YYEMPTY) 2969 yydestruct ("Cleanup: discarding lookahead", 2970 yytoken, &yylval); 2971 while (yyssp != yyss) 2972 { 2973 yydestruct ("Cleanup: popping", 2974 yystos[*yyssp], yyvsp); 2975 YYPOPSTACK; 2976 } 2977 #ifndef yyoverflow 2978 if (yyss != yyssa) 2979 YYSTACK_FREE (yyss); 2980 #endif 2981 return yyresult; 2982 } 2983 2984 2985 #line 503 "grammar.y" 2986 2987 2988
