Coverage Report

Created: 2023-05-05 14:17

/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
25.4k
#define yylex           pcap_lex
69
895
#define yyerror         pcap_error
70
#define yydebug         pcap_debug
71
4.29k
#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
0
#define QSET(q, p, d, a) (q).proto = (unsigned char)(p),\
163
0
       (q).dir = (unsigned char)(d),\
164
0
       (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
0
{
262
0
  int i;
263
264
0
  for (i = 0; toks[i].s != NULL; i++) {
265
0
    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
0
      if (toks[i].v == -1)
273
0
        abort();
274
0
      return (toks[i].v);
275
0
    }
276
0
  }
277
0
  return (-1);
278
0
}
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
895
{
285
895
  bpf_set_error(cstate, "can't parse filter expression: %s", msg);
286
895
}
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
1.71k
#define CHECK_INT_VAL(val)  if (val == -1) YYABORT
374
19.3k
#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
79.5k
#   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
3.40k
#  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
895
#  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
35.5k
# 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
6.80k
# 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
79.5k
#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
79.5k
#define YYFINAL  3
886
/* YYLAST -- Last index in YYTABLE.  */
887
129k
#define YYLAST   800
888
889
/* YYNTOKENS -- Number of terminals.  */
890
51.7k
#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
31.9k
#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
32.8k
  (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
80.8k
#define YYPACT_NINF (-217)
1037
1038
#define yypact_value_is_default(Yyn) \
1039
80.8k
  ((Yyn) == YYPACT_NINF)
1040
1041
#define YYTABLE_NINF (-42)
1042
1043
#define yytable_value_is_error(Yyn) \
1044
1.16k
  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
72.2k
#define YYEMPTY         (-2)
1408
50.4k
#define YYEOF           0
1409
1410
2.33k
#define YYACCEPT        goto yyacceptlab
1411
1.06k
#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
5.60k
#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
3.40k
# 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
8.89k
{
1830
8.89k
  YYUSE (yyvaluep);
1831
8.89k
  YYUSE (yyscanner);
1832
8.89k
  YYUSE (cstate);
1833
8.89k
  if (!yymsg)
1834
0
    yymsg = "Deleting";
1835
8.89k
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1836
1837
8.89k
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1838
8.89k
  YYUSE (yytype);
1839
8.89k
  YY_IGNORE_MAYBE_UNINITIALIZED_END
1840
8.89k
}
1841
1842
1843
1844
1845
/*----------.
1846
| yyparse.  |
1847
`----------*/
1848
1849
int
1850
yyparse (void *yyscanner, compiler_state_t *cstate)
1851
3.40k
{
1852
/* The lookahead symbol.  */
1853
3.40k
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
3.40k
YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1860
3.40k
YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1861
1862
    /* Number of syntax errors so far.  */
1863
3.40k
    int yynerrs;
1864
1865
3.40k
    yy_state_fast_t yystate;
1866
    /* Number of tokens to shift before error messages enabled.  */
1867
3.40k
    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
3.40k
    yy_state_t yyssa[YYINITDEPTH];
1878
3.40k
    yy_state_t *yyss;
1879
3.40k
    yy_state_t *yyssp;
1880
1881
    /* The semantic value stack.  */
1882
3.40k
    YYSTYPE yyvsa[YYINITDEPTH];
1883
3.40k
    YYSTYPE *yyvs;
1884
3.40k
    YYSTYPE *yyvsp;
1885
1886
3.40k
    YYPTRDIFF_T yystacksize;
1887
1888
3.40k
  int yyn;
1889
3.40k
  int yyresult;
1890
  /* Lookahead token as an internal (translated) token number.  */
1891
3.40k
  int yytoken = 0;
1892
  /* The variables used to return semantic value and location from the
1893
     action routines.  */
1894
3.40k
  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
63.0k
#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
3.40k
  int yylen = 0;
1908
1909
3.40k
  yyssp = yyss = yyssa;
1910
3.40k
  yyvsp = yyvs = yyvsa;
1911
3.40k
  yystacksize = YYINITDEPTH;
1912
1913
3.40k
  YYDPRINTF ((stderr, "Starting parse\n"));
1914
1915
3.40k
  yystate = 0;
1916
3.40k
  yyerrstatus = 0;
1917
3.40k
  yynerrs = 0;
1918
3.40k
  yychar = YYEMPTY; /* Cause a token to be read.  */
1919
3.40k
  goto yysetstate;
1920
1921
1922
/*------------------------------------------------------------.
1923
| yynewstate -- push a new state, which is found in yystate.  |
1924
`------------------------------------------------------------*/
1925
76.1k
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
76.1k
  yyssp++;
1929
1930
1931
/*--------------------------------------------------------------------.
1932
| yysetstate -- set current state (the top of the stack) to yystate.  |
1933
`--------------------------------------------------------------------*/
1934
79.5k
yysetstate:
1935
79.5k
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1936
79.5k
  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1937
79.5k
  YY_IGNORE_USELESS_CAST_BEGIN
1938
79.5k
  *yyssp = YY_CAST (yy_state_t, yystate);
1939
79.5k
  YY_IGNORE_USELESS_CAST_END
1940
1941
79.5k
  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
79.5k
#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
2003
2004
79.5k
  if (yystate == YYFINAL)
2005
2.33k
    YYACCEPT;
2006
2007
77.1k
  goto yybackup;
2008
2009
2010
/*-----------.
2011
| yybackup.  |
2012
`-----------*/
2013
77.1k
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
77.1k
  yyn = yypact[yystate];
2019
77.1k
  if (yypact_value_is_default (yyn))
2020
36.9k
    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
40.2k
  if (yychar == YYEMPTY)
2026
25.4k
    {
2027
25.4k
      YYDPRINTF ((stderr, "Reading a token: "));
2028
25.4k
      yychar = yylex (&yylval, yyscanner);
2029
25.4k
    }
2030
2031
40.2k
  if (yychar <= YYEOF)
2032
10.2k
    {
2033
10.2k
      yychar = yytoken = YYEOF;
2034
10.2k
      YYDPRINTF ((stderr, "Now at end of input.\n"));
2035
10.2k
    }
2036
30.0k
  else
2037
30.0k
    {
2038
30.0k
      yytoken = YYTRANSLATE (yychar);
2039
30.0k
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2040
30.0k
    }
2041
2042
  /* If the proper action on seeing token YYTOKEN is to reduce or to
2043
     detect an error, take that action.  */
2044
40.2k
  yyn += yytoken;
2045
40.2k
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2046
14.7k
    goto yydefault;
2047
25.5k
  yyn = yytable[yyn];
2048
25.5k
  if (yyn <= 0)
2049
1.16k
    {
2050
1.16k
      if (yytable_value_is_error (yyn))
2051
0
        goto yyerrlab;
2052
1.16k
      yyn = -yyn;
2053
1.16k
      goto yyreduce;
2054
1.16k
    }
2055
2056
  /* Count tokens shifted since error; after three, turn off error
2057
     status.  */
2058
24.3k
  if (yyerrstatus)
2059
0
    yyerrstatus--;
2060
2061
  /* Shift the lookahead token.  */
2062
24.3k
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2063
24.3k
  yystate = yyn;
2064
24.3k
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2065
24.3k
  *++yyvsp = yylval;
2066
24.3k
  YY_IGNORE_MAYBE_UNINITIALIZED_END
2067
2068
  /* Discard the shifted token.  */
2069
24.3k
  yychar = YYEMPTY;
2070
24.3k
  goto yynewstate;
2071
2072
2073
/*-----------------------------------------------------------.
2074
| yydefault -- do the default action for the current state.  |
2075
`-----------------------------------------------------------*/
2076
51.6k
yydefault:
2077
51.6k
  yyn = yydefact[yystate];
2078
51.6k
  if (yyn == 0)
2079
895
    goto yyerrlab;
2080
50.7k
  goto yyreduce;
2081
2082
2083
/*-----------------------------.
2084
| yyreduce -- do a reduction.  |
2085
`-----------------------------*/
2086
51.9k
yyreduce:
2087
  /* yyn is the number of a rule to reduce with.  */
2088
51.9k
  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
51.9k
  yyval = yyvsp[1-yylen];
2099
2100
2101
51.9k
  YY_REDUCE_PRINT (yyn);
2102
51.9k
  switch (yyn)
2103
51.9k
    {
2104
1.71k
  case 2:
2105
1.71k
#line 426 "/src/libpcap/build/grammar.y"
2106
1.71k
{
2107
1.71k
  CHECK_INT_VAL(finish_parse(cstate, (yyvsp[0].blk).b));
2108
1.71k
}
2109
1.71k
#line 2110 "/src/libpcap/build/grammar.c"
2110
1.71k
    break;
2111
2112
3.40k
  case 4:
2113
3.40k
#line 431 "/src/libpcap/build/grammar.y"
2114
3.40k
                                { (yyval.blk).q = qerr; }
2115
3.40k
#line 2116 "/src/libpcap/build/grammar.c"
2116
3.40k
    break;
2117
2118
79
  case 6:
2119
79
#line 434 "/src/libpcap/build/grammar.y"
2120
79
                                { gen_and((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2121
79
#line 2122 "/src/libpcap/build/grammar.c"
2122
79
    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
0
  case 8:
2131
0
#line 436 "/src/libpcap/build/grammar.y"
2132
0
                                { gen_or((yyvsp[-2].blk).b, (yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2133
0
#line 2134 "/src/libpcap/build/grammar.c"
2134
0
    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
100
  case 10:
2143
100
#line 439 "/src/libpcap/build/grammar.y"
2144
100
                                { (yyval.blk) = (yyvsp[-1].blk); }
2145
100
#line 2146 "/src/libpcap/build/grammar.c"
2146
100
    break;
2147
2148
15
  case 11:
2149
15
#line 441 "/src/libpcap/build/grammar.y"
2150
15
                                { (yyval.blk) = (yyvsp[-1].blk); }
2151
15
#line 2152 "/src/libpcap/build/grammar.c"
2152
15
    break;
2153
2154
3
  case 13:
2155
3
#line 444 "/src/libpcap/build/grammar.y"
2156
3
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_ncode(cstate, NULL, (yyvsp[0].h),
2157
3
               (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
4
  case 15:
2168
4
#line 448 "/src/libpcap/build/grammar.y"
2169
4
                                { 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
0
  case 16:
2174
0
#line 449 "/src/libpcap/build/grammar.y"
2175
0
                                { CHECK_PTR_VAL((yyvsp[-2].s)); CHECK_PTR_VAL(((yyval.blk).b = gen_mcode(cstate, (yyvsp[-2].s), NULL, (yyvsp[0].h),
2176
0
            (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
10
  case 18:
2188
10
#line 453 "/src/libpcap/build/grammar.y"
2189
10
                                {
2190
10
          CHECK_PTR_VAL((yyvsp[0].s));
2191
          /* Decide how to parse HID based on proto */
2192
10
          (yyval.blk).q = (yyvsp[-1].blk).q;
2193
10
          if ((yyval.blk).q.addr == Q_PORT) {
2194
0
          bpf_set_error(cstate, "'port' modifier applied to ip host");
2195
0
          YYABORT;
2196
10
          } else if ((yyval.blk).q.addr == Q_PORTRANGE) {
2197
0
          bpf_set_error(cstate, "'portrange' modifier applied to ip host");
2198
0
          YYABORT;
2199
10
          } else if ((yyval.blk).q.addr == Q_PROTO) {
2200
0
          bpf_set_error(cstate, "'proto' modifier applied to ip host");
2201
0
          YYABORT;
2202
10
          } 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
10
          CHECK_PTR_VAL(((yyval.blk).b = gen_ncode(cstate, (yyvsp[0].s), 0, (yyval.blk).q)));
2207
10
        }
2208
0
#line 2209 "/src/libpcap/build/grammar.c"
2209
0
    break;
2210
2211
0
  case 19:
2212
0
#line 472 "/src/libpcap/build/grammar.y"
2213
0
                                {
2214
0
          CHECK_PTR_VAL((yyvsp[-2].s));
2215
0
#ifdef INET6
2216
0
          CHECK_PTR_VAL(((yyval.blk).b = gen_mcode6(cstate, (yyvsp[-2].s), NULL, (yyvsp[0].h),
2217
0
            (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
0
        }
2224
0
#line 2225 "/src/libpcap/build/grammar.c"
2225
0
    break;
2226
2227
0
  case 20:
2228
0
#line 483 "/src/libpcap/build/grammar.y"
2229
0
                                {
2230
0
          CHECK_PTR_VAL((yyvsp[0].s));
2231
0
#ifdef INET6
2232
0
          CHECK_PTR_VAL(((yyval.blk).b = gen_mcode6(cstate, (yyvsp[0].s), 0, 128,
2233
0
            (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
0
        }
2240
0
#line 2241 "/src/libpcap/build/grammar.c"
2241
0
    break;
2242
2243
0
  case 21:
2244
0
#line 494 "/src/libpcap/build/grammar.y"
2245
0
                                { 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
5
  case 22:
2250
5
#line 495 "/src/libpcap/build/grammar.y"
2251
5
                                { 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
1.87k
  case 24:
2262
1.87k
#line 498 "/src/libpcap/build/grammar.y"
2263
1.87k
                                { (yyval.blk) = (yyvsp[-1].blk); }
2264
1.87k
#line 2265 "/src/libpcap/build/grammar.c"
2265
1.87k
    break;
2266
2267
151
  case 25:
2268
151
#line 500 "/src/libpcap/build/grammar.y"
2269
151
                                { (yyval.blk) = (yyvsp[-1].blk); }
2270
151
#line 2271 "/src/libpcap/build/grammar.c"
2271
151
    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
0
  case 29:
2286
0
#line 506 "/src/libpcap/build/grammar.y"
2287
0
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_ncode(cstate, NULL, (yyvsp[0].h),
2288
0
               (yyval.blk).q = (yyvsp[-1].blk).q))); }
2289
0
#line 2290 "/src/libpcap/build/grammar.c"
2290
0
    break;
2291
2292
1.34k
  case 32:
2293
1.34k
#line 511 "/src/libpcap/build/grammar.y"
2294
1.34k
                                { gen_not((yyvsp[0].blk).b); (yyval.blk) = (yyvsp[0].blk); }
2295
1.34k
#line 2296 "/src/libpcap/build/grammar.c"
2296
1.34k
    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
0
  case 34:
2305
0
#line 514 "/src/libpcap/build/grammar.y"
2306
0
                                { QSET((yyval.blk).q, (yyvsp[-1].i), (yyvsp[0].i), Q_DEFAULT); }
2307
0
#line 2308 "/src/libpcap/build/grammar.c"
2308
0
    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
0
  case 40:
2348
0
#line 528 "/src/libpcap/build/grammar.y"
2349
0
                                { (yyval.blk).b = (yyvsp[-1].blk).b; (yyval.blk).q = (yyvsp[-2].blk).q; }
2350
0
#line 2351 "/src/libpcap/build/grammar.c"
2351
0
    break;
2352
2353
448
  case 41:
2354
448
#line 529 "/src/libpcap/build/grammar.y"
2355
448
                                { 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
893
  case 42:
2360
893
#line 530 "/src/libpcap/build/grammar.y"
2361
893
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_relation(cstate, (yyvsp[-1].i), (yyvsp[-2].a), (yyvsp[0].a), 0)));
2362
893
          (yyval.blk).q = qerr; }
2363
0
#line 2364 "/src/libpcap/build/grammar.c"
2364
0
    break;
2365
2366
612
  case 43:
2367
612
#line 532 "/src/libpcap/build/grammar.y"
2368
612
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_relation(cstate, (yyvsp[-1].i), (yyvsp[-2].a), (yyvsp[0].a), 1)));
2369
612
          (yyval.blk).q = qerr; }
2370
0
#line 2371 "/src/libpcap/build/grammar.c"
2371
0
    break;
2372
2373
0
  case 44:
2374
0
#line 534 "/src/libpcap/build/grammar.y"
2375
0
                                { (yyval.blk).b = (yyvsp[0].rblk); (yyval.blk).q = qerr; }
2376
0
#line 2377 "/src/libpcap/build/grammar.c"
2377
0
    break;
2378
2379
0
  case 45:
2380
0
#line 535 "/src/libpcap/build/grammar.y"
2381
0
                                { 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
0
  case 48:
2398
0
#line 538 "/src/libpcap/build/grammar.y"
2399
0
                                { 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
0
  case 49:
2404
0
#line 539 "/src/libpcap/build/grammar.y"
2405
0
                                { (yyval.blk).b = (yyvsp[0].blk).b; (yyval.blk).q = qerr; }
2406
0
#line 2407 "/src/libpcap/build/grammar.c"
2407
0
    break;
2408
2409
340
  case 51:
2410
340
#line 543 "/src/libpcap/build/grammar.y"
2411
340
                                { (yyval.i) = Q_DEFAULT; }
2412
340
#line 2413 "/src/libpcap/build/grammar.c"
2413
340
    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
0
  case 53:
2422
0
#line 547 "/src/libpcap/build/grammar.y"
2423
0
                                { (yyval.i) = Q_DST; }
2424
0
#line 2425 "/src/libpcap/build/grammar.c"
2425
0
    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
0
  case 62:
2476
0
#line 556 "/src/libpcap/build/grammar.y"
2477
0
                                { (yyval.i) = Q_RA; }
2478
0
#line 2479 "/src/libpcap/build/grammar.c"
2479
0
    break;
2480
2481
0
  case 63:
2482
0
#line 557 "/src/libpcap/build/grammar.y"
2483
0
                                { (yyval.i) = Q_TA; }
2484
0
#line 2485 "/src/libpcap/build/grammar.c"
2485
0
    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
1
  case 69:
2518
1
#line 568 "/src/libpcap/build/grammar.y"
2519
1
                                { (yyval.i) = Q_LINK; }
2520
1
#line 2521 "/src/libpcap/build/grammar.c"
2521
1
    break;
2522
2523
0
  case 70:
2524
0
#line 569 "/src/libpcap/build/grammar.y"
2525
0
                                { (yyval.i) = Q_IP; }
2526
0
#line 2527 "/src/libpcap/build/grammar.c"
2527
0
    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
0
  case 74:
2548
0
#line 573 "/src/libpcap/build/grammar.y"
2549
0
                                { (yyval.i) = Q_TCP; }
2550
0
#line 2551 "/src/libpcap/build/grammar.c"
2551
0
    break;
2552
2553
0
  case 75:
2554
0
#line 574 "/src/libpcap/build/grammar.y"
2555
0
                                { (yyval.i) = Q_UDP; }
2556
0
#line 2557 "/src/libpcap/build/grammar.c"
2557
0
    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
0
  case 85:
2614
0
#line 584 "/src/libpcap/build/grammar.y"
2615
0
                                { (yyval.i) = Q_LAT; }
2616
0
#line 2617 "/src/libpcap/build/grammar.c"
2617
0
    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
0
  case 89:
2638
0
#line 588 "/src/libpcap/build/grammar.y"
2639
0
                                { (yyval.i) = Q_IPV6; }
2640
0
#line 2641 "/src/libpcap/build/grammar.c"
2641
0
    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
167
  case 91:
2650
167
#line 590 "/src/libpcap/build/grammar.y"
2651
167
                                { (yyval.i) = Q_AH; }
2652
167
#line 2653 "/src/libpcap/build/grammar.c"
2653
167
    break;
2654
2655
0
  case 92:
2656
0
#line 591 "/src/libpcap/build/grammar.y"
2657
0
                                { (yyval.i) = Q_ESP; }
2658
0
#line 2659 "/src/libpcap/build/grammar.c"
2659
0
    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
103
  case 96:
2680
103
#line 595 "/src/libpcap/build/grammar.y"
2681
103
                                { (yyval.i) = Q_ISIS_L1; }
2682
103
#line 2683 "/src/libpcap/build/grammar.c"
2683
103
    break;
2684
2685
183
  case 97:
2686
183
#line 596 "/src/libpcap/build/grammar.y"
2687
183
                                { (yyval.i) = Q_ISIS_L2; }
2688
183
#line 2689 "/src/libpcap/build/grammar.c"
2689
183
    break;
2690
2691
0
  case 98:
2692
0
#line 597 "/src/libpcap/build/grammar.y"
2693
0
                                { (yyval.i) = Q_ISIS_IIH; }
2694
0
#line 2695 "/src/libpcap/build/grammar.c"
2695
0
    break;
2696
2697
0
  case 99:
2698
0
#line 598 "/src/libpcap/build/grammar.y"
2699
0
                                { (yyval.i) = Q_ISIS_LSP; }
2700
0
#line 2701 "/src/libpcap/build/grammar.c"
2701
0
    break;
2702
2703
0
  case 100:
2704
0
#line 599 "/src/libpcap/build/grammar.y"
2705
0
                                { (yyval.i) = Q_ISIS_SNP; }
2706
0
#line 2707 "/src/libpcap/build/grammar.c"
2707
0
    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
0
  case 104:
2728
0
#line 603 "/src/libpcap/build/grammar.y"
2729
0
                                { (yyval.i) = Q_STP; }
2730
0
#line 2731 "/src/libpcap/build/grammar.c"
2731
0
    break;
2732
2733
0
  case 105:
2734
0
#line 604 "/src/libpcap/build/grammar.y"
2735
0
                                { (yyval.i) = Q_IPX; }
2736
0
#line 2737 "/src/libpcap/build/grammar.c"
2737
0
    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
0
  case 125:
2854
0
#line 625 "/src/libpcap/build/grammar.y"
2855
0
                                { (yyval.rblk) = (yyvsp[0].rblk); }
2856
0
#line 2857 "/src/libpcap/build/grammar.c"
2857
0
    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
0
  case 127:
2866
0
#line 627 "/src/libpcap/build/grammar.y"
2867
0
                                { (yyval.rblk) = (yyvsp[0].rblk); }
2868
0
#line 2869 "/src/libpcap/build/grammar.c"
2869
0
    break;
2870
2871
0
  case 128:
2872
0
#line 630 "/src/libpcap/build/grammar.y"
2873
0
                                { CHECK_PTR_VAL((yyvsp[0].s)); CHECK_PTR_VAL(((yyval.rblk) = gen_pf_ifname(cstate, (yyvsp[0].s)))); }
2874
0
#line 2875 "/src/libpcap/build/grammar.c"
2875
0
    break;
2876
2877
0
  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
0
  case 143:
3020
0
#line 714 "/src/libpcap/build/grammar.y"
3021
0
                                { CHECK_PTR_VAL(((yyval.rblk) = gen_llc(cstate))); }
3022
0
#line 3023 "/src/libpcap/build/grammar.c"
3023
0
    break;
3024
3025
0
  case 144:
3026
0
#line 715 "/src/libpcap/build/grammar.y"
3027
0
                                { CHECK_PTR_VAL((yyvsp[0].s));
3028
0
          if (pcap_strcasecmp((yyvsp[0].s), "i") == 0) {
3029
0
          CHECK_PTR_VAL(((yyval.rblk) = gen_llc_i(cstate)));
3030
0
          } else if (pcap_strcasecmp((yyvsp[0].s), "s") == 0) {
3031
0
          CHECK_PTR_VAL(((yyval.rblk) = gen_llc_s(cstate)));
3032
0
          } else if (pcap_strcasecmp((yyvsp[0].s), "u") == 0) {
3033
0
          CHECK_PTR_VAL(((yyval.rblk) = gen_llc_u(cstate)));
3034
0
          } else {
3035
0
          int subtype;
3036
3037
0
          subtype = str2tok((yyvsp[0].s), llc_s_subtypes);
3038
0
          if (subtype != -1) {
3039
0
            CHECK_PTR_VAL(((yyval.rblk) = gen_llc_s_subtype(cstate, subtype)));
3040
0
          } else {
3041
0
            subtype = str2tok((yyvsp[0].s), llc_u_subtypes);
3042
0
            if (subtype == -1) {
3043
0
              bpf_set_error(cstate, "unknown LLC type name \"%s\"", (yyvsp[0].s));
3044
0
              YYABORT;
3045
0
            }
3046
0
            CHECK_PTR_VAL(((yyval.rblk) = gen_llc_u_subtype(cstate, subtype)));
3047
0
          }
3048
0
          }
3049
0
        }
3050
0
#line 3051 "/src/libpcap/build/grammar.c"
3051
0
    break;
3052
3053
0
  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
234
  case 151:
3103
234
#line 766 "/src/libpcap/build/grammar.y"
3104
234
                                { (yyval.i) = BPF_JGT; }
3105
234
#line 3106 "/src/libpcap/build/grammar.c"
3106
234
    break;
3107
3108
37
  case 152:
3109
37
#line 767 "/src/libpcap/build/grammar.y"
3110
37
                                { (yyval.i) = BPF_JGE; }
3111
37
#line 3112 "/src/libpcap/build/grammar.c"
3112
37
    break;
3113
3114
645
  case 153:
3115
645
#line 768 "/src/libpcap/build/grammar.y"
3116
645
                                { (yyval.i) = BPF_JEQ; }
3117
645
#line 3118 "/src/libpcap/build/grammar.c"
3118
645
    break;
3119
3120
22
  case 154:
3121
22
#line 770 "/src/libpcap/build/grammar.y"
3122
22
                                { (yyval.i) = BPF_JGT; }
3123
22
#line 3124 "/src/libpcap/build/grammar.c"
3124
22
    break;
3125
3126
606
  case 155:
3127
606
#line 771 "/src/libpcap/build/grammar.y"
3128
606
                                { (yyval.i) = BPF_JGE; }
3129
606
#line 3130 "/src/libpcap/build/grammar.c"
3130
606
    break;
3131
3132
6
  case 156:
3133
6
#line 772 "/src/libpcap/build/grammar.y"
3134
6
                                { (yyval.i) = BPF_JEQ; }
3135
6
#line 3136 "/src/libpcap/build/grammar.c"
3136
6
    break;
3137
3138
7.15k
  case 157:
3139
7.15k
#line 774 "/src/libpcap/build/grammar.y"
3140
7.15k
                                { CHECK_PTR_VAL(((yyval.a) = gen_loadi(cstate, (yyvsp[0].h)))); }
3141
7.15k
#line 3142 "/src/libpcap/build/grammar.c"
3142
7.15k
    break;
3143
3144
7.15k
  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
159
  case 161:
3157
159
#line 779 "/src/libpcap/build/grammar.y"
3158
159
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_ADD, (yyvsp[-2].a), (yyvsp[0].a)))); }
3159
159
#line 3160 "/src/libpcap/build/grammar.c"
3160
159
    break;
3161
3162
916
  case 162:
3163
916
#line 780 "/src/libpcap/build/grammar.y"
3164
916
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_SUB, (yyvsp[-2].a), (yyvsp[0].a)))); }
3165
916
#line 3166 "/src/libpcap/build/grammar.c"
3166
916
    break;
3167
3168
916
  case 163:
3169
151
#line 781 "/src/libpcap/build/grammar.y"
3170
151
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_MUL, (yyvsp[-2].a), (yyvsp[0].a)))); }
3171
151
#line 3172 "/src/libpcap/build/grammar.c"
3172
151
    break;
3173
3174
766
  case 164:
3175
766
#line 782 "/src/libpcap/build/grammar.y"
3176
766
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_DIV, (yyvsp[-2].a), (yyvsp[0].a)))); }
3177
759
#line 3178 "/src/libpcap/build/grammar.c"
3178
759
    break;
3179
3180
759
  case 165:
3181
441
#line 783 "/src/libpcap/build/grammar.y"
3182
441
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_MOD, (yyvsp[-2].a), (yyvsp[0].a)))); }
3183
433
#line 3184 "/src/libpcap/build/grammar.c"
3184
433
    break;
3185
3186
1.01k
  case 166:
3187
1.01k
#line 784 "/src/libpcap/build/grammar.y"
3188
1.01k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_AND, (yyvsp[-2].a), (yyvsp[0].a)))); }
3189
1.01k
#line 3190 "/src/libpcap/build/grammar.c"
3190
1.01k
    break;
