Coverage Report

Created: 2023-09-28 22:18

/src/libpcap/build/grammar.c
Line
Count
Source (jump to first uncovered line)
1
/* A Bison parser, made by GNU Bison 3.5.1.  */
2
3
/* Bison implementation for Yacc-like parsers in C
4
5
   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
6
   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 3 of the License, or
11
   (at your option) 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, see <http://www.gnu.org/licenses/>.  */
20
21
/* As a special exception, you may create a larger work that contains
22
   part or all of the Bison parser skeleton and distribute that work
23
   under terms of your choice, so long as that work isn't itself a
24
   parser generator using the skeleton or a modified version thereof
25
   as a parser skeleton.  Alternatively, if you modify or redistribute
26
   the parser skeleton itself, you may (at your option) remove this
27
   special exception, which will cause the skeleton and the resulting
28
   Bison output files to be licensed under the GNU General Public
29
   License without this special exception.
30
31
   This special exception was added by the Free Software Foundation in
32
   version 2.2 of Bison.  */
33
34
/* C LALR(1) parser skeleton written by Richard Stallman, by
35
   simplifying the original so-called "semantic" parser.  */
36
37
/* All symbols defined below should begin with yy or YY, to avoid
38
   infringing on user name space.  This should be done even for local
39
   variables, as they might otherwise be expanded by user macros.
40
   There are some unavoidable exceptions within include files to
41
   define necessary library symbols; they are noted "INFRINGES ON
42
   USER NAME SPACE" below.  */
43
44
/* Undocumented macros, especially those whose name start with YY_,
45
   are private implementation details.  Do not rely on them.  */
46
47
/* Identify Bison output.  */
48
#define YYBISON 1
49
50
/* Bison version.  */
51
#define YYBISON_VERSION "3.5.1"
52
53
/* Skeleton name.  */
54
#define YYSKELETON_NAME "yacc.c"
55
56
/* Pure parsers.  */
57
#define YYPURE 1
58
59
/* Push parsers.  */
60
#define YYPUSH 0
61
62
/* Pull parsers.  */
63
#define YYPULL 1
64
65
66
/* Substitute the variable and function names.  */
67
#define yyparse         pcap_parse
68
532k
#define yylex           pcap_lex
69
6.16k
#define yyerror         pcap_error
70
#define yydebug         pcap_debug
71
38.2k
#define yynerrs         pcap_nerrs
72
73
/* First part of user prologue.  */
74
#line 47 "/src/libpcap/build/grammar.y"
75
76
/*
77
 * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
78
 *  The Regents of the University of California.  All rights reserved.
79
 *
80
 * Redistribution and use in source and binary forms, with or without
81
 * modification, are permitted provided that: (1) source code distributions
82
 * retain the above copyright notice and this paragraph in its entirety, (2)
83
 * distributions including binary code include the above copyright notice and
84
 * this paragraph in its entirety in the documentation or other materials
85
 * provided with the distribution, and (3) all advertising materials mentioning
86
 * features or use of this software display the following acknowledgement:
87
 * ``This product includes software developed by the University of California,
88
 * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
89
 * the University nor the names of its contributors may be used to endorse
90
 * or promote products derived from this software without specific prior
91
 * written permission.
92
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
93
 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
94
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
95
 *
96
 */
97
98
#ifdef HAVE_CONFIG_H
99
#include <config.h>
100
#endif
101
102
/*
103
 * grammar.h requires gencode.h and sometimes breaks in a polluted namespace
104
 * (see ftmacros.h), so include it early.
105
 */
106
#include "gencode.h"
107
#include "grammar.h"
108
109
#include <stdlib.h>
110
111
#ifndef _WIN32
112
#include <sys/types.h>
113
#include <sys/socket.h>
114
115
#if __STDC__
116
struct mbuf;
117
struct rtentry;
118
#endif
119
120
#include <netinet/in.h>
121
#include <arpa/inet.h>
122
#endif /* _WIN32 */
123
124
#include <stdio.h>
125
126
#include "diag-control.h"
127
128
#include "pcap-int.h"
129
130
#include "scanner.h"
131
132
#include "llc.h"
133
#include "ieee80211.h"
134
#include "pflog.h"
135
#include <pcap/namedb.h>
136
137
#ifdef HAVE_OS_PROTO_H
138
#include "os-proto.h"
139
#endif
140
141
#ifdef YYBYACC
142
/*
143
 * Both Berkeley YACC and Bison define yydebug (under whatever name
144
 * it has) as a global, but Bison does so only if YYDEBUG is defined.
145
 * Berkeley YACC define it even if YYDEBUG isn't defined; declare it
146
 * here to suppress a warning.
147
 */
148
#if !defined(YYDEBUG)
149
extern int yydebug;
150
#endif
151
152
/*
153
 * In Berkeley YACC, yynerrs (under whatever name it has) is global,
154
 * even if it's building a reentrant parser.  In Bison, it's local
155
 * in reentrant parsers.
156
 *
157
 * Declare it to squelch a warning.
158
 */
159
extern int yynerrs;
160
#endif
161
162
33
#define QSET(q, p, d, a) (q).proto = (unsigned char)(p),\
163
33
       (q).dir = (unsigned char)(d),\
164
33
       (q).addr = (unsigned char)(a)
165
166
struct tok {
167
  int v;      /* value */
168
  const char *s;    /* string */
169
};
170
171
static const struct tok ieee80211_types[] = {
172
  { IEEE80211_FC0_TYPE_DATA, "data" },
173
  { IEEE80211_FC0_TYPE_MGT, "mgt" },
174
  { IEEE80211_FC0_TYPE_MGT, "management" },
175
  { IEEE80211_FC0_TYPE_CTL, "ctl" },
176
  { IEEE80211_FC0_TYPE_CTL, "control" },
177
  { 0, NULL }
178
};
179
static const struct tok ieee80211_mgt_subtypes[] = {
180
  { IEEE80211_FC0_SUBTYPE_ASSOC_REQ, "assocreq" },
181
  { IEEE80211_FC0_SUBTYPE_ASSOC_REQ, "assoc-req" },
182
  { IEEE80211_FC0_SUBTYPE_ASSOC_RESP, "assocresp" },
183
  { IEEE80211_FC0_SUBTYPE_ASSOC_RESP, "assoc-resp" },
184
  { IEEE80211_FC0_SUBTYPE_REASSOC_REQ, "reassocreq" },
185
  { IEEE80211_FC0_SUBTYPE_REASSOC_REQ, "reassoc-req" },
186
  { IEEE80211_FC0_SUBTYPE_REASSOC_RESP, "reassocresp" },
187
  { IEEE80211_FC0_SUBTYPE_REASSOC_RESP, "reassoc-resp" },
188
  { IEEE80211_FC0_SUBTYPE_PROBE_REQ, "probereq" },
189
  { IEEE80211_FC0_SUBTYPE_PROBE_REQ, "probe-req" },
190
  { IEEE80211_FC0_SUBTYPE_PROBE_RESP, "proberesp" },
191
  { IEEE80211_FC0_SUBTYPE_PROBE_RESP, "probe-resp" },
192
  { IEEE80211_FC0_SUBTYPE_BEACON, "beacon" },
193
  { IEEE80211_FC0_SUBTYPE_ATIM, "atim" },
194
  { IEEE80211_FC0_SUBTYPE_DISASSOC, "disassoc" },
195
  { IEEE80211_FC0_SUBTYPE_DISASSOC, "disassociation" },
196
  { IEEE80211_FC0_SUBTYPE_AUTH, "auth" },
197
  { IEEE80211_FC0_SUBTYPE_AUTH, "authentication" },
198
  { IEEE80211_FC0_SUBTYPE_DEAUTH, "deauth" },
199
  { IEEE80211_FC0_SUBTYPE_DEAUTH, "deauthentication" },
200
  { 0, NULL }
201
};
202
static const struct tok ieee80211_ctl_subtypes[] = {
203
  { IEEE80211_FC0_SUBTYPE_BAR, "bar" },
204
  { IEEE80211_FC0_SUBTYPE_BA, "ba" },
205
  { IEEE80211_FC0_SUBTYPE_PS_POLL, "ps-poll" },
206
  { IEEE80211_FC0_SUBTYPE_RTS, "rts" },
207
  { IEEE80211_FC0_SUBTYPE_CTS, "cts" },
208
  { IEEE80211_FC0_SUBTYPE_ACK, "ack" },
209
  { IEEE80211_FC0_SUBTYPE_CF_END, "cf-end" },
210
  { IEEE80211_FC0_SUBTYPE_CF_END_ACK, "cf-end-ack" },
211
  { 0, NULL }
212
};
213
static const struct tok ieee80211_data_subtypes[] = {
214
  { IEEE80211_FC0_SUBTYPE_DATA, "data" },
215
  { IEEE80211_FC0_SUBTYPE_CF_ACK, "data-cf-ack" },
216
  { IEEE80211_FC0_SUBTYPE_CF_POLL, "data-cf-poll" },
217
  { IEEE80211_FC0_SUBTYPE_CF_ACPL, "data-cf-ack-poll" },
218
  { IEEE80211_FC0_SUBTYPE_NODATA, "null" },
219
  { IEEE80211_FC0_SUBTYPE_NODATA_CF_ACK, "cf-ack" },
220
  { IEEE80211_FC0_SUBTYPE_NODATA_CF_POLL, "cf-poll"  },
221
  { IEEE80211_FC0_SUBTYPE_NODATA_CF_ACPL, "cf-ack-poll" },
222
  { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_DATA, "qos-data" },
223
  { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_CF_ACK, "qos-data-cf-ack" },
224
  { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_CF_POLL, "qos-data-cf-poll" },
225
  { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_CF_ACPL, "qos-data-cf-ack-poll" },
226
  { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_NODATA, "qos" },
227
  { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_NODATA_CF_POLL, "qos-cf-poll" },
228
  { IEEE80211_FC0_SUBTYPE_QOS|IEEE80211_FC0_SUBTYPE_NODATA_CF_ACPL, "qos-cf-ack-poll" },
229
  { 0, NULL }
230
};
231
static const struct tok llc_s_subtypes[] = {
232
  { LLC_RR, "rr" },
233
  { LLC_RNR, "rnr" },
234
  { LLC_REJ, "rej" },
235
  { 0, NULL }
236
};
237
static const struct tok llc_u_subtypes[] = {
238
  { LLC_UI, "ui" },
239
  { LLC_UA, "ua" },
240
  { LLC_DISC, "disc" },
241
  { LLC_DM, "dm" },
242
  { LLC_SABME, "sabme" },
243
  { LLC_TEST, "test" },
244
  { LLC_XID, "xid" },
245
  { LLC_FRMR, "frmr" },
246
  { 0, NULL }
247
};
248
struct type2tok {
249
  int type;
250
  const struct tok *tok;
251
};
252
static const struct type2tok ieee80211_type_subtypes[] = {
253
  { IEEE80211_FC0_TYPE_MGT, ieee80211_mgt_subtypes },
254
  { IEEE80211_FC0_TYPE_CTL, ieee80211_ctl_subtypes },
255
  { IEEE80211_FC0_TYPE_DATA, ieee80211_data_subtypes },
256
  { 0, NULL }
257
};
258
259
static int
260
str2tok(const char *str, const struct tok *toks)
261
16
{
262
16
  int i;
263
264
75
  for (i = 0; toks[i].s != NULL; i++) {
265
63
    if (pcap_strcasecmp(toks[i].s, str) == 0) {
266
      /*
267
       * Just in case somebody is using this to
268
       * generate values of -1/0xFFFFFFFF.
269
       * That won't work, as it's indistinguishable
270
       * from an error.
271
       */
272
4
      if (toks[i].v == -1)
273
0
        abort();
274
4
      return (toks[i].v);
275
4
    }
276
63
  }
277
12
  return (-1);
278
16
}
279
280
static const struct qual qerr = { Q_UNDEF, Q_UNDEF, Q_UNDEF, Q_UNDEF };
281
282
static void
283
yyerror(void *yyscanner _U_, compiler_state_t *cstate, const char *msg)
284
6.16k
{
285
6.16k
  bpf_set_error(cstate, "can't parse filter expression: %s", msg);
286
6.16k
}
287
288
static const struct tok pflog_reasons[] = {
289
  { PFRES_MATCH,    "match" },
290
  { PFRES_BADOFF,   "bad-offset" },
291
  { PFRES_FRAG,   "fragment" },
292
  { PFRES_SHORT,    "short" },
293
  { PFRES_NORM,   "normalize" },
294
  { PFRES_MEMORY,   "memory" },
295
  { PFRES_TS,   "bad-timestamp" },
296
  { PFRES_CONGEST,  "congestion" },
297
  { PFRES_IPOPTIONS,  "ip-option" },
298
  { PFRES_PROTCKSUM,  "proto-cksum" },
299
  { PFRES_BADSTATE, "state-mismatch" },
300
  { PFRES_STATEINS, "state-insert" },
301
  { PFRES_MAXSTATES,  "state-limit" },
302
  { PFRES_SRCLIMIT, "src-limit" },
303
  { PFRES_SYNPROXY, "synproxy" },
304
#if defined(__FreeBSD__)
305
  { PFRES_MAPFAILED,  "map-failed" },
306
#elif defined(__NetBSD__)
307
  { PFRES_STATELOCKED,  "state-locked" },
308
#elif defined(__OpenBSD__)
309
  { PFRES_TRANSLATE,  "translate" },
310
  { PFRES_NOROUTE,  "no-route" },
311
#elif defined(__APPLE__)
312
  { PFRES_DUMMYNET, "dummynet" },
313
#endif
314
  { 0, NULL }
315
};
316
317
static int
318
pfreason_to_num(compiler_state_t *cstate, const char *reason)
319
0
{
320
0
  int i;
321
322
0
  i = str2tok(reason, pflog_reasons);
323
0
  if (i == -1)
324
0
    bpf_set_error(cstate, "unknown PF reason \"%s\"", reason);
325
0
  return (i);
326
0
}
327
328
static const struct tok pflog_actions[] = {
329
  { PF_PASS,    "pass" },
330
  { PF_PASS,    "accept" }, /* alias for "pass" */
331
  { PF_DROP,    "drop" },
332
  { PF_DROP,    "block" },  /* alias for "drop" */
333
  { PF_SCRUB,   "scrub" },
334
  { PF_NOSCRUB,   "noscrub" },
335
  { PF_NAT,   "nat" },
336
  { PF_NONAT,   "nonat" },
337
  { PF_BINAT,   "binat" },
338
  { PF_NOBINAT,   "nobinat" },
339
  { PF_RDR,   "rdr" },
340
  { PF_NORDR,   "nordr" },
341
  { PF_SYNPROXY_DROP, "synproxy-drop" },
342
#if defined(__FreeBSD__)
343
  { PF_DEFER,   "defer" },
344
#elif defined(__OpenBSD__)
345
  { PF_DEFER,   "defer" },
346
  { PF_MATCH,   "match" },
347
  { PF_DIVERT,    "divert" },
348
  { PF_RT,    "rt" },
349
  { PF_AFRT,    "afrt" },
350
#elif defined(__APPLE__)
351
  { PF_DUMMYNET,    "dummynet" },
352
  { PF_NODUMMYNET,  "nodummynet" },
353
  { PF_NAT64,   "nat64" },
354
  { PF_NONAT64,   "nonat64" },
355
#endif
356
  { 0, NULL },
357
};
358
359
static int
360
pfaction_to_num(compiler_state_t *cstate, const char *action)
361
0
{
362
0
  int i;
363
364
0
  i = str2tok(action, pflog_actions);
365
0
  if (i == -1)
366
0
    bpf_set_error(cstate, "unknown PF action \"%s\"", action);
367
0
  return (i);
368
0
}
369
370
/*
371
 * For calls that might return an "an error occurred" value.
372
 */
373
20.7k
#define CHECK_INT_VAL(val)  if (val == -1) YYABORT
374
436k
#define CHECK_PTR_VAL(val)  if (val == NULL) YYABORT
375
376
DIAG_OFF_BISON_BYACC
377
378
#line 379 "/src/libpcap/build/grammar.c"
379
380
# ifndef YY_CAST
381
#  ifdef __cplusplus
382
#   define YY_CAST(Type, Val) static_cast<Type> (Val)
383
#   define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
384
#  else
385
1.68M
#   define YY_CAST(Type, Val) ((Type) (Val))
386
#   define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
387
#  endif
388
# endif
389
# ifndef YY_NULLPTR
390
#  if defined __cplusplus
391
#   if 201103L <= __cplusplus
392
#    define YY_NULLPTR nullptr
393
#   else
394
#    define YY_NULLPTR 0
395
#   endif
396
#  else
397
#   define YY_NULLPTR ((void*)0)
398
#  endif
399
# endif
400
401
/* Enabling verbose error messages.  */
402
#ifdef YYERROR_VERBOSE
403
# undef YYERROR_VERBOSE
404
# define YYERROR_VERBOSE 1
405
#else
406
# define YYERROR_VERBOSE 0
407
#endif
408
409
/* Use api.header.include to #include this header
410
   instead of duplicating it here.  */
411
#ifndef YY_PCAP_SRC_LIBPCAP_BUILD_GRAMMAR_H_INCLUDED
412
# define YY_PCAP_SRC_LIBPCAP_BUILD_GRAMMAR_H_INCLUDED
413
/* Debug traces.  */
414
#ifndef YYDEBUG
415
# define YYDEBUG 0
416
#endif
417
#if YYDEBUG
418
extern int pcap_debug;
419
#endif
420
421
/* Token type.  */
422
#ifndef YYTOKENTYPE
423
# define YYTOKENTYPE
424
  enum yytokentype
425
  {
426
    DST = 258,
427
    SRC = 259,
428
    HOST = 260,
429
    GATEWAY = 261,
430
    NET = 262,
431
    NETMASK = 263,
432
    PORT = 264,
433
    PORTRANGE = 265,
434
    LESS = 266,
435
    GREATER = 267,
436
    PROTO = 268,
437
    PROTOCHAIN = 269,
438
    CBYTE = 270,
439
    ARP = 271,
440
    RARP = 272,
441
    IP = 273,
442
    SCTP = 274,
443
    TCP = 275,
444
    UDP = 276,
445
    ICMP = 277,
446
    IGMP = 278,
447
    IGRP = 279,
448
    PIM = 280,
449
    VRRP = 281,
450
    CARP = 282,
451
    ATALK = 283,
452
    AARP = 284,
453
    DECNET = 285,
454
    LAT = 286,
455
    SCA = 287,
456
    MOPRC = 288,
457
    MOPDL = 289,
458
    TK_BROADCAST = 290,
459
    TK_MULTICAST = 291,
460
    NUM = 292,
461
    INBOUND = 293,
462
    OUTBOUND = 294,
463
    IFINDEX = 295,
464
    PF_IFNAME = 296,
465
    PF_RSET = 297,
466
    PF_RNR = 298,
467
    PF_SRNR = 299,
468
    PF_REASON = 300,
469
    PF_ACTION = 301,
470
    TYPE = 302,
471
    SUBTYPE = 303,
472
    DIR = 304,
473
    ADDR1 = 305,
474
    ADDR2 = 306,
475
    ADDR3 = 307,
476
    ADDR4 = 308,
477
    RA = 309,
478
    TA = 310,
479
    LINK = 311,
480
    GEQ = 312,
481
    LEQ = 313,
482
    NEQ = 314,
483
    ID = 315,
484
    EID = 316,
485
    HID = 317,
486
    HID6 = 318,
487
    AID = 319,
488
    LSH = 320,
489
    RSH = 321,
490
    LEN = 322,
491
    IPV6 = 323,
492
    ICMPV6 = 324,
493
    AH = 325,
494
    ESP = 326,
495
    VLAN = 327,
496
    MPLS = 328,
497
    PPPOED = 329,
498
    PPPOES = 330,
499
    GENEVE = 331,
500
    ISO = 332,
501
    ESIS = 333,
502
    CLNP = 334,
503
    ISIS = 335,
504
    L1 = 336,
505
    L2 = 337,
506
    IIH = 338,
507
    LSP = 339,
508
    SNP = 340,
509
    CSNP = 341,
510
    PSNP = 342,
511
    STP = 343,
512
    IPX = 344,
513
    NETBEUI = 345,
514
    LANE = 346,
515
    LLC = 347,
516
    METAC = 348,
517
    BCC = 349,
518
    SC = 350,
519
    ILMIC = 351,
520
    OAMF4EC = 352,
521
    OAMF4SC = 353,
522
    OAM = 354,
523
    OAMF4 = 355,
524
    CONNECTMSG = 356,
525
    METACONNECT = 357,
526
    VPI = 358,
527
    VCI = 359,
528
    RADIO = 360,
529
    FISU = 361,
530
    LSSU = 362,
531
    MSU = 363,
532
    HFISU = 364,
533
    HLSSU = 365,
534
    HMSU = 366,
535
    SIO = 367,
536
    OPC = 368,
537
    DPC = 369,
538
    SLS = 370,
539
    HSIO = 371,
540
    HOPC = 372,
541
    HDPC = 373,
542
    HSLS = 374,
543
    LEX_ERROR = 375,
544
    OR = 376,
545
    AND = 377,
546
    UMINUS = 378
547
  };