3191
3192
1.01k
  case 167:
3193
163
#line 785 "/src/libpcap/build/grammar.y"
3194
163
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_OR, (yyvsp[-2].a), (yyvsp[0].a)))); }
3195
163
#line 3196 "/src/libpcap/build/grammar.c"
3196
163
    break;
3197
3198
163
  case 168:
3199
17
#line 786 "/src/libpcap/build/grammar.y"
3200
17
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_XOR, (yyvsp[-2].a), (yyvsp[0].a)))); }
3201
17
#line 3202 "/src/libpcap/build/grammar.c"
3202
17
    break;
3203
3204
22
  case 169:
3205
22
#line 787 "/src/libpcap/build/grammar.y"
3206
22
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_LSH, (yyvsp[-2].a), (yyvsp[0].a)))); }
3207
14
#line 3208 "/src/libpcap/build/grammar.c"
3208
14
    break;
3209
3210
14
  case 170:
3211
6
#line 788 "/src/libpcap/build/grammar.y"
3212
6
                                        { CHECK_PTR_VAL(((yyval.a) = gen_arth(cstate, BPF_RSH, (yyvsp[-2].a), (yyvsp[0].a)))); }
3213
3
#line 3214 "/src/libpcap/build/grammar.c"
3214
3
    break;
3215
3216
6.53k
  case 171:
3217
6.53k
#line 789 "/src/libpcap/build/grammar.y"
3218
6.53k
                                        { CHECK_PTR_VAL(((yyval.a) = gen_neg(cstate, (yyvsp[0].a)))); }
3219
6.53k
#line 3220 "/src/libpcap/build/grammar.c"
3220
6.53k
    break;
3221
3222
6.53k
  case 172:
3223
1
#line 790 "/src/libpcap/build/grammar.y"
3224
1
                                        { (yyval.a) = (yyvsp[-1].a); }
3225
1
#line 3226 "/src/libpcap/build/grammar.c"
3226
1
    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
1
  case 180:
3265
1
#line 800 "/src/libpcap/build/grammar.y"
3266
1
                                { (yyval.h) = (yyvsp[-1].h); }
3267
1
#line 3268 "/src/libpcap/build/grammar.c"
3268
1
    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
0
  case 183:
3283
0
#line 804 "/src/libpcap/build/grammar.y"
3284
0
                                { (yyval.i) = A_BCC; }
3285
0
#line 3286 "/src/libpcap/build/grammar.c"
3286
0
    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
0
  case 186:
3301
0
#line 807 "/src/libpcap/build/grammar.y"
3302
0
                                { (yyval.i) = A_SC; }
3303
0
#line 3304 "/src/libpcap/build/grammar.c"
3304
0
    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