548
#endif
549
550
/* Value type.  */
551
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
552
union YYSTYPE
553
{
554
#line 351 "/src/libpcap/build/grammar.y"
555
556
  int i;
557
  bpf_u_int32 h;
558
  char *s;
559
  struct stmt *stmt;
560
  struct arth *a;
561
  struct {
562
    struct qual q;
563
    int atmfieldtype;
564
    int mtp3fieldtype;
565
    struct block *b;
566
  } blk;
567
  struct block *rblk;
568
569
#line 570 "/src/libpcap/build/grammar.c"
570
571
};
572
typedef union YYSTYPE YYSTYPE;
573
# define YYSTYPE_IS_TRIVIAL 1
574
# define YYSTYPE_IS_DECLARED 1
575
#endif
576
577
578
579
int pcap_parse (void *yyscanner, compiler_state_t *cstate);
580
581
#endif /* !YY_PCAP_SRC_LIBPCAP_BUILD_GRAMMAR_H_INCLUDED  */
582
583
584
585
#ifdef short
586
# undef short
587
#endif
588
589
/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
590
   <limits.h> and (if available) <stdint.h> are included
591
   so that the code can choose integer types of a good width.  */
592
593
#ifndef __PTRDIFF_MAX__
594
# include <limits.h> /* INFRINGES ON USER NAME SPACE */
595
# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
596
#  include <stdint.h> /* INFRINGES ON USER NAME SPACE */
597
#  define YY_STDINT_H
598
# endif
599
#endif
600
601
/* Narrow types that promote to a signed type and that can represent a
602
   signed or unsigned integer of at least N bits.  In tables they can
603
   save space and decrease cache pressure.  Promoting to a signed type
604
   helps avoid bugs in integer arithmetic.  */
605
606
#ifdef __INT_LEAST8_MAX__
607
typedef __INT_LEAST8_TYPE__ yytype_int8;
608
#elif defined YY_STDINT_H
609
typedef int_least8_t yytype_int8;
610
#else
611
typedef signed char yytype_int8;
612
#endif
613
614
#ifdef __INT_LEAST16_MAX__
615
typedef __INT_LEAST16_TYPE__ yytype_int16;
616
#elif defined YY_STDINT_H
617
typedef int_least16_t yytype_int16;
618
#else
619
typedef short yytype_int16;
620
#endif
621
622
#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
623
typedef __UINT_LEAST8_TYPE__ yytype_uint8;
624
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
625
       && UINT_LEAST8_MAX <= INT_MAX)
626
typedef uint_least8_t yytype_uint8;
627
#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
628
typedef unsigned char yytype_uint8;
629
#else
630
typedef short yytype_uint8;
631
#endif
632
633
#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
634
typedef __UINT_LEAST16_TYPE__ yytype_uint16;
635
#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
636
       && UINT_LEAST16_MAX <= INT_MAX)
637
typedef uint_least16_t yytype_uint16;
638
#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
639
typedef unsigned short yytype_uint16;
640
#else
641
typedef int yytype_uint16;
642
#endif
643
644
#ifndef YYPTRDIFF_T
645
# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
646
32.1k
#  define YYPTRDIFF_T __PTRDIFF_TYPE__
647
#  define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
648
# elif defined PTRDIFF_MAX
649
#  ifndef ptrdiff_t
650
#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
651
#  endif
652
#  define YYPTRDIFF_T ptrdiff_t
653
#  define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
654
# else
655
#  define YYPTRDIFF_T long
656
#  define YYPTRDIFF_MAXIMUM LONG_MAX
657
# endif
658
#endif
659
660
#ifndef YYSIZE_T
661
# ifdef __SIZE_TYPE__
662
#  define YYSIZE_T __SIZE_TYPE__
663
# elif defined size_t
664
#  define YYSIZE_T size_t
665
# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
666
#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
667
#  define YYSIZE_T size_t
668
# else
669
#  define YYSIZE_T unsigned
670
# endif
671
#endif
672
673
#define YYSIZE_MAXIMUM                                  \
674
  YY_CAST (YYPTRDIFF_T,                                 \
675
           (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1)  \
676
            ? YYPTRDIFF_MAXIMUM                         \
677
            : YY_CAST (YYSIZE_T, -1)))
678
679
0
#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
680
681
/* Stored state numbers (used for stacks). */
682
typedef yytype_int16 yy_state_t;
683
684
/* State numbers in computations.  */
685
typedef int yy_state_fast_t;
686
687
#ifndef YY_
688
# if defined YYENABLE_NLS && YYENABLE_NLS
689
#  if ENABLE_NLS
690
#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
691
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
692
#  endif
693
# endif
694
# ifndef YY_
695
6.16k
#  define YY_(Msgid) Msgid
696
# endif
697
#endif
698
699
#ifndef YY_ATTRIBUTE_PURE
700
# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
701
#  define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
702
# else
703
#  define YY_ATTRIBUTE_PURE
704
# endif
705
#endif
706
707
#ifndef YY_ATTRIBUTE_UNUSED
708
# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
709
#  define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
710
# else
711
#  define YY_ATTRIBUTE_UNUSED
712
# endif
713
#endif
714
715
/* Suppress unused-variable warnings by "using" E.  */
716
#if ! defined lint || defined __GNUC__
717
363k
# define YYUSE(E) ((void) (E))
718
#else
719
# define YYUSE(E) /* empty */
720
#endif
721
722
#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
723
/* Suppress an incorrect diagnostic about yylval being uninitialized.  */
724
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN                            \
725
    _Pragma ("GCC diagnostic push")                                     \
726
    _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")              \
727
    _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
728
# define YY_IGNORE_MAYBE_UNINITIALIZED_END      \
729
    _Pragma ("GCC diagnostic pop")
730
#else
731
64.2k
# define YY_INITIAL_VALUE(Value) Value
732
#endif
733
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
734
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
735
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
736
#endif
737
#ifndef YY_INITIAL_VALUE
738
# define YY_INITIAL_VALUE(Value) /* Nothing. */
739
#endif
740
741
#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
742
# define YY_IGNORE_USELESS_CAST_BEGIN                          \
743
    _Pragma ("GCC diagnostic push")                            \
744
    _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
745
# define YY_IGNORE_USELESS_CAST_END            \
746
    _Pragma ("GCC diagnostic pop")
747
#endif
748
#ifndef YY_IGNORE_USELESS_CAST_BEGIN
749
# define YY_IGNORE_USELESS_CAST_BEGIN
750
# define YY_IGNORE_USELESS_CAST_END
751
#endif
752
753
754
1.68M
#define YY_ASSERT(E) ((void) (0 && (E)))
755
756
#if ! defined yyoverflow || YYERROR_VERBOSE
757
758
/* The parser invokes alloca or malloc; define the necessary symbols.  */
759
760
# ifdef YYSTACK_USE_ALLOCA
761
#  if YYSTACK_USE_ALLOCA
762
#   ifdef __GNUC__
763
#    define YYSTACK_ALLOC __builtin_alloca
764
#   elif defined __BUILTIN_VA_ARG_INCR
765
#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
766
#   elif defined _AIX
767
#    define YYSTACK_ALLOC __alloca
768
#   elif defined _MSC_VER
769
#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
770
#    define alloca _alloca
771
#   else
772
#    define YYSTACK_ALLOC alloca
773
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
774
#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
775
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
776
#     ifndef EXIT_SUCCESS
777
#      define EXIT_SUCCESS 0
778
#     endif
779
#    endif
780
#   endif
781
#  endif
782
# endif
783
784
# ifdef YYSTACK_ALLOC
785
   /* Pacify GCC's 'empty if-body' warning.  */
786
#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
787
#  ifndef YYSTACK_ALLOC_MAXIMUM
788
    /* The OS might guarantee only one guard page at the bottom of the stack,
789
       and a page size can be as small as 4096 bytes.  So we cannot safely
790
       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
791
       to allow for a few compiler-allocated temporary stack slots.  */
792
#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
793
#  endif
794
# else
795
#  define YYSTACK_ALLOC YYMALLOC
796
0
#  define YYSTACK_FREE YYFREE
797
#  ifndef YYSTACK_ALLOC_MAXIMUM
798
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
799
#  endif
800
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
801
       && ! ((defined YYMALLOC || defined malloc) \
802
             && (defined YYFREE || defined free)))
803
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
804
#   ifndef EXIT_SUCCESS
805
#    define EXIT_SUCCESS 0
806
#   endif
807
#  endif
808
#  ifndef YYMALLOC
809
#   define YYMALLOC malloc
810
#   if ! defined malloc && ! defined EXIT_SUCCESS
811
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
812
#   endif
813
#  endif
814
#  ifndef YYFREE
815
0
#   define YYFREE free
816
#   if ! defined free && ! defined EXIT_SUCCESS
817
void free (void *); /* INFRINGES ON USER NAME SPACE */
818
#   endif
819
#  endif
820
# endif
821
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
822
823
824
#if (! defined yyoverflow \
825
     && (! defined __cplusplus \
826
         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
827
828
/* A type that is properly aligned for any stack member.  */
829
union yyalloc
830
{
831
  yy_state_t yyss_alloc;
832
  YYSTYPE yyvs_alloc;
833
};
834
835
/* The size of the maximum gap between one aligned stack and the next.  */
836
0
# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
837
838
/* The size of an array large to enough to hold all stacks, each with
839
   N elements.  */
840
# define YYSTACK_BYTES(N) \
841
     ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
842
      + YYSTACK_GAP_MAXIMUM)
843
844
# define YYCOPY_NEEDED 1
845
846
/* Relocate STACK from its old location to the new one.  The
847
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
848
   elements in the stack, and YYPTR gives the new location of the
849
   stack.  Advance YYPTR to a properly aligned location for the next
850
   stack.  */
851
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
852
0
    do                                                                  \
853
0
      {                                                                 \
854
0
        YYPTRDIFF_T yynewbytes;                                         \
855
0
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
856
0
        Stack = &yyptr->Stack_alloc;                                    \
857
0
        yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
858
0
        yyptr += yynewbytes / YYSIZEOF (*yyptr);                        \
859
0
      }                                                                 \
860
0
    while (0)
861
862
#endif
863
864
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
865
/* Copy COUNT objects from SRC to DST.  The source and destination do
866
   not overlap.  */
867
# ifndef YYCOPY
868
#  if defined __GNUC__ && 1 < __GNUC__
869
#   define YYCOPY(Dst, Src, Count) \
870
0
      __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
871
#  else
872
#   define YYCOPY(Dst, Src, Count)              \
873
      do                                        \
874
        {                                       \
875
          YYPTRDIFF_T yyi;                      \
876
          for (yyi = 0; yyi < (Count); yyi++)   \
877
            (Dst)[yyi] = (Src)[yyi];            \
878
        }                                       \
879
      while (0)
880
#  endif
881
# endif
882
#endif /* !YYCOPY_NEEDED */
883
884
/* YYFINAL -- State number of the termination state.  */
885
1.68M
#define YYFINAL  3
886
/* YYLAST -- Last index in YYTABLE.  */
887
2.83M
#define YYLAST   800
888
889
/* YYNTOKENS -- Number of terminals.  */
890
1.12M
#define YYNTOKENS  141
891
/* YYNNTS -- Number of nonterminals.  */
892
#define YYNNTS  47
893
/* YYNRULES -- Number of rules.  */
894
#define YYNRULES  221
895
/* YYNSTATES -- Number of states.  */
896
#define YYNSTATES  296
897
898
0
#define YYUNDEFTOK  2
899
730k
#define YYMAXUTOK   378
900
901
902
/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
903
   as returned by yylex, with out-of-bounds checking.  */