0
  case 202:
3390
0
#line 836 "/src/libpcap/build/grammar.y"
3391
0
                                { (yyval.i) = M_LSSU; }
3392
0
#line 3393 "/src/libpcap/build/grammar.c"
3393
0
    break;
3394
3395
0
  case 203:
3396
0
#line 837 "/src/libpcap/build/grammar.y"
3397
0
                                { (yyval.i) = M_MSU; }
3398
0
#line 3399 "/src/libpcap/build/grammar.c"
3399
0
    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
0
  case 207:
3420
0
#line 843 "/src/libpcap/build/grammar.y"
3421
0
                                { (yyval.blk).mtp3fieldtype = M_SIO; }
3422
0
#line 3423 "/src/libpcap/build/grammar.c"
3423
0
    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
0
  case 210:
3438
0
#line 846 "/src/libpcap/build/grammar.y"
3439
0
                                { (yyval.blk).mtp3fieldtype = M_SLS; }
3440
0
#line 3441 "/src/libpcap/build/grammar.c"
3441
0
    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
0
  case 216:
3468
0
#line 853 "/src/libpcap/build/grammar.y"
3469
0
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_mtp3field_code(cstate, (yyvsp[-2].blk).mtp3fieldtype, (yyvsp[0].h), (yyvsp[-1].i), 0))); }
3470
0
#line 3471 "/src/libpcap/build/grammar.c"
3471
0
    break;