904
#define YYTRANSLATE(YYX)                                                \
905
736k
  (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
906
907
/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
908
   as returned by yylex.  */
909
static const yytype_uint8 yytranslate[] =
910
{
911
       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
912
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
913
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
914
       2,     2,     2,   123,     2,     2,     2,   139,   125,     2,
915
     132,   131,   128,   126,     2,   127,     2,   129,     2,     2,
916
       2,     2,     2,     2,     2,     2,     2,     2,   138,     2,
917
     135,   134,   133,     2,     2,     2,     2,     2,     2,     2,
918
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
919
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
920
       2,   136,     2,   137,   140,     2,     2,     2,     2,     2,
921
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
922
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
923
       2,     2,     2,     2,   124,     2,     2,     2,     2,     2,
924
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
925
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
926
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
927
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
928
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
929
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
930
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
931
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
932
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
933
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
934
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
935
       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
936
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
937
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
938
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
939
      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
940
      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
941
      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
942
      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
943
      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
944
      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
945
      85,    86,    87,    88,    89,    90,    91,    92,    93,    94,
946
      95,    96,    97,    98,    99,   100,   101,   102,   103,   104,
947
     105,   106,   107,   108,   109,   110,   111,   112,   113,   114,
948
     115,   116,   117,   118,   119,   120,   121,   122,   130
949
};
950
951
#if YYDEBUG
952
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
953
static const yytype_int16 yyrline[] =
954
{
955
       0,   425,   425,   429,   431,   433,   434,   435,   436,   437,
956
     439,   441,   443,   444,   446,   448,   449,   451,   453,   472,
957
     483,   494,   495,   496,   498,   500,   502,   503,   504,   506,
958
     508,   510,   511,   513,   514,   515,   516,   517,   525,   527,
959
     528,   529,   530,   532,   534,   535,   536,   537,   538,   539,
960
     542,   543,   546,   547,   548,   549,   550,   551,   552,   553,
961
     554,   555,   556,   557,   560,   561,   562,   563,   566,   568,
962
     569,   570,   571,   572,   573,   574,   575,   576,   577,   578,
963
     579,   580,   581,   582,   583,   584,   585,   586,   587,   588,
964
     589,   590,   591,   592,   593,   594,   595,   596,   597,   598,
965
     599,   600,   601,   602,   603,   604,   605,   606,   608,   609,
966
     610,   611,   612,   613,   614,   615,   616,   617,   618,   619,
967
     620,   621,   622,   623,   624,   625,   626,   627,   630,   631,
968
     632,   633,   634,   635,   638,   643,   646,   650,   653,   659,
969
     668,   674,   697,   714,   715,   739,   742,   743,   759,   760,
970
     763,   766,   767,   768,   770,   771,   772,   774,   775,   777,
971
     778,   779,   780,   781,   782,   783,   784,   785,   786,   787,
972
     788,   789,   790,   791,   793,   794,   795,   796,   797,   799,
973
     800,   802,   803,   804,   805,   806,   807,   808,   810,   811,
974
     812,   813,   816,   817,   819,   820,   821,   822,   824,   831,
975
     832,   835,   836,   837,   838,   839,   840,   843,   844,   845,
976
     846,   847,   848,   849,   850,   852,   853,   854,   855,   857,
977
     870,   871
978
};
979
#endif
980
981
#if YYDEBUG || YYERROR_VERBOSE || 0
982
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
983
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
984
static const char *const yytname[] =
985
{
986
  "$end", "error", "$undefined", "DST", "SRC", "HOST", "GATEWAY", "NET",
987
  "NETMASK", "PORT", "PORTRANGE", "LESS", "GREATER", "PROTO", "PROTOCHAIN",
988
  "CBYTE", "ARP", "RARP", "IP", "SCTP", "TCP", "UDP", "ICMP", "IGMP",
989
  "IGRP", "PIM", "VRRP", "CARP", "ATALK", "AARP", "DECNET", "LAT", "SCA",
990
  "MOPRC", "MOPDL", "TK_BROADCAST", "TK_MULTICAST", "NUM", "INBOUND",
991
  "OUTBOUND", "IFINDEX", "PF_IFNAME", "PF_RSET", "PF_RNR", "PF_SRNR",
992
  "PF_REASON", "PF_ACTION", "TYPE", "SUBTYPE", "DIR", "ADDR1", "ADDR2",
993
  "ADDR3", "ADDR4", "RA", "TA", "LINK", "GEQ", "LEQ", "NEQ", "ID", "EID",
994
  "HID", "HID6", "AID", "LSH", "RSH", "LEN", "IPV6", "ICMPV6", "AH", "ESP",
995
  "VLAN", "MPLS", "PPPOED", "PPPOES", "GENEVE", "ISO", "ESIS", "CLNP",
996
  "ISIS", "L1", "L2", "IIH", "LSP", "SNP", "CSNP", "PSNP", "STP", "IPX",
997
  "NETBEUI", "LANE", "LLC", "METAC", "BCC", "SC", "ILMIC", "OAMF4EC",
998
  "OAMF4SC", "OAM", "OAMF4", "CONNECTMSG", "METACONNECT", "VPI", "VCI",
999
  "RADIO", "FISU", "LSSU", "MSU", "HFISU", "HLSSU", "HMSU", "SIO", "OPC",
1000
  "DPC", "SLS", "HSIO", "HOPC", "HDPC", "HSLS", "LEX_ERROR", "OR", "AND",
1001
  "'!'", "'|'", "'&'", "'+'", "'-'", "'*'", "'/'", "UMINUS", "')'", "'('",
1002
  "'>'", "'='", "'<'", "'['", "']'", "':'", "'%'", "'^'", "$accept",
1003
  "prog", "null", "expr", "and", "or", "id", "nid", "not", "paren", "pid",
1004
  "qid", "term", "head", "rterm", "pqual", "dqual", "aqual", "ndaqual",
1005
  "pname", "other", "pfvar", "p80211", "type", "subtype", "type_subtype",
1006
  "pllc", "dir", "reason", "action", "relop", "irelop", "arth", "narth",
1007
  "byteop", "pnum", "atmtype", "atmmultitype", "atmfield", "atmvalue",
1008
  "atmfieldvalue", "atmlistvalue", "mtp2type", "mtp3field", "mtp3value",
1009
  "mtp3fieldvalue", "mtp3listvalue", YY_NULLPTR
1010
};
1011
#endif
1012
1013
# ifdef YYPRINT
1014
/* YYTOKNUM[NUM] -- (External) token number corresponding to the
1015
   (internal) symbol number NUM (which must be that of a token).  */
1016
static const yytype_int16 yytoknum[] =
1017
{
1018
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1019
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
1020
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
1021
     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
1022
     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
1023
     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
1024
     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
1025
     325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
1026
     335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
1027
     345,   346,   347,   348,   349,   350,   351,   352,   353,   354,
1028
     355,   356,   357,   358,   359,   360,   361,   362,   363,   364,
1029
     365,   366,   367,   368,   369,   370,   371,   372,   373,   374,
1030
     375,   376,   377,    33,   124,    38,    43,    45,    42,    47,
1031
     378,    41,    40,    62,    61,    60,    91,    93,    58,    37,
1032
      94
1033
};
1034
# endif
1035
1036
1.69M
#define YYPACT_NINF (-217)
1037
1038
#define yypact_value_is_default(Yyn) \
1039
1.69M
  ((Yyn) == YYPACT_NINF)
1040
1041
#define YYTABLE_NINF (-42)
1042
1043
#define yytable_value_is_error(Yyn) \
1044
31.6k
  0
1045
1046
  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1047
     STATE-NUM.  */
1048
static const yytype_int16 yypact[] =
1049
{
1050
    -217,    28,   223,  -217,    13,    18,    21,  -217,  -217,  -217,
1051
    -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,
1052
    -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,    41,
1053
     -30,    24,    51,    79,   -25,    26,  -217,  -217,  -217,  -217,
1054
    -217,  -217,   -24,   -24,  -217,   -24,   -24,  -217,  -217,  -217,
1055
    -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,
1056
    -217,  -217,   -23,  -217,  -217,  -217,  -217,  -217,  -217,  -217,
1057
    -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,
1058
    -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,
1059
    -217,   576,  -217,   -50,   459,   459,  -217,    19,  -217,   745,
1060
       3,  -217,  -217,  -217,   558,  -217,  -217,  -217,  -217,    -5,
1061
    -217,    39,  -217,  -217,   -14,  -217,  -217,  -217,  -217,  -217,
1062
    -217,  -217,  -217,  -217,  -217,   -24,  -217,  -217,  -217,  -217,
1063
    -217,  -217,   576,  -103,   -49,  -217,  -217,   341,   341,  -217,
1064
    -100,     2,    12,  -217,  -217,    -7,    -3,  -217,  -217,  -217,
1065
      19,    19,  -217,    -4,    31,  -217,  -217,  -217,  -217,  -217,
1066
    -217,  -217,  -217,  -217,   -22,    78,   -18,  -217,  -217,  -217,
1067
    -217,  -217,  -217,    60,  -217,  -217,  -217,   576,  -217,  -217,
1068
    -217,   576,   576,   576,   576,   576,   576,   576,   576,  -217,
1069
    -217,  -217,   576,   576,   576,   576,  -217,   125,   126,   127,
1070
    -217,  -217,  -217,   132,   133,   144,  -217,  -217,  -217,  -217,
1071
    -217,  -217,  -217,   145,    12,   602,  -217,   341,   341,  -217,
1072
      10,  -217,  -217,  -217,  -217,  -217,   123,   149,   150,  -217,
1073
    -217,    63,   -50,    12,   191,   192,   194,   195,  -217,  -217,
1074
     151,  -217,  -217,  -217,  -217,  -217,  -217,   585,    64,    64,
1075
     607,    49,   -66,   -66,   -49,   -49,   602,   602,   602,   602,
1076
    -217,   -97,  -217,  -217,  -217,   -92,  -217,  -217,  -217,   -95,
1077
    -217,  -217,  -217,  -217,    19,    19,  -217,  -217,  -217,  -217,
1078
     -12,  -217,   163,  -217,   125,  -217,   132,  -217,  -217,  -217,
1079
    -217,  -217,    65,  -217,  -217,  -217
1080
};
1081
1082
  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1083
     Performed when YYTABLE does not specify something else to do.  Zero
1084
     means the default is an error.  */
1085
static const yytype_uint8 yydefact[] =
1086
{
1087
       4,     0,    51,     1,     0,     0,     0,    71,    72,    70,
1088
      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
1089
      83,    84,    85,    86,    88,    87,   179,   113,   114,     0,
1090
       0,     0,     0,     0,     0,     0,    69,   173,    89,    90,
1091
      91,    92,   117,   119,   120,   122,   124,    93,    94,   103,
1092
      95,    96,    97,    98,    99,   100,   102,   101,   104,   105,
1093
     106,   181,   143,   182,   183,   186,   187,   184,   185,   188,
1094
     189,   190,   191,   192,   193,   107,   201,   202,   203,   204,
1095
     205,   206,   207,   208,   209,   210,   211,   212,   213,   214,
1096
      24,     0,    25,     2,    51,    51,     5,     0,    31,     0,
1097
      50,    44,   125,   127,     0,   158,   157,    45,    46,     0,
1098
      48,     0,   110,   111,     0,   115,   128,   129,   130,   131,
1099
     148,   149,   132,   150,   133,     0,   116,   118,   121,   123,
1100
     145,   144,     0,     0,   171,    11,    10,    51,    51,    32,
1101
       0,   158,   157,    15,    21,    18,    20,    22,    39,    12,
1102
       0,     0,    13,    53,    52,    64,    68,    65,    66,    67,
1103
      36,    37,   108,   109,     0,     0,     0,    58,    59,    60,
1104
      61,    62,    63,    34,    35,    38,   126,     0,   152,   154,
1105
     156,     0,     0,     0,     0,     0,     0,     0,     0,   151,
1106
     153,   155,     0,     0,     0,     0,   198,     0,     0,     0,
1107
      47,   194,   219,     0,     0,     0,    49,   215,   175,   174,
1108
     177,   178,   176,     0,     0,     0,     7,    51,    51,     6,
1109
     157,     9,     8,    40,   172,   180,     0,     0,     0,    23,
1110
      26,    30,     0,    29,     0,     0,     0,     0,   138,   139,
1111
     135,   142,   136,   146,   147,   137,    33,     0,   169,   170,
1112
     167,   166,   161,   162,   163,   164,   165,   168,    42,    43,
1113
     199,     0,   195,   196,   220,     0,   216,   217,   112,   157,
1114
      17,    16,    19,    14,     0,     0,    55,    57,    54,    56,
1115
       0,   159,     0,   197,     0,   218,     0,    27,    28,   140,
1116
     141,   134,     0,   200,   221,   160
1117
};
1118
1119
  /* YYPGOTO[NTERM-NUM].  */
1120
static const yytype_int16 yypgoto[] =
1121
{
1122
    -217,  -217,  -217,   199,   -26,  -216,   -91,  -133,     7,    -2,
1123
    -217,  -217,   -77,  -217,  -217,  -217,  -217,    32,  -217,     9,
1124
    -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,  -217,
1125
     -43,   -34,   -27,   -81,  -217,   -38,  -217,  -217,  -217,  -217,
1126
    -195,  -217,  -217,  -217,  -217,  -180,  -217
1127
};
1128
1129
  /* YYDEFGOTO[NTERM-NUM].  */
1130
static const yytype_int16 yydefgoto[] =
1131
{
1132
      -1,     1,     2,   140,   137,   138,   229,   149,   150,   132,
1133
     231,   232,    96,    97,    98,    99,   173,   174,   175,   133,
1134
     101,   102,   176,   240,   291,   242,   103,   245,   122,   124,
1135
     194,   195,   104,   105,   213,   106,   107,   108,   109,   200,
1136
     201,   261,   110,   111,   206,   207,   265
1137
};
1138
1139
  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
1140
     positive, shift that token.  If negative, reduce the rule whose
1141
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
1142
static const yytype_int16 yytable[] =
1143
{
1144
      95,   226,   260,   -41,   126,   127,   148,   128,   129,    94,
1145
     -13,   100,   120,    26,   141,   238,   275,   139,   230,   243,
1146
     130,   135,   136,   264,   135,   289,   -29,   -29,     3,   135,
1147
     116,   223,   196,   177,   283,   121,   225,   131,   239,   285,
1148
     125,   125,   244,   125,   125,   284,   216,   221,   290,   286,
1149
     112,   141,   178,   179,   180,   113,    26,   142,   114,   152,
1150
     219,   222,   187,   188,   134,   155,   198,   157,   204,   158,
1151
     159,   135,   136,   192,   193,   199,   202,   205,   115,   143,
1152
     144,   145,   146,   147,   117,   230,   123,   214,   118,   293,
1153
     192,   193,    95,    95,   142,   151,   178,   179,   180,   220,
1154
     220,    94,    94,   100,   100,   215,   294,   197,    92,   203,
1155
     208,   209,   152,   233,   181,   182,   119,   234,   235,   210,
1156
     211,   212,   227,   125,   -41,   -41,   228,    92,   189,   190,
1157
     191,   -13,   -13,   224,   -41,   218,   218,   141,   241,   177,
1158
     139,   -13,    90,   225,   217,   217,   100,   100,   151,   125,
1159
     247,    92,   236,   237,   248,   249,   250,   251,   252,   253,
1160
     254,   255,   196,   262,   263,   256,   257,   258,   259,   202,
1161
     266,    92,   189,   190,   191,   185,   186,   187,   188,   220,
1162
     269,   267,   268,   287,   288,   270,   271,   272,   192,   193,
1163
     185,   186,   187,   188,   273,   276,   277,   278,   279,   280,
1164
     292,    93,   295,   192,   193,   246,   274,     0,     0,     0,
1165
       0,     0,     0,     0,     0,   218,    95,     0,     0,     0,
1166
       0,     0,     0,    -3,   217,   217,   100,   100,     0,     0,
1167
       0,     0,     0,     0,     4,     5,   152,   152,     6,     7,
1168
       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
1169
      18,    19,    20,    21,    22,    23,    24,    25,     0,     0,
1170
      26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
1171
       0,     0,   151,   151,     0,     0,     0,     0,     0,    36,
1172
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1173
      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1174
      47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
1175
      57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
1176
      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
1177
      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
1178
      87,    88,    89,     0,     0,     0,    90,     0,     0,     0,
1179
      91,     0,     4,     5,     0,    92,     6,     7,     8,     9,
1180
      10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
1181
      20,    21,    22,    23,    24,    25,     0,     0,    26,    27,
1182
      28,    29,    30,    31,    32,    33,    34,    35,     0,     0,
1183
       0,     0,     0,     0,     0,     0,     0,    36,     0,     0,
1184
       0,   143,   144,   145,   146,   147,     0,     0,    37,    38,
1185
      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
1186
      49,    50,    51,    52,    53,    54,    55,    56,    57,    58,
1187
      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
1188
      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
1189
      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
1190
      89,     0,     0,     0,    90,     0,     0,     0,    91,     0,
1191
       4,     5,     0,    92,     6,     7,     8,     9,    10,    11,
1192
      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
1193
      22,    23,    24,    25,     0,     0,    26,    27,    28,    29,
1194
      30,    31,    32,    33,    34,    35,     0,     0,     0,     0,
1195
       0,     0,     0,     0,     0,    36,     0,     0,     0,     0,
1196
       0,     0,     0,     0,     0,     0,    37,    38,    39,    40,
1197
      41,    42,    43,    44,    45,    46,    47,    48,    49,    50,
1198
      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
1199
      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
1200
      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
1201
      81,    82,    83,    84,    85,    86,    87,    88,    89,     0,
1202
       0,     0,    90,     0,     0,     0,    91,     0,     0,     0,
1203
       0,    92,     7,     8,     9,    10,    11,    12,    13,    14,
1204
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
1205
      25,     0,     0,    26,     0,   178,   179,   180,     0,     0,
1206
       0,     0,     0,   181,   182,     0,     0,     0,     0,     0,
1207
       0,     0,    36,     0,     0,     0,     0,     0,     0,     0,
1208
       0,     0,     0,    37,    38,    39,    40,    41,     0,     0,
1209
     181,   182,     0,    47,    48,    49,    50,    51,    52,    53,
1210
      54,    55,    56,    57,    58,    59,    60,   181,   182,     0,
1211
       0,     0,   181,   182,     0,     0,     0,     0,     0,     0,
1212
       0,    75,   183,   184,   185,   186,   187,   188,     0,     0,
1213
       0,   189,   190,   191,     0,     0,     0,   192,   193,     0,
1214
       0,     0,     0,    91,     0,     0,     0,     0,    92,   183,
1215
     184,   185,   186,   187,   188,     0,     0,     0,     0,     0,
1216
       0,     0,   281,   282,   192,   193,   183,   184,   185,   186,
1217
     187,   188,   184,   185,   186,   187,   188,     0,     0,     0,
1218
       0,   192,   193,     0,     0,     0,   192,   193,   153,   154,
1219
     155,   156,   157,     0,   158,   159,     0,     0,   160,   161,
1220
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1221
       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1222
     162,   163,     0,     0,     0,     0,     0,     0,     0,     0,
1223
       0,     0,   164,   165,   166,   167,   168,   169,   170,   171,
1224
     172
1225
};
1226
1227
static const yytype_int16 yycheck[] =
1228
{
1229
       2,     8,   197,     0,    42,    43,    97,    45,    46,     2,
1230
       0,     2,    37,    37,    95,    37,   232,    94,   151,    37,
1231
      43,   121,   122,   203,   121,    37,   121,   122,     0,   121,
1232
      60,   131,    37,   136,   131,    60,   131,    60,    60,   131,
1233
      42,    43,    60,    45,    46,   261,   137,   138,    60,   265,
1234
      37,   132,    57,    58,    59,    37,    37,    95,    37,    97,
1235
     137,   138,   128,   129,    91,     5,   109,     7,   111,     9,
1236
      10,   121,   122,   139,   140,   109,    37,   111,    37,    60,
1237
      61,    62,    63,    64,    60,   218,    60,   125,    37,   284,
1238
     139,   140,    94,    95,   132,    97,    57,    58,    59,   137,
1239
     138,    94,    95,    94,    95,   132,   286,   109,   132,   111,
1240
     124,   125,   150,   151,    65,    66,    37,   121,   122,   133,
1241
     134,   135,   129,   125,   121,   122,   129,   132,   133,   134,
1242
     135,   121,   122,   131,   131,   137,   138,   218,    60,   136,
1243
     217,   131,   123,   131,   137,   138,   137,   138,   150,   151,
1244
     177,   132,   121,   122,   181,   182,   183,   184,   185,   186,
1245
     187,   188,    37,    37,    37,   192,   193,   194,   195,    37,
1246
      37,   132,   133,   134,   135,   126,   127,   128,   129,   217,
1247
     218,    37,    37,   274,   275,    62,    37,    37,   139,   140,
1248
     126,   127,   128,   129,   131,     4,     4,     3,     3,    48,
1249
      37,     2,   137,   139,   140,   173,   232,    -1,    -1,    -1,
1250
      -1,    -1,    -1,    -1,    -1,   217,   218,    -1,    -1,    -1,
1251
      -1,    -1,    -1,     0,   217,   218,   217,   218,    -1,    -1,
1252
      -1,    -1,    -1,    -1,    11,    12,   274,   275,    15,    16,
1253
      17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
1254
      27,    28,    29,    30,    31,    32,    33,    34,    -1,    -1,
1255
      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
1256
      -1,    -1,   274,   275,    -1,    -1,    -1,    -1,    -1,    56,
1257
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1258
      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
1259
      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
1260
      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
1261
      97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
1262
     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
1263
     117,   118,   119,    -1,    -1,    -1,   123,    -1,    -1,    -1,
1264
     127,    -1,    11,    12,    -1,   132,    15,    16,    17,    18,
1265
      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
1266
      29,    30,    31,    32,    33,    34,    -1,    -1,    37,    38,
1267
      39,    40,    41,    42,    43,    44,    45,    46,    -1,    -1,
1268
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    56,    -1,    -1,
1269
      -1,    60,    61,    62,    63,    64,    -1,    -1,    67,    68,
1270
      69,    70,    71,    72,    73,    74,    75,    76,    77,    78,
1271
      79,    80,    81,    82,    83,    84,    85,    86,    87,    88,
1272
      89,    90,    91,    92,    93,    94,    95,    96,    97,    98,
1273
      99,   100,   101,   102,   103,   104,   105,   106,   107,   108,
1274
     109,   110,   111,   112,   113,   114,   115,   116,   117,   118,
1275
     119,    -1,    -1,    -1,   123,    -1,    -1,    -1,   127,    -1,
1276
      11,    12,    -1,   132,    15,    16,    17,    18,    19,    20,
1277
      21,    22,    23,    24,    25,    26,    27,    28,    29,    30,
1278
      31,    32,    33,    34,    -1,    -1,    37,    38,    39,    40,
1279
      41,    42,    43,    44,    45,    46,    -1,    -1,    -1,    -1,
1280
      -1,    -1,    -1,    -1,    -1,    56,    -1,    -1,    -1,    -1,
1281
      -1,    -1,    -1,    -1,    -1,    -1,    67,    68,    69,    70,
1282
      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
1283
      81,    82,    83,    84,    85,    86,    87,    88,    89,    90,
1284
      91,    92,    93,    94,    95,    96,    97,    98,    99,   100,
1285
     101,   102,   103,   104,   105,   106,   107,   108,   109,   110,
1286
     111,   112,   113,   114,   115,   116,   117,   118,   119,    -1,
1287
      -1,    -1,   123,    -1,    -1,    -1,   127,    -1,    -1,    -1,
1288
      -1,   132,    16,    17,    18,    19,    20,    21,    22,    23,
1289
      24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
1290
      34,    -1,    -1,    37,    -1,    57,    58,    59,    -1,    -1,
1291
      -1,    -1,    -1,    65,    66,    -1,    -1,    -1,    -1,    -1,
1292
      -1,    -1,    56,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1293
      -1,    -1,    -1,    67,    68,    69,    70,    71,    -1,    -1,
1294
      65,    66,    -1,    77,    78,    79,    80,    81,    82,    83,
1295
      84,    85,    86,    87,    88,    89,    90,    65,    66,    -1,
1296
      -1,    -1,    65,    66,    -1,    -1,    -1,    -1,    -1,    -1,
1297
      -1,   105,   124,   125,   126,   127,   128,   129,    -1,    -1,
1298
      -1,   133,   134,   135,    -1,    -1,    -1,   139,   140,    -1,
1299
      -1,    -1,    -1,   127,    -1,    -1,    -1,    -1,   132,   124,
1300
     125,   126,   127,   128,   129,    -1,    -1,    -1,    -1,    -1,
1301
      -1,    -1,   137,   138,   139,   140,   124,   125,   126,   127,
1302
     128,   129,   125,   126,   127,   128,   129,    -1,    -1,    -1,
1303
      -1,   139,   140,    -1,    -1,    -1,   139,   140,     3,     4,
1304
       5,     6,     7,    -1,     9,    10,    -1,    -1,    13,    14,
1305
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1306
      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1307
      35,    36,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
1308
      -1,    -1,    47,    48,    49,    50,    51,    52,    53,    54,
1309
      55
1310
};
1311
1312
  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1313
     symbol of state STATE-NUM.  */
1314
static const yytype_uint8 yystos[] =
1315
{
1316
       0,   142,   143,     0,    11,    12,    15,    16,    17,    18,
1317
      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
1318
      29,    30,    31,    32,    33,    34,    37,    38,    39,    40,
1319
      41,    42,    43,    44,    45,    46,    56,    67,    68,    69,
1320
      70,    71,    72,    73,    74,    75,    76,    77,    78,    79,
1321
      80,    81,    82,    83,    84,    85,    86,    87,    88,    89,
1322
      90,    91,    92,    93,    94,    95,    96,    97,    98,    99,
1323
     100,   101,   102,   103,   104,   105,   106,   107,   108,   109,
1324
     110,   111,   112,   113,   114,   115,   116,   117,   118,   119,
1325
     123,   127,   132,   144,   149,   150,   153,   154,   155,   156,
1326
     160,   161,   162,   167,   173,   174,   176,   177,   178,   179,
1327
     183,   184,    37,    37,    37,    37,    60,    60,    37,    37,
1328
      37,    60,   169,    60,   170,   150,   176,   176,   176,   176,
1329
      43,    60,   150,   160,   173,   121,   122,   145,   146,   153,
1330
     144,   174,   176,    60,    61,    62,    63,    64,   147,   148,
1331
     149,   150,   176,     3,     4,     5,     6,     7,     9,    10,
1332
      13,    14,    35,    36,    47,    48,    49,    50,    51,    52,
1333
      53,    54,    55,   157,   158,   159,   163,   136,    57,    58,
1334
      59,    65,    66,   124,   125,   126,   127,   128,   129,   133,
1335
     134,   135,   139,   140,   171,   172,    37,   150,   171,   172,
1336
     180,   181,    37,   150,   171,   172,   185,   186,   124,   125,
1337
     133,   134,   135,   175,   176,   173,   147,   149,   150,   153,
1338
     176,   147,   153,   131,   131,   131,     8,   129,   129,   147,
1339
     148,   151,   152,   176,   121,   122,   121,   122,    37,    60,
1340
     164,    60,   166,    37,    60,   168,   158,   173,   173,   173,
1341
     173,   173,   173,   173,   173,   173,   173,   173,   173,   173,
1342
     181,   182,    37,    37,   186,   187,    37,    37,    37,   176,
1343
      62,    37,    37,   131,   145,   146,     4,     4,     3,     3,
1344
      48,   137,   138,   131,   146,   131,   146,   147,   147,    37,
1345
      60,   165,    37,   181,   186,   137
1346
};
1347
1348
  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1349
static const yytype_uint8 yyr1[] =
1350
{
1351
       0,   141,   142,   142,   143,   144,   144,   144,   144,   144,
1352
     145,   146,   147,   147,   147,   148,   148,   148,   148,   148,
1353
     148,   148,   148,   148,   149,   150,   151,   151,   151,   152,
1354
     152,   153,   153,   154,   154,   154,   154,   154,   154,   155,
1355
     155,   155,   155,   155,   155,   155,   155,   155,   155,   155,
1356
     156,   156,   157,   157,   157,   157,   157,   157,   157,   157,
1357
     157,   157,   157,   157,   158,   158,   158,   158,   159,   160,
1358
     160,   160,   160,   160,   160,   160,   160,   160,   160,   160,
1359
     160,   160,   160,   160,   160,   160,   160,   160,   160,   160,
1360
     160,   160,   160,   160,   160,   160,   160,   160,   160,   160,
1361
     160,   160,   160,   160,   160,   160,   160,   160,   161,   161,
1362
     161,   161,   161,   161,   161,   161,   161,   161,   161,   161,
1363
     161,   161,   161,   161,   161,   161,   161,   161,   162,   162,
1364
     162,   162,   162,   162,   163,   163,   163,   163,   164,   164,
1365
     165,   165,   166,   167,   167,   167,   168,   168,   169,   169,
1366
     170,   171,   171,   171,   172,   172,   172,   173,   173,   174,
1367
     174,   174,   174,   174,   174,   174,   174,   174,   174,   174,
1368
     174,   174,   174,   174,   175,   175,   175,   175,   175,   176,
1369
     176,   177,   177,   177,   177,   177,   177,   177,   178,   178,
1370
     178,   178,   179,   179,   180,   180,   180,   180,   181,   182,
1371
     182,   183,   183,   183,   183,   183,   183,   184,   184,   184,
1372
     184,   184,   184,   184,   184,   185,   185,   185,   185,   186,
1373
     187,   187
1374
};
1375
1376
  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
1377
static const yytype_int8 yyr2[] =
1378
{
1379
       0,     2,     2,     1,     0,     1,     3,     3,     3,     3,
1380
       1,     1,     1,     1,     3,     1,     3,     3,     1,     3,
1381
       1,     1,     1,     2,     1,     1,     1,     3,     3,     1,
1382
       1,     1,     2,     3,     2,     2,     2,     2,     2,     2,
1383
       3,     1,     3,     3,     1,     1,     1,     2,     1,     2,
1384
       1,     0,     1,     1,     3,     3,     3,     3,     1,     1,
1385
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1386
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1387
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1388
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1389
       1,     1,     1,     1,     1,     1,     1,     1,     2,     2,
1390
       2,     2,     4,     1,     1,     2,     2,     1,     2,     1,
1391
       1,     2,     1,     2,     1,     1,     2,     1,     2,     2,
1392
       2,     2,     2,     2,     4,     2,     2,     2,     1,     1,
1393
       1,     1,     1,     1,     2,     2,     1,     1,     1,     1,
1394
       1,     1,     1,     1,     1,     1,     1,     1,     1,     4,
1395
       6,     3,     3,     3,     3,     3,     3,     3,     3,     3,
1396
       3,     2,     3,     1,     1,     1,     1,     1,     1,     1,
1397
       3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1398
       1,     1,     1,     1,     1,     2,     2,     3,     1,     1,
1399
       3,     1,     1,     1,     1,     1,     1,     1,     1,     1,
1400
       1,     1,     1,     1,     1,     1,     2,     2,     3,     1,
1401
       1,     3
1402
};
1403
1404
1405
#define yyerrok         (yyerrstatus = 0)
1406
#define yyclearin       (yychar = YYEMPTY)
1407
1.41M
#define YYEMPTY         (-2)
1408
913k
#define YYEOF           0
1409
1410
24.3k
#define YYACCEPT        goto yyacceptlab
1411
7.77k
#define YYABORT         goto yyabortlab
1412
0
#define YYERROR         goto yyerrorlab
1413
1414
1415
#define YYRECOVERING()  (!!yyerrstatus)
1416
1417
#define YYBACKUP(Token, Value)                                    \
1418
  do                                                              \
1419
    if (yychar == YYEMPTY)                                        \
1420
      {                                                           \
1421
        yychar = (Token);                                         \
1422
        yylval = (Value);                                         \
1423
        YYPOPSTACK (yylen);                                       \
1424
        yystate = *yyssp;                                         \
1425
        goto yybackup;                                            \
1426
      }                                                           \
1427
    else                                                          \
1428
      {                                                           \
1429
        yyerror (yyscanner, cstate, YY_("syntax error: cannot back up")); \
1430
        YYERROR;                                                  \
1431
      }                                                           \
1432
  while (0)
1433
1434
/* Error token number */
1435
47.9k
#define YYTERROR        1
1436
#define YYERRCODE       256
1437
1438
1439
1440
/* Enable debugging if requested.  */
1441
#if YYDEBUG
1442
1443
# ifndef YYFPRINTF
1444
#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1445
#  define YYFPRINTF fprintf
1446
# endif
1447
1448
# define YYDPRINTF(Args)                        \
1449
do {                                            \
1450
  if (yydebug)                                  \
1451
    YYFPRINTF Args;                             \
1452
} while (0)
1453
1454
/* This macro is provided for backward compatibility. */
1455
#ifndef YY_LOCATION_PRINT
1456
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1457
#endif
1458
1459
1460
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1461
do {                                                                      \
1462
  if (yydebug)                                                            \
1463
    {                                                                     \
1464
      YYFPRINTF (stderr, "%s ", Title);                                   \
1465
      yy_symbol_print (stderr,                                            \
1466
                  Type, Value, yyscanner, cstate); \
1467
      YYFPRINTF (stderr, "\n");                                           \
1468
    }                                                                     \
1469
} while (0)
1470
1471
1472
/*-----------------------------------.
1473
| Print this symbol's value on YYO.  |
1474
`-----------------------------------*/
1475
1476
static void
1477
yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, void *yyscanner, compiler_state_t *cstate)
1478
{
1479
  FILE *yyoutput = yyo;
1480
  YYUSE (yyoutput);
1481
  YYUSE (yyscanner);
1482
  YYUSE (cstate);
1483
  if (!yyvaluep)
1484
    return;
1485
# ifdef YYPRINT
1486
  if (yytype < YYNTOKENS)
1487
    YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
1488
# endif
1489
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1490
  YYUSE (yytype);
1491
  YY_IGNORE_MAYBE_UNINITIALIZED_END
1492
}
1493
1494
1495
/*---------------------------.
1496
| Print this symbol on YYO.  |
1497
`---------------------------*/
1498
1499
static void
1500
yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep, void *yyscanner, compiler_state_t *cstate)
1501
{
1502
  YYFPRINTF (yyo, "%s %s (",
1503
             yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1504
1505
  yy_symbol_value_print (yyo, yytype, yyvaluep, yyscanner, cstate);
1506
  YYFPRINTF (yyo, ")");
1507
}
1508
1509
/*------------------------------------------------------------------.
1510
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1511
| TOP (included).                                                   |
1512
`------------------------------------------------------------------*/
1513
1514
static void
1515
yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1516
{
1517
  YYFPRINTF (stderr, "Stack now");
1518
  for (; yybottom <= yytop; yybottom++)
1519
    {
1520
      int yybot = *yybottom;
1521
      YYFPRINTF (stderr, " %d", yybot);
1522
    }
1523
  YYFPRINTF (stderr, "\n");
1524
}
1525
1526
# define YY_STACK_PRINT(Bottom, Top)                            \
1527
do {                                                            \
1528
  if (yydebug)                                                  \
1529
    yy_stack_print ((Bottom), (Top));                           \
1530
} while (0)
1531
1532
1533
/*------------------------------------------------.
1534
| Report that the YYRULE is going to be reduced.  |
1535
`------------------------------------------------*/
1536
1537
static void
1538
yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule, void *yyscanner, compiler_state_t *cstate)
1539
{
1540
  int yylno = yyrline[yyrule];
1541
  int yynrhs = yyr2[yyrule];
1542
  int yyi;
1543
  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1544
             yyrule - 1, yylno);