3472
3473
0
  case 217:
3474
0
#line 854 "/src/libpcap/build/grammar.y"
3475
0
                                { CHECK_PTR_VAL(((yyval.blk).b = gen_mtp3field_code(cstate, (yyvsp[-2].blk).mtp3fieldtype, (yyvsp[0].h), (yyvsp[-1].i), 1))); }
3476
0
#line 3477 "/src/libpcap/build/grammar.c"
3477
0
    break;
3478
3479
0
  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
0
  case 219:
3486
0
#line 857 "/src/libpcap/build/grammar.y"
3487
0
                    {
3488
0
  (yyval.blk).mtp3fieldtype = (yyvsp[-1].blk).mtp3fieldtype;
3489
0
  if ((yyval.blk).mtp3fieldtype == M_SIO ||
3490
0
      (yyval.blk).mtp3fieldtype == M_OPC ||
3491
0
      (yyval.blk).mtp3fieldtype == M_DPC ||
3492
0
      (yyval.blk).mtp3fieldtype == M_SLS ||
3493
0
      (yyval.blk).mtp3fieldtype == MH_SIO ||
3494
0
      (yyval.blk).mtp3fieldtype == MH_OPC ||
3495
0
      (yyval.blk).mtp3fieldtype == MH_DPC ||
3496
0
      (yyval.blk).mtp3fieldtype == MH_SLS)
3497
0
    CHECK_PTR_VAL(((yyval.blk).b = gen_mtp3field_code(cstate, (yyval.blk).mtp3fieldtype, (yyvsp[0].h), BPF_JEQ, 0)));
3498
0
  }