1545
  /* The symbols being reduced.  */
1546
  for (yyi = 0; yyi < yynrhs; yyi++)
1547
    {
1548
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1549
      yy_symbol_print (stderr,
1550
                       yystos[+yyssp[yyi + 1 - yynrhs]],
1551
                       &yyvsp[(yyi + 1) - (yynrhs)]
1552
                                              , yyscanner, cstate);
1553
      YYFPRINTF (stderr, "\n");
1554
    }
1555
}
1556
1557
# define YY_REDUCE_PRINT(Rule)          \
1558
do {                                    \
1559
  if (yydebug)                          \
1560
    yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, cstate); \
1561
} while (0)
1562
1563
/* Nonzero means print parse trace.  It is left uninitialized so that
1564
   multiple parsers can coexist.  */
1565
int yydebug;
1566
#else /* !YYDEBUG */
1567
# define YYDPRINTF(Args)
1568
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1569
# define YY_STACK_PRINT(Bottom, Top)
1570
# define YY_REDUCE_PRINT(Rule)
1571
#endif /* !YYDEBUG */
1572
1573
1574
/* YYINITDEPTH -- initial size of the parser's stacks.  */
1575
#ifndef YYINITDEPTH
1576
32.1k
# define YYINITDEPTH 200
1577
#endif
1578
1579
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1580
   if the built-in stack extension method is used).
1581
1582
   Do not make this value too large; the results are undefined if
1583
   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1584
   evaluated with infinite-precision integer arithmetic.  */
1585
1586
#ifndef YYMAXDEPTH
1587
0
# define YYMAXDEPTH 10000
1588
#endif
1589
1590
1591
#if YYERROR_VERBOSE
1592
1593
# ifndef yystrlen
1594
#  if defined __GLIBC__ && defined _STRING_H
1595
#   define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
1596
#  else
1597
/* Return the length of YYSTR.  */
1598
static YYPTRDIFF_T
1599
yystrlen (const char *yystr)
1600
{
1601
  YYPTRDIFF_T yylen;
1602
  for (yylen = 0; yystr[yylen]; yylen++)
1603
    continue;
1604
  return yylen;
1605
}
1606
#  endif
1607
# endif
1608
1609
# ifndef yystpcpy
1610
#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1611
#   define yystpcpy stpcpy
1612
#  else
1613
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1614
   YYDEST.  */
1615
static char *
1616
yystpcpy (char *yydest, const char *yysrc)
1617
{
1618
  char *yyd = yydest;
1619
  const char *yys = yysrc;
1620
1621
  while ((*yyd++ = *yys++) != '\0')
1622
    continue;
1623
1624
  return yyd - 1;
1625
}
1626
#  endif
1627
# endif
1628
1629
# ifndef yytnamerr
1630
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1631
   quotes and backslashes, so that it's suitable for yyerror.  The
1632
   heuristic is that double-quoting is unnecessary unless the string
1633
   contains an apostrophe, a comma, or backslash (other than
1634
   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1635
   null, do not copy; instead, return the length of what the result
1636
   would have been.  */
1637
static YYPTRDIFF_T
1638
yytnamerr (char *yyres, const char *yystr)
1639
{
1640
  if (*yystr == '"')
1641
    {
1642
      YYPTRDIFF_T yyn = 0;
1643
      char const *yyp = yystr;
1644
1645
      for (;;)
1646
        switch (*++yyp)
1647
          {
1648
          case '\'':
1649
          case ',':
1650
            goto do_not_strip_quotes;
1651
1652
          case '\\':
1653
            if (*++yyp != '\\')
1654
              goto do_not_strip_quotes;
1655
            else
1656
              goto append;
1657
1658
          append:
1659
          default:
1660
            if (yyres)
1661
              yyres[yyn] = *yyp;
1662
            yyn++;
1663
            break;
1664
1665
          case '"':
1666
            if (yyres)
1667
              yyres[yyn] = '\0';
1668
            return yyn;
1669
          }
1670
    do_not_strip_quotes: ;
1671
    }
1672
1673
  if (yyres)
1674
    return yystpcpy (yyres, yystr) - yyres;
1675
  else
1676
    return yystrlen (yystr);
1677
}
1678
# endif
1679
1680
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1681
   about the unexpected token YYTOKEN for the state stack whose top is
1682
   YYSSP.
1683
1684
   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1685
   not large enough to hold the message.  In that case, also set
1686
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1687
   required number of bytes is too large to store.  */
1688
static int
1689
yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
1690
                yy_state_t *yyssp, int yytoken)
1691
{
1692
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1693
  /* Internationalized format string. */
1694
  const char *yyformat = YY_NULLPTR;
1695
  /* Arguments of yyformat: reported tokens (one for the "unexpected",
1696
     one per "expected"). */
1697
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1698
  /* Actual size of YYARG. */
1699
  int yycount = 0;
1700
  /* Cumulated lengths of YYARG.  */
1701
  YYPTRDIFF_T yysize = 0;
1702
1703
  /* There are many possibilities here to consider:
1704
     - If this state is a consistent state with a default action, then
1705
       the only way this function was invoked is if the default action
1706
       is an error action.  In that case, don't check for expected
1707
       tokens because there are none.
1708
     - The only way there can be no lookahead present (in yychar) is if
1709
       this state is a consistent state with a default action.  Thus,
1710
       detecting the absence of a lookahead is sufficient to determine
1711
       that there is no unexpected or expected token to report.  In that
1712
       case, just report a simple "syntax error".
1713
     - Don't assume there isn't a lookahead just because this state is a
1714
       consistent state with a default action.  There might have been a
1715
       previous inconsistent state, consistent state with a non-default
1716
       action, or user semantic action that manipulated yychar.
1717
     - Of course, the expected token list depends on states to have
1718
       correct lookahead information, and it depends on the parser not
1719
       to perform extra reductions after fetching a lookahead from the
1720
       scanner and before detecting a syntax error.  Thus, state merging
1721
       (from LALR or IELR) and default reductions corrupt the expected
1722
       token list.  However, the list is correct for canonical LR with
1723
       one exception: it will still contain any token that will not be
1724
       accepted due to an error action in a later state.
1725
  */
1726
  if (yytoken != YYEMPTY)
1727
    {
1728
      int yyn = yypact[+*yyssp];
1729
      YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1730
      yysize = yysize0;
1731
      yyarg[yycount++] = yytname[yytoken];
1732
      if (!yypact_value_is_default (yyn))
1733
        {
1734
          /* Start YYX at -YYN if negative to avoid negative indexes in
1735
             YYCHECK.  In other words, skip the first -YYN actions for
1736
             this state because they are default actions.  */
1737
          int yyxbegin = yyn < 0 ? -yyn : 0;
1738
          /* Stay within bounds of both yycheck and yytname.  */
1739
          int yychecklim = YYLAST - yyn + 1;
1740
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1741
          int yyx;
1742
1743
          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1744
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1745
                && !yytable_value_is_error (yytable[yyx + yyn]))
1746
              {
1747
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1748
                  {
1749
                    yycount = 1;
1750
                    yysize = yysize0;
1751
                    break;
1752
                  }
1753
                yyarg[yycount++] = yytname[yyx];
1754
                {
1755
                  YYPTRDIFF_T yysize1
1756
                    = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1757
                  if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1758
                    yysize = yysize1;
1759
                  else
1760
                    return 2;
1761
                }
1762
              }
1763
        }
1764
    }
1765
1766
  switch (yycount)
1767
    {
1768
# define YYCASE_(N, S)                      \
1769
      case N:                               \
1770
        yyformat = S;                       \
1771
      break
1772
    default: /* Avoid compiler warnings. */
1773
      YYCASE_(0, YY_("syntax error"));
1774
      YYCASE_(1, YY_("syntax error, unexpected %s"));
1775
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1776
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1777
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1778
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1779
# undef YYCASE_
1780
    }
1781
1782
  {
1783
    /* Don't count the "%s"s in the final size, but reserve room for
1784
       the terminator.  */
1785
    YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
1786
    if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1787
      yysize = yysize1;
1788
    else
1789
      return 2;
1790
  }
1791
1792
  if (*yymsg_alloc < yysize)
1793
    {
1794
      *yymsg_alloc = 2 * yysize;
1795
      if (! (yysize <= *yymsg_alloc
1796
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1797
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1798
      return 1;
1799
    }
1800
1801
  /* Avoid sprintf, as that infringes on the user's name space.
1802
     Don't have undefined behavior even if the translation
1803
     produced a string with the wrong number of "%s"s.  */
1804
  {
1805
    char *yyp = *yymsg;
1806
    int yyi = 0;
1807
    while ((*yyp = *yyformat) != '\0')
1808
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1809
        {
1810
          yyp += yytnamerr (yyp, yyarg[yyi++]);
1811
          yyformat += 2;
1812
        }
1813
      else
1814
        {
1815
          ++yyp;
1816
          ++yyformat;
1817
        }
1818
  }
1819
  return 0;
1820
}
1821
#endif /* YYERROR_VERBOSE */
1822
1823
/*-----------------------------------------------.
1824
| Release the memory associated to this symbol.  |
1825
`-----------------------------------------------*/
1826
1827
static void
1828
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, void *yyscanner, compiler_state_t *cstate)
1829
90.7k
{
1830
90.7k
  YYUSE (yyvaluep);
1831
90.7k
  YYUSE (yyscanner);
1832
90.7k
  YYUSE (cstate);
1833
90.7k
  if (!yymsg)
1834
0
    yymsg = "Deleting";
1835
90.7k
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1836
1837
90.7k
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1838
90.7k
  YYUSE (yytype);
1839
90.7k
  YY_IGNORE_MAYBE_UNINITIALIZED_END
1840
90.7k
}
1841
1842
1843
1844
1845
/*----------.
1846
| yyparse.  |
1847
`----------*/
1848
1849
int
1850
yyparse (void *yyscanner, compiler_state_t *cstate)
1851
32.1k
{
1852
/* The lookahead symbol.  */
1853
32.1k
int yychar;
1854
1855
1856
/* The semantic value of the lookahead symbol.  */
1857
/* Default value used for initialization, for pacifying older GCCs
1858
   or non-GCC compilers.  */
1859
32.1k
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1860
32.1k
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1861
1862
    /* Number of syntax errors so far.  */
1863
32.1k
    int yynerrs;
1864
1865
32.1k
    yy_state_fast_t yystate;
1866
    /* Number of tokens to shift before error messages enabled.  */
1867
32.1k
    int yyerrstatus;
1868
1869
    /* The stacks and their tools:
1870
       'yyss': related to states.
1871
       'yyvs': related to semantic values.
1872
1873
       Refer to the stacks through separate pointers, to allow yyoverflow
1874
       to reallocate them elsewhere.  */
1875
1876
    /* The state stack.  */
1877
32.1k
    yy_state_t yyssa[YYINITDEPTH];
1878
32.1k
    yy_state_t *yyss;
1879
32.1k
    yy_state_t *yyssp;
1880
1881
    /* The semantic value stack.  */
1882
32.1k
    YYSTYPE yyvsa[YYINITDEPTH];
1883
32.1k
    YYSTYPE *yyvs;
1884
32.1k
    YYSTYPE *yyvsp;
1885
1886
32.1k
    YYPTRDIFF_T yystacksize;
1887
1888
32.1k
  int yyn;
1889
32.1k
  int yyresult;
1890
  /* Lookahead token as an internal (translated) token number.  */
1891
32.1k
  int yytoken = 0;
1892
  /* The variables used to return semantic value and location from the
1893
     action routines.  */
1894
32.1k
  YYSTYPE yyval;
1895
1896
#if YYERROR_VERBOSE
1897
  /* Buffer for error messages, and its allocated size.  */
1898
  char yymsgbuf[128];
1899
  char *yymsg = yymsgbuf;
1900
  YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
1901
#endif
1902
1903
1.24M
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1904
1905
  /* The number of symbols on the RHS of the reduced rule.
1906
     Keep to zero when no symbol should be popped.  */
1907
32.1k
  int yylen = 0;
1908
1909
32.1k
  yyssp = yyss = yyssa;
1910
32.1k
  yyvsp = yyvs = yyvsa;
1911
32.1k
  yystacksize = YYINITDEPTH;
1912
1913
32.1k
  YYDPRINTF ((stderr, "Starting parse\n"));
1914
1915
32.1k
  yystate = 0;
1916
32.1k
  yyerrstatus = 0;
1917
32.1k
  yynerrs = 0;
1918
32.1k
  yychar = YYEMPTY; /* Cause a token to be read.  */
1919
32.1k
  goto yysetstate;
1920
1921
1922
/*------------------------------------------------------------.
1923
| yynewstate -- push a new state, which is found in yystate.  |
1924
`------------------------------------------------------------*/
1925
1.65M
yynewstate:
1926
  /* In all cases, when you get here, the value and location stacks
1927
     have just been pushed.  So pushing a state here evens the stacks.  */
1928
1.65M
  yyssp++;
1929
1930
1931
/*--------------------------------------------------------------------.
1932
| yysetstate -- set current state (the top of the stack) to yystate.  |
1933
`--------------------------------------------------------------------*/
1934
1.68M
yysetstate:
1935
1.68M
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1936
1.68M
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1937
1.68M
  YY_IGNORE_USELESS_CAST_BEGIN
1938
1.68M
  *yyssp = YY_CAST (yy_state_t, yystate);
1939
1.68M
  YY_IGNORE_USELESS_CAST_END
1940
1941
1.68M
  if (yyss + yystacksize - 1 <= yyssp)
1942
#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1943
    goto yyexhaustedlab;
1944
#else
1945
0
    {
1946
      /* Get the current used size of the three stacks, in elements.  */
1947
0
      YYPTRDIFF_T yysize = yyssp - yyss + 1;
1948
1949
# if defined yyoverflow
1950
      {
1951
        /* Give user a chance to reallocate the stack.  Use copies of
1952
           these so that the &'s don't force the real ones into
1953
           memory.  */
1954
        yy_state_t *yyss1 = yyss;
1955
        YYSTYPE *yyvs1 = yyvs;
1956
1957
        /* Each stack pointer address is followed by the size of the
1958
           data in use in that stack, in bytes.  This used to be a
1959
           conditional around just the two extra args, but that might
1960
           be undefined if yyoverflow is a macro.  */
1961
        yyoverflow (YY_("memory exhausted"),
1962
                    &yyss1, yysize * YYSIZEOF (*yyssp),
1963
                    &yyvs1, yysize * YYSIZEOF (*yyvsp),
1964
                    &yystacksize);
1965
        yyss = yyss1;
1966
        yyvs = yyvs1;
1967
      }
1968
# else /* defined YYSTACK_RELOCATE */
1969
      /* Extend the stack our own way.  */
1970
0
      if (YYMAXDEPTH <= yystacksize)
1971
0
        goto yyexhaustedlab;
1972
0
      yystacksize *= 2;
1973
0
      if (YYMAXDEPTH < yystacksize)
1974
0
        yystacksize = YYMAXDEPTH;
1975
1976
0
      {
1977
0
        yy_state_t *yyss1 = yyss;
1978
0
        union yyalloc *yyptr =
1979
0
          YY_CAST (union yyalloc *,
1980
0
                   YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1981
0
        if (! yyptr)
1982
0
          goto yyexhaustedlab;
1983
0
        YYSTACK_RELOCATE (yyss_alloc, yyss);
1984
0
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1985
0
# undef YYSTACK_RELOCATE
1986
0
        if (yyss1 != yyssa)
1987
0
          YYSTACK_FREE (yyss1);
1988
0
      }
1989
0
# endif
1990
1991
0
      yyssp = yyss + yysize - 1;
1992
0
      yyvsp = yyvs + yysize - 1;
1993
1994
0
      YY_IGNORE_USELESS_CAST_BEGIN
1995
0
      YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1996
0
                  YY_CAST (long, yystacksize)));
1997
0
      YY_IGNORE_USELESS_CAST_END
1998
1999
0
      if (yyss + yystacksize - 1 <= yyssp)
2000
0
        YYABORT;
2001
0
    }