3499
0
#line 3500 "/src/libpcap/build/grammar.c"
3500
0
    break;
3501
3502
0
  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
21.6k
      default: break;
3512
51.9k
    }
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
51.7k
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3525
3526
51.7k
  YYPOPSTACK (yylen);
3527
51.7k
  yylen = 0;
3528
51.7k
  YY_STACK_PRINT (yyss, yyssp);
3529
3530
51.7k
  *++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
51.7k
  {
3536
51.7k
    const int yylhs = yyr1[yyn] - YYNTOKENS;
3537
51.7k
    const int yyi = yypgoto[yylhs] + *yyssp;
3538
51.7k
    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
3539
51.7k
               ? yytable[yyi]
3540
51.7k
               : yydefgoto[yylhs]);
3541
51.7k
  }
3542
3543
51.7k
  goto yynewstate;
3544
3545
3546
/*--------------------------------------.
3547
| yyerrlab -- here on detecting error.  |
3548
`--------------------------------------*/
3549
895
yyerrlab:
3550
  /* Make sure we have latest lookahead translation.  See comments at
3551
     user semantic actions for why this is necessary.  */
3552
895
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3553
3554
  /* If not already recovering from an error, report this error.  */
3555
895
  if (!yyerrstatus)
3556
895
    {
3557
895
      ++yynerrs;
3558
895
#if ! YYERROR_VERBOSE
3559
895
      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
895
    }