2002
1.68M
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
2003
2004
1.68M
  if (yystate == YYFINAL)
2005
24.3k
    YYACCEPT;
2006
2007
1.66M
  goto yybackup;
2008
2009
2010
/*-----------.
2011
| yybackup.  |
2012
`-----------*/
2013
1.66M
yybackup:
2014
  /* Do appropriate processing given the current state.  Read a
2015
     lookahead token if we need one and don't already have one.  */
2016
2017
  /* First try to decide what to do without reference to lookahead token.  */
2018
1.66M
  yyn = yypact[yystate];
2019
1.66M
  if (yypact_value_is_default (yyn))
2020
844k
    goto yydefault;
2021
2022
  /* Not known => get a lookahead token if don't already have one.  */
2023
2024
  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
2025
815k
  if (yychar == YYEMPTY)
2026
532k
    {
2027
532k
      YYDPRINTF ((stderr, "Reading a token: "));
2028
532k
      yychar = yylex (&yylval, yyscanner);
2029
532k
    }
2030
2031
815k
  if (yychar <= YYEOF)
2032
97.8k
    {
2033
97.8k
      yychar = yytoken = YYEOF;
2034
97.8k
      YYDPRINTF ((stderr, "Now at end of input.\n"));
2035
97.8k
    }
2036
717k
  else
2037
717k
    {
2038
717k
      yytoken = YYTRANSLATE (yychar);
2039
717k
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2040
717k
    }
2041
2042
  /* If the proper action on seeing token YYTOKEN is to reduce or to
2043
     detect an error, take that action.  */
2044
815k
  yyn += yytoken;
2045
815k
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2046
258k
    goto yydefault;
2047
556k
  yyn = yytable[yyn];
2048
556k
  if (yyn <= 0)
2049
31.6k
    {
2050
31.6k
      if (yytable_value_is_error (yyn))
2051
0
        goto yyerrlab;
2052
31.6k
      yyn = -yyn;
2053
31.6k
      goto yyreduce;
2054
31.6k
    }
2055
2056
  /* Count tokens shifted since error; after three, turn off error
2057
     status.  */
2058
525k
  if (yyerrstatus)
2059
0
    yyerrstatus--;
2060
2061
  /* Shift the lookahead token.  */
2062
525k
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2063
525k
  yystate = yyn;
2064
525k
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2065
525k
  *++yyvsp = yylval;
2066
525k
  YY_IGNORE_MAYBE_UNINITIALIZED_END
2067
2068
  /* Discard the shifted token.  */
2069
525k
  yychar = YYEMPTY;
2070
525k
  goto yynewstate;
2071
2072
2073
/*-----------------------------------------------------------.
2074
| yydefault -- do the default action for the current state.  |
2075
`-----------------------------------------------------------*/
2076
1.10M
yydefault:
2077
1.10M
  yyn = yydefact[yystate];
2078
1.10M
  if (yyn == 0)
2079
6.16k
    goto yyerrlab;
2080
1.09M
  goto yyreduce;
2081
2082
2083
/*-----------------------------.
2084
| yyreduce -- do a reduction.  |
2085
`-----------------------------*/
2086
1.12M
yyreduce:
2087
  /* yyn is the number of a rule to reduce with.  */
2088
1.12M
  yylen = yyr2[yyn];
2089
2090
  /* If YYLEN is nonzero, implement the default value of the action:
2091
     '$$ = $1'.
2092
2093
     Otherwise, the following line sets YYVAL to garbage.
2094
     This behavior is undocumented and Bison
2095
     users should not rely upon it.  Assigning to YYVAL
2096
     unconditionally makes the parser a bit smaller, and it avoids a
2097
     GCC warning that YYVAL may be used uninitialized.  */
2098
1.12M
  yyval = yyvsp[1-yylen];
2099
2100
2101
1.12M
  YY_REDUCE_PRINT (yyn);
2102
1.12M
  switch (yyn)
2103
1.12M
    {
2104
20.7k
  case 2:
2105
20.7k
#line 426 "/src/libpcap/build/grammar.y"
2106
20.7k
{
2107
20.7k
  CHECK_INT_VAL(finish_parse(cstate, (yyvsp[0].blk).b));
2108
20.7k
}
2109
20.7k
#line 2110 "/src/libpcap/build/grammar.c"
2110
20.7k
    break;
2111
2112
32.1k
  case 4:
2113
32.1k
#line 431 "/src/libpcap/build/grammar.y"
2114
32.1k
                                { (yyval.blk).q = qerr; }
2115
32.1k
#line 2116 "/src/libpcap/build/grammar.c"
2116
32.1k
    break;
2117
2118
26.7k
  case 6:
2119
26.7k
#line 434 "/src/libpcap/build/grammar.y"
2120
26.7k
                                { gen_and((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2121
26.7k
#line 2122 "/src/libpcap/build/grammar.c"
2122
26.7k
    break;
2123
2124
0
  case 7:
2125
0
#line 435 "/src/libpcap/build/grammar.y"
2126
0
                                { gen_and((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2127
0
#line 2128 "/src/libpcap/build/grammar.c"
2128
0
    break;
2129
2130
18.5k
  case 8:
2131
18.5k
#line 436 "/src/libpcap/build/grammar.y"
2132
18.5k
                                { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2133
18.5k
#line 2134 "/src/libpcap/build/grammar.c"
2134
18.5k
    break;
2135
2136
0
  case 9:
2137
0
#line 437 "/src/libpcap/build/grammar.y"
2138
0
                                { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2139
0
#line 2140 "/src/libpcap/build/grammar.c"
2140
0
    break;
2141
2142
28.0k
  case 10:
2143
28.0k
#line 439 "/src/libpcap/build/grammar.y"
2144
28.0k
                                { (yyval.blk) = (yyvsp[-1].blk); }
2145
28.0k
#line 2146 "/src/libpcap/build/grammar.c"
2146
28.0k
    break;
2147
2148
19.4k
  case 11:
2149
19.4k
#line 441 "/src/libpcap/build/grammar.y"
2150
19.4k
                                { (yyval.blk) = (yyvsp[-1].blk); }
2151
19.4k
#line 2152 "/src/libpcap/build/grammar.c"
2152
19.4k
    break;
2153
2154
124
  case 13:
2155
124
#line 444 "/src/libpcap/build/grammar.y"
2156
124
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_ncode(cstate, NULL, (yyvsp[0].h),
2157
124
               (yyval.blk).q = (yyvsp[-1].blk).q))); }
2158
0
#line 2159 "/src/libpcap/build/grammar.c"
2159
0
    break;
2160
2161
0
  case 14:
2162
0
#line 446 "/src/libpcap/build/grammar.y"
2163
0
                                { (yyval.blk) = (yyvsp[-1].blk); }
2164
0
#line 2165 "/src/libpcap/build/grammar.c"
2165
0
    break;
2166
2167
184
  case 15:
2168
184
#line 448 "/src/libpcap/build/grammar.y"
2169
184
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_PTR_VAL(((yyval.blk).b = gen_scode(cstate, (yyvsp[0].s), (yyval.blk).q = (yyvsp[-1].blk).q))); }
2170
0
#line 2171 "/src/libpcap/build/grammar.c"
2171
0
    break;
2172
2173
81
  case 16:
2174
81
#line 449 "/src/libpcap/build/grammar.y"
2175
81
                                { CHECK_PTR_VAL((yyvsp[-2].s)); CHECK_PTR_VAL(((yyval.blk).b = gen_mcode(cstate, (yyvsp[-2].s), NULL, (yyvsp[0].h),
2176
81
            (yyval.blk).q = (yyvsp[-3].blk).q))); }
2177
0
#line 2178 "/src/libpcap/build/grammar.c"
2178
0
    break;
2179
2180
0
  case 17:
2181
0
#line 451 "/src/libpcap/build/grammar.y"
2182
0
                                { CHECK_PTR_VAL((yyvsp[-2].s)); CHECK_PTR_VAL(((yyval.blk).b = gen_mcode(cstate, (yyvsp[-2].s), (yyvsp[0].s), 0,
2183
0
            (yyval.blk).q = (yyvsp[-3].blk).q))); }
2184
0
#line 2185 "/src/libpcap/build/grammar.c"
2185
0
    break;
2186
2187
127
  case 18:
2188
127
#line 453 "/src/libpcap/build/grammar.y"
2189
127
                                {
2190
127
          CHECK_PTR_VAL((yyvsp[0].s));
2191
          /* Decide how to parse HID based on proto */
2192
127
          (yyval.blk).q = (yyvsp[-1].blk).q;
2193
127
          if ((yyval.blk).q.addr == Q_PORT) {
2194
0
          bpf_set_error(cstate, "'port' modifier applied to ip host");
2195
0
          YYABORT;
2196
127
          } else if ((yyval.blk).q.addr == Q_PORTRANGE) {
2197
0
          bpf_set_error(cstate, "'portrange' modifier applied to ip host");
2198
0
          YYABORT;
2199
127
          } else if ((yyval.blk).q.addr == Q_PROTO) {
2200
0
          bpf_set_error(cstate, "'proto' modifier applied to ip host");
2201
0
          YYABORT;
2202
127
          } else if ((yyval.blk).q.addr == Q_PROTOCHAIN) {
2203
0
          bpf_set_error(cstate, "'protochain' modifier applied to ip host");
2204
0
          YYABORT;
2205
0
          }
2206
127
          CHECK_PTR_VAL(((yyval.blk).b = gen_ncode(cstate, (yyvsp[0].s), 0, (yyval.blk).q)));
2207
127
        }
2208
0
#line 2209 "/src/libpcap/build/grammar.c"
2209
0
    break;
2210
2211
31
  case 19:
2212
31
#line 472 "/src/libpcap/build/grammar.y"
2213
31
                                {
2214
31
          CHECK_PTR_VAL((yyvsp[-2].s));
2215
31
#ifdef INET6
2216
31
          CHECK_PTR_VAL(((yyval.blk).b = gen_mcode6(cstate, (yyvsp[-2].s), NULL, (yyvsp[0].h),
2217
31
            (yyval.blk).q = (yyvsp[-3].blk).q)));
2218
#else
2219
          bpf_set_error(cstate, "'ip6addr/prefixlen' not supported "
2220
          "in this configuration");
2221
          YYABORT;
2222
#endif /*INET6*/
2223
31
        }
2224
0
#line 2225 "/src/libpcap/build/grammar.c"
2225
0
    break;
2226
2227
27
  case 20:
2228
27
#line 483 "/src/libpcap/build/grammar.y"
2229
27
                                {
2230
27
          CHECK_PTR_VAL((yyvsp[0].s));
2231
27
#ifdef INET6
2232
27
          CHECK_PTR_VAL(((yyval.blk).b = gen_mcode6(cstate, (yyvsp[0].s), 0, 128,
2233
27
            (yyval.blk).q = (yyvsp[-1].blk).q)));
2234
#else
2235
          bpf_set_error(cstate, "'ip6addr' not supported "
2236
          "in this configuration");
2237
          YYABORT;
2238
#endif /*INET6*/
2239
27
        }
2240
0
#line 2241 "/src/libpcap/build/grammar.c"
2241
0
    break;
2242
2243
39
  case 21:
2244
39
#line 494 "/src/libpcap/build/grammar.y"
2245
39
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_PTR_VAL(((yyval.blk).b = gen_ecode(cstate, (yyvsp[0].s), (yyval.blk).q = (yyvsp[-1].blk).q))); }
2246
0
#line 2247 "/src/libpcap/build/grammar.c"
2247
0
    break;
2248
2249
60
  case 22:
2250
60
#line 495 "/src/libpcap/build/grammar.y"
2251
60
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_PTR_VAL(((yyval.blk).b = gen_acode(cstate, (yyvsp[0].s), (yyval.blk).q = (yyvsp[-1].blk).q))); }
2252
0
#line 2253 "/src/libpcap/build/grammar.c"
2253
0
    break;
2254
2255
0
  case 23:
2256
0
#line 496 "/src/libpcap/build/grammar.y"
2257
0
                                { gen_not((yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2258
0
#line 2259 "/src/libpcap/build/grammar.c"
2259
0
    break;
2260
2261
4.55k
  case 24:
2262
4.55k
#line 498 "/src/libpcap/build/grammar.y"
2263
4.55k
                                { (yyval.blk) = (yyvsp[-1].blk); }
2264
4.55k
#line 2265 "/src/libpcap/build/grammar.c"
2265
4.55k
    break;
2266
2267
2.77k
  case 25:
2268
2.77k
#line 500 "/src/libpcap/build/grammar.y"
2269
2.77k
                                { (yyval.blk) = (yyvsp[-1].blk); }
2270
2.77k
#line 2271 "/src/libpcap/build/grammar.c"
2271
2.77k
    break;
2272
2273
0
  case 27:
2274
0
#line 503 "/src/libpcap/build/grammar.y"
2275
0
                                { gen_and((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2276
0
#line 2277 "/src/libpcap/build/grammar.c"
2277
0
    break;
2278
2279
0
  case 28:
2280
0
#line 504 "/src/libpcap/build/grammar.y"
2281
0
                                { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2282
0
#line 2283 "/src/libpcap/build/grammar.c"
2283
0
    break;
2284
2285
19
  case 29:
2286
19
#line 506 "/src/libpcap/build/grammar.y"
2287
19
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_ncode(cstate, NULL, (yyvsp[0].h),
2288
19
               (yyval.blk).q = (yyvsp[-1].blk).q))); }
2289
0
#line 2290 "/src/libpcap/build/grammar.c"
2290
0
    break;
2291
2292
3.26k
  case 32:
2293
3.26k
#line 511 "/src/libpcap/build/grammar.y"
2294
3.26k
                                { gen_not((yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2295
3.26k
#line 2296 "/src/libpcap/build/grammar.c"
2296
3.26k
    break;
2297
2298
0
  case 33:
2299
0
#line 513 "/src/libpcap/build/grammar.y"
2300
0
                                { QSET((yyval.blk).q, (yyvsp[-2].i), (yyvsp[-1].i), (yyvsp[0].i)); }
2301
0
#line 2302 "/src/libpcap/build/grammar.c"
2302
0
    break;
2303
2304
33
  case 34:
2305
33
#line 514 "/src/libpcap/build/grammar.y"
2306
33
                                { QSET((yyval.blk).q, (yyvsp[-1].i), (yyvsp[0].i), Q_DEFAULT); }
2307
33
#line 2308 "/src/libpcap/build/grammar.c"
2308
33
    break;
2309
2310
0
  case 35:
2311
0
#line 515 "/src/libpcap/build/grammar.y"
2312
0
                                { QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, (yyvsp[0].i)); }
2313
0
#line 2314 "/src/libpcap/build/grammar.c"
2314
0
    break;
2315
2316
0
  case 36:
2317
0
#line 516 "/src/libpcap/build/grammar.y"
2318
0
                                { QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, Q_PROTO); }
2319
0
#line 2320 "/src/libpcap/build/grammar.c"
2320
0
    break;
2321
2322
0
  case 37:
2323
0
#line 517 "/src/libpcap/build/grammar.y"
2324
0
                                {
2325
#ifdef NO_PROTOCHAIN
2326
          bpf_set_error(cstate, "protochain not supported");
2327
          YYABORT;
2328
#else
2329
0
          QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, Q_PROTOCHAIN);
2330
0
#endif
2331
0
        }
2332
0
#line 2333 "/src/libpcap/build/grammar.c"
2333
0
    break;
2334
2335
0
  case 38:
2336
0
#line 525 "/src/libpcap/build/grammar.y"
2337
0
                                { QSET((yyval.blk).q, (yyvsp[-1].i), Q_DEFAULT, (yyvsp[0].i)); }
2338
0
#line 2339 "/src/libpcap/build/grammar.c"
2339
0
    break;
2340
2341
0
  case 39:
2342
0
#line 527 "/src/libpcap/build/grammar.y"
2343
0
                                { (yyval.blk) = (yyvsp[0].blk); }
2344
0
#line 2345 "/src/libpcap/build/grammar.c"
2345
0
    break;
2346
2347
278
  case 40:
2348
278
#line 528 "/src/libpcap/build/grammar.y"
2349
278
                                { (yyval.blk).b = (yyvsp[-1].blk).b; (yyval.blk).q = (yyvsp[-2].blk).q; }
2350
278
#line 2351 "/src/libpcap/build/grammar.c"
2351
278
    break;
2352
2353
27.0k
  case 41:
2354
27.0k
#line 529 "/src/libpcap/build/grammar.y"
2355
27.0k
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_proto_abbrev(cstate, (yyvsp[0].i)))); (yyval.blk).q = qerr; }
2356
0
#line 2357 "/src/libpcap/build/grammar.c"
2357
0
    break;
2358
2359
23.2k
  case 42:
2360
23.2k
#line 530 "/src/libpcap/build/grammar.y"
2361
23.2k
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_relation(cstate, (yyvsp[-1].i), (yyvsp[-2].a), (yyvsp[0].a), 0)));
2362
23.2k
          (yyval.blk).q = qerr; }
2363
0
#line 2364 "/src/libpcap/build/grammar.c"
2364
0
    break;
2365
2366
18.4k
  case 43:
2367
18.4k
#line 532 "/src/libpcap/build/grammar.y"
2368
18.4k
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_relation(cstate, (yyvsp[-1].i), (yyvsp[-2].a), (yyvsp[0].a), 1)));
2369
18.4k
          (yyval.blk).q = qerr; }
2370
0
#line 2371 "/src/libpcap/build/grammar.c"
2371
0
    break;
2372
2373
38
  case 44:
2374
38
#line 534 "/src/libpcap/build/grammar.y"
2375
38
                                { (yyval.blk).b = (yyvsp[0].rblk); (yyval.blk).q = qerr; }
2376
38
#line 2377 "/src/libpcap/build/grammar.c"
2377
38
    break;
2378
2379
35
  case 45:
2380
35
#line 535 "/src/libpcap/build/grammar.y"
2381
35
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_atmtype_abbrev(cstate, (yyvsp[0].i)))); (yyval.blk).q = qerr; }
2382
0
#line 2383 "/src/libpcap/build/grammar.c"
2383
0
    break;
2384
2385
0
  case 46:
2386
0
#line 536 "/src/libpcap/build/grammar.y"
2387
0
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_atmmulti_abbrev(cstate, (yyvsp[0].i)))); (yyval.blk).q = qerr; }
2388
0
#line 2389 "/src/libpcap/build/grammar.c"
2389
0
    break;
2390
2391
0
  case 47:
2392
0
#line 537 "/src/libpcap/build/grammar.y"
2393
0
                                { (yyval.blk).b = (yyvsp[0].blk).b; (yyval.blk).q = qerr; }
2394
0
#line 2395 "/src/libpcap/build/grammar.c"
2395
0
    break;
2396
2397
8
  case 48:
2398
8
#line 538 "/src/libpcap/build/grammar.y"
2399
8
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_mtp2type_abbrev(cstate, (yyvsp[0].i)))); (yyval.blk).q = qerr; }
2400
0
#line 2401 "/src/libpcap/build/grammar.c"
2401
0
    break;
2402
2403
16
  case 49:
2404
16
#line 539 "/src/libpcap/build/grammar.y"
2405
16
                                { (yyval.blk).b = (yyvsp[0].blk).b; (yyval.blk).q = qerr; }
2406
16
#line 2407 "/src/libpcap/build/grammar.c"
2407
16
    break;
2408
2409
2.36k
  case 51:
2410
2.36k
#line 543 "/src/libpcap/build/grammar.y"
2411
2.36k
                                { (yyval.i) = Q_DEFAULT; }
2412
2.36k
#line 2413 "/src/libpcap/build/grammar.c"
2413
2.36k
    break;
2414
2415
0
  case 52:
2416
0
#line 546 "/src/libpcap/build/grammar.y"
2417
0
                                { (yyval.i) = Q_SRC; }
2418
0
#line 2419 "/src/libpcap/build/grammar.c"
2419
0
    break;
2420
2421
1
  case 53:
2422
1
#line 547 "/src/libpcap/build/grammar.y"
2423
1
                                { (yyval.i) = Q_DST; }
2424
1
#line 2425 "/src/libpcap/build/grammar.c"
2425
1
    break;
2426
2427
0
  case 54:
2428
0
#line 548 "/src/libpcap/build/grammar.y"
2429
0
                                { (yyval.i) = Q_OR; }
2430
0
#line 2431 "/src/libpcap/build/grammar.c"
2431
0
    break;
2432
2433
0
  case 55:
2434
0
#line 549 "/src/libpcap/build/grammar.y"
2435
0
                                { (yyval.i) = Q_OR; }
2436
0
#line 2437 "/src/libpcap/build/grammar.c"
2437
0
    break;
2438
2439
0
  case 56:
2440
0
#line 550 "/src/libpcap/build/grammar.y"
2441
0
                                { (yyval.i) = Q_AND; }
2442
0
#line 2443 "/src/libpcap/build/grammar.c"
2443
0
    break;
2444
2445
0
  case 57:
2446
0
#line 551 "/src/libpcap/build/grammar.y"
2447
0
                                { (yyval.i) = Q_AND; }
2448
0
#line 2449 "/src/libpcap/build/grammar.c"
2449
0
    break;
2450
2451
0
  case 58:
2452
0
#line 552 "/src/libpcap/build/grammar.y"
2453
0
                                { (yyval.i) = Q_ADDR1; }
2454
0
#line 2455 "/src/libpcap/build/grammar.c"
2455
0
    break;
2456
2457
0
  case 59:
2458
0
#line 553 "/src/libpcap/build/grammar.y"
2459
0
                                { (yyval.i) = Q_ADDR2; }
2460
0
#line 2461 "/src/libpcap/build/grammar.c"
2461
0
    break;
2462
2463
0
  case 60:
2464
0
#line 554 "/src/libpcap/build/grammar.y"
2465
0
                                { (yyval.i) = Q_ADDR3; }
2466
0
#line 2467 "/src/libpcap/build/grammar.c"
2467
0
    break;
2468
2469
0
  case 61:
2470
0
#line 555 "/src/libpcap/build/grammar.y"
2471
0
                                { (yyval.i) = Q_ADDR4; }
2472
0
#line 2473 "/src/libpcap/build/grammar.c"
2473
0
    break;
2474
2475
11
  case 62:
2476
11
#line 556 "/src/libpcap/build/grammar.y"
2477
11
                                { (yyval.i) = Q_RA; }
2478
11
#line 2479 "/src/libpcap/build/grammar.c"
2479
11
    break;
2480
2481
21
  case 63:
2482
21
#line 557 "/src/libpcap/build/grammar.y"
2483
21
                                { (yyval.i) = Q_TA; }
2484
21
#line 2485 "/src/libpcap/build/grammar.c"
2485
21
    break;
2486
2487
0
  case 64:
2488
0
#line 560 "/src/libpcap/build/grammar.y"
2489
0
                                { (yyval.i) = Q_HOST; }
2490
0
#line 2491 "/src/libpcap/build/grammar.c"
2491
0
    break;
2492
2493
0
  case 65:
2494
0
#line 561 "/src/libpcap/build/grammar.y"
2495
0
                                { (yyval.i) = Q_NET; }
2496
0
#line 2497 "/src/libpcap/build/grammar.c"
2497
0
    break;
2498
2499
0
  case 66:
2500
0
#line 562 "/src/libpcap/build/grammar.y"
2501
0
                                { (yyval.i) = Q_PORT; }
2502
0
#line 2503 "/src/libpcap/build/grammar.c"
2503
0
    break;
2504
2505
0
  case 67:
2506
0
#line 563 "/src/libpcap/build/grammar.y"
2507
0
                                { (yyval.i) = Q_PORTRANGE; }
2508
0
#line 2509 "/src/libpcap/build/grammar.c"
2509
0
    break;
2510
2511
0
  case 68:
2512
0
#line 566 "/src/libpcap/build/grammar.y"
2513
0
                                { (yyval.i) = Q_GATEWAY; }
2514
0
#line 2515 "/src/libpcap/build/grammar.c"
2515
0
    break;
2516
2517
62
  case 69:
2518
62
#line 568 "/src/libpcap/build/grammar.y"
2519
62
                                { (yyval.i) = Q_LINK; }
2520
62
#line 2521 "/src/libpcap/build/grammar.c"
2521
62
    break;
2522
2523
6.10k
  case 70:
2524
6.10k
#line 569 "/src/libpcap/build/grammar.y"
2525
6.10k
                                { (yyval.i) = Q_IP; }
2526
6.10k
#line 2527 "/src/libpcap/build/grammar.c"
2527
6.10k
    break;
2528
2529
0
  case 71:
2530
0
#line 570 "/src/libpcap/build/grammar.y"
2531
0
                                { (yyval.i) = Q_ARP; }
2532
0
#line 2533 "/src/libpcap/build/grammar.c"
2533
0
    break;
2534
2535
0
  case 72:
2536
0
#line 571 "/src/libpcap/build/grammar.y"
2537
0
                                { (yyval.i) = Q_RARP; }
2538
0
#line 2539 "/src/libpcap/build/grammar.c"
2539
0
    break;
2540
2541
0
  case 73:
2542
0
#line 572 "/src/libpcap/build/grammar.y"
2543
0
                                { (yyval.i) = Q_SCTP; }
2544
0
#line 2545 "/src/libpcap/build/grammar.c"
2545
0
    break;
2546
2547
530
  case 74:
2548
530
#line 573 "/src/libpcap/build/grammar.y"
2549
530
                                { (yyval.i) = Q_TCP; }
2550
530
#line 2551 "/src/libpcap/build/grammar.c"
2551
530
    break;
2552
2553
47
  case 75:
2554
47
#line 574 "/src/libpcap/build/grammar.y"
2555
47
                                { (yyval.i) = Q_UDP; }
2556
47
#line 2557 "/src/libpcap/build/grammar.c"
2557
47
    break;
2558
2559
0
  case 76:
2560
0
#line 575 "/src/libpcap/build/grammar.y"
2561
0
                                { (yyval.i) = Q_ICMP; }
2562
0
#line 2563 "/src/libpcap/build/grammar.c"
2563
0
    break;
2564
2565
0
  case 77:
2566
0
#line 576 "/src/libpcap/build/grammar.y"
2567
0
                                { (yyval.i) = Q_IGMP; }
2568
0
#line 2569 "/src/libpcap/build/grammar.c"
2569
0
    break;
2570
2571
0
  case 78:
2572
0
#line 577 "/src/libpcap/build/grammar.y"
2573
0
                                { (yyval.i) = Q_IGRP; }
2574
0
#line 2575 "/src/libpcap/build/grammar.c"
2575
0
    break;
2576
2577
0
  case 79:
2578
0
#line 578 "/src/libpcap/build/grammar.y"
2579
0
                                { (yyval.i) = Q_PIM; }
2580
0
#line 2581 "/src/libpcap/build/grammar.c"
2581
0
    break;
2582
2583
0
  case 80:
2584
0
#line 579 "/src/libpcap/build/grammar.y"
2585
0
                                { (yyval.i) = Q_VRRP; }
2586
0
#line 2587 "/src/libpcap/build/grammar.c"
2587
0
    break;
2588
2589
0
  case 81:
2590
0
#line 580 "/src/libpcap/build/grammar.y"
2591
0
                                { (yyval.i) = Q_CARP; }
2592
0
#line 2593 "/src/libpcap/build/grammar.c"
2593
0
    break;
2594
2595
0
  case 82:
2596
0
#line 581 "/src/libpcap/build/grammar.y"
2597
0
                                { (yyval.i) = Q_ATALK; }
2598
0
#line 2599 "/src/libpcap/build/grammar.c"
2599
0
    break;
2600
2601
0
  case 83:
2602
0
#line 582 "/src/libpcap/build/grammar.y"
2603
0
                                { (yyval.i) = Q_AARP; }
2604
0
#line 2605 "/src/libpcap/build/grammar.c"
2605
0
    break;
2606
2607
0
  case 84:
2608
0
#line 583 "/src/libpcap/build/grammar.y"
2609
0
                                { (yyval.i) = Q_DECNET; }
2610
0
#line 2611 "/src/libpcap/build/grammar.c"
2611
0
    break;
2612
2613
3
  case 85:
2614
3
#line 584 "/src/libpcap/build/grammar.y"
2615
3
                                { (yyval.i) = Q_LAT; }
2616
3
#line 2617 "/src/libpcap/build/grammar.c"
2617
3
    break;
2618
2619
0
  case 86:
2620
0
#line 585 "/src/libpcap/build/grammar.y"
2621
0
                                { (yyval.i) = Q_SCA; }
2622
0
#line 2623 "/src/libpcap/build/grammar.c"
2623
0
    break;
2624
2625
0
  case 87:
2626
0
#line 586 "/src/libpcap/build/grammar.y"
2627
0
                                { (yyval.i) = Q_MOPDL; }
2628
0
#line 2629 "/src/libpcap/build/grammar.c"
2629
0
    break;
2630
2631
0
  case 88:
2632
0
#line 587 "/src/libpcap/build/grammar.y"
2633
0
                                { (yyval.i) = Q_MOPRC; }
2634
0
#line 2635 "/src/libpcap/build/grammar.c"
2635
0
    break;
2636
2637
1.56k
  case 89:
2638
1.56k
#line 588 "/src/libpcap/build/grammar.y"
2639
1.56k
                                { (yyval.i) = Q_IPV6; }
2640
1.56k
#line 2641 "/src/libpcap/build/grammar.c"
2641
1.56k
    break;
2642
2643
0
  case 90:
2644
0
#line 589 "/src/libpcap/build/grammar.y"
2645
0
                                { (yyval.i) = Q_ICMPV6; }
2646
0
#line 2647 "/src/libpcap/build/grammar.c"
2647
0
    break;
2648
2649
595
  case 91:
2650
595
#line 590 "/src/libpcap/build/grammar.y"
2651
595
                                { (yyval.i) = Q_AH; }
2652
595
#line 2653 "/src/libpcap/build/grammar.c"
2653
595
    break;
2654
2655
1
  case 92:
2656
1
#line 591 "/src/libpcap/build/grammar.y"
2657
1
                                { (yyval.i) = Q_ESP; }
2658
1
#line 2659 "/src/libpcap/build/grammar.c"
2659
1
    break;
2660
2661
0
  case 93:
2662
0
#line 592 "/src/libpcap/build/grammar.y"
2663
0
                                { (yyval.i) = Q_ISO; }
2664
0
#line 2665 "/src/libpcap/build/grammar.c"
2665
0
    break;
2666
2667
0
  case 94:
2668
0
#line 593 "/src/libpcap/build/grammar.y"
2669
0
                                { (yyval.i) = Q_ESIS; }
2670
0
#line 2671 "/src/libpcap/build/grammar.c"
2671
0
    break;
2672
2673
0
  case 95:
2674
0
#line 594 "/src/libpcap/build/grammar.y"
2675
0
                                { (yyval.i) = Q_ISIS; }
2676
0
#line 2677 "/src/libpcap/build/grammar.c"
2677
0
    break;
2678
2679
8.57k
  case 96:
2680
8.57k
#line 595 "/src/libpcap/build/grammar.y"
2681
8.57k
                                { (yyval.i) = Q_ISIS_L1; }
2682
8.57k
#line 2683 "/src/libpcap/build/grammar.c"
2683
8.57k
    break;
2684
2685
7.10k
  case 97:
2686
7.10k
#line 596 "/src/libpcap/build/grammar.y"
2687
7.10k
                                { (yyval.i) = Q_ISIS_L2; }
2688
7.10k
#line 2689 "/src/libpcap/build/grammar.c"
2689
7.10k
    break;
2690
2691
1.35k
  case 98:
2692
1.35k
#line 597 "/src/libpcap/build/grammar.y"
2693
1.35k
                                { (yyval.i) = Q_ISIS_IIH; }
2694
1.35k
#line 2695 "/src/libpcap/build/grammar.c"
2695
1.35k
    break;
2696
2697
10
  case 99:
2698
10
#line 598 "/src/libpcap/build/grammar.y"
2699
10
                                { (yyval.i) = Q_ISIS_LSP; }
2700
10
#line 2701 "/src/libpcap/build/grammar.c"
2701
10
    break;
2702
2703
2
  case 100:
2704
2
#line 599 "/src/libpcap/build/grammar.y"
2705
2
                                { (yyval.i) = Q_ISIS_SNP; }
2706
2
#line 2707 "/src/libpcap/build/grammar.c"
2707
2
    break;
2708
2709
0
  case 101:
2710
0
#line 600 "/src/libpcap/build/grammar.y"
2711
0
                                { (yyval.i) = Q_ISIS_PSNP; }
2712
0
#line 2713 "/src/libpcap/build/grammar.c"
2713
0
    break;
2714
2715
0
  case 102:
2716
0
#line 601 "/src/libpcap/build/grammar.y"
2717
0
                                { (yyval.i) = Q_ISIS_CSNP; }
2718
0
#line 2719 "/src/libpcap/build/grammar.c"
2719
0
    break;
2720
2721
0
  case 103:
2722
0
#line 602 "/src/libpcap/build/grammar.y"
2723
0
                                { (yyval.i) = Q_CLNP; }
2724
0
#line 2725 "/src/libpcap/build/grammar.c"
2725
0
    break;
2726
2727
9
  case 104:
2728
9
#line 603 "/src/libpcap/build/grammar.y"
2729
9
                                { (yyval.i) = Q_STP; }
2730
9
#line 2731 "/src/libpcap/build/grammar.c"
2731
9
    break;
2732
2733
1.23k
  case 105:
2734
1.23k
#line 604 "/src/libpcap/build/grammar.y"
2735
1.23k
                                { (yyval.i) = Q_IPX; }
2736
1.23k
#line 2737 "/src/libpcap/build/grammar.c"
2737
1.23k
    break;
2738
2739
0
  case 106:
2740
0
#line 605 "/src/libpcap/build/grammar.y"
2741
0
                                { (yyval.i) = Q_NETBEUI; }
2742
0
#line 2743 "/src/libpcap/build/grammar.c"
2743
0
    break;
2744
2745
0
  case 107:
2746
0
#line 606 "/src/libpcap/build/grammar.y"
2747
0
                                { (yyval.i) = Q_RADIO; }
2748
0
#line 2749 "/src/libpcap/build/grammar.c"
2749
0
    break;
2750
2751
0
  case 108:
2752
0
#line 608 "/src/libpcap/build/grammar.y"
2753
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_broadcast(cstate, (yyvsp[-1].i)))); }
2754
0
#line 2755 "/src/libpcap/build/grammar.c"
2755
0
    break;
2756
2757
0
  case 109:
2758
0
#line 609 "/src/libpcap/build/grammar.y"
2759
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_multicast(cstate, (yyvsp[-1].i)))); }
2760
0
#line 2761 "/src/libpcap/build/grammar.c"
2761
0
    break;
2762
2763
0
  case 110:
2764
0
#line 610 "/src/libpcap/build/grammar.y"
2765
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_less(cstate, (yyvsp[0].h)))); }
2766
0
#line 2767 "/src/libpcap/build/grammar.c"
2767
0
    break;
2768
2769
0
  case 111:
2770
0
#line 611 "/src/libpcap/build/grammar.y"
2771
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_greater(cstate, (yyvsp[0].h)))); }
2772
0
#line 2773 "/src/libpcap/build/grammar.c"
2773
0
    break;
2774
2775
0
  case 112:
2776
0
#line 612 "/src/libpcap/build/grammar.y"
2777
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_byteop(cstate, (yyvsp[-1].i), (yyvsp[-2].h), (yyvsp[0].h)))); }
2778
0
#line 2779 "/src/libpcap/build/grammar.c"
2779
0
    break;
2780
2781
0
  case 113:
2782
0
#line 613 "/src/libpcap/build/grammar.y"
2783
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_inbound(cstate, 0))); }
2784
0
#line 2785 "/src/libpcap/build/grammar.c"
2785
0
    break;
2786
2787
0
  case 114:
2788
0
#line 614 "/src/libpcap/build/grammar.y"
2789
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_inbound(cstate, 1))); }
2790
0
#line 2791 "/src/libpcap/build/grammar.c"
2791
0
    break;
2792
2793
0
  case 115:
2794
0
#line 615 "/src/libpcap/build/grammar.y"
2795
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_ifindex(cstate, (yyvsp[0].h)))); }
2796
0
#line 2797 "/src/libpcap/build/grammar.c"
2797
0
    break;
2798
2799
0
  case 116:
2800
0
#line 616 "/src/libpcap/build/grammar.y"
2801
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_vlan(cstate, (yyvsp[0].h), 1))); }
2802
0
#line 2803 "/src/libpcap/build/grammar.c"
2803
0
    break;
2804
2805
0
  case 117:
2806
0
#line 617 "/src/libpcap/build/grammar.y"
2807
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_vlan(cstate, 0, 0))); }
2808
0
#line 2809 "/src/libpcap/build/grammar.c"
2809
0
    break;
2810
2811
0
  case 118:
2812
0
#line 618 "/src/libpcap/build/grammar.y"
2813
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_mpls(cstate, (yyvsp[0].h), 1))); }
2814
0
#line 2815 "/src/libpcap/build/grammar.c"
2815
0
    break;
2816
2817
0
  case 119:
2818
0
#line 619 "/src/libpcap/build/grammar.y"
2819
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_mpls(cstate, 0, 0))); }
2820
0
#line 2821 "/src/libpcap/build/grammar.c"
2821
0
    break;
2822
2823
0
  case 120:
2824
0
#line 620 "/src/libpcap/build/grammar.y"
2825
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_pppoed(cstate))); }
2826
0
#line 2827 "/src/libpcap/build/grammar.c"
2827
0
    break;
2828
2829
0
  case 121:
2830
0
#line 621 "/src/libpcap/build/grammar.y"
2831
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_pppoes(cstate, (yyvsp[0].h), 1))); }
2832
0
#line 2833 "/src/libpcap/build/grammar.c"
2833
0
    break;
2834
2835
0
  case 122:
2836
0
#line 622 "/src/libpcap/build/grammar.y"
2837
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_pppoes(cstate, 0, 0))); }
2838
0
#line 2839 "/src/libpcap/build/grammar.c"
2839
0
    break;
2840
2841
0
  case 123:
2842
0
#line 623 "/src/libpcap/build/grammar.y"
2843
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_geneve(cstate, (yyvsp[0].h), 1))); }
2844
0
#line 2845 "/src/libpcap/build/grammar.c"
2845
0
    break;
2846
2847
0
  case 124:
2848
0
#line 624 "/src/libpcap/build/grammar.y"
2849
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_geneve(cstate, 0, 0))); }
2850
0
#line 2851 "/src/libpcap/build/grammar.c"
2851
0
    break;
2852
2853
18
  case 125:
2854
18
#line 625 "/src/libpcap/build/grammar.y"
2855
18
                                { (yyval.rblk) = (yyvsp[0].rblk); }