3593
3594
3595
3596
895
  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
895
  goto yyerrlab1;
3618
3619
3620
/*---------------------------------------------------.
3621
| yyerrorlab -- error raised explicitly by YYERROR.  |
3622
`---------------------------------------------------*/
3623
895
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
895
yyerrlab1:
3642
895
  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3643
3644
895
  for (;;)
3645
3.70k
    {
3646
3.70k
      yyn = yypact[yystate];
3647
3.70k
      if (!yypact_value_is_default (yyn))
3648
2.81k
        {
3649
2.81k
          yyn += YYTERROR;
3650
2.81k
          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
2.81k
        }
3657
3658
      /* Pop the current state because it cannot handle the error token.  */
3659
3.70k
      if (yyssp == yyss)
3660
895
        YYABORT;
3661
3662
3663
2.81k
      yydestruct ("Error: popping",
3664
2.81k
                  yystos[yystate], yyvsp, yyscanner, cstate);
3665
2.81k
      YYPOPSTACK (1);
3666
2.81k
      yystate = *yyssp;
3667
2.81k
      YY_STACK_PRINT (yyss, yyssp);
3668
2.81k
    }
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
2.33k
yyacceptlab:
3686
2.33k
  yyresult = 0;
3687
2.33k
  goto yyreturn;
3688
3689
3690
/*-----------------------------------.
3691
| yyabortlab -- YYABORT comes here.  |
3692
`-----------------------------------*/
3693
1.06k
yyabortlab:
3694
1.06k
  yyresult = 1;
3695
1.06k
  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
3.40k
yyreturn:
3713
3.40k
  if (yychar != YYEMPTY)
3714
1.05k
    {
3715
      /* Make sure we have latest lookahead translation.  See comments at
3716
         user semantic actions for why this is necessary.  */
3717
1.05k
      yytoken = YYTRANSLATE (yychar);
3718
1.05k
      yydestruct ("Cleanup: discarding lookahead",
3719
1.05k
                  yytoken, &yylval, yyscanner, cstate);
3720
1.05k
    }
3721
  /* Do not reclaim the symbols of the rule whose action triggered
3722
     this YYABORT or YYACCEPT.  */
3723
3.40k
  YYPOPSTACK (yylen);
3724
3.40k
  YY_STACK_PRINT (yyss, yyssp);
3725
8.42k
  while (yyssp != yyss)
3726
5.02k
    {
3727
5.02k
      yydestruct ("Cleanup: popping",
3728
5.02k
                  yystos[+*yyssp], yyvsp, yyscanner, cstate);
3729
5.02k
      YYPOPSTACK (1);
3730
5.02k
    }
3731
3.40k
#ifndef yyoverflow
3732
3.40k
  if (yyss != yyssa)
3733
0
    YYSTACK_FREE (yyss);
3734
3.40k
#endif
3735
#if YYERROR_VERBOSE
3736
  if (yymsg != yymsgbuf)
3737
    YYSTACK_FREE (yymsg);
3738
#endif
3739
3.40k
  return yyresult;
3740
0
}
3741
#line 873 "/src/libpcap/build/grammar.y"
3742