2856
18
#line 2857 "/src/libpcap/build/grammar.c"
2857
18
    break;
2858
2859
0
  case 126:
2860
0
#line 626 "/src/libpcap/build/grammar.y"
2861
0
                                { (yyval.rblk) = (yyvsp[0].rblk); }
2862
0
#line 2863 "/src/libpcap/build/grammar.c"
2863
0
    break;
2864
2865
20
  case 127:
2866
20
#line 627 "/src/libpcap/build/grammar.y"
2867
20
                                { (yyval.rblk) = (yyvsp[0].rblk); }
2868
20
#line 2869 "/src/libpcap/build/grammar.c"
2869
20
    break;
2870
2871
24
  case 128:
2872
24
#line 630 "/src/libpcap/build/grammar.y"
2873
24
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_PTR_VAL(((yyval.rblk) = gen_pf_ifname(cstate, (yyvsp[0].s)))); }
2874
18
#line 2875 "/src/libpcap/build/grammar.c"
2875
18
    break;
2876
2877
18
  case 129:
2878
0
#line 631 "/src/libpcap/build/grammar.y"
2879
0
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_PTR_VAL(((yyval.rblk) = gen_pf_ruleset(cstate, (yyvsp[0].s)))); }
2880
0
#line 2881 "/src/libpcap/build/grammar.c"
2881
0
    break;
2882
2883
0
  case 130:
2884
0
#line 632 "/src/libpcap/build/grammar.y"
2885
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_pf_rnr(cstate, (yyvsp[0].h)))); }
2886
0
#line 2887 "/src/libpcap/build/grammar.c"
2887
0
    break;
2888
2889
0
  case 131:
2890
0
#line 633 "/src/libpcap/build/grammar.y"
2891
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_pf_srnr(cstate, (yyvsp[0].h)))); }
2892
0
#line 2893 "/src/libpcap/build/grammar.c"
2893
0
    break;
2894
2895
0
  case 132:
2896
0
#line 634 "/src/libpcap/build/grammar.y"
2897
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_pf_reason(cstate, (yyvsp[0].i)))); }
2898
0
#line 2899 "/src/libpcap/build/grammar.c"
2899
0
    break;
2900
2901
0
  case 133:
2902
0
#line 635 "/src/libpcap/build/grammar.y"
2903
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_pf_action(cstate, (yyvsp[0].i)))); }
2904
0
#line 2905 "/src/libpcap/build/grammar.c"
2905
0
    break;
2906
2907
0
  case 134:
2908
0
#line 639 "/src/libpcap/build/grammar.y"
2909
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_p80211_type(cstate, (yyvsp[-2].i) | (yyvsp[0].i),
2910
0
          IEEE80211_FC0_TYPE_MASK |
2911
0
          IEEE80211_FC0_SUBTYPE_MASK)));
2912
0
        }
2913
0
#line 2914 "/src/libpcap/build/grammar.c"
2914
0
    break;
2915
2916
0
  case 135:
2917
0
#line 643 "/src/libpcap/build/grammar.y"
2918
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_p80211_type(cstate, (yyvsp[0].i),
2919
0
          IEEE80211_FC0_TYPE_MASK)));
2920
0
        }
2921
0
#line 2922 "/src/libpcap/build/grammar.c"
2922
0
    break;
2923
2924
0
  case 136:
2925
0
#line 646 "/src/libpcap/build/grammar.y"
2926
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_p80211_type(cstate, (yyvsp[0].i),
2927
0
          IEEE80211_FC0_TYPE_MASK |
2928
0
          IEEE80211_FC0_SUBTYPE_MASK)));
2929
0
        }
2930
0
#line 2931 "/src/libpcap/build/grammar.c"
2931
0
    break;
2932
2933
0
  case 137:
2934
0
#line 650 "/src/libpcap/build/grammar.y"
2935
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_p80211_fcdir(cstate, (yyvsp[0].i)))); }
2936
0
#line 2937 "/src/libpcap/build/grammar.c"
2937
0
    break;
2938
2939
0
  case 138:
2940
0
#line 653 "/src/libpcap/build/grammar.y"
2941
0
                                { if (((yyvsp[0].h) & (~IEEE80211_FC0_TYPE_MASK)) != 0) {
2942
0
          bpf_set_error(cstate, "invalid 802.11 type value 0x%02x", (yyvsp[0].h));
2943
0
          YYABORT;
2944
0
          }
2945
0
          (yyval.i) = (int)(yyvsp[0].h);
2946
0
        }
2947
0
#line 2948 "/src/libpcap/build/grammar.c"
2948
0
    break;
2949
2950
0
  case 139:
2951
0
#line 659 "/src/libpcap/build/grammar.y"
2952
0
                                { CHECK_PTR_VAL((yyvsp[0].s));
2953
0
          (yyval.i) = str2tok((yyvsp[0].s), ieee80211_types);
2954
0
          if ((yyval.i) == -1) {
2955
0
          bpf_set_error(cstate, "unknown 802.11 type name \"%s\"", (yyvsp[0].s));
2956
0
          YYABORT;
2957
0
          }
2958
0
        }
2959
0
#line 2960 "/src/libpcap/build/grammar.c"
2960
0
    break;
2961
2962
0
  case 140:
2963
0
#line 668 "/src/libpcap/build/grammar.y"
2964
0
                                { if (((yyvsp[0].h) & (~IEEE80211_FC0_SUBTYPE_MASK)) != 0) {
2965
0
          bpf_set_error(cstate, "invalid 802.11 subtype value 0x%02x", (yyvsp[0].h));
2966
0
          YYABORT;
2967
0
          }
2968
0
          (yyval.i) = (int)(yyvsp[0].h);
2969
0
        }
2970
0
#line 2971 "/src/libpcap/build/grammar.c"
2971
0
    break;
2972
2973
0
  case 141:
2974
0
#line 674 "/src/libpcap/build/grammar.y"
2975
0
                                { const struct tok *types = NULL;
2976
0
          int i;
2977
0
          CHECK_PTR_VAL((yyvsp[0].s));
2978
0
          for (i = 0;; i++) {
2979
0
          if (ieee80211_type_subtypes[i].tok == NULL) {
2980
            /* Ran out of types */
2981
0
            bpf_set_error(cstate, "unknown 802.11 type");
2982
0
            YYABORT;
2983
0
          }
2984
0
          if ((yyvsp[(-1) - (1)].i) == ieee80211_type_subtypes[i].type) {
2985
0
            types = ieee80211_type_subtypes[i].tok;
2986
0
            break;
2987
0
          }
2988
0
          }
2989
2990
0
          (yyval.i) = str2tok((yyvsp[0].s), types);
2991
0
          if ((yyval.i) == -1) {
2992
0
          bpf_set_error(cstate, "unknown 802.11 subtype name \"%s\"", (yyvsp[0].s));
2993
0
          YYABORT;
2994
0
          }
2995
0
        }
2996
0
#line 2997 "/src/libpcap/build/grammar.c"
2997
0
    break;
2998
2999
0
  case 142:
3000
0
#line 697 "/src/libpcap/build/grammar.y"
3001
0
                                { int i;
3002
0
          CHECK_PTR_VAL((yyvsp[0].s));
3003
0
          for (i = 0;; i++) {
3004
0
          if (ieee80211_type_subtypes[i].tok == NULL) {
3005
            /* Ran out of types */
3006
0
            bpf_set_error(cstate, "unknown 802.11 type name");
3007
0
            YYABORT;
3008
0
          }
3009
0
          (yyval.i) = str2tok((yyvsp[0].s), ieee80211_type_subtypes[i].tok);
3010
0
          if ((yyval.i) != -1) {
3011
0
            (yyval.i) |= ieee80211_type_subtypes[i].type;
3012
0
            break;
3013
0
          }
3014
0
          }
3015
0
        }
3016
0
#line 3017 "/src/libpcap/build/grammar.c"
3017
0
    break;
3018
3019
12
  case 143:
3020
12
#line 714 "/src/libpcap/build/grammar.y"
3021
12
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_llc(cstate))); }
3022
11
#line 3023 "/src/libpcap/build/grammar.c"
3023
11
    break;
3024
3025
17
  case 144:
3026
17
#line 715 "/src/libpcap/build/grammar.y"
3027
17
                                { CHECK_PTR_VAL((yyvsp[0].s));
3028
17
          if (pcap_strcasecmp((yyvsp[0].s), "i") == 0) {
3029
3
          CHECK_PTR_VAL(((yyval.rblk) = gen_llc_i(cstate)));
3030
14
          } else if (pcap_strcasecmp((yyvsp[0].s), "s") == 0) {
3031
3
          CHECK_PTR_VAL(((yyval.rblk) = gen_llc_s(cstate)));
3032
11
          } else if (pcap_strcasecmp((yyvsp[0].s), "u") == 0) {
3033
3
          CHECK_PTR_VAL(((yyval.rblk) = gen_llc_u(cstate)));
3034
8
          } else {
3035
8
          int subtype;
3036
3037
8
          subtype = str2tok((yyvsp[0].s), llc_s_subtypes);
3038
8
          if (subtype != -1) {
3039
0
            CHECK_PTR_VAL(((yyval.rblk) = gen_llc_s_subtype(cstate, subtype)));
3040
8
          } else {
3041
8
            subtype = str2tok((yyvsp[0].s), llc_u_subtypes);
3042
8
            if (subtype == -1) {
3043
4
              bpf_set_error(cstate, "unknown LLC type name \"%s\"", (yyvsp[0].s));
3044
4
              YYABORT;
3045
4
            }
3046
4
            CHECK_PTR_VAL(((yyval.rblk) = gen_llc_u_subtype(cstate, subtype)));
3047
4
          }
3048
8
          }
3049
17
        }
3050
9
#line 3051 "/src/libpcap/build/grammar.c"
3051
9
    break;
3052
3053
9
  case 145:
3054
0
#line 739 "/src/libpcap/build/grammar.y"
3055
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_llc_s_subtype(cstate, LLC_RNR))); }
3056
0
#line 3057 "/src/libpcap/build/grammar.c"
3057
0
    break;
3058
3059
0
  case 146:
3060
0
#line 742 "/src/libpcap/build/grammar.y"
3061
0
                                { (yyval.i) = (int)(yyvsp[0].h); }
3062
0
#line 3063 "/src/libpcap/build/grammar.c"
3063
0
    break;
3064
3065
0
  case 147:
3066
0
#line 743 "/src/libpcap/build/grammar.y"
3067
0
                                { CHECK_PTR_VAL((yyvsp[0].s));
3068
0
          if (pcap_strcasecmp((yyvsp[0].s), "nods") == 0)
3069
0
          (yyval.i) = IEEE80211_FC1_DIR_NODS;
3070
0
          else if (pcap_strcasecmp((yyvsp[0].s), "tods") == 0)
3071
0
          (yyval.i) = IEEE80211_FC1_DIR_TODS;
3072
0
          else if (pcap_strcasecmp((yyvsp[0].s), "fromds") == 0)
3073
0
          (yyval.i) = IEEE80211_FC1_DIR_FROMDS;
3074
0
          else if (pcap_strcasecmp((yyvsp[0].s), "dstods") == 0)
3075
0
          (yyval.i) = IEEE80211_FC1_DIR_DSTODS;
3076
0
          else {
3077
0
          bpf_set_error(cstate, "unknown 802.11 direction");
3078
0
          YYABORT;
3079
0
          }
3080
0
        }
3081
0
#line 3082 "/src/libpcap/build/grammar.c"
3082
0
    break;
3083
3084
0
  case 148:
3085
0
#line 759 "/src/libpcap/build/grammar.y"
3086
0
                                { (yyval.i) = (yyvsp[0].h); }
3087
0
#line 3088 "/src/libpcap/build/grammar.c"
3088
0
    break;
3089
3090
0
  case 149:
3091
0
#line 760 "/src/libpcap/build/grammar.y"
3092
0
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_INT_VAL(((yyval.i) = pfreason_to_num(cstate, (yyvsp[0].s)))); }
3093
0
#line 3094 "/src/libpcap/build/grammar.c"
3094
0
    break;
3095
3096
0
  case 150:
3097
0
#line 763 "/src/libpcap/build/grammar.y"
3098
0
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_INT_VAL(((yyval.i) = pfaction_to_num(cstate, (yyvsp[0].s)))); }
3099
0
#line 3100 "/src/libpcap/build/grammar.c"
3100
0
    break;
3101
3102
9.90k
  case 151:
3103
9.90k
#line 766 "/src/libpcap/build/grammar.y"
3104
9.90k
                                { (yyval.i) = BPF_JGT; }
3105
9.90k
#line 3106 "/src/libpcap/build/grammar.c"
3106
9.90k
    break;
3107
3108
501
  case 152:
3109
501
#line 767 "/src/libpcap/build/grammar.y"
3110
501
                                { (yyval.i) = BPF_JGE; }
3111
501
#line 3112 "/src/libpcap/build/grammar.c"
3112
501
    break;
3113
3114
13.2k
  case 153:
3115
13.2k
#line 768 "/src/libpcap/build/grammar.y"
3116
13.2k
                                { (yyval.i) = BPF_JEQ; }
3117
13.2k
#line 3118 "/src/libpcap/build/grammar.c"
3118
13.2k
    break;
3119
3120
1.11k
  case 154:
3121
1.11k
#line 770 "/src/libpcap/build/grammar.y"
3122
1.11k
                                { (yyval.i) = BPF_JGT; }
3123
1.11k
#line 3124 "/src/libpcap/build/grammar.c"
3124
1.11k
    break;
3125
3126
15.9k
  case 155:
3127
15.9k
#line 771 "/src/libpcap/build/grammar.y"
3128
15.9k
                                { (yyval.i) = BPF_JGE; }
3129
15.9k
#line 3130 "/src/libpcap/build/grammar.c"
3130
15.9k
    break;
3131
3132
1.55k
  case 156:
3133
1.55k
#line 772 "/src/libpcap/build/grammar.y"
3134
1.55k
                                { (yyval.i) = BPF_JEQ; }
3135
1.55k
#line 3136 "/src/libpcap/build/grammar.c"
3136
1.55k
    break;
3137
3138
201k
  case 157:
3139
201k
#line 774 "/src/libpcap/build/grammar.y"
3140
201k
                                { CHECK_PTR_VAL(((yyval.a) = gen_loadi(cstate, (yyvsp[0].h)))); }
3141
201k
#line 3142 "/src/libpcap/build/grammar.c"
3142
201k
    break;
3143
3144
201k
  case 159:
3145
0
#line 777 "/src/libpcap/build/grammar.y"
3146
0
                                        { CHECK_PTR_VAL(((yyval.a) = gen_load(cstate, (yyvsp[-3].i), (yyvsp[-1].a), 1))); }
3147
0
#line 3148 "/src/libpcap/build/grammar.c"
3148
0
    break;
3149
3150
0
  case 160:
3151
0
#line 778 "/src/libpcap/build/grammar.y"
3152
0
                                        { CHECK_PTR_VAL(((yyval.a) = gen_load(cstate, (yyvsp[-5].i), (yyvsp[-3].a), (yyvsp[-1].h)))); }
3153
0
#line 3154 "/src/libpcap/build/grammar.c"
3154
0
    break;
3155
3156
13.2k
  case 161:
3157
13.2k
#line 779 "/src/libpcap/build/grammar.y"
3158
13.2k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_ADD, (yyvsp[-2].a), (yyvsp[0].a)))); }
3159
13.2k
#line 3160 "/src/libpcap/build/grammar.c"
3160
13.2k
    break;
3161
3162
13.2k
  case 162:
3163
4.15k
#line 780 "/src/libpcap/build/grammar.y"
3164
4.15k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_SUB, (yyvsp[-2].a), (yyvsp[0].a)))); }
3165
4.15k
#line 3166 "/src/libpcap/build/grammar.c"
3166
4.15k
    break;
3167
3168
21.4k
  case 163:
3169
21.4k
#line 781 "/src/libpcap/build/grammar.y"
3170
21.4k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_MUL, (yyvsp[-2].a), (yyvsp[0].a)))); }
3171
21.4k
#line 3172 "/src/libpcap/build/grammar.c"
3172
21.4k
    break;
3173
3174
21.4k
  case 164:
3175
11.2k
#line 782 "/src/libpcap/build/grammar.y"
3176
11.2k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_DIV, (yyvsp[-2].a), (yyvsp[0].a)))); }
3177
11.1k
#line 3178 "/src/libpcap/build/grammar.c"
3178
11.1k
    break;
3179
3180
14.2k
  case 165:
3181
14.2k
#line 783 "/src/libpcap/build/grammar.y"
3182
14.2k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_MOD, (yyvsp[-2].a), (yyvsp[0].a)))); }
3183
14.1k
#line 3184 "/src/libpcap/build/grammar.c"
3184
14.1k
    break;
3185
3186
22.6k
  case 166:
3187
22.6k
#line 784 "/src/libpcap/build/grammar.y"
3188
22.6k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_AND, (yyvsp[-2].a), (yyvsp[0].a)))); }
3189
22.6k
#line 3190 "/src/libpcap/build/grammar.c"
3190
22.6k
    break;
3191
3192
22.6k
  case 167:
3193
9.76k
#line 785 "/src/libpcap/build/grammar.y"
3194
9.76k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_OR, (yyvsp[-2].a), (yyvsp[0].a)))); }
3195
9.76k
#line 3196 "/src/libpcap/build/grammar.c"
3196
9.76k
    break;
3197
3198
10.3k
  case 168:
3199
10.3k
#line 786 "/src/libpcap/build/grammar.y"
3200
10.3k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_XOR, (yyvsp[-2].a), (yyvsp[0].a)))); }
3201
10.3k
#line 3202 "/src/libpcap/build/grammar.c"
3202
10.3k
    break;
3203
3204
10.3k
  case 169:
3205
1.38k
#line 787 "/src/libpcap/build/grammar.y"
3206
1.38k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_LSH, (yyvsp[-2].a), (yyvsp[0].a)))); }
3207
1.36k
#line 3208 "/src/libpcap/build/grammar.c"
3208
1.36k
    break;
3209
3210
1.36k
  case 170:
3211
812
#line 788 "/src/libpcap/build/grammar.y"
3212
812
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_RSH, (yyvsp[-2].a), (yyvsp[0].a)))); }
3213
791
#line 3214 "/src/libpcap/build/grammar.c"
3214
791
    break;
3215
3216
55.8k
  case 171:
3217
55.8k
#line 789 "/src/libpcap/build/grammar.y"
3218
55.8k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_neg(cstate, (yyvsp[0].a)))); }
3219
55.8k
#line 3220 "/src/libpcap/build/grammar.c"
3220
55.8k
    break;
3221
3222
55.8k
  case 172:
3223
173
#line 790 "/src/libpcap/build/grammar.y"
3224
173
                                        { (yyval.a) = (yyvsp[-1].a); }
3225
173
#line 3226 "/src/libpcap/build/grammar.c"
3226
173
    break;
3227
3228
0
  case 173:
3229
0
#line 791 "/src/libpcap/build/grammar.y"
3230
0
                                        { CHECK_PTR_VAL(((yyval.a) = gen_loadlen(cstate))); }
3231
0
#line 3232 "/src/libpcap/build/grammar.c"
3232
0
    break;
3233
3234
0
  case 174:
3235
0
#line 793 "/src/libpcap/build/grammar.y"
3236
0
                                { (yyval.i) = '&'; }
3237
0
#line 3238 "/src/libpcap/build/grammar.c"
3238
0
    break;
3239
3240
0
  case 175:
3241
0
#line 794 "/src/libpcap/build/grammar.y"
3242
0
                                { (yyval.i) = '|'; }
3243
0
#line 3244 "/src/libpcap/build/grammar.c"
3244
0
    break;
3245
3246
0
  case 176:
3247
0
#line 795 "/src/libpcap/build/grammar.y"
3248
0
                                { (yyval.i) = '<'; }
3249
0
#line 3250 "/src/libpcap/build/grammar.c"
3250
0
    break;
3251
3252
0
  case 177:
3253
0
#line 796 "/src/libpcap/build/grammar.y"
3254
0
                                { (yyval.i) = '>'; }
3255
0
#line 3256 "/src/libpcap/build/grammar.c"
3256
0
    break;
3257
3258
0
  case 178:
3259
0
#line 797 "/src/libpcap/build/grammar.y"
3260
0
                                { (yyval.i) = '='; }
3261
0
#line 3262 "/src/libpcap/build/grammar.c"
3262
0
    break;
3263
3264
212
  case 180:
3265
212
#line 800 "/src/libpcap/build/grammar.y"
3266
212
                                { (yyval.h) = (yyvsp[-1].h); }
3267
212
#line 3268 "/src/libpcap/build/grammar.c"
3268
212
    break;
3269
3270
0
  case 181:
3271
0
#line 802 "/src/libpcap/build/grammar.y"
3272
0
                                { (yyval.i) = A_LANE; }
3273
0
#line 3274 "/src/libpcap/build/grammar.c"
3274
0
    break;
3275
3276
0
  case 182:
3277
0
#line 803 "/src/libpcap/build/grammar.y"
3278
0
                                { (yyval.i) = A_METAC; }
3279
0
#line 3280 "/src/libpcap/build/grammar.c"
3280
0
    break;
3281
3282
7
  case 183:
3283
7
#line 804 "/src/libpcap/build/grammar.y"
3284
7
                                { (yyval.i) = A_BCC; }
3285
7
#line 3286 "/src/libpcap/build/grammar.c"
3286
7
    break;
3287
3288
0
  case 184:
3289
0
#line 805 "/src/libpcap/build/grammar.y"
3290
0
                                { (yyval.i) = A_OAMF4EC; }
3291
0
#line 3292 "/src/libpcap/build/grammar.c"
3292
0
    break;
3293
3294
0
  case 185:
3295
0
#line 806 "/src/libpcap/build/grammar.y"
3296
0
                                { (yyval.i) = A_OAMF4SC; }
3297
0
#line 3298 "/src/libpcap/build/grammar.c"
3298
0
    break;
3299
3300
28
  case 186:
3301
28
#line 807 "/src/libpcap/build/grammar.y"
3302
28
                                { (yyval.i) = A_SC; }
3303
28
#line 3304 "/src/libpcap/build/grammar.c"
3304
28
    break;
3305
3306
0
  case 187:
3307
0
#line 808 "/src/libpcap/build/grammar.y"
3308
0
                                { (yyval.i) = A_ILMIC; }
3309
0
#line 3310 "/src/libpcap/build/grammar.c"
3310
0
    break;
3311
3312
0
  case 188:
3313
0
#line 810 "/src/libpcap/build/grammar.y"
3314
0
                                { (yyval.i) = A_OAM; }
3315
0
#line 3316 "/src/libpcap/build/grammar.c"
3316
0
    break;
3317
3318
0
  case 189:
3319
0
#line 811 "/src/libpcap/build/grammar.y"
3320
0
                                { (yyval.i) = A_OAMF4; }
3321
0
#line 3322 "/src/libpcap/build/grammar.c"
3322
0
    break;
3323
3324
0
  case 190:
3325
0
#line 812 "/src/libpcap/build/grammar.y"
3326
0
                                { (yyval.i) = A_CONNECTMSG; }
3327
0
#line 3328 "/src/libpcap/build/grammar.c"
3328
0
    break;
3329
3330
0
  case 191:
3331
0
#line 813 "/src/libpcap/build/grammar.y"
3332
0
                                { (yyval.i) = A_METACONNECT; }
3333
0
#line 3334 "/src/libpcap/build/grammar.c"
3334
0
    break;
3335
3336
0
  case 192:
3337
0
#line 816 "/src/libpcap/build/grammar.y"
3338
0
                                { (yyval.blk).atmfieldtype = A_VPI; }
3339
0
#line 3340 "/src/libpcap/build/grammar.c"
3340
0
    break;
3341
3342
0
  case 193:
3343
0
#line 817 "/src/libpcap/build/grammar.y"
3344
0
                                { (yyval.blk).atmfieldtype = A_VCI; }
3345
0
#line 3346 "/src/libpcap/build/grammar.c"
3346
0
    break;
3347
3348
0
  case 195:
3349
0
#line 820 "/src/libpcap/build/grammar.y"
3350
0
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_atmfield_code(cstate, (yyvsp[-2].blk).atmfieldtype, (yyvsp[0].h), (yyvsp[-1].i), 0))); }
3351
0
#line 3352 "/src/libpcap/build/grammar.c"
3352
0
    break;
3353
3354
0
  case 196:
3355
0
#line 821 "/src/libpcap/build/grammar.y"
3356
0
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_atmfield_code(cstate, (yyvsp[-2].blk).atmfieldtype, (yyvsp[0].h), (yyvsp[-1].i), 1))); }
3357
0
#line 3358 "/src/libpcap/build/grammar.c"
3358
0
    break;
3359
3360
0
  case 197:
3361
0
#line 822 "/src/libpcap/build/grammar.y"
3362
0
                                 { (yyval.blk).b = (yyvsp[-1].blk).b; (yyval.blk).q = qerr; }
3363
0
#line 3364 "/src/libpcap/build/grammar.c"
3364
0
    break;
3365
3366
0
  case 198:
3367
0
#line 824 "/src/libpcap/build/grammar.y"
3368
0
                   {
3369
0
  (yyval.blk).atmfieldtype = (yyvsp[-1].blk).atmfieldtype;
3370
0
  if ((yyval.blk).atmfieldtype == A_VPI ||
3371
0
      (yyval.blk).atmfieldtype == A_VCI)
3372
0
    CHECK_PTR_VAL(((yyval.blk).b = gen_atmfield_code(cstate, (yyval.blk).atmfieldtype, (yyvsp[0].h), BPF_JEQ, 0)));
3373
0
  }
3374
0
#line 3375 "/src/libpcap/build/grammar.c"
3375
0
    break;
3376
3377
0
  case 200:
3378
0
#line 832 "/src/libpcap/build/grammar.y"
3379
0
                                        { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
3380
0
#line 3381 "/src/libpcap/build/grammar.c"
3381
0
    break;
3382
3383
0
  case 201:
3384
0
#line 835 "/src/libpcap/build/grammar.y"
3385
0
                                { (yyval.i) = M_FISU; }
3386
0
#line 3387 "/src/libpcap/build/grammar.c"
3387
0
    break;
3388
3389
4
  case 202:
3390
4
#line 836 "/src/libpcap/build/grammar.y"
3391
4
                                { (yyval.i) = M_LSSU; }
3392
4
#line 3393 "/src/libpcap/build/grammar.c"
3393
4
    break;
3394
3395
4
  case 203:
3396
4
#line 837 "/src/libpcap/build/grammar.y"
3397
4
                                { (yyval.i) = M_MSU; }
3398
4
#line 3399 "/src/libpcap/build/grammar.c"
3399
4
    break;
3400
3401
0
  case 204:
3402
0
#line 838 "/src/libpcap/build/grammar.y"
3403
0
                                { (yyval.i) = MH_FISU; }
3404
0
#line 3405 "/src/libpcap/build/grammar.c"
3405
0
    break;
3406
3407
0
  case 205:
3408
0
#line 839 "/src/libpcap/build/grammar.y"
3409
0
                                { (yyval.i) = MH_LSSU; }
3410
0
#line 3411 "/src/libpcap/build/grammar.c"
3411
0
    break;
3412
3413
0
  case 206:
3414
0
#line 840 "/src/libpcap/build/grammar.y"
3415
0
                                { (yyval.i) = MH_MSU; }
3416
0
#line 3417 "/src/libpcap/build/grammar.c"
3417
0
    break;
3418
3419
1
  case 207:
3420
1
#line 843 "/src/libpcap/build/grammar.y"
3421
1
                                { (yyval.blk).mtp3fieldtype = M_SIO; }
3422
1
#line 3423 "/src/libpcap/build/grammar.c"
3423
1
    break;
3424
3425
0
  case 208:
3426
0
#line 844 "/src/libpcap/build/grammar.y"
3427
0
                                { (yyval.blk).mtp3fieldtype = M_OPC; }
3428
0
#line 3429 "/src/libpcap/build/grammar.c"
3429
0
    break;
3430
3431
0
  case 209:
3432
0
#line 845 "/src/libpcap/build/grammar.y"
3433
0
                                { (yyval.blk).mtp3fieldtype = M_DPC; }
3434
0
#line 3435 "/src/libpcap/build/grammar.c"
3435
0
    break;
3436
3437
22
  case 210:
3438
22
#line 846 "/src/libpcap/build/grammar.y"
3439
22
                                { (yyval.blk).mtp3fieldtype = M_SLS; }
3440
22
#line 3441 "/src/libpcap/build/grammar.c"
3441
22
    break;
3442
3443
0
  case 211:
3444
0
#line 847 "/src/libpcap/build/grammar.y"
3445
0
                                { (yyval.blk).mtp3fieldtype = MH_SIO; }
3446
0
#line 3447 "/src/libpcap/build/grammar.c"
3447
0
    break;
3448
3449
0
  case 212:
3450
0
#line 848 "/src/libpcap/build/grammar.y"
3451
0
                                { (yyval.blk).mtp3fieldtype = MH_OPC; }
3452
0
#line 3453 "/src/libpcap/build/grammar.c"
3453
0
    break;
3454
3455
0
  case 213:
3456
0
#line 849 "/src/libpcap/build/grammar.y"
3457
0
                                { (yyval.blk).mtp3fieldtype = MH_DPC; }
3458
0
#line 3459 "/src/libpcap/build/grammar.c"
3459
0
    break;
3460
3461
0
  case 214:
3462
0
#line 850 "/src/libpcap/build/grammar.y"
3463
0
                                { (yyval.blk).mtp3fieldtype = MH_SLS; }
3464
0
#line 3465 "/src/libpcap/build/grammar.c"
3465
0
    break;
3466
3467
3
  case 216:
3468
3
#line 853 "/src/libpcap/build/grammar.y"
3469
3
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_mtp3field_code(cstate, (yyvsp[-2].blk).mtp3fieldtype, (yyvsp[0].h), (yyvsp[-1].i), 0))); }
3470
2
#line 3471 "/src/libpcap/build/grammar.c"
3471
2
    break;
3472
3473
2
  case 217:
3474
2
#line 854 "/src/libpcap/build/grammar.y"
3475
2
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_mtp3field_code(cstate, (yyvsp[-2].blk).mtp3fieldtype, (yyvsp[0].h), (yyvsp[-1].i), 1))); }
3476
1
#line 3477 "/src/libpcap/build/grammar.c"
3477
1
    break;
3478
3479
1
  case 218:
3480
0
#line 855 "/src/libpcap/build/grammar.y"
3481
0
                                  { (yyval.blk).b = (yyvsp[-1].blk).b; (yyval.blk).q = qerr; }
3482
0
#line 3483 "/src/libpcap/build/grammar.c"
3483
0
    break;
3484
3485
15
  case 219:
3486
15
#line 857 "/src/libpcap/build/grammar.y"
3487
15
                    {
3488
15
  (yyval.blk).mtp3fieldtype = (yyvsp[-1].blk).mtp3fieldtype;
3489
15
  if ((yyval.blk).mtp3fieldtype == M_SIO ||
3490
15
      (yyval.blk).mtp3fieldtype == M_OPC ||
3491
15
      (yyval.blk).mtp3fieldtype == M_DPC ||
3492
15
      (yyval.blk).mtp3fieldtype == M_SLS ||
3493
15
      (yyval.blk).mtp3fieldtype == MH_SIO ||
3494
15
      (yyval.blk).mtp3fieldtype == MH_OPC ||
3495
15
      (yyval.blk).mtp3fieldtype == MH_DPC ||
3496
15
      (yyval.blk).mtp3fieldtype == MH_SLS)
3497
15
    CHECK_PTR_VAL(((yyval.blk).b = gen_mtp3field_code(cstate, (yyval.blk).mtp3fieldtype, (yyvsp[0].h), BPF_JEQ, 0)));
3498
15
  }
3499
13
#line 3500 "/src/libpcap/build/grammar.c"
3500
13
    break;
3501
3502
13
  case 221:
3503
0
#line 871 "/src/libpcap/build/grammar.y"
3504
0
                                          { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
3505
0
#line 3506 "/src/libpcap/build/grammar.c"
3506
0
    break;
3507
3508
3509
0
#line 3510 "/src/libpcap/build/grammar.c"
3510
3511
463k
      default: break;
3512
1.12M
    }
3513
  /* User semantic actions sometimes alter yychar, and that requires
3514
     that yytoken be updated with the new translation.  We take the
3515
     approach of translating immediately before every use of yytoken.
3516
     One alternative is translating here after every semantic action,
3517
     but that translation would be missed if the semantic action invokes
3518
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3519
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
3520
     incorrect destructor might then be invoked immediately.  In the
3521
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
3522
     to an incorrect destructor call or verbose syntax error message
3523
     before the lookahead is translated.  */
3524
1.12M
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3525
3526
1.12M
  YYPOPSTACK (yylen);
3527
1.12M
  yylen = 0;
3528
1.12M
  YY_STACK_PRINT (yyss, yyssp);
3529
3530
1.12M
  *++yyvsp = yyval;
3531
3532
  /* Now 'shift' the result of the reduction.  Determine what state
3533
     that goes to, based on the state we popped back to and the rule
3534
     number reduced by.  */
3535
1.12M
  {
3536
1.12M
    const int yylhs = yyr1[yyn] - YYNTOKENS;
3537
1.12M
    const int yyi = yypgoto[yylhs] + *yyssp;
3538
1.12M
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
3539
1.12M
               ? yytable[yyi]
3540
1.12M
               : yydefgoto[yylhs]);
3541
1.12M
  }
3542
3543
1.12M
  goto yynewstate;
3544
3545
3546
/*--------------------------------------.
3547
| yyerrlab -- here on detecting error.  |
3548
`--------------------------------------*/
3549
6.16k
yyerrlab:
3550
  /* Make sure we have latest lookahead translation.  See comments at
3551
     user semantic actions for why this is necessary.  */
3552
6.16k
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3553
3554
  /* If not already recovering from an error, report this error.  */
3555
6.16k
  if (!yyerrstatus)
3556
6.16k
    {
3557
6.16k
      ++yynerrs;
3558
6.16k
#if ! YYERROR_VERBOSE
3559
6.16k
      yyerror (yyscanner, cstate, YY_("syntax error"));
3560
#else
3561
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3562
                                        yyssp, yytoken)
3563
      {
3564
        char const *yymsgp = YY_("syntax error");
3565
        int yysyntax_error_status;
3566
        yysyntax_error_status = YYSYNTAX_ERROR;
3567
        if (yysyntax_error_status == 0)
3568
          yymsgp = yymsg;
3569
        else if (yysyntax_error_status == 1)
3570
          {
3571
            if (yymsg != yymsgbuf)
3572
              YYSTACK_FREE (yymsg);
3573
            yymsg = YY_CAST (char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
3574
            if (!yymsg)
3575
              {
3576
                yymsg = yymsgbuf;
3577
                yymsg_alloc = sizeof yymsgbuf;
3578
                yysyntax_error_status = 2;
3579
              }
3580
            else
3581
              {
3582
                yysyntax_error_status = YYSYNTAX_ERROR;
3583
                yymsgp = yymsg;
3584
              }
3585
          }
3586
        yyerror (yyscanner, cstate, yymsgp);
3587
        if (yysyntax_error_status == 2)
3588
          goto yyexhaustedlab;
3589
      }
3590
# undef YYSYNTAX_ERROR
3591
#endif
3592
6.16k
    }
3593
3594
3595
3596
6.16k
  if (yyerrstatus == 3)
3597
0
    {
3598
      /* If just tried and failed to reuse lookahead token after an
3599
         error, discard it.  */
3600
3601
0
      if (yychar <= YYEOF)
3602
0
        {
3603
          /* Return failure if at end of input.  */
3604
0
          if (yychar == YYEOF)
3605
0
            YYABORT;
3606
0
        }
3607
0
      else
3608
0
        {
3609
0
          yydestruct ("Error: discarding",
3610
0
                      yytoken, &yylval, yyscanner, cstate);
3611
0
          yychar = YYEMPTY;
3612
0
        }
3613
0
    }
3614
3615
  /* Else will try to reuse lookahead token after shifting the error
3616
     token.  */
3617
6.16k
  goto yyerrlab1;
3618
3619
3620
/*---------------------------------------------------.
3621
| yyerrorlab -- error raised explicitly by YYERROR.  |
3622
`---------------------------------------------------*/
3623
6.16k
yyerrorlab:
3624
  /* Pacify compilers when the user code never invokes YYERROR and the
3625
     label yyerrorlab therefore never appears in user code.  */
3626
0
  if (0)
3627
0
    YYERROR;
3628
3629
  /* Do not reclaim the symbols of the rule whose action triggered
3630
     this YYERROR.  */
3631
0
  YYPOPSTACK (yylen);
3632
0
  yylen = 0;
3633
0
  YY_STACK_PRINT (yyss, yyssp);
3634
0
  yystate = *yyssp;
3635
0
  goto yyerrlab1;
3636
3637
3638
/*-------------------------------------------------------------.
3639
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
3640
`-------------------------------------------------------------*/
3641
6.16k
yyerrlab1:
3642
6.16k
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3643
3644
6.16k
  for (;;)
3645
31.2k
    {
3646
31.2k
      yyn = yypact[yystate];
3647
31.2k
      if (!yypact_value_is_default (yyn))
3648
25.0k
        {
3649
25.0k
          yyn += YYTERROR;
3650
25.0k
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3651
0
            {
3652
0
              yyn = yytable[yyn];
3653
0
              if (0 < yyn)
3654
0
                break;
3655
0
            }
3656
25.0k
        }
3657
3658
      /* Pop the current state because it cannot handle the error token.  */
3659
31.2k
      if (yyssp == yyss)
3660
6.16k
        YYABORT;
3661
3662
3663
25.0k
      yydestruct ("Error: popping",
3664
25.0k
                  yystos[yystate], yyvsp, yyscanner, cstate);
3665
25.0k
      YYPOPSTACK (1);
3666
25.0k
      yystate = *yyssp;
3667
25.0k
      YY_STACK_PRINT (yyss, yyssp);
3668
25.0k
    }
3669
3670
0
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3671
0
  *++yyvsp = yylval;
3672
0
  YY_IGNORE_MAYBE_UNINITIALIZED_END
3673
3674
3675
  /* Shift the error token.  */
3676
0
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3677
3678
0
  yystate = yyn;
3679
0
  goto yynewstate;
3680
3681
3682
/*-------------------------------------.
3683
| yyacceptlab -- YYACCEPT comes here.  |
3684
`-------------------------------------*/
3685
24.3k
yyacceptlab:
3686
24.3k
  yyresult = 0;
3687
24.3k
  goto yyreturn;
3688
3689
3690
/*-----------------------------------.
3691
| yyabortlab -- YYABORT comes here.  |
3692
`-----------------------------------*/
3693
7.77k
yyabortlab:
3694
7.77k
  yyresult = 1;
3695
7.77k
  goto yyreturn;
3696
3697
3698
0
#if !defined yyoverflow || YYERROR_VERBOSE
3699
/*-------------------------------------------------.
3700
| yyexhaustedlab -- memory exhaustion comes here.  |
3701
`-------------------------------------------------*/
3702
0
yyexhaustedlab:
3703
0
  yyerror (yyscanner, cstate, YY_("memory exhausted"));
3704
0
  yyresult = 2;
3705
  /* Fall through.  */
3706
0
#endif
3707
3708
3709
/*-----------------------------------------------------.
3710
| yyreturn -- parsing is finished, return the result.  |
3711
`-----------------------------------------------------*/
3712
32.1k
yyreturn:
3713
32.1k
  if (yychar != YYEMPTY)
3714
7.21k
    {
3715
      /* Make sure we have latest lookahead translation.  See comments at
3716
         user semantic actions for why this is necessary.  */
3717
7.21k
      yytoken = YYTRANSLATE (yychar);
3718
7.21k
      yydestruct ("Cleanup: discarding lookahead",
3719
7.21k
                  yytoken, &yylval, yyscanner, cstate);
3720
7.21k
    }
3721
  /* Do not reclaim the symbols of the rule whose action triggered
3722
     this YYABORT or YYACCEPT.  */
3723
32.1k
  YYPOPSTACK (yylen);
3724
32.1k
  YY_STACK_PRINT (yyss, yyssp);
3725
90.6k
  while (yyssp != yyss)
3726
58.5k
    {
3727
58.5k
      yydestruct ("Cleanup: popping",
3728
58.5k
                  yystos[+*yyssp], yyvsp, yyscanner, cstate);
3729
58.5k
      YYPOPSTACK (1);
3730
58.5k
    }
3731
32.1k
#ifndef yyoverflow
3732
32.1k
  if (yyss != yyssa)
3733
0
    YYSTACK_FREE (yyss);
3734
32.1k
#endif
3735
#if YYERROR_VERBOSE
3736
  if (yymsg != yymsgbuf)
3737
    YYSTACK_FREE (yymsg);
3738
#endif
3739
32.1k
  return yyresult;
3740
0
}
3741
#line 873 "/src/libpcap/build/grammar.y"
3742