ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.c
Revision: 8964
Committed: Sat May 11 21:07:44 2019 UTC (6 years, 3 months ago) by michael
Content type: text/x-csrc
File size: 218482 byte(s)
Log Message: 
- Recreate parser files

File Contents

# Content
1 /* A Bison parser, made by GNU Bison 3.3.2. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2019 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.3.2"
52
53 /* Skeleton name. */
54 #define YYSKELETON_NAME "yacc.c"
55
56 /* Pure parsers. */
57 #define YYPURE 0
58
59 /* Push parsers. */
60 #define YYPUSH 0
61
62 /* Pull parsers. */
63 #define YYPULL 1
64
65
66
67
68 /* First part of user prologue. */
69 #line 28 "conf_parser.y" /* yacc.c:337 */
70
71
72 #include "config.h"
73 #include "stdinc.h"
74 #include "ircd.h"
75 #include "list.h"
76 #include "parse.h"
77 #include "conf.h"
78 #include "conf_class.h"
79 #include "conf_cluster.h"
80 #include "conf_gecos.h"
81 #include "conf_pseudo.h"
82 #include "conf_resv.h"
83 #include "conf_service.h"
84 #include "conf_shared.h"
85 #include "event.h"
86 #include "id.h"
87 #include "log.h"
88 #include "irc_string.h"
89 #include "memory.h"
90 #include "modules.h"
91 #include "server.h"
92 #include "hostmask.h"
93 #include "listener.h"
94 #include "user.h"
95 #include "motd.h"
96
97 int yylex(void);
98
99 static struct
100 {
101 struct
102 {
103 dlink_list list;
104 } mask,
105 leaf,
106 hub;
107
108 struct
109 {
110 char buf[IRCD_BUFSIZE];
111 } name,
112 nick,
113 user,
114 host,
115 addr,
116 bind,
117 file,
118 ciph,
119 cert,
120 rpass,
121 spass,
122 whois,
123 class,
124 target,
125 prepend,
126 command;
127
128 struct
129 {
130 unsigned int value;
131 } flags,
132 modes,
133 size,
134 type,
135 port,
136 aftype,
137 ping_freq,
138 max_perip_local,
139 max_perip_global,
140 con_freq,
141 min_idle,
142 max_idle,
143 max_total,
144 max_sendq,
145 max_recvq,
146 max_channels,
147 cidr_bitlen_ipv4,
148 cidr_bitlen_ipv6,
149 number_per_cidr;
150 } block_state;
151
152 static void
153 reset_block_state(void)
154 {
155 dlink_node *node = NULL, *node_next = NULL;
156
157 DLINK_FOREACH_SAFE(node, node_next, block_state.mask.list.head)
158 {
159 xfree(node->data);
160 dlinkDelete(node, &block_state.mask.list);
161 free_dlink_node(node);
162 }
163
164 DLINK_FOREACH_SAFE(node, node_next, block_state.leaf.list.head)
165 {
166 xfree(node->data);
167 dlinkDelete(node, &block_state.leaf.list);
168 free_dlink_node(node);
169 }
170
171 DLINK_FOREACH_SAFE(node, node_next, block_state.hub.list.head)
172 {
173 xfree(node->data);
174 dlinkDelete(node, &block_state.hub.list);
175 free_dlink_node(node);
176 }
177
178 memset(&block_state, 0, sizeof(block_state));
179 }
180
181
182 #line 183 "conf_parser.c" /* yacc.c:337 */
183 # ifndef YY_NULLPTR
184 # if defined __cplusplus
185 # if 201103L <= __cplusplus
186 # define YY_NULLPTR nullptr
187 # else
188 # define YY_NULLPTR 0
189 # endif
190 # else
191 # define YY_NULLPTR ((void*)0)
192 # endif
193 # endif
194
195 /* Enabling verbose error messages. */
196 #ifdef YYERROR_VERBOSE
197 # undef YYERROR_VERBOSE
198 # define YYERROR_VERBOSE 1
199 #else
200 # define YYERROR_VERBOSE 0
201 #endif
202
203 /* In a future release of Bison, this section will be replaced
204 by #include "y.tab.h". */
205 #ifndef YY_YY_CONF_PARSER_H_INCLUDED
206 # define YY_YY_CONF_PARSER_H_INCLUDED
207 /* Debug traces. */
208 #ifndef YYDEBUG
209 # define YYDEBUG 0
210 #endif
211 #if YYDEBUG
212 extern int yydebug;
213 #endif
214
215 /* Token type. */
216 #ifndef YYTOKENTYPE
217 # define YYTOKENTYPE
218 enum yytokentype
219 {
220 ACCEPT_PASSWORD = 258,
221 ADMIN = 259,
222 AFTYPE = 260,
223 ANTI_NICK_FLOOD = 261,
224 ANTI_SPAM_EXIT_MESSAGE_TIME = 262,
225 AUTOCONN = 263,
226 AWAY_COUNT = 264,
227 AWAY_TIME = 265,
228 BYTES = 266,
229 KBYTES = 267,
230 MBYTES = 268,
231 CALLER_ID_WAIT = 269,
232 CAN_FLOOD = 270,
233 CHANNEL = 271,
234 CIDR_BITLEN_IPV4 = 272,
235 CIDR_BITLEN_IPV6 = 273,
236 CLASS = 274,
237 CLOSE = 275,
238 CONNECT = 276,
239 CONNECTFREQ = 277,
240 CYCLE_ON_HOST_CHANGE = 278,
241 DEFAULT_FLOODCOUNT = 279,
242 DEFAULT_FLOODTIME = 280,
243 DEFAULT_JOIN_FLOOD_COUNT = 281,
244 DEFAULT_JOIN_FLOOD_TIME = 282,
245 DEFAULT_MAX_CLIENTS = 283,
246 DENY = 284,
247 DESCRIPTION = 285,
248 DIE = 286,
249 DISABLE_AUTH = 287,
250 DISABLE_FAKE_CHANNELS = 288,
251 DISABLE_REMOTE_COMMANDS = 289,
252 DLINE_MIN_CIDR = 290,
253 DLINE_MIN_CIDR6 = 291,
254 DOTS_IN_IDENT = 292,
255 EMAIL = 293,
256 ENCRYPTED = 294,
257 EXCEED_LIMIT = 295,
258 EXEMPT = 296,
259 EXPIRATION = 297,
260 FAILED_OPER_NOTICE = 298,
261 FLATTEN_LINKS = 299,
262 FLATTEN_LINKS_DELAY = 300,
263 FLATTEN_LINKS_FILE = 301,
264 GECOS = 302,
265 GENERAL = 303,
266 HIDDEN = 304,
267 HIDDEN_NAME = 305,
268 HIDE_CHANS = 306,
269 HIDE_IDLE = 307,
270 HIDE_IDLE_FROM_OPERS = 308,
271 HIDE_SERVER_IPS = 309,
272 HIDE_SERVERS = 310,
273 HIDE_SERVICES = 311,
274 HOST = 312,
275 HUB = 313,
276 HUB_MASK = 314,
277 INVISIBLE_ON_CONNECT = 315,
278 INVITE_CLIENT_COUNT = 316,
279 INVITE_CLIENT_TIME = 317,
280 INVITE_DELAY_CHANNEL = 318,
281 INVITE_EXPIRE_TIME = 319,
282 IP = 320,
283 IRCD_AUTH = 321,
284 IRCD_FLAGS = 322,
285 IRCD_SID = 323,
286 JOIN = 324,
287 KILL = 325,
288 KILL_CHASE_TIME_LIMIT = 326,
289 KLINE = 327,
290 KLINE_EXEMPT = 328,
291 KLINE_MIN_CIDR = 329,
292 KLINE_MIN_CIDR6 = 330,
293 KNOCK_CLIENT_COUNT = 331,
294 KNOCK_CLIENT_TIME = 332,
295 KNOCK_DELAY_CHANNEL = 333,
296 LEAF_MASK = 334,
297 LISTEN = 335,
298 MASK = 336,
299 MAX_ACCEPT = 337,
300 MAX_BANS = 338,
301 MAX_BANS_LARGE = 339,
302 MAX_CHANNELS = 340,
303 MAX_IDLE = 341,
304 MAX_INVITES = 342,
305 MAX_NICK_CHANGES = 343,
306 MAX_NICK_LENGTH = 344,
307 MAX_NICK_TIME = 345,
308 MAX_NUMBER = 346,
309 MAX_TARGETS = 347,
310 MAX_TOPIC_LENGTH = 348,
311 MAX_WATCH = 349,
312 MIN_IDLE = 350,
313 MIN_NONWILDCARD = 351,
314 MIN_NONWILDCARD_SIMPLE = 352,
315 MODULE = 353,
316 MODULES = 354,
317 MOTD = 355,
318 NAME = 356,
319 NEED_IDENT = 357,
320 NEED_PASSWORD = 358,
321 NETWORK_DESC = 359,
322 NETWORK_NAME = 360,
323 NICK = 361,
324 NO_OPER_FLOOD = 362,
325 NO_TILDE = 363,
326 NUMBER = 364,
327 NUMBER_PER_CIDR = 365,
328 NUMBER_PER_IP_GLOBAL = 366,
329 NUMBER_PER_IP_LOCAL = 367,
330 OPER_ONLY_UMODES = 368,
331 OPER_UMODES = 369,
332 OPERATOR = 370,
333 OPERS_BYPASS_CALLERID = 371,
334 PACE_WAIT = 372,
335 PACE_WAIT_SIMPLE = 373,
336 PASSWORD = 374,
337 PATH = 375,
338 PING_COOKIE = 376,
339 PING_TIME = 377,
340 PORT = 378,
341 QSTRING = 379,
342 RANDOM_IDLE = 380,
343 REASON = 381,
344 REDIRPORT = 382,
345 REDIRSERV = 383,
346 REHASH = 384,
347 REMOTE = 385,
348 REMOTEBAN = 386,
349 RESV = 387,
350 RESV_EXEMPT = 388,
351 RSA_PRIVATE_KEY_FILE = 389,
352 SECONDS = 390,
353 MINUTES = 391,
354 HOURS = 392,
355 DAYS = 393,
356 WEEKS = 394,
357 MONTHS = 395,
358 YEARS = 396,
359 SEND_PASSWORD = 397,
360 SENDQ = 398,
361 SERVERHIDE = 399,
362 SERVERINFO = 400,
363 SHORT_MOTD = 401,
364 SPOOF = 402,
365 SPOOF_NOTICE = 403,
366 SQUIT = 404,
367 SSL_CERTIFICATE_FILE = 405,
368 SSL_CERTIFICATE_FINGERPRINT = 406,
369 SSL_CONNECTION_REQUIRED = 407,
370 SSL_DH_ELLIPTIC_CURVE = 408,
371 SSL_DH_PARAM_FILE = 409,
372 SSL_MESSAGE_DIGEST_ALGORITHM = 410,
373 STATS_E_DISABLED = 411,
374 STATS_I_OPER_ONLY = 412,
375 STATS_K_OPER_ONLY = 413,
376 STATS_M_OPER_ONLY = 414,
377 STATS_O_OPER_ONLY = 415,
378 STATS_P_OPER_ONLY = 416,
379 STATS_U_OPER_ONLY = 417,
380 T_ALL = 418,
381 T_BIND = 419,
382 T_BOTS = 420,
383 T_CALLERID = 421,
384 T_CCONN = 422,
385 T_COMMAND = 423,
386 T_CLUSTER = 424,
387 T_DEAF = 425,
388 T_DEBUG = 426,
389 T_DLINE = 427,
390 T_EXTERNAL = 428,
391 T_FARCONNECT = 429,
392 T_FILE = 430,
393 T_FULL = 431,
394 T_GLOBOPS = 432,
395 T_INVISIBLE = 433,
396 T_IPV4 = 434,
397 T_IPV6 = 435,
398 T_LOCOPS = 436,
399 T_LOG = 437,
400 T_NCHANGE = 438,
401 T_NONONREG = 439,
402 T_OPME = 440,
403 T_PREPEND = 441,
404 T_PSEUDO = 442,
405 T_RECVQ = 443,
406 T_REJ = 444,
407 T_RESTART = 445,
408 T_SERVER = 446,
409 T_SERVICE = 447,
410 T_SERVNOTICE = 448,
411 T_SET = 449,
412 T_SHARED = 450,
413 T_SIZE = 451,
414 T_SKILL = 452,
415 T_SOFTCALLERID = 453,
416 T_SPY = 454,
417 T_SSL = 455,
418 T_SSL_CIPHER_LIST = 456,
419 T_TARGET = 457,
420 T_UMODES = 458,
421 T_UNAUTH = 459,
422 T_UNDLINE = 460,
423 T_UNLIMITED = 461,
424 T_UNRESV = 462,
425 T_UNXLINE = 463,
426 T_WALLOP = 464,
427 T_WALLOPS = 465,
428 T_WEBIRC = 466,
429 TBOOL = 467,
430 THROTTLE_COUNT = 468,
431 THROTTLE_TIME = 469,
432 TMASKED = 470,
433 TS_MAX_DELTA = 471,
434 TS_WARN_DELTA = 472,
435 TWODOTS = 473,
436 TYPE = 474,
437 UNKLINE = 475,
438 USE_LOGGING = 476,
439 USER = 477,
440 VHOST = 478,
441 VHOST6 = 479,
442 WARN_NO_CONNECT_BLOCK = 480,
443 WHOIS = 481,
444 WHOWAS_HISTORY_LENGTH = 482,
445 XLINE = 483,
446 XLINE_EXEMPT = 484
447 };
448 #endif
449 /* Tokens. */
450 #define ACCEPT_PASSWORD 258
451 #define ADMIN 259
452 #define AFTYPE 260
453 #define ANTI_NICK_FLOOD 261
454 #define ANTI_SPAM_EXIT_MESSAGE_TIME 262
455 #define AUTOCONN 263
456 #define AWAY_COUNT 264
457 #define AWAY_TIME 265
458 #define BYTES 266
459 #define KBYTES 267
460 #define MBYTES 268
461 #define CALLER_ID_WAIT 269
462 #define CAN_FLOOD 270
463 #define CHANNEL 271
464 #define CIDR_BITLEN_IPV4 272
465 #define CIDR_BITLEN_IPV6 273
466 #define CLASS 274
467 #define CLOSE 275
468 #define CONNECT 276
469 #define CONNECTFREQ 277
470 #define CYCLE_ON_HOST_CHANGE 278
471 #define DEFAULT_FLOODCOUNT 279
472 #define DEFAULT_FLOODTIME 280
473 #define DEFAULT_JOIN_FLOOD_COUNT 281
474 #define DEFAULT_JOIN_FLOOD_TIME 282
475 #define DEFAULT_MAX_CLIENTS 283
476 #define DENY 284
477 #define DESCRIPTION 285
478 #define DIE 286
479 #define DISABLE_AUTH 287
480 #define DISABLE_FAKE_CHANNELS 288
481 #define DISABLE_REMOTE_COMMANDS 289
482 #define DLINE_MIN_CIDR 290
483 #define DLINE_MIN_CIDR6 291
484 #define DOTS_IN_IDENT 292
485 #define EMAIL 293
486 #define ENCRYPTED 294
487 #define EXCEED_LIMIT 295
488 #define EXEMPT 296
489 #define EXPIRATION 297
490 #define FAILED_OPER_NOTICE 298
491 #define FLATTEN_LINKS 299
492 #define FLATTEN_LINKS_DELAY 300
493 #define FLATTEN_LINKS_FILE 301
494 #define GECOS 302
495 #define GENERAL 303
496 #define HIDDEN 304
497 #define HIDDEN_NAME 305
498 #define HIDE_CHANS 306
499 #define HIDE_IDLE 307
500 #define HIDE_IDLE_FROM_OPERS 308
501 #define HIDE_SERVER_IPS 309
502 #define HIDE_SERVERS 310
503 #define HIDE_SERVICES 311
504 #define HOST 312
505 #define HUB 313
506 #define HUB_MASK 314
507 #define INVISIBLE_ON_CONNECT 315
508 #define INVITE_CLIENT_COUNT 316
509 #define INVITE_CLIENT_TIME 317
510 #define INVITE_DELAY_CHANNEL 318
511 #define INVITE_EXPIRE_TIME 319
512 #define IP 320
513 #define IRCD_AUTH 321
514 #define IRCD_FLAGS 322
515 #define IRCD_SID 323
516 #define JOIN 324
517 #define KILL 325
518 #define KILL_CHASE_TIME_LIMIT 326
519 #define KLINE 327
520 #define KLINE_EXEMPT 328
521 #define KLINE_MIN_CIDR 329
522 #define KLINE_MIN_CIDR6 330
523 #define KNOCK_CLIENT_COUNT 331
524 #define KNOCK_CLIENT_TIME 332
525 #define KNOCK_DELAY_CHANNEL 333
526 #define LEAF_MASK 334
527 #define LISTEN 335
528 #define MASK 336
529 #define MAX_ACCEPT 337
530 #define MAX_BANS 338
531 #define MAX_BANS_LARGE 339
532 #define MAX_CHANNELS 340
533 #define MAX_IDLE 341
534 #define MAX_INVITES 342
535 #define MAX_NICK_CHANGES 343
536 #define MAX_NICK_LENGTH 344
537 #define MAX_NICK_TIME 345
538 #define MAX_NUMBER 346
539 #define MAX_TARGETS 347
540 #define MAX_TOPIC_LENGTH 348
541 #define MAX_WATCH 349
542 #define MIN_IDLE 350
543 #define MIN_NONWILDCARD 351
544 #define MIN_NONWILDCARD_SIMPLE 352
545 #define MODULE 353
546 #define MODULES 354
547 #define MOTD 355
548 #define NAME 356
549 #define NEED_IDENT 357
550 #define NEED_PASSWORD 358
551 #define NETWORK_DESC 359
552 #define NETWORK_NAME 360
553 #define NICK 361
554 #define NO_OPER_FLOOD 362
555 #define NO_TILDE 363
556 #define NUMBER 364
557 #define NUMBER_PER_CIDR 365
558 #define NUMBER_PER_IP_GLOBAL 366
559 #define NUMBER_PER_IP_LOCAL 367
560 #define OPER_ONLY_UMODES 368
561 #define OPER_UMODES 369
562 #define OPERATOR 370
563 #define OPERS_BYPASS_CALLERID 371
564 #define PACE_WAIT 372
565 #define PACE_WAIT_SIMPLE 373
566 #define PASSWORD 374
567 #define PATH 375
568 #define PING_COOKIE 376
569 #define PING_TIME 377
570 #define PORT 378
571 #define QSTRING 379
572 #define RANDOM_IDLE 380
573 #define REASON 381
574 #define REDIRPORT 382
575 #define REDIRSERV 383
576 #define REHASH 384
577 #define REMOTE 385
578 #define REMOTEBAN 386
579 #define RESV 387
580 #define RESV_EXEMPT 388
581 #define RSA_PRIVATE_KEY_FILE 389
582 #define SECONDS 390
583 #define MINUTES 391
584 #define HOURS 392
585 #define DAYS 393
586 #define WEEKS 394
587 #define MONTHS 395
588 #define YEARS 396
589 #define SEND_PASSWORD 397
590 #define SENDQ 398
591 #define SERVERHIDE 399
592 #define SERVERINFO 400
593 #define SHORT_MOTD 401
594 #define SPOOF 402
595 #define SPOOF_NOTICE 403
596 #define SQUIT 404
597 #define SSL_CERTIFICATE_FILE 405
598 #define SSL_CERTIFICATE_FINGERPRINT 406
599 #define SSL_CONNECTION_REQUIRED 407
600 #define SSL_DH_ELLIPTIC_CURVE 408
601 #define SSL_DH_PARAM_FILE 409
602 #define SSL_MESSAGE_DIGEST_ALGORITHM 410
603 #define STATS_E_DISABLED 411
604 #define STATS_I_OPER_ONLY 412
605 #define STATS_K_OPER_ONLY 413
606 #define STATS_M_OPER_ONLY 414
607 #define STATS_O_OPER_ONLY 415
608 #define STATS_P_OPER_ONLY 416
609 #define STATS_U_OPER_ONLY 417
610 #define T_ALL 418
611 #define T_BIND 419
612 #define T_BOTS 420
613 #define T_CALLERID 421
614 #define T_CCONN 422
615 #define T_COMMAND 423
616 #define T_CLUSTER 424
617 #define T_DEAF 425
618 #define T_DEBUG 426
619 #define T_DLINE 427
620 #define T_EXTERNAL 428
621 #define T_FARCONNECT 429
622 #define T_FILE 430
623 #define T_FULL 431
624 #define T_GLOBOPS 432
625 #define T_INVISIBLE 433
626 #define T_IPV4 434
627 #define T_IPV6 435
628 #define T_LOCOPS 436
629 #define T_LOG 437
630 #define T_NCHANGE 438
631 #define T_NONONREG 439
632 #define T_OPME 440
633 #define T_PREPEND 441
634 #define T_PSEUDO 442
635 #define T_RECVQ 443
636 #define T_REJ 444
637 #define T_RESTART 445
638 #define T_SERVER 446
639 #define T_SERVICE 447
640 #define T_SERVNOTICE 448
641 #define T_SET 449
642 #define T_SHARED 450
643 #define T_SIZE 451
644 #define T_SKILL 452
645 #define T_SOFTCALLERID 453
646 #define T_SPY 454
647 #define T_SSL 455
648 #define T_SSL_CIPHER_LIST 456
649 #define T_TARGET 457
650 #define T_UMODES 458
651 #define T_UNAUTH 459
652 #define T_UNDLINE 460
653 #define T_UNLIMITED 461
654 #define T_UNRESV 462
655 #define T_UNXLINE 463
656 #define T_WALLOP 464
657 #define T_WALLOPS 465
658 #define T_WEBIRC 466
659 #define TBOOL 467
660 #define THROTTLE_COUNT 468
661 #define THROTTLE_TIME 469
662 #define TMASKED 470
663 #define TS_MAX_DELTA 471
664 #define TS_WARN_DELTA 472
665 #define TWODOTS 473
666 #define TYPE 474
667 #define UNKLINE 475
668 #define USE_LOGGING 476
669 #define USER 477
670 #define VHOST 478
671 #define VHOST6 479
672 #define WARN_NO_CONNECT_BLOCK 480
673 #define WHOIS 481
674 #define WHOWAS_HISTORY_LENGTH 482
675 #define XLINE 483
676 #define XLINE_EXEMPT 484
677
678 /* Value type. */
679 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
680
681 union YYSTYPE
682 {
683 #line 141 "conf_parser.y" /* yacc.c:352 */
684
685 int number;
686 char *string;
687
688 #line 689 "conf_parser.c" /* yacc.c:352 */
689 };
690
691 typedef union YYSTYPE YYSTYPE;
692 # define YYSTYPE_IS_TRIVIAL 1
693 # define YYSTYPE_IS_DECLARED 1
694 #endif
695
696
697 extern YYSTYPE yylval;
698
699 int yyparse (void);
700
701 #endif /* !YY_YY_CONF_PARSER_H_INCLUDED */
702
703
704
705 #ifdef short
706 # undef short
707 #endif
708
709 #ifdef YYTYPE_UINT8
710 typedef YYTYPE_UINT8 yytype_uint8;
711 #else
712 typedef unsigned char yytype_uint8;
713 #endif
714
715 #ifdef YYTYPE_INT8
716 typedef YYTYPE_INT8 yytype_int8;
717 #else
718 typedef signed char yytype_int8;
719 #endif
720
721 #ifdef YYTYPE_UINT16
722 typedef YYTYPE_UINT16 yytype_uint16;
723 #else
724 typedef unsigned short yytype_uint16;
725 #endif
726
727 #ifdef YYTYPE_INT16
728 typedef YYTYPE_INT16 yytype_int16;
729 #else
730 typedef short yytype_int16;
731 #endif
732
733 #ifndef YYSIZE_T
734 # ifdef __SIZE_TYPE__
735 # define YYSIZE_T __SIZE_TYPE__
736 # elif defined size_t
737 # define YYSIZE_T size_t
738 # elif ! defined YYSIZE_T
739 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
740 # define YYSIZE_T size_t
741 # else
742 # define YYSIZE_T unsigned
743 # endif
744 #endif
745
746 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
747
748 #ifndef YY_
749 # if defined YYENABLE_NLS && YYENABLE_NLS
750 # if ENABLE_NLS
751 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
752 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
753 # endif
754 # endif
755 # ifndef YY_
756 # define YY_(Msgid) Msgid
757 # endif
758 #endif
759
760 #ifndef YY_ATTRIBUTE
761 # if (defined __GNUC__ \
762 && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
763 || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
764 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
765 # else
766 # define YY_ATTRIBUTE(Spec) /* empty */
767 # endif
768 #endif
769
770 #ifndef YY_ATTRIBUTE_PURE
771 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
772 #endif
773
774 #ifndef YY_ATTRIBUTE_UNUSED
775 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
776 #endif
777
778 /* Suppress unused-variable warnings by "using" E. */
779 #if ! defined lint || defined __GNUC__
780 # define YYUSE(E) ((void) (E))
781 #else
782 # define YYUSE(E) /* empty */
783 #endif
784
785 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
786 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
787 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
788 _Pragma ("GCC diagnostic push") \
789 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
790 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
791 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
792 _Pragma ("GCC diagnostic pop")
793 #else
794 # define YY_INITIAL_VALUE(Value) Value
795 #endif
796 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
797 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
798 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
799 #endif
800 #ifndef YY_INITIAL_VALUE
801 # define YY_INITIAL_VALUE(Value) /* Nothing. */
802 #endif
803
804
805 #if ! defined yyoverflow || YYERROR_VERBOSE
806
807 /* The parser invokes alloca or malloc; define the necessary symbols. */
808
809 # ifdef YYSTACK_USE_ALLOCA
810 # if YYSTACK_USE_ALLOCA
811 # ifdef __GNUC__
812 # define YYSTACK_ALLOC __builtin_alloca
813 # elif defined __BUILTIN_VA_ARG_INCR
814 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
815 # elif defined _AIX
816 # define YYSTACK_ALLOC __alloca
817 # elif defined _MSC_VER
818 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
819 # define alloca _alloca
820 # else
821 # define YYSTACK_ALLOC alloca
822 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
823 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
824 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
825 # ifndef EXIT_SUCCESS
826 # define EXIT_SUCCESS 0
827 # endif
828 # endif
829 # endif
830 # endif
831 # endif
832
833 # ifdef YYSTACK_ALLOC
834 /* Pacify GCC's 'empty if-body' warning. */
835 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
836 # ifndef YYSTACK_ALLOC_MAXIMUM
837 /* The OS might guarantee only one guard page at the bottom of the stack,
838 and a page size can be as small as 4096 bytes. So we cannot safely
839 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
840 to allow for a few compiler-allocated temporary stack slots. */
841 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
842 # endif
843 # else
844 # define YYSTACK_ALLOC YYMALLOC
845 # define YYSTACK_FREE YYFREE
846 # ifndef YYSTACK_ALLOC_MAXIMUM
847 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
848 # endif
849 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
850 && ! ((defined YYMALLOC || defined malloc) \
851 && (defined YYFREE || defined free)))
852 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
853 # ifndef EXIT_SUCCESS
854 # define EXIT_SUCCESS 0
855 # endif
856 # endif
857 # ifndef YYMALLOC
858 # define YYMALLOC malloc
859 # if ! defined malloc && ! defined EXIT_SUCCESS
860 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
861 # endif
862 # endif
863 # ifndef YYFREE
864 # define YYFREE free
865 # if ! defined free && ! defined EXIT_SUCCESS
866 void free (void *); /* INFRINGES ON USER NAME SPACE */
867 # endif
868 # endif
869 # endif
870 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
871
872
873 #if (! defined yyoverflow \
874 && (! defined __cplusplus \
875 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
876
877 /* A type that is properly aligned for any stack member. */
878 union yyalloc
879 {
880 yytype_int16 yyss_alloc;
881 YYSTYPE yyvs_alloc;
882 };
883
884 /* The size of the maximum gap between one aligned stack and the next. */
885 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
886
887 /* The size of an array large to enough to hold all stacks, each with
888 N elements. */
889 # define YYSTACK_BYTES(N) \
890 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
891 + YYSTACK_GAP_MAXIMUM)
892
893 # define YYCOPY_NEEDED 1
894
895 /* Relocate STACK from its old location to the new one. The
896 local variables YYSIZE and YYSTACKSIZE give the old and new number of
897 elements in the stack, and YYPTR gives the new location of the
898 stack. Advance YYPTR to a properly aligned location for the next
899 stack. */
900 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
901 do \
902 { \
903 YYSIZE_T yynewbytes; \
904 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
905 Stack = &yyptr->Stack_alloc; \
906 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
907 yyptr += yynewbytes / sizeof (*yyptr); \
908 } \
909 while (0)
910
911 #endif
912
913 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
914 /* Copy COUNT objects from SRC to DST. The source and destination do
915 not overlap. */
916 # ifndef YYCOPY
917 # if defined __GNUC__ && 1 < __GNUC__
918 # define YYCOPY(Dst, Src, Count) \
919 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
920 # else
921 # define YYCOPY(Dst, Src, Count) \
922 do \
923 { \
924 YYSIZE_T yyi; \
925 for (yyi = 0; yyi < (Count); yyi++) \
926 (Dst)[yyi] = (Src)[yyi]; \
927 } \
928 while (0)
929 # endif
930 # endif
931 #endif /* !YYCOPY_NEEDED */
932
933 /* YYFINAL -- State number of the termination state. */
934 #define YYFINAL 2
935 /* YYLAST -- Last index in YYTABLE. */
936 #define YYLAST 1348
937
938 /* YYNTOKENS -- Number of terminals. */
939 #define YYNTOKENS 236
940 /* YYNNTS -- Number of nonterminals. */
941 #define YYNNTS 291
942 /* YYNRULES -- Number of rules. */
943 #define YYNRULES 663
944 /* YYNSTATES -- Number of states. */
945 #define YYNSTATES 1302
946
947 #define YYUNDEFTOK 2
948 #define YYMAXUTOK 484
949
950 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
951 as returned by yylex, with out-of-bounds checking. */
952 #define YYTRANSLATE(YYX) \
953 ((unsigned) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
954
955 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
956 as returned by yylex. */
957 static const yytype_uint8 yytranslate[] =
958 {
959 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
960 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
961 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
962 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
963 2, 2, 2, 2, 234, 2, 2, 2, 2, 2,
964 2, 2, 2, 2, 2, 2, 2, 2, 235, 230,
965 2, 233, 2, 2, 2, 2, 2, 2, 2, 2,
966 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
967 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
968 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
969 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
970 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
971 2, 2, 2, 232, 2, 231, 2, 2, 2, 2,
972 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
973 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
974 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
975 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
976 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
977 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
978 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
979 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
980 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
981 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
982 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
983 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
984 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
985 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
986 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
987 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
988 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
989 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
990 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
991 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
992 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
993 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
994 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
995 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
996 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
997 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
998 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
999 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
1000 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
1001 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
1002 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
1003 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
1004 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
1005 205, 206, 207, 208, 209, 210, 211, 212, 213, 214,
1006 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
1007 225, 226, 227, 228, 229
1008 };
1009
1010 #if YYDEBUG
1011 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1012 static const yytype_uint16 yyrline[] =
1013 {
1014 0, 374, 374, 375, 378, 379, 380, 381, 382, 383,
1015 384, 385, 386, 387, 388, 389, 390, 391, 392, 393,
1016 394, 395, 396, 397, 398, 399, 400, 401, 405, 405,
1017 406, 407, 408, 409, 410, 411, 412, 413, 416, 416,
1018 417, 418, 419, 420, 427, 429, 429, 430, 430, 430,
1019 432, 438, 448, 450, 450, 451, 452, 453, 454, 455,
1020 456, 457, 458, 459, 460, 461, 462, 463, 464, 465,
1021 466, 469, 478, 487, 496, 505, 514, 523, 538, 553,
1022 563, 577, 586, 609, 632, 655, 665, 667, 667, 668,
1023 669, 670, 671, 673, 682, 691, 705, 704, 722, 722,
1024 723, 723, 723, 725, 731, 742, 741, 760, 760, 761,
1025 761, 761, 761, 761, 763, 769, 775, 781, 803, 804,
1026 804, 806, 806, 807, 809, 816, 816, 829, 830, 832,
1027 832, 833, 833, 835, 843, 846, 852, 851, 857, 857,
1028 858, 862, 866, 870, 874, 878, 882, 886, 897, 896,
1029 959, 959, 960, 961, 962, 963, 964, 965, 966, 967,
1030 968, 969, 970, 972, 978, 984, 990, 996, 1007, 1013,
1031 1024, 1031, 1030, 1036, 1036, 1037, 1041, 1045, 1049, 1053,
1032 1057, 1061, 1065, 1069, 1073, 1077, 1081, 1085, 1089, 1093,
1033 1097, 1101, 1105, 1109, 1113, 1117, 1121, 1125, 1132, 1131,
1034 1137, 1137, 1138, 1142, 1146, 1150, 1154, 1158, 1162, 1166,
1035 1170, 1174, 1178, 1182, 1186, 1190, 1194, 1198, 1202, 1206,
1036 1210, 1214, 1218, 1222, 1226, 1230, 1234, 1238, 1242, 1246,
1037 1250, 1261, 1260, 1317, 1317, 1318, 1319, 1320, 1321, 1322,
1038 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332,
1039 1333, 1335, 1341, 1347, 1353, 1359, 1365, 1371, 1377, 1383,
1040 1390, 1396, 1402, 1408, 1417, 1427, 1426, 1432, 1432, 1433,
1041 1437, 1448, 1447, 1454, 1453, 1458, 1458, 1459, 1463, 1467,
1042 1473, 1473, 1474, 1474, 1474, 1474, 1474, 1476, 1476, 1478,
1043 1478, 1480, 1493, 1510, 1516, 1527, 1526, 1573, 1573, 1574,
1044 1575, 1576, 1577, 1578, 1579, 1580, 1581, 1582, 1584, 1590,
1045 1596, 1602, 1614, 1613, 1619, 1619, 1620, 1624, 1628, 1632,
1046 1636, 1640, 1644, 1648, 1652, 1656, 1662, 1676, 1685, 1699,
1047 1698, 1713, 1713, 1714, 1714, 1714, 1714, 1716, 1722, 1728,
1048 1738, 1740, 1740, 1741, 1741, 1743, 1760, 1759, 1782, 1782,
1049 1783, 1783, 1783, 1783, 1785, 1791, 1811, 1810, 1816, 1816,
1050 1817, 1821, 1825, 1829, 1833, 1837, 1841, 1845, 1849, 1853,
1051 1864, 1863, 1882, 1882, 1883, 1883, 1883, 1885, 1892, 1891,
1052 1897, 1897, 1898, 1902, 1906, 1910, 1914, 1918, 1922, 1926,
1053 1930, 1934, 1945, 1944, 2020, 2020, 2021, 2022, 2023, 2024,
1054 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034,
1055 2035, 2037, 2043, 2049, 2055, 2068, 2081, 2087, 2093, 2097,
1056 2104, 2103, 2108, 2108, 2109, 2113, 2119, 2130, 2136, 2142,
1057 2148, 2164, 2163, 2187, 2187, 2188, 2188, 2188, 2190, 2210,
1058 2221, 2220, 2245, 2245, 2246, 2246, 2246, 2248, 2254, 2264,
1059 2266, 2266, 2267, 2267, 2269, 2287, 2286, 2307, 2307, 2308,
1060 2308, 2308, 2310, 2316, 2326, 2328, 2328, 2329, 2330, 2331,
1061 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341,
1062 2342, 2343, 2344, 2345, 2346, 2347, 2348, 2349, 2350, 2351,
1063 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361,
1064 2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371,
1065 2372, 2373, 2374, 2377, 2382, 2387, 2392, 2397, 2402, 2407,
1066 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457,
1067 2462, 2467, 2472, 2477, 2482, 2487, 2492, 2497, 2502, 2505,
1068 2510, 2513, 2518, 2523, 2528, 2533, 2538, 2543, 2548, 2553,
1069 2558, 2563, 2568, 2573, 2579, 2578, 2583, 2583, 2584, 2587,
1070 2590, 2593, 2596, 2599, 2602, 2605, 2608, 2611, 2614, 2617,
1071 2620, 2623, 2626, 2629, 2632, 2635, 2638, 2641, 2644, 2647,
1072 2650, 2656, 2655, 2660, 2660, 2661, 2664, 2667, 2670, 2673,
1073 2676, 2679, 2682, 2685, 2688, 2691, 2694, 2697, 2700, 2703,
1074 2706, 2709, 2712, 2715, 2718, 2721, 2726, 2731, 2736, 2741,
1075 2750, 2752, 2752, 2753, 2754, 2755, 2756, 2757, 2758, 2759,
1076 2760, 2761, 2762, 2763, 2764, 2765, 2766, 2767, 2769, 2774,
1077 2779, 2784, 2789, 2794, 2799, 2804, 2809, 2814, 2819, 2824,
1078 2829, 2834, 2843, 2845, 2845, 2846, 2847, 2848, 2849, 2850,
1079 2851, 2852, 2853, 2854, 2855, 2857, 2863, 2879, 2888, 2894,
1080 2900, 2906, 2915, 2921
1081 };
1082 #endif
1083
1084 #if YYDEBUG || YYERROR_VERBOSE || 0
1085 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1086 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1087 static const char *const yytname[] =
1088 {
1089 "$end", "error", "$undefined", "ACCEPT_PASSWORD", "ADMIN", "AFTYPE",
1090 "ANTI_NICK_FLOOD", "ANTI_SPAM_EXIT_MESSAGE_TIME", "AUTOCONN",
1091 "AWAY_COUNT", "AWAY_TIME", "BYTES", "KBYTES", "MBYTES", "CALLER_ID_WAIT",
1092 "CAN_FLOOD", "CHANNEL", "CIDR_BITLEN_IPV4", "CIDR_BITLEN_IPV6", "CLASS",
1093 "CLOSE", "CONNECT", "CONNECTFREQ", "CYCLE_ON_HOST_CHANGE",
1094 "DEFAULT_FLOODCOUNT", "DEFAULT_FLOODTIME", "DEFAULT_JOIN_FLOOD_COUNT",
1095 "DEFAULT_JOIN_FLOOD_TIME", "DEFAULT_MAX_CLIENTS", "DENY", "DESCRIPTION",
1096 "DIE", "DISABLE_AUTH", "DISABLE_FAKE_CHANNELS",
1097 "DISABLE_REMOTE_COMMANDS", "DLINE_MIN_CIDR", "DLINE_MIN_CIDR6",
1098 "DOTS_IN_IDENT", "EMAIL", "ENCRYPTED", "EXCEED_LIMIT", "EXEMPT",
1099 "EXPIRATION", "FAILED_OPER_NOTICE", "FLATTEN_LINKS",
1100 "FLATTEN_LINKS_DELAY", "FLATTEN_LINKS_FILE", "GECOS", "GENERAL",
1101 "HIDDEN", "HIDDEN_NAME", "HIDE_CHANS", "HIDE_IDLE",
1102 "HIDE_IDLE_FROM_OPERS", "HIDE_SERVER_IPS", "HIDE_SERVERS",
1103 "HIDE_SERVICES", "HOST", "HUB", "HUB_MASK", "INVISIBLE_ON_CONNECT",
1104 "INVITE_CLIENT_COUNT", "INVITE_CLIENT_TIME", "INVITE_DELAY_CHANNEL",
1105 "INVITE_EXPIRE_TIME", "IP", "IRCD_AUTH", "IRCD_FLAGS", "IRCD_SID",
1106 "JOIN", "KILL", "KILL_CHASE_TIME_LIMIT", "KLINE", "KLINE_EXEMPT",
1107 "KLINE_MIN_CIDR", "KLINE_MIN_CIDR6", "KNOCK_CLIENT_COUNT",
1108 "KNOCK_CLIENT_TIME", "KNOCK_DELAY_CHANNEL", "LEAF_MASK", "LISTEN",
1109 "MASK", "MAX_ACCEPT", "MAX_BANS", "MAX_BANS_LARGE", "MAX_CHANNELS",
1110 "MAX_IDLE", "MAX_INVITES", "MAX_NICK_CHANGES", "MAX_NICK_LENGTH",
1111 "MAX_NICK_TIME", "MAX_NUMBER", "MAX_TARGETS", "MAX_TOPIC_LENGTH",
1112 "MAX_WATCH", "MIN_IDLE", "MIN_NONWILDCARD", "MIN_NONWILDCARD_SIMPLE",
1113 "MODULE", "MODULES", "MOTD", "NAME", "NEED_IDENT", "NEED_PASSWORD",
1114 "NETWORK_DESC", "NETWORK_NAME", "NICK", "NO_OPER_FLOOD", "NO_TILDE",
1115 "NUMBER", "NUMBER_PER_CIDR", "NUMBER_PER_IP_GLOBAL",
1116 "NUMBER_PER_IP_LOCAL", "OPER_ONLY_UMODES", "OPER_UMODES", "OPERATOR",
1117 "OPERS_BYPASS_CALLERID", "PACE_WAIT", "PACE_WAIT_SIMPLE", "PASSWORD",
1118 "PATH", "PING_COOKIE", "PING_TIME", "PORT", "QSTRING", "RANDOM_IDLE",
1119 "REASON", "REDIRPORT", "REDIRSERV", "REHASH", "REMOTE", "REMOTEBAN",
1120 "RESV", "RESV_EXEMPT", "RSA_PRIVATE_KEY_FILE", "SECONDS", "MINUTES",
1121 "HOURS", "DAYS", "WEEKS", "MONTHS", "YEARS", "SEND_PASSWORD", "SENDQ",
1122 "SERVERHIDE", "SERVERINFO", "SHORT_MOTD", "SPOOF", "SPOOF_NOTICE",
1123 "SQUIT", "SSL_CERTIFICATE_FILE", "SSL_CERTIFICATE_FINGERPRINT",
1124 "SSL_CONNECTION_REQUIRED", "SSL_DH_ELLIPTIC_CURVE", "SSL_DH_PARAM_FILE",
1125 "SSL_MESSAGE_DIGEST_ALGORITHM", "STATS_E_DISABLED", "STATS_I_OPER_ONLY",
1126 "STATS_K_OPER_ONLY", "STATS_M_OPER_ONLY", "STATS_O_OPER_ONLY",
1127 "STATS_P_OPER_ONLY", "STATS_U_OPER_ONLY", "T_ALL", "T_BIND", "T_BOTS",
1128 "T_CALLERID", "T_CCONN", "T_COMMAND", "T_CLUSTER", "T_DEAF", "T_DEBUG",
1129 "T_DLINE", "T_EXTERNAL", "T_FARCONNECT", "T_FILE", "T_FULL", "T_GLOBOPS",
1130 "T_INVISIBLE", "T_IPV4", "T_IPV6", "T_LOCOPS", "T_LOG", "T_NCHANGE",
1131 "T_NONONREG", "T_OPME", "T_PREPEND", "T_PSEUDO", "T_RECVQ", "T_REJ",
1132 "T_RESTART", "T_SERVER", "T_SERVICE", "T_SERVNOTICE", "T_SET",
1133 "T_SHARED", "T_SIZE", "T_SKILL", "T_SOFTCALLERID", "T_SPY", "T_SSL",
1134 "T_SSL_CIPHER_LIST", "T_TARGET", "T_UMODES", "T_UNAUTH", "T_UNDLINE",
1135 "T_UNLIMITED", "T_UNRESV", "T_UNXLINE", "T_WALLOP", "T_WALLOPS",
1136 "T_WEBIRC", "TBOOL", "THROTTLE_COUNT", "THROTTLE_TIME", "TMASKED",
1137 "TS_MAX_DELTA", "TS_WARN_DELTA", "TWODOTS", "TYPE", "UNKLINE",
1138 "USE_LOGGING", "USER", "VHOST", "VHOST6", "WARN_NO_CONNECT_BLOCK",
1139 "WHOIS", "WHOWAS_HISTORY_LENGTH", "XLINE", "XLINE_EXEMPT", "';'", "'}'",
1140 "'{'", "'='", "','", "':'", "$accept", "conf", "conf_item", "timespec_",
1141 "timespec", "sizespec_", "sizespec", "modules_entry", "modules_items",
1142 "modules_item", "modules_module", "modules_path", "serverinfo_entry",
1143 "serverinfo_items", "serverinfo_item", "serverinfo_ssl_certificate_file",
1144 "serverinfo_rsa_private_key_file", "serverinfo_ssl_dh_param_file",
1145 "serverinfo_ssl_cipher_list", "serverinfo_ssl_message_digest_algorithm",
1146 "serverinfo_ssl_dh_elliptic_curve", "serverinfo_name", "serverinfo_sid",
1147 "serverinfo_description", "serverinfo_network_name",
1148 "serverinfo_network_desc", "serverinfo_default_max_clients",
1149 "serverinfo_max_nick_length", "serverinfo_max_topic_length",
1150 "serverinfo_hub", "admin_entry", "admin_items", "admin_item",
1151 "admin_name", "admin_email", "admin_description", "motd_entry", "$@1",
1152 "motd_items", "motd_item", "motd_mask", "motd_file", "pseudo_entry",
1153 "$@2", "pseudo_items", "pseudo_item", "pseudo_command", "pseudo_name",
1154 "pseudo_prepend", "pseudo_target", "logging_entry", "logging_items",
1155 "logging_item", "logging_use_logging", "logging_file_entry", "$@3",
1156 "logging_file_items", "logging_file_item", "logging_file_name",
1157 "logging_file_size", "logging_file_type", "$@4",
1158 "logging_file_type_items", "logging_file_type_item", "oper_entry", "$@5",
1159 "oper_items", "oper_item", "oper_name", "oper_user", "oper_password",
1160 "oper_whois", "oper_encrypted", "oper_ssl_certificate_fingerprint",
1161 "oper_ssl_connection_required", "oper_class", "oper_umodes", "$@6",
1162 "oper_umodes_items", "oper_umodes_item", "oper_flags", "$@7",
1163 "oper_flags_items", "oper_flags_item", "class_entry", "$@8",
1164 "class_items", "class_item", "class_name", "class_ping_time",
1165 "class_number_per_ip_local", "class_number_per_ip_global",
1166 "class_connectfreq", "class_max_channels", "class_max_number",
1167 "class_sendq", "class_recvq", "class_cidr_bitlen_ipv4",
1168 "class_cidr_bitlen_ipv6", "class_number_per_cidr", "class_min_idle",
1169 "class_max_idle", "class_flags", "$@9", "class_flags_items",
1170 "class_flags_item", "listen_entry", "$@10", "listen_flags", "$@11",
1171 "listen_flags_items", "listen_flags_item", "listen_items", "listen_item",
1172 "listen_port", "$@12", "port_items", "port_item", "listen_address",
1173 "listen_host", "auth_entry", "$@13", "auth_items", "auth_item",
1174 "auth_user", "auth_passwd", "auth_class", "auth_encrypted", "auth_flags",
1175 "$@14", "auth_flags_items", "auth_flags_item", "auth_spoof",
1176 "auth_redir_serv", "auth_redir_port", "resv_entry", "$@15", "resv_items",
1177 "resv_item", "resv_mask", "resv_reason", "resv_exempt", "service_entry",
1178 "service_items", "service_item", "service_name", "shared_entry", "$@16",
1179 "shared_items", "shared_item", "shared_name", "shared_user",
1180 "shared_type", "$@17", "shared_types", "shared_type_item",
1181 "cluster_entry", "$@18", "cluster_items", "cluster_item", "cluster_name",
1182 "cluster_type", "$@19", "cluster_types", "cluster_type_item",
1183 "connect_entry", "$@20", "connect_items", "connect_item", "connect_name",
1184 "connect_host", "connect_bind", "connect_send_password",
1185 "connect_accept_password", "connect_ssl_certificate_fingerprint",
1186 "connect_port", "connect_aftype", "connect_flags", "$@21",
1187 "connect_flags_items", "connect_flags_item", "connect_encrypted",
1188 "connect_hub_mask", "connect_leaf_mask", "connect_class",
1189 "connect_ssl_cipher_list", "kill_entry", "$@22", "kill_items",
1190 "kill_item", "kill_user", "kill_reason", "deny_entry", "$@23",
1191 "deny_items", "deny_item", "deny_ip", "deny_reason", "exempt_entry",
1192 "exempt_items", "exempt_item", "exempt_ip", "gecos_entry", "$@24",
1193 "gecos_items", "gecos_item", "gecos_name", "gecos_reason",
1194 "general_entry", "general_items", "general_item", "general_away_count",
1195 "general_away_time", "general_max_watch",
1196 "general_whowas_history_length", "general_cycle_on_host_change",
1197 "general_dline_min_cidr", "general_dline_min_cidr6",
1198 "general_kline_min_cidr", "general_kline_min_cidr6",
1199 "general_kill_chase_time_limit", "general_failed_oper_notice",
1200 "general_anti_nick_flood", "general_max_nick_time",
1201 "general_max_nick_changes", "general_max_accept",
1202 "general_anti_spam_exit_message_time", "general_ts_warn_delta",
1203 "general_ts_max_delta", "general_invisible_on_connect",
1204 "general_warn_no_connect_block", "general_stats_e_disabled",
1205 "general_stats_m_oper_only", "general_stats_o_oper_only",
1206 "general_stats_P_oper_only", "general_stats_u_oper_only",
1207 "general_stats_k_oper_only", "general_stats_i_oper_only",
1208 "general_pace_wait", "general_caller_id_wait",
1209 "general_opers_bypass_callerid", "general_pace_wait_simple",
1210 "general_short_motd", "general_no_oper_flood", "general_dots_in_ident",
1211 "general_max_targets", "general_ping_cookie", "general_disable_auth",
1212 "general_throttle_count", "general_throttle_time", "general_oper_umodes",
1213 "$@25", "umode_oitems", "umode_oitem", "general_oper_only_umodes",
1214 "$@26", "umode_items", "umode_item", "general_min_nonwildcard",
1215 "general_min_nonwildcard_simple", "general_default_floodcount",
1216 "general_default_floodtime", "channel_entry", "channel_items",
1217 "channel_item", "channel_disable_fake_channels",
1218 "channel_invite_client_count", "channel_invite_client_time",
1219 "channel_invite_delay_channel", "channel_invite_expire_time",
1220 "channel_knock_client_count", "channel_knock_client_time",
1221 "channel_knock_delay_channel", "channel_max_channels",
1222 "channel_max_invites", "channel_max_bans", "channel_max_bans_large",
1223 "channel_default_join_flood_count", "channel_default_join_flood_time",
1224 "serverhide_entry", "serverhide_items", "serverhide_item",
1225 "serverhide_flatten_links", "serverhide_flatten_links_delay",
1226 "serverhide_flatten_links_file", "serverhide_disable_remote_commands",
1227 "serverhide_hide_servers", "serverhide_hide_services",
1228 "serverhide_hidden_name", "serverhide_hidden",
1229 "serverhide_hide_server_ips", YY_NULLPTR
1230 };
1231 #endif
1232
1233 # ifdef YYPRINT
1234 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
1235 (internal) symbol number NUM (which must be that of a token). */
1236 static const yytype_uint16 yytoknum[] =
1237 {
1238 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1239 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1240 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1241 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1242 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1243 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1244 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1245 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1246 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1247 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1248 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1249 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
1250 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
1251 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
1252 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
1253 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
1254 415, 416, 417, 418, 419, 420, 421, 422, 423, 424,
1255 425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
1256 435, 436, 437, 438, 439, 440, 441, 442, 443, 444,
1257 445, 446, 447, 448, 449, 450, 451, 452, 453, 454,
1258 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
1259 465, 466, 467, 468, 469, 470, 471, 472, 473, 474,
1260 475, 476, 477, 478, 479, 480, 481, 482, 483, 484,
1261 59, 125, 123, 61, 44, 58
1262 };
1263 # endif
1264
1265 #define YYPACT_NINF -740
1266
1267 #define yypact_value_is_default(Yystate) \
1268 (!!((Yystate) == (-740)))
1269
1270 #define YYTABLE_NINF -126
1271
1272 #define yytable_value_is_error(Yytable_value) \
1273 0
1274
1275 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1276 STATE-NUM. */
1277 static const yytype_int16 yypact[] =
1278 {
1279 -740, 634, -740, -140, -211, -205, -740, -740, -740, -197,
1280 -740, -195, -740, -740, -740, -181, -740, -740, -740, -176,
1281 -144, -740, -125, -740, -111, -740, -740, -740, -740, -740,
1282 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1283 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1284 -740, 23, 911, -99, -88, -83, 21, -77, 401, -70,
1285 -69, -55, 183, -50, -38, -17, 538, 506, -5, 18,
1286 55, 17, 56, -188, -24, 64, 68, 51, -740, -740,
1287 -740, -740, -740, 69, 75, 78, 79, 84, 89, 92,
1288 102, 103, 106, 107, 109, 111, 112, 243, -740, -740,
1289 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1290 -740, -740, -740, 630, 566, 22, -740, 121, 28, -740,
1291 -740, 19, -740, 123, 125, 127, 128, 129, 130, 131,
1292 135, 137, 139, 144, 146, 147, 158, 159, 160, 168,
1293 170, 172, 176, 179, 180, 181, 185, 186, -740, -740,
1294 187, 188, 189, 195, 197, 199, 201, 206, 207, 208,
1295 209, 210, 212, 218, 219, 220, 221, 223, 40, -740,
1296 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1297 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1298 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1299 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1300 -740, -740, -740, -740, -740, 330, 15, 308, 148, 226,
1301 227, 11, -740, -740, -740, 35, 328, 309, -740, 229,
1302 230, 231, 234, 237, 238, 249, 251, 252, 24, -740,
1303 -740, -740, -740, -740, -740, -740, -740, -740, -740, 166,
1304 253, 254, 255, 257, 259, 263, 266, 267, 268, 270,
1305 271, 272, 273, 276, 279, 145, -740, -740, -740, -740,
1306 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1307 -740, -740, 65, 283, 287, 47, -740, -740, -740, 119,
1308 3, -740, 288, 42, -740, -740, 7, -740, 282, 399,
1309 400, 296, -740, 246, 420, 318, 423, 420, 420, 420,
1310 424, 420, 420, 426, 428, 429, 431, 312, -740, 313,
1311 311, 315, 316, -740, 320, 322, 332, 333, 337, 342,
1312 343, 345, 346, 347, 358, 150, -740, -740, -740, -740,
1313 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1314 -740, -740, 321, 363, 364, 365, 367, 369, 375, -740,
1315 376, 379, 380, 387, 388, 389, 394, 173, -740, -740,
1316 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1317 -740, -740, -740, -740, 397, 406, 54, -740, -740, -740,
1318 422, 402, -740, -740, 409, 410, 59, -740, -740, -740,
1319 417, 420, 532, 420, 420, 432, 537, 420, 437, 542,
1320 545, 548, 446, 450, 420, 555, 556, 557, 567, 420,
1321 568, 569, 570, 571, 473, 454, 455, 479, 420, 420,
1322 482, 483, 486, -130, 9, 487, 489, 490, 491, 596,
1323 420, 420, 420, 494, 600, 480, -740, 481, 485, 493,
1324 -740, 499, 510, 511, 514, 515, 224, -740, -740, -740,
1325 -740, -740, -740, -740, -740, -740, -740, 517, 518, 61,
1326 -740, -740, -740, 492, 520, 521, -740, 522, -740, 27,
1327 -740, -740, -740, -740, -740, 588, 589, 509, -740, 526,
1328 524, 525, 44, -740, -740, -740, 529, 527, 528, -740,
1329 530, 531, 541, 543, -740, 544, 547, 247, -740, -740,
1330 -740, -740, -740, -740, -740, -740, -740, -740, -740, 535,
1331 549, 550, 554, 16, -740, -740, -740, -740, 507, 508,
1332 420, 599, 512, 638, 558, 576, 577, 551, -740, -740,
1333 681, 667, 581, 670, 687, 688, 671, 674, 675, 676,
1334 677, 678, 680, 685, 689, 575, -740, 580, 590, -740,
1335 122, -740, -740, -740, -740, 615, 598, -740, 601, 602,
1336 604, 608, 610, 611, 2, -740, -740, -740, -740, -740,
1337 707, 605, -740, 616, 621, -740, 622, 58, -740, -740,
1338 -740, -740, 617, 618, 619, -740, 628, 248, 631, 633,
1339 635, 636, 642, 643, 644, 646, 647, 648, 651, 652,
1340 656, -740, -740, 759, 762, 420, 654, 779, 420, 780,
1341 420, 770, 789, 792, 794, 420, 796, 796, 683, -740,
1342 -740, 782, -84, 784, 702, 793, 797, 693, 798, 803,
1343 807, 804, 808, 809, 810, 701, -740, 812, 815, 710,
1344 -740, 711, -740, 818, 819, 715, -740, 716, 717, 718,
1345 719, 720, 721, 722, 724, 727, 728, 729, 730, 731,
1346 732, 733, 734, 735, 736, 737, 739, 740, 741, 747,
1347 749, 750, 726, 641, 751, 752, 753, 754, 755, 756,
1348 760, 761, 763, 767, 769, 771, 772, 773, 774, 775,
1349 776, 777, 778, 781, -740, -740, 854, 706, 783, 868,
1350 891, 885, 886, 888, 785, -740, 889, 890, 787, -740,
1351 -740, 894, 895, 788, 913, 790, -740, 795, 799, -740,
1352 -740, 899, 900, 800, -740, -740, 902, 816, 801, 903,
1353 907, 908, 821, 802, 912, 914, 811, -740, -740, 915,
1354 916, 918, 813, -740, 814, 817, 820, 822, 823, 824,
1355 825, 826, 827, -740, 828, 829, 830, 831, 832, 833,
1356 834, 835, 836, 837, 838, 839, 840, 841, 842, -740,
1357 -740, 921, 843, 844, -740, 845, -740, 12, -740, 922,
1358 924, 925, 927, 847, -740, 848, -740, -740, 949, 846,
1359 956, 851, -740, -740, -740, -740, -740, 420, 420, 420,
1360 420, 420, 420, 420, -740, -740, -740, -740, -740, -740,
1361 -740, -740, -740, -740, -740, -740, -740, -740, -740, 852,
1362 853, 855, -27, 856, 857, 858, 859, 860, 861, 862,
1363 863, 864, 20, 865, 866, -740, 867, 869, 870, 871,
1364 872, 873, 874, 6, 875, 876, 877, 878, 879, 880,
1365 881, -740, 882, 883, -740, -740, 884, 887, -740, -740,
1366 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1367 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1368 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1369 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1370 -740, -740, -740, -740, -740, -219, -740, -740, -740, -740,
1371 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1372 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1373 -200, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1374 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1375 -740, -740, 892, 893, 408, 896, 897, 898, 901, 904,
1376 -740, 905, 906, -740, 909, 910, -10, 919, 850, -740,
1377 -740, -740, -740, 917, 920, -740, 923, 926, 396, 928,
1378 929, 930, 931, 686, 932, 933, -740, 934, 935, 936,
1379 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1380 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1381 -740, -740, -740, -740, -740, 937, 564, -740, -740, 938,
1382 939, 940, -740, 163, -740, -740, -740, -740, 941, 944,
1383 945, 946, -740, -740, 947, 748, 948, -740, -740, -740,
1384 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1385 -190, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1386 -740, 796, 796, 796, -740, -740, -740, -740, -740, -740,
1387 -740, -740, -740, -740, -740, -740, -740, -163, -740, -740,
1388 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1389 -740, 726, -740, 641, -740, -740, -740, -740, -740, -740,
1390 -740, -740, -740, -740, -740, -740, -124, -740, -740, -740,
1391 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1392 -65, -740, 989, 913, 950, -740, -740, -740, -740, -740,
1393 -740, 951, -740, 952, 953, -740, -740, 954, 955, -740,
1394 -740, 957, -740, -740, -740, -740, -740, -740, -740, -740,
1395 -740, -740, -740, -740, -51, -740, -740, -740, -740, -740,
1396 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1397 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1398 -740, -740, -740, -39, -740, -740, -740, -740, -740, -740,
1399 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1400 -740, -23, -740, -740, 991, -71, 958, 963, -740, -740,
1401 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1402 -740, -740, -740, -740, -16, -740, -740, -740, -27, -740,
1403 -740, -740, -740, 6, -740, -740, -740, 408, -740, -10,
1404 -740, -740, -740, 986, 987, 988, 992, 990, 995, -740,
1405 396, -740, 686, -740, 564, 964, 965, 966, 614, -740,
1406 -740, 748, -740, -740, -740, -740, -740, -740, -740, -740,
1407 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1408 -740, -740, -740, -740, -740, -740, -14, -740, -740, -740,
1409 614, -740
1410 };
1411
1412 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1413 Performed when YYTABLE does not specify something else to do. Zero
1414 means the default is an error. */
1415 static const yytype_uint16 yydefact[] =
1416 {
1417 2, 0, 1, 0, 0, 0, 231, 392, 440, 0,
1418 455, 0, 295, 431, 271, 0, 96, 148, 329, 0,
1419 0, 370, 0, 105, 0, 346, 3, 23, 11, 4,
1420 24, 25, 5, 6, 8, 9, 10, 13, 14, 15,
1421 16, 17, 18, 19, 20, 22, 21, 7, 12, 26,
1422 27, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1423 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1424 0, 0, 0, 0, 0, 0, 0, 0, 88, 89,
1425 91, 90, 627, 0, 0, 0, 0, 0, 0, 0,
1426 0, 0, 0, 0, 0, 0, 0, 0, 612, 626,
1427 615, 616, 617, 618, 619, 620, 621, 622, 623, 613,
1428 614, 624, 625, 0, 0, 0, 453, 0, 0, 451,
1429 452, 0, 512, 0, 0, 0, 0, 0, 0, 0,
1430 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1431 0, 0, 0, 0, 0, 0, 0, 0, 581, 554,
1432 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1433 0, 0, 0, 0, 0, 0, 0, 0, 0, 466,
1434 467, 468, 510, 474, 511, 505, 506, 507, 508, 478,
1435 469, 470, 471, 472, 473, 475, 476, 477, 479, 480,
1436 509, 484, 485, 486, 487, 483, 482, 488, 495, 496,
1437 489, 490, 491, 481, 493, 503, 504, 501, 502, 494,
1438 492, 499, 500, 497, 498, 0, 0, 0, 0, 0,
1439 0, 0, 46, 47, 48, 0, 0, 0, 654, 0,
1440 0, 0, 0, 0, 0, 0, 0, 0, 0, 644,
1441 645, 646, 647, 648, 649, 650, 652, 651, 653, 0,
1442 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1443 0, 0, 0, 0, 0, 0, 54, 67, 65, 63,
1444 68, 69, 64, 55, 66, 57, 58, 59, 60, 61,
1445 62, 56, 0, 0, 0, 0, 120, 121, 122, 0,
1446 0, 344, 0, 0, 342, 343, 0, 92, 0, 0,
1447 0, 0, 87, 0, 0, 0, 0, 0, 0, 0,
1448 0, 0, 0, 0, 0, 0, 0, 0, 611, 0,
1449 0, 0, 0, 265, 0, 0, 0, 0, 0, 0,
1450 0, 0, 0, 0, 0, 0, 234, 235, 238, 240,
1451 241, 242, 243, 244, 245, 246, 236, 237, 239, 247,
1452 248, 249, 0, 0, 0, 0, 0, 0, 0, 420,
1453 0, 0, 0, 0, 0, 0, 0, 0, 395, 396,
1454 397, 398, 399, 400, 401, 403, 402, 405, 409, 406,
1455 407, 408, 404, 446, 0, 0, 0, 443, 444, 445,
1456 0, 0, 450, 461, 0, 0, 0, 458, 459, 460,
1457 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1458 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1459 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1460 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1461 0, 0, 0, 0, 0, 0, 465, 0, 0, 0,
1462 312, 0, 0, 0, 0, 0, 0, 298, 299, 300,
1463 301, 306, 302, 303, 304, 305, 437, 0, 0, 0,
1464 434, 435, 436, 0, 0, 0, 273, 0, 283, 0,
1465 281, 282, 284, 285, 49, 0, 0, 0, 45, 0,
1466 0, 0, 0, 99, 100, 101, 0, 0, 0, 198,
1467 0, 0, 0, 0, 171, 0, 0, 0, 151, 152,
1468 153, 154, 155, 158, 159, 160, 157, 156, 161, 0,
1469 0, 0, 0, 0, 332, 333, 334, 335, 0, 0,
1470 0, 0, 0, 0, 0, 0, 0, 0, 643, 70,
1471 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1472 0, 0, 0, 0, 0, 0, 53, 0, 0, 378,
1473 0, 373, 374, 375, 123, 0, 0, 119, 0, 0,
1474 0, 0, 0, 0, 0, 108, 109, 111, 110, 112,
1475 0, 0, 341, 0, 0, 356, 0, 0, 349, 350,
1476 351, 352, 0, 0, 0, 86, 0, 28, 0, 0,
1477 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1478 0, 610, 250, 0, 0, 0, 0, 0, 0, 0,
1479 0, 0, 0, 0, 0, 0, 0, 0, 0, 233,
1480 410, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1481 0, 0, 0, 0, 0, 0, 394, 0, 0, 0,
1482 442, 0, 449, 0, 0, 0, 457, 0, 0, 0,
1483 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1484 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1485 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1486 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1487 0, 0, 0, 0, 464, 307, 0, 0, 0, 0,
1488 0, 0, 0, 0, 0, 297, 0, 0, 0, 433,
1489 286, 0, 0, 0, 0, 0, 280, 0, 0, 44,
1490 102, 0, 0, 0, 98, 162, 0, 0, 0, 0,
1491 0, 0, 0, 0, 0, 0, 0, 150, 336, 0,
1492 0, 0, 0, 331, 0, 0, 0, 0, 0, 0,
1493 0, 0, 0, 642, 0, 0, 0, 0, 0, 0,
1494 0, 0, 0, 0, 0, 0, 0, 0, 0, 52,
1495 376, 0, 0, 0, 372, 0, 118, 0, 113, 0,
1496 0, 0, 0, 0, 107, 0, 340, 353, 0, 0,
1497 0, 0, 348, 95, 94, 93, 640, 28, 28, 28,
1498 28, 28, 28, 28, 30, 29, 641, 628, 629, 630,
1499 631, 632, 633, 634, 635, 638, 639, 636, 637, 0,
1500 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1501 0, 0, 38, 0, 0, 232, 0, 0, 0, 0,
1502 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1503 0, 393, 0, 0, 441, 454, 0, 0, 456, 524,
1504 528, 513, 514, 543, 517, 608, 609, 551, 518, 519,
1505 548, 523, 531, 522, 520, 521, 527, 526, 525, 549,
1506 515, 606, 607, 547, 605, 591, 585, 601, 586, 587,
1507 588, 596, 604, 589, 598, 602, 592, 603, 593, 597,
1508 590, 600, 595, 594, 599, 0, 584, 580, 563, 564,
1509 565, 558, 576, 559, 560, 561, 571, 579, 562, 573,
1510 577, 567, 578, 568, 572, 566, 575, 570, 569, 574,
1511 0, 557, 544, 542, 545, 550, 546, 533, 540, 541,
1512 538, 539, 534, 535, 536, 537, 552, 553, 530, 529,
1513 532, 516, 0, 0, 0, 0, 0, 0, 0, 0,
1514 296, 0, 0, 432, 0, 0, 0, 291, 287, 290,
1515 272, 50, 51, 0, 0, 97, 0, 0, 0, 0,
1516 0, 0, 0, 0, 0, 0, 149, 0, 0, 0,
1517 330, 658, 655, 656, 657, 662, 661, 663, 659, 660,
1518 82, 79, 85, 78, 83, 84, 77, 81, 80, 72,
1519 71, 76, 73, 75, 74, 0, 0, 371, 124, 0,
1520 0, 0, 136, 0, 128, 129, 131, 130, 0, 0,
1521 0, 0, 106, 345, 0, 0, 0, 347, 31, 32,
1522 33, 34, 35, 36, 37, 260, 261, 255, 270, 269,
1523 0, 268, 256, 264, 257, 263, 251, 262, 254, 253,
1524 252, 38, 38, 38, 40, 39, 258, 259, 415, 418,
1525 419, 429, 426, 412, 427, 424, 425, 0, 423, 428,
1526 411, 417, 414, 416, 413, 430, 447, 448, 462, 463,
1527 582, 0, 555, 0, 310, 311, 321, 317, 318, 320,
1528 325, 322, 323, 316, 324, 319, 0, 315, 309, 328,
1529 327, 326, 308, 439, 438, 294, 293, 278, 279, 277,
1530 0, 276, 0, 0, 0, 103, 104, 170, 167, 218,
1531 230, 205, 214, 0, 203, 208, 224, 0, 217, 222,
1532 228, 207, 210, 219, 221, 225, 215, 223, 211, 229,
1533 213, 220, 209, 212, 0, 201, 163, 165, 168, 169,
1534 197, 180, 181, 182, 175, 193, 176, 177, 178, 188,
1535 196, 179, 190, 194, 184, 195, 185, 189, 183, 192,
1536 187, 186, 191, 0, 174, 164, 166, 339, 337, 338,
1537 377, 382, 388, 391, 384, 390, 385, 389, 387, 383,
1538 386, 0, 381, 132, 0, 0, 0, 0, 127, 115,
1539 114, 116, 117, 354, 360, 366, 369, 362, 368, 363,
1540 367, 365, 361, 364, 0, 359, 355, 266, 0, 41,
1541 42, 43, 421, 0, 583, 556, 313, 0, 274, 0,
1542 292, 289, 288, 0, 0, 0, 0, 0, 0, 199,
1543 0, 172, 0, 379, 0, 0, 0, 0, 0, 126,
1544 357, 0, 267, 422, 314, 275, 204, 227, 202, 226,
1545 216, 206, 200, 173, 380, 133, 135, 134, 146, 145,
1546 141, 143, 147, 144, 140, 142, 0, 139, 358, 137,
1547 0, 138
1548 };
1549
1550 /* YYPGOTO[NTERM-NUM]. */
1551 static const yytype_int16 yypgoto[] =
1552 {
1553 -740, -740, -740, -139, -302, -739, -626, -740, -740, 960,
1554 -740, -740, -740, -740, 942, -740, -740, -740, -740, -740,
1555 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1556 -740, -740, 1044, -740, -740, -740, -740, -740, -740, 637,
1557 -740, -740, -740, -740, -740, 463, -740, -740, -740, -740,
1558 -740, -740, 943, -740, -740, -740, -740, 97, -740, -740,
1559 -740, -740, -740, -168, -740, -740, -740, 626, -740, -740,
1560 -740, -740, -740, -740, -740, -740, -740, -740, -740, -121,
1561 -740, -740, -740, -122, -740, -740, -740, 849, -740, -740,
1562 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1563 -740, -740, -740, -740, -740, -96, -740, -740, -740, -740,
1564 -740, -106, -740, 665, -740, -740, -740, 13, -740, -740,
1565 -740, -740, -740, 692, -740, -740, -740, -740, -740, -740,
1566 -740, -102, -740, -740, -740, -740, -740, -740, 629, -740,
1567 -740, -740, -740, -740, 959, -740, -740, -740, -740, 562,
1568 -740, -740, -740, -740, -740, -120, -740, -740, -740, 594,
1569 -740, -740, -740, -740, -109, -740, -740, -740, 961, -740,
1570 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1571 -86, -740, -740, -740, -740, -740, -740, -740, -740, 700,
1572 -740, -740, -740, -740, -740, 962, -740, -740, -740, -740,
1573 1052, -740, -740, -740, -740, 786, -740, -740, -740, -740,
1574 1011, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1575 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1576 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1577 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1578 -740, -740, -740, 80, -740, -740, -740, 96, -740, -740,
1579 -740, -740, -740, -740, 1088, -740, -740, -740, -740, -740,
1580 -740, -740, -740, -740, -740, -740, -740, -740, -740, -740,
1581 -740, 967, -740, -740, -740, -740, -740, -740, -740, -740,
1582 -740
1583 };
1584
1585 /* YYDEFGOTO[NTERM-NUM]. */
1586 static const yytype_int16 yydefgoto[] =
1587 {
1588 -1, 1, 26, 814, 815, 1074, 1075, 27, 221, 222,
1589 223, 224, 28, 265, 266, 267, 268, 269, 270, 271,
1590 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
1591 29, 77, 78, 79, 80, 81, 30, 63, 492, 493,
1592 494, 495, 31, 70, 574, 575, 576, 577, 578, 579,
1593 32, 285, 286, 287, 288, 289, 1033, 1034, 1035, 1036,
1594 1037, 1216, 1296, 1297, 33, 64, 507, 508, 509, 510,
1595 511, 512, 513, 514, 515, 516, 517, 743, 1193, 1194,
1596 518, 738, 1164, 1165, 34, 53, 335, 336, 337, 338,
1597 339, 340, 341, 342, 343, 344, 345, 346, 347, 348,
1598 349, 350, 351, 616, 1060, 1061, 35, 61, 478, 723,
1599 1130, 1131, 479, 480, 481, 1134, 978, 979, 482, 483,
1600 36, 59, 456, 457, 458, 459, 460, 461, 462, 708,
1601 1116, 1117, 463, 464, 465, 37, 65, 523, 524, 525,
1602 526, 527, 38, 293, 294, 295, 39, 72, 587, 588,
1603 589, 590, 591, 799, 1234, 1235, 40, 68, 560, 561,
1604 562, 563, 782, 1211, 1212, 41, 54, 367, 368, 369,
1605 370, 371, 372, 373, 374, 375, 376, 377, 637, 1087,
1606 1088, 378, 379, 380, 381, 382, 42, 60, 469, 470,
1607 471, 472, 43, 55, 386, 387, 388, 389, 44, 118,
1608 119, 120, 45, 57, 396, 397, 398, 399, 46, 168,
1609 169, 170, 171, 172, 173, 174, 175, 176, 177, 178,
1610 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
1611 189, 190, 191, 192, 193, 194, 195, 196, 197, 198,
1612 199, 200, 201, 202, 203, 204, 205, 206, 207, 208,
1613 209, 426, 940, 941, 210, 425, 915, 916, 211, 212,
1614 213, 214, 47, 97, 98, 99, 100, 101, 102, 103,
1615 104, 105, 106, 107, 108, 109, 110, 111, 112, 48,
1616 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
1617 248
1618 };
1619
1620 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1621 positive, shift that token. If negative, reduce the rule whose
1622 number is the opposite. If YYTABLE_NINF, syntax error. */
1623 static const yytype_int16 yytable[] =
1624 {
1625 843, 844, 598, 569, 569, 601, 602, 603, 583, 605,
1626 606, 1100, 218, 1029, 1085, 1101, 466, 519, 291, 283,
1627 393, 51, 116, 383, 73, 228, 1058, 52, 473, 116,
1628 1102, 1071, 1072, 1073, 1103, 56, 489, 58, 842, 1127,
1629 1237, 122, 297, 291, 1238, 489, 123, 124, 283, 125,
1630 126, 62, 73, 74, 127, 383, 66, 520, 229, 583,
1631 393, 75, 466, 128, 129, 130, 557, 1242, 230, 231,
1632 232, 1243, 131, 233, 234, 132, 133, 134, 235, 236,
1633 237, 74, 690, 135, 474, 691, 117, 384, 67, 75,
1634 49, 50, 475, 117, 476, 847, 848, 521, 1059, 658,
1635 136, 660, 661, 570, 570, 664, 1246, 69, 584, 219,
1636 1247, 137, 671, 1030, 138, 139, 490, 676, 292, 384,
1637 394, 71, 140, 557, 76, 490, 685, 686, 141, 842,
1638 142, 220, 143, 113, 144, 1266, 145, 146, 699, 700,
1639 701, 467, 522, 292, 114, 395, 249, 147, 385, 115,
1640 477, 319, 76, 148, 149, 121, 150, 151, 152, 584,
1641 394, 153, 215, 216, 1029, 1248, 558, 320, 321, 1249,
1642 571, 571, 322, 250, 352, 251, 353, 217, 354, 1259,
1643 385, 1128, 225, 1260, 218, 395, 154, 467, 572, 572,
1644 1129, 1261, 355, -125, 226, 1262, 155, 156, 157, 158,
1645 159, 160, 161, 252, 573, 573, 1086, 1263, 1031, 298,
1646 491, 1264, 356, 253, 1270, 227, 1299, 323, 1271, 491,
1647 1300, 692, -125, 558, 693, 447, 585, 282, 756, 586,
1648 357, 1032, 358, 793, 254, 324, 325, 468, 255, 284,
1649 359, 326, 487, 448, 82, 327, 256, 752, 496, 257,
1650 258, 328, 360, 162, 163, 537, 164, 165, 725, 391,
1651 329, 330, 331, 449, 1030, 166, 497, 167, 284, 83,
1652 84, 445, 332, 581, 361, 733, 85, 585, 566, 259,
1653 586, 219, 301, 468, 559, 649, 498, 290, 296, 801,
1654 655, 450, 718, 333, 568, 260, 362, 299, 261, 262,
1655 263, 300, 303, 220, 86, 87, 88, 89, 304, 473,
1656 519, 305, 306, 831, 499, 363, 834, 307, 836, 90,
1657 91, 92, 308, 841, 364, 309, 93, 94, 95, 496,
1658 96, 447, 1239, 1240, 1241, 310, 311, 365, 334, 312,
1659 313, 559, 314, 451, 315, 316, 264, 497, 500, 448,
1660 520, 452, 453, 783, 390, 596, 400, 597, 401, 1031,
1661 402, 403, 404, 405, 406, 474, 501, 498, 407, 449,
1662 408, 454, 409, 475, 366, 476, 555, 410, 484, 411,
1663 412, 628, 1032, 807, 808, 809, 810, 811, 812, 813,
1664 521, 413, 414, 415, 1217, 499, 539, 450, 502, 503,
1665 1139, 416, 122, 417, 645, 418, 592, 123, 124, 419,
1666 125, 126, 420, 421, 422, 127, 1140, 1141, 423, 424,
1667 427, 428, 429, 1106, 128, 129, 130, 1142, 430, 500,
1668 431, 477, 432, 131, 433, 522, 132, 133, 134, 434,
1669 435, 436, 437, 438, 135, 439, 455, 501, 1107, 451,
1670 504, 440, 441, 442, 443, 714, 444, 452, 453, 485,
1671 486, 136, 528, 529, 530, 1143, 1144, 531, 1145, 505,
1672 532, 533, 137, 506, 317, 138, 139, 454, 746, 502,
1673 503, 1108, 534, 140, 535, 536, 540, 541, 542, 141,
1674 543, 142, 544, 143, 1146, 144, 545, 145, 146, 546,
1675 547, 548, 1147, 549, 550, 551, 552, 249, 147, 553,
1676 1109, 1110, 554, 564, 148, 149, 1111, 150, 151, 152,
1677 565, 580, 153, 593, 594, 1148, 595, 1149, 1150, 597,
1678 599, 504, 600, 604, 250, 607, 251, 608, 609, 228,
1679 610, 1112, 611, 612, 613, 1151, 651, 154, 614, 615,
1680 505, 630, 455, 617, 506, 618, 1113, 155, 156, 157,
1681 158, 159, 160, 161, 252, 619, 620, 352, 1152, 353,
1682 621, 354, 229, 1153, 253, 622, 623, 1154, 624, 625,
1683 626, 1155, 230, 231, 232, 355, 1156, 233, 234, 1267,
1684 1157, 627, 235, 236, 237, 254, 631, 632, 633, 255,
1685 634, 1158, 635, 1159, 1160, 356, 1161, 256, 636, 638,
1686 257, 258, 639, 640, 162, 163, 1162, 164, 165, 1114,
1687 641, 642, 643, 357, 1163, 358, 166, 644, 167, 657,
1688 647, 319, 652, 359, 2, 3, 1201, 1115, 4, 648,
1689 259, 659, 653, 654, 662, 360, 663, 320, 321, 665,
1690 5, 666, 322, 6, 667, 7, 260, 668, 669, 261,
1691 262, 263, 670, 8, 672, 673, 674, 361, 1048, 1049,
1692 1050, 1051, 1052, 1053, 1054, 9, 675, 677, 678, 679,
1693 680, 10, 11, 917, 1288, 681, 1289, 682, 683, 362,
1694 918, 684, 919, 920, 687, 688, 1202, 323, 689, 694,
1695 12, 695, 696, 697, 13, 698, 702, 264, 363, 703,
1696 704, 705, 727, 728, 14, 324, 325, 364, 706, 754,
1697 755, 326, 720, 757, 758, 327, 707, 1203, 1170, 1290,
1698 365, 328, 709, 15, 16, 1171, 1204, 1172, 1173, 729,
1699 329, 330, 331, 710, 711, 1205, 1291, 712, 713, 17,
1700 716, 717, 332, 721, 722, 724, 730, 731, 732, 735,
1701 736, 737, 759, 739, 740, 748, 18, 366, 894, 1206,
1702 760, 1207, 1208, 333, 741, 895, 742, 744, 19, 20,
1703 745, 763, 749, 750, 1209, 1292, 1293, 751, 761, 762,
1704 764, 765, 1210, 766, 767, 770, 768, 769, 771, 772,
1705 773, 774, 775, 21, 776, 779, 921, 922, 923, 777,
1706 780, 924, 925, 778, 926, 927, 22, 928, 334, 929,
1707 1224, 23, 930, 781, 931, 932, 24, 785, 786, 25,
1708 933, 795, 788, 787, 934, 796, 1294, 789, 935, 936,
1709 937, 790, 1295, 791, 792, 938, 797, 803, 804, 805,
1710 939, 1174, 1175, 1176, 798, 800, 1177, 1178, 806, 1179,
1711 1180, 816, 1181, 817, 1182, 818, 819, 1183, 829, 1184,
1712 1185, 830, 820, 821, 822, 1186, 823, 824, 825, 1187,
1713 1225, 826, 827, 1188, 1189, 1190, 828, 832, 833, 835,
1714 1191, 896, 897, 898, 837, 1192, 899, 900, 838, 901,
1715 902, 839, 903, 840, 904, 842, 846, 905, 849, 906,
1716 907, 1226, 82, 845, 850, 908, 856, 851, 963, 909,
1717 1227, 852, 854, 910, 911, 912, 853, 855, 857, 1228,
1718 913, 861, 858, 859, 860, 914, 862, 83, 84, 863,
1719 864, 865, 866, 867, 85, 868, 869, 870, 871, 872,
1720 873, 874, 875, 1229, 876, 1230, 1231, 877, 878, 879,
1721 880, 881, 882, 883, 884, 885, 886, 887, 1232, 888,
1722 889, 890, 86, 87, 88, 89, 1233, 891, 962, 892,
1723 893, 942, 943, 944, 945, 946, 947, 90, 91, 92,
1724 948, 949, 965, 950, 93, 94, 95, 951, 96, 952,
1725 966, 953, 954, 955, 956, 957, 958, 959, 960, 967,
1726 968, 961, 969, 971, 972, 970, 964, 973, 974, 975,
1727 980, 976, 977, 983, 984, 981, 986, 989, 987, 982,
1728 985, 990, 991, 992, 988, 993, 994, 794, 995, 997,
1729 998, 996, 999, 1000, 1001, 1025, 1038, 1002, 1039, 1040,
1730 1003, 1041, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011,
1731 1012, 1013, 1014, 1015, 1016, 1017, 1018, 1019, 1020, 1021,
1732 1022, 1023, 1024, 1044, 1027, 1028, 1026, 1042, 1043, 1045,
1733 1046, 1047, 1055, 1056, 1133, 1057, 1062, 1063, 1064, 1065,
1734 1066, 1067, 1068, 1069, 1070, 1076, 1077, 1078, 1250, 1079,
1735 1080, 1081, 1082, 1083, 1084, 1089, 1090, 1091, 1092, 1093,
1736 1094, 1095, 1096, 1097, 1098, 1265, 1276, 1099, 1278, 1277,
1737 1280, 302, 1104, 1105, 1279, 1281, 1118, 1119, 1120, 734,
1738 1218, 1121, 1301, 747, 1122, 1123, 1124, 1132, 1282, 1125,
1739 1126, 1283, 1272, 1275, 726, 1274, 1251, 1135, 715, 802,
1740 1136, 1298, 753, 1137, 784, 1284, 1138, 1273, 1166, 1167,
1741 1168, 1169, 1195, 1196, 1197, 1198, 1199, 1200, 1213, 719,
1742 392, 1219, 1214, 1215, 1220, 1221, 1222, 1223, 1236, 446,
1743 1252, 488, 656, 1245, 629, 318, 1253, 1254, 1255, 1256,
1744 1257, 1268, 1258, 1269, 1285, 1286, 1287, 1244, 0, 0,
1745 0, 0, 0, 0, 0, 538, 0, 556, 0, 0,
1746 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1747 0, 0, 0, 0, 0, 0, 0, 0, 567, 0,
1748 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1750 0, 0, 582, 0, 0, 0, 0, 0, 0, 0,
1751 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1752 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1753 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1754 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1755 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1756 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1757 0, 0, 0, 0, 0, 0, 0, 0, 646, 0,
1758 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1759 0, 0, 0, 0, 0, 0, 0, 0, 650
1760 };
1761
1762 static const yytype_int16 yycheck[] =
1763 {
1764 626, 627, 304, 1, 1, 307, 308, 309, 1, 311,
1765 312, 230, 1, 1, 8, 234, 1, 1, 1, 1,
1766 1, 232, 1, 1, 1, 1, 53, 232, 1, 1,
1767 230, 11, 12, 13, 234, 232, 1, 232, 109, 49,
1768 230, 1, 230, 1, 234, 1, 6, 7, 1, 9,
1769 10, 232, 1, 30, 14, 1, 232, 41, 34, 1,
1770 1, 38, 1, 23, 24, 25, 1, 230, 44, 45,
1771 46, 234, 32, 49, 50, 35, 36, 37, 54, 55,
1772 56, 30, 212, 43, 57, 215, 65, 65, 232, 38,
1773 230, 231, 65, 65, 67, 179, 180, 81, 125, 401,
1774 60, 403, 404, 101, 101, 407, 230, 232, 101, 98,
1775 234, 71, 414, 101, 74, 75, 81, 419, 101, 65,
1776 101, 232, 82, 1, 101, 81, 428, 429, 88, 109,
1777 90, 120, 92, 232, 94, 206, 96, 97, 440, 441,
1778 442, 126, 126, 101, 232, 126, 1, 107, 126, 232,
1779 123, 1, 101, 113, 114, 232, 116, 117, 118, 101,
1780 101, 121, 232, 232, 1, 230, 101, 17, 18, 234,
1781 168, 168, 22, 28, 1, 30, 3, 232, 5, 230,
1782 126, 191, 232, 234, 1, 126, 146, 126, 186, 186,
1783 200, 230, 19, 175, 232, 234, 156, 157, 158, 159,
1784 160, 161, 162, 58, 202, 202, 200, 230, 196, 233,
1785 175, 234, 39, 68, 230, 232, 230, 67, 234, 175,
1786 234, 212, 175, 101, 215, 1, 219, 232, 530, 222,
1787 57, 219, 59, 231, 89, 85, 86, 222, 93, 221,
1788 67, 91, 231, 19, 1, 95, 101, 231, 1, 104,
1789 105, 101, 79, 213, 214, 231, 216, 217, 231, 231,
1790 110, 111, 112, 39, 101, 225, 19, 227, 221, 26,
1791 27, 231, 122, 231, 101, 231, 33, 219, 231, 134,
1792 222, 98, 231, 222, 219, 231, 39, 232, 232, 231,
1793 231, 67, 231, 143, 175, 150, 123, 233, 153, 154,
1794 155, 233, 233, 120, 61, 62, 63, 64, 233, 1,
1795 1, 233, 233, 615, 67, 142, 618, 233, 620, 76,
1796 77, 78, 233, 625, 151, 233, 83, 84, 85, 1,
1797 87, 1, 1071, 1072, 1073, 233, 233, 164, 188, 233,
1798 233, 219, 233, 119, 233, 233, 201, 19, 101, 19,
1799 41, 127, 128, 231, 233, 109, 233, 109, 233, 196,
1800 233, 233, 233, 233, 233, 57, 119, 39, 233, 39,
1801 233, 147, 233, 65, 201, 67, 231, 233, 230, 233,
1802 233, 231, 219, 135, 136, 137, 138, 139, 140, 141,
1803 81, 233, 233, 233, 231, 67, 230, 67, 151, 152,
1804 4, 233, 1, 233, 231, 233, 124, 6, 7, 233,
1805 9, 10, 233, 233, 233, 14, 20, 21, 233, 233,
1806 233, 233, 233, 15, 23, 24, 25, 31, 233, 101,
1807 233, 123, 233, 32, 233, 126, 35, 36, 37, 233,
1808 233, 233, 233, 233, 43, 233, 222, 119, 40, 119,
1809 203, 233, 233, 233, 233, 231, 233, 127, 128, 233,
1810 233, 60, 233, 233, 233, 69, 70, 233, 72, 222,
1811 233, 233, 71, 226, 231, 74, 75, 147, 231, 151,
1812 152, 73, 233, 82, 233, 233, 233, 233, 233, 88,
1813 233, 90, 233, 92, 98, 94, 233, 96, 97, 233,
1814 233, 233, 106, 233, 233, 233, 233, 1, 107, 233,
1815 102, 103, 233, 230, 113, 114, 108, 116, 117, 118,
1816 233, 233, 121, 124, 124, 129, 230, 131, 132, 109,
1817 212, 203, 109, 109, 28, 109, 30, 109, 109, 1,
1818 109, 133, 230, 230, 233, 149, 124, 146, 233, 233,
1819 222, 230, 222, 233, 226, 233, 148, 156, 157, 158,
1820 159, 160, 161, 162, 58, 233, 233, 1, 172, 3,
1821 233, 5, 34, 177, 68, 233, 233, 181, 233, 233,
1822 233, 185, 44, 45, 46, 19, 190, 49, 50, 1215,
1823 194, 233, 54, 55, 56, 89, 233, 233, 233, 93,
1824 233, 205, 233, 207, 208, 39, 210, 101, 233, 233,
1825 104, 105, 233, 233, 213, 214, 220, 216, 217, 211,
1826 233, 233, 233, 57, 228, 59, 225, 233, 227, 212,
1827 233, 1, 230, 67, 0, 1, 72, 229, 4, 233,
1828 134, 109, 233, 233, 212, 79, 109, 17, 18, 212,
1829 16, 109, 22, 19, 109, 21, 150, 109, 212, 153,
1830 154, 155, 212, 29, 109, 109, 109, 101, 807, 808,
1831 809, 810, 811, 812, 813, 41, 109, 109, 109, 109,
1832 109, 47, 48, 42, 70, 212, 72, 233, 233, 123,
1833 49, 212, 51, 52, 212, 212, 132, 67, 212, 212,
1834 66, 212, 212, 212, 70, 109, 212, 201, 142, 109,
1835 230, 230, 124, 124, 80, 85, 86, 151, 233, 212,
1836 212, 91, 230, 124, 212, 95, 233, 163, 42, 115,
1837 164, 101, 233, 99, 100, 49, 172, 51, 52, 230,
1838 110, 111, 112, 233, 233, 181, 132, 233, 233, 115,
1839 233, 233, 122, 233, 233, 233, 230, 233, 233, 230,
1840 233, 233, 124, 233, 233, 230, 132, 201, 42, 205,
1841 212, 207, 208, 143, 233, 49, 233, 233, 144, 145,
1842 233, 230, 233, 233, 220, 171, 172, 233, 212, 212,
1843 109, 124, 228, 212, 124, 124, 109, 109, 124, 124,
1844 124, 124, 124, 169, 124, 230, 165, 166, 167, 124,
1845 230, 170, 171, 124, 173, 174, 182, 176, 188, 178,
1846 72, 187, 181, 233, 183, 184, 192, 212, 230, 195,
1847 189, 124, 230, 232, 193, 230, 222, 233, 197, 198,
1848 199, 233, 228, 233, 233, 204, 230, 230, 230, 230,
1849 209, 165, 166, 167, 233, 233, 170, 171, 230, 173,
1850 174, 230, 176, 230, 178, 230, 230, 181, 109, 183,
1851 184, 109, 230, 230, 230, 189, 230, 230, 230, 193,
1852 132, 230, 230, 197, 198, 199, 230, 233, 109, 109,
1853 204, 165, 166, 167, 124, 209, 170, 171, 109, 173,
1854 174, 109, 176, 109, 178, 109, 124, 181, 124, 183,
1855 184, 163, 1, 230, 212, 189, 109, 124, 212, 193,
1856 172, 124, 124, 197, 198, 199, 233, 124, 124, 181,
1857 204, 230, 124, 124, 124, 209, 124, 26, 27, 124,
1858 230, 230, 124, 124, 33, 230, 230, 230, 230, 230,
1859 230, 230, 230, 205, 230, 207, 208, 230, 230, 230,
1860 230, 230, 230, 230, 230, 230, 230, 230, 220, 230,
1861 230, 230, 61, 62, 63, 64, 228, 230, 124, 230,
1862 230, 230, 230, 230, 230, 230, 230, 76, 77, 78,
1863 230, 230, 124, 230, 83, 84, 85, 230, 87, 230,
1864 109, 230, 230, 230, 230, 230, 230, 230, 230, 124,
1865 124, 230, 124, 124, 124, 230, 233, 230, 124, 124,
1866 230, 233, 109, 124, 124, 230, 124, 124, 212, 230,
1867 230, 124, 124, 212, 233, 233, 124, 574, 124, 124,
1868 124, 230, 124, 230, 230, 124, 124, 230, 124, 124,
1869 230, 124, 230, 230, 230, 230, 230, 230, 230, 230,
1870 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
1871 230, 230, 230, 124, 230, 230, 233, 230, 230, 233,
1872 124, 230, 230, 230, 234, 230, 230, 230, 230, 230,
1873 230, 230, 230, 230, 230, 230, 230, 230, 109, 230,
1874 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
1875 230, 230, 230, 230, 230, 124, 130, 230, 130, 132,
1876 130, 77, 230, 230, 132, 130, 230, 230, 230, 492,
1877 1033, 230, 1300, 507, 230, 230, 230, 218, 1260, 230,
1878 230, 1262, 1238, 1249, 479, 1247, 1133, 230, 456, 587,
1879 230, 1271, 523, 230, 560, 1264, 230, 1243, 230, 230,
1880 230, 230, 230, 230, 230, 230, 230, 230, 230, 469,
1881 118, 230, 233, 233, 230, 230, 230, 230, 230, 168,
1882 230, 221, 396, 1103, 335, 97, 235, 235, 235, 235,
1883 235, 233, 235, 230, 230, 230, 230, 1101, -1, -1,
1884 -1, -1, -1, -1, -1, 238, -1, 265, -1, -1,
1885 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1886 -1, -1, -1, -1, -1, -1, -1, -1, 285, -1,
1887 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1888 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1889 -1, -1, 293, -1, -1, -1, -1, -1, -1, -1,
1890 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1891 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1892 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1893 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1894 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1895 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1896 -1, -1, -1, -1, -1, -1, -1, -1, 367, -1,
1897 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1898 -1, -1, -1, -1, -1, -1, -1, -1, 386
1899 };
1900
1901 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1902 symbol of state STATE-NUM. */
1903 static const yytype_uint16 yystos[] =
1904 {
1905 0, 237, 0, 1, 4, 16, 19, 21, 29, 41,
1906 47, 48, 66, 70, 80, 99, 100, 115, 132, 144,
1907 145, 169, 182, 187, 192, 195, 238, 243, 248, 266,
1908 272, 278, 286, 300, 320, 342, 356, 371, 378, 382,
1909 392, 401, 422, 428, 434, 438, 444, 498, 515, 230,
1910 231, 232, 232, 321, 402, 429, 232, 439, 232, 357,
1911 423, 343, 232, 273, 301, 372, 232, 232, 393, 232,
1912 279, 232, 383, 1, 30, 38, 101, 267, 268, 269,
1913 270, 271, 1, 26, 27, 33, 61, 62, 63, 64,
1914 76, 77, 78, 83, 84, 85, 87, 499, 500, 501,
1915 502, 503, 504, 505, 506, 507, 508, 509, 510, 511,
1916 512, 513, 514, 232, 232, 232, 1, 65, 435, 436,
1917 437, 232, 1, 6, 7, 9, 10, 14, 23, 24,
1918 25, 32, 35, 36, 37, 43, 60, 71, 74, 75,
1919 82, 88, 90, 92, 94, 96, 97, 107, 113, 114,
1920 116, 117, 118, 121, 146, 156, 157, 158, 159, 160,
1921 161, 162, 213, 214, 216, 217, 225, 227, 445, 446,
1922 447, 448, 449, 450, 451, 452, 453, 454, 455, 456,
1923 457, 458, 459, 460, 461, 462, 463, 464, 465, 466,
1924 467, 468, 469, 470, 471, 472, 473, 474, 475, 476,
1925 477, 478, 479, 480, 481, 482, 483, 484, 485, 486,
1926 490, 494, 495, 496, 497, 232, 232, 232, 1, 98,
1927 120, 244, 245, 246, 247, 232, 232, 232, 1, 34,
1928 44, 45, 46, 49, 50, 54, 55, 56, 516, 517,
1929 518, 519, 520, 521, 522, 523, 524, 525, 526, 1,
1930 28, 30, 58, 68, 89, 93, 101, 104, 105, 134,
1931 150, 153, 154, 155, 201, 249, 250, 251, 252, 253,
1932 254, 255, 256, 257, 258, 259, 260, 261, 262, 263,
1933 264, 265, 232, 1, 221, 287, 288, 289, 290, 291,
1934 232, 1, 101, 379, 380, 381, 232, 230, 233, 233,
1935 233, 231, 268, 233, 233, 233, 233, 233, 233, 233,
1936 233, 233, 233, 233, 233, 233, 233, 231, 500, 1,
1937 17, 18, 22, 67, 85, 86, 91, 95, 101, 110,
1938 111, 112, 122, 143, 188, 322, 323, 324, 325, 326,
1939 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
1940 337, 338, 1, 3, 5, 19, 39, 57, 59, 67,
1941 79, 101, 123, 142, 151, 164, 201, 403, 404, 405,
1942 406, 407, 408, 409, 410, 411, 412, 413, 417, 418,
1943 419, 420, 421, 1, 65, 126, 430, 431, 432, 433,
1944 233, 231, 436, 1, 101, 126, 440, 441, 442, 443,
1945 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
1946 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
1947 233, 233, 233, 233, 233, 491, 487, 233, 233, 233,
1948 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
1949 233, 233, 233, 233, 233, 231, 446, 1, 19, 39,
1950 67, 119, 127, 128, 147, 222, 358, 359, 360, 361,
1951 362, 363, 364, 368, 369, 370, 1, 126, 222, 424,
1952 425, 426, 427, 1, 57, 65, 67, 123, 344, 348,
1953 349, 350, 354, 355, 230, 233, 233, 231, 245, 1,
1954 81, 175, 274, 275, 276, 277, 1, 19, 39, 67,
1955 101, 119, 151, 152, 203, 222, 226, 302, 303, 304,
1956 305, 306, 307, 308, 309, 310, 311, 312, 316, 1,
1957 41, 81, 126, 373, 374, 375, 376, 377, 233, 233,
1958 233, 233, 233, 233, 233, 233, 233, 231, 517, 230,
1959 233, 233, 233, 233, 233, 233, 233, 233, 233, 233,
1960 233, 233, 233, 233, 233, 231, 250, 1, 101, 219,
1961 394, 395, 396, 397, 230, 233, 231, 288, 175, 1,
1962 101, 168, 186, 202, 280, 281, 282, 283, 284, 285,
1963 233, 231, 380, 1, 101, 219, 222, 384, 385, 386,
1964 387, 388, 124, 124, 124, 230, 109, 109, 240, 212,
1965 109, 240, 240, 240, 109, 240, 240, 109, 109, 109,
1966 109, 230, 230, 233, 233, 233, 339, 233, 233, 233,
1967 233, 233, 233, 233, 233, 233, 233, 233, 231, 323,
1968 230, 233, 233, 233, 233, 233, 233, 414, 233, 233,
1969 233, 233, 233, 233, 233, 231, 404, 233, 233, 231,
1970 431, 124, 230, 233, 233, 231, 441, 212, 240, 109,
1971 240, 240, 212, 109, 240, 212, 109, 109, 109, 212,
1972 212, 240, 109, 109, 109, 109, 240, 109, 109, 109,
1973 109, 212, 233, 233, 212, 240, 240, 212, 212, 212,
1974 212, 215, 212, 215, 212, 212, 212, 212, 109, 240,
1975 240, 240, 212, 109, 230, 230, 233, 233, 365, 233,
1976 233, 233, 233, 233, 231, 359, 233, 233, 231, 425,
1977 230, 233, 233, 345, 233, 231, 349, 124, 124, 230,
1978 230, 233, 233, 231, 275, 230, 233, 233, 317, 233,
1979 233, 233, 233, 313, 233, 233, 231, 303, 230, 233,
1980 233, 233, 231, 374, 212, 212, 240, 124, 212, 124,
1981 212, 212, 212, 230, 109, 124, 212, 124, 109, 109,
1982 124, 124, 124, 124, 124, 124, 124, 124, 124, 230,
1983 230, 233, 398, 231, 395, 212, 230, 232, 230, 233,
1984 233, 233, 233, 231, 281, 124, 230, 230, 233, 389,
1985 233, 231, 385, 230, 230, 230, 230, 135, 136, 137,
1986 138, 139, 140, 141, 239, 240, 230, 230, 230, 230,
1987 230, 230, 230, 230, 230, 230, 230, 230, 230, 109,
1988 109, 240, 233, 109, 240, 109, 240, 124, 109, 109,
1989 109, 240, 109, 242, 242, 230, 124, 179, 180, 124,
1990 212, 124, 124, 233, 124, 124, 109, 124, 124, 124,
1991 124, 230, 124, 124, 230, 230, 124, 124, 230, 230,
1992 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
1993 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
1994 230, 230, 230, 230, 42, 49, 165, 166, 167, 170,
1995 171, 173, 174, 176, 178, 181, 183, 184, 189, 193,
1996 197, 198, 199, 204, 209, 492, 493, 42, 49, 51,
1997 52, 165, 166, 167, 170, 171, 173, 174, 176, 178,
1998 181, 183, 184, 189, 193, 197, 198, 199, 204, 209,
1999 488, 489, 230, 230, 230, 230, 230, 230, 230, 230,
2000 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
2001 230, 230, 124, 212, 233, 124, 109, 124, 124, 124,
2002 230, 124, 124, 230, 124, 124, 233, 109, 352, 353,
2003 230, 230, 230, 124, 124, 230, 124, 212, 233, 124,
2004 124, 124, 212, 233, 124, 124, 230, 124, 124, 124,
2005 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
2006 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
2007 230, 230, 230, 230, 230, 124, 233, 230, 230, 1,
2008 101, 196, 219, 292, 293, 294, 295, 296, 124, 124,
2009 124, 124, 230, 230, 124, 233, 124, 230, 239, 239,
2010 239, 239, 239, 239, 239, 230, 230, 230, 53, 125,
2011 340, 341, 230, 230, 230, 230, 230, 230, 230, 230,
2012 230, 11, 12, 13, 241, 242, 230, 230, 230, 230,
2013 230, 230, 230, 230, 230, 8, 200, 415, 416, 230,
2014 230, 230, 230, 230, 230, 230, 230, 230, 230, 230,
2015 230, 234, 230, 234, 230, 230, 15, 40, 73, 102,
2016 103, 108, 133, 148, 211, 229, 366, 367, 230, 230,
2017 230, 230, 230, 230, 230, 230, 230, 49, 191, 200,
2018 346, 347, 218, 234, 351, 230, 230, 230, 230, 4,
2019 20, 21, 31, 69, 70, 72, 98, 106, 129, 131,
2020 132, 149, 172, 177, 181, 185, 190, 194, 205, 207,
2021 208, 210, 220, 228, 318, 319, 230, 230, 230, 230,
2022 42, 49, 51, 52, 165, 166, 167, 170, 171, 173,
2023 174, 176, 178, 181, 183, 184, 189, 193, 197, 198,
2024 199, 204, 209, 314, 315, 230, 230, 230, 230, 230,
2025 230, 72, 132, 163, 172, 181, 205, 207, 208, 220,
2026 228, 399, 400, 230, 233, 233, 297, 231, 293, 230,
2027 230, 230, 230, 230, 72, 132, 163, 172, 181, 205,
2028 207, 208, 220, 228, 390, 391, 230, 230, 234, 241,
2029 241, 241, 230, 234, 493, 489, 230, 234, 230, 234,
2030 109, 353, 230, 235, 235, 235, 235, 235, 235, 230,
2031 234, 230, 234, 230, 234, 124, 206, 242, 233, 230,
2032 230, 234, 341, 416, 367, 347, 130, 132, 130, 132,
2033 130, 130, 319, 315, 400, 230, 230, 230, 70, 72,
2034 115, 132, 171, 172, 222, 228, 298, 299, 391, 230,
2035 234, 299
2036 };
2037
2038 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
2039 static const yytype_uint16 yyr1[] =
2040 {
2041 0, 236, 237, 237, 238, 238, 238, 238, 238, 238,
2042 238, 238, 238, 238, 238, 238, 238, 238, 238, 238,
2043 238, 238, 238, 238, 238, 238, 238, 238, 239, 239,
2044 240, 240, 240, 240, 240, 240, 240, 240, 241, 241,
2045 242, 242, 242, 242, 243, 244, 244, 245, 245, 245,
2046 246, 247, 248, 249, 249, 250, 250, 250, 250, 250,
2047 250, 250, 250, 250, 250, 250, 250, 250, 250, 250,
2048 250, 251, 252, 253, 254, 255, 256, 257, 258, 259,
2049 260, 261, 262, 263, 264, 265, 266, 267, 267, 268,
2050 268, 268, 268, 269, 270, 271, 273, 272, 274, 274,
2051 275, 275, 275, 276, 277, 279, 278, 280, 280, 281,
2052 281, 281, 281, 281, 282, 283, 284, 285, 286, 287,
2053 287, 288, 288, 288, 289, 291, 290, 292, 292, 293,
2054 293, 293, 293, 294, 295, 295, 297, 296, 298, 298,
2055 299, 299, 299, 299, 299, 299, 299, 299, 301, 300,
2056 302, 302, 303, 303, 303, 303, 303, 303, 303, 303,
2057 303, 303, 303, 304, 305, 306, 307, 308, 309, 310,
2058 311, 313, 312, 314, 314, 315, 315, 315, 315, 315,
2059 315, 315, 315, 315, 315, 315, 315, 315, 315, 315,
2060 315, 315, 315, 315, 315, 315, 315, 315, 317, 316,
2061 318, 318, 319, 319, 319, 319, 319, 319, 319, 319,
2062 319, 319, 319, 319, 319, 319, 319, 319, 319, 319,
2063 319, 319, 319, 319, 319, 319, 319, 319, 319, 319,
2064 319, 321, 320, 322, 322, 323, 323, 323, 323, 323,
2065 323, 323, 323, 323, 323, 323, 323, 323, 323, 323,
2066 323, 324, 325, 326, 327, 328, 329, 330, 331, 332,
2067 333, 334, 335, 336, 337, 339, 338, 340, 340, 341,
2068 341, 343, 342, 345, 344, 346, 346, 347, 347, 347,
2069 348, 348, 349, 349, 349, 349, 349, 351, 350, 352,
2070 352, 353, 353, 354, 355, 357, 356, 358, 358, 359,
2071 359, 359, 359, 359, 359, 359, 359, 359, 360, 361,
2072 362, 363, 365, 364, 366, 366, 367, 367, 367, 367,
2073 367, 367, 367, 367, 367, 367, 368, 369, 370, 372,
2074 371, 373, 373, 374, 374, 374, 374, 375, 376, 377,
2075 378, 379, 379, 380, 380, 381, 383, 382, 384, 384,
2076 385, 385, 385, 385, 386, 387, 389, 388, 390, 390,
2077 391, 391, 391, 391, 391, 391, 391, 391, 391, 391,
2078 393, 392, 394, 394, 395, 395, 395, 396, 398, 397,
2079 399, 399, 400, 400, 400, 400, 400, 400, 400, 400,
2080 400, 400, 402, 401, 403, 403, 404, 404, 404, 404,
2081 404, 404, 404, 404, 404, 404, 404, 404, 404, 404,
2082 404, 405, 406, 407, 408, 409, 410, 411, 412, 412,
2083 414, 413, 415, 415, 416, 416, 417, 418, 419, 420,
2084 421, 423, 422, 424, 424, 425, 425, 425, 426, 427,
2085 429, 428, 430, 430, 431, 431, 431, 432, 433, 434,
2086 435, 435, 436, 436, 437, 439, 438, 440, 440, 441,
2087 441, 441, 442, 443, 444, 445, 445, 446, 446, 446,
2088 446, 446, 446, 446, 446, 446, 446, 446, 446, 446,
2089 446, 446, 446, 446, 446, 446, 446, 446, 446, 446,
2090 446, 446, 446, 446, 446, 446, 446, 446, 446, 446,
2091 446, 446, 446, 446, 446, 446, 446, 446, 446, 446,
2092 446, 446, 446, 447, 448, 449, 450, 451, 452, 453,
2093 454, 455, 456, 457, 458, 459, 460, 461, 462, 463,
2094 464, 465, 466, 467, 468, 469, 470, 471, 472, 472,
2095 473, 473, 474, 475, 476, 477, 478, 479, 480, 481,
2096 482, 483, 484, 485, 487, 486, 488, 488, 489, 489,
2097 489, 489, 489, 489, 489, 489, 489, 489, 489, 489,
2098 489, 489, 489, 489, 489, 489, 489, 489, 489, 489,
2099 489, 491, 490, 492, 492, 493, 493, 493, 493, 493,
2100 493, 493, 493, 493, 493, 493, 493, 493, 493, 493,
2101 493, 493, 493, 493, 493, 493, 494, 495, 496, 497,
2102 498, 499, 499, 500, 500, 500, 500, 500, 500, 500,
2103 500, 500, 500, 500, 500, 500, 500, 500, 501, 502,
2104 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
2105 513, 514, 515, 516, 516, 517, 517, 517, 517, 517,
2106 517, 517, 517, 517, 517, 518, 519, 520, 521, 522,
2107 523, 524, 525, 526
2108 };
2109
2110 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
2111 static const yytype_uint8 yyr2[] =
2112 {
2113 0, 2, 0, 2, 1, 1, 1, 1, 1, 1,
2114 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2115 1, 1, 1, 1, 1, 1, 2, 2, 0, 1,
2116 2, 3, 3, 3, 3, 3, 3, 3, 0, 1,
2117 2, 3, 3, 3, 5, 2, 1, 1, 1, 2,
2118 4, 4, 5, 2, 1, 1, 1, 1, 1, 1,
2119 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2120 2, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2121 4, 4, 4, 4, 4, 4, 5, 2, 1, 1,
2122 1, 1, 2, 4, 4, 4, 0, 6, 2, 1,
2123 1, 1, 2, 4, 4, 0, 6, 2, 1, 1,
2124 1, 1, 1, 2, 4, 4, 4, 4, 5, 2,
2125 1, 1, 1, 2, 4, 0, 6, 2, 1, 1,
2126 1, 1, 2, 4, 4, 4, 0, 5, 3, 1,
2127 1, 1, 1, 1, 1, 1, 1, 1, 0, 6,
2128 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2129 1, 1, 2, 4, 4, 4, 4, 4, 4, 4,
2130 4, 0, 5, 3, 1, 1, 1, 1, 1, 1,
2131 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2132 1, 1, 1, 1, 1, 1, 1, 1, 0, 5,
2133 3, 1, 3, 1, 3, 1, 3, 1, 1, 1,
2134 1, 1, 1, 1, 1, 1, 3, 1, 1, 1,
2135 1, 1, 1, 1, 1, 1, 3, 3, 1, 1,
2136 1, 0, 6, 2, 1, 1, 1, 1, 1, 1,
2137 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2138 2, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2139 4, 4, 4, 4, 4, 0, 5, 3, 1, 1,
2140 1, 0, 6, 0, 5, 3, 1, 1, 1, 1,
2141 2, 1, 1, 1, 1, 1, 2, 0, 5, 3,
2142 1, 1, 3, 4, 4, 0, 6, 2, 1, 1,
2143 1, 1, 1, 1, 1, 1, 1, 2, 4, 4,
2144 4, 4, 0, 5, 3, 1, 1, 1, 1, 1,
2145 1, 1, 1, 1, 1, 1, 4, 4, 4, 0,
2146 6, 2, 1, 1, 1, 1, 2, 4, 4, 4,
2147 5, 2, 1, 1, 1, 4, 0, 6, 2, 1,
2148 1, 1, 1, 2, 4, 4, 0, 5, 3, 1,
2149 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2150 0, 6, 2, 1, 1, 1, 2, 4, 0, 5,
2151 3, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2152 1, 1, 0, 6, 2, 1, 1, 1, 1, 1,
2153 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2154 2, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2155 0, 5, 3, 1, 1, 1, 4, 4, 4, 4,
2156 4, 0, 6, 2, 1, 1, 1, 1, 4, 4,
2157 0, 6, 2, 1, 1, 1, 1, 4, 4, 5,
2158 2, 1, 1, 1, 4, 0, 6, 2, 1, 1,
2159 1, 1, 4, 4, 5, 2, 1, 1, 1, 1,
2160 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2161 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2162 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2163 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2164 1, 1, 1, 4, 4, 4, 4, 4, 4, 4,
2165 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2166 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2167 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2168 4, 4, 4, 4, 0, 5, 3, 1, 1, 1,
2169 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2170 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2171 1, 0, 5, 3, 1, 1, 1, 1, 1, 1,
2172 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2173 1, 1, 1, 1, 1, 1, 4, 4, 4, 4,
2174 5, 2, 1, 1, 1, 1, 1, 1, 1, 1,
2175 1, 1, 1, 1, 1, 1, 1, 1, 4, 4,
2176 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
2177 4, 4, 5, 2, 1, 1, 1, 1, 1, 1,
2178 1, 1, 1, 1, 1, 4, 4, 4, 4, 4,
2179 4, 4, 4, 4
2180 };
2181
2182
2183 #define yyerrok (yyerrstatus = 0)
2184 #define yyclearin (yychar = YYEMPTY)
2185 #define YYEMPTY (-2)
2186 #define YYEOF 0
2187
2188 #define YYACCEPT goto yyacceptlab
2189 #define YYABORT goto yyabortlab
2190 #define YYERROR goto yyerrorlab
2191
2192
2193 #define YYRECOVERING() (!!yyerrstatus)
2194
2195 #define YYBACKUP(Token, Value) \
2196 do \
2197 if (yychar == YYEMPTY) \
2198 { \
2199 yychar = (Token); \
2200 yylval = (Value); \
2201 YYPOPSTACK (yylen); \
2202 yystate = *yyssp; \
2203 goto yybackup; \
2204 } \
2205 else \
2206 { \
2207 yyerror (YY_("syntax error: cannot back up")); \
2208 YYERROR; \
2209 } \
2210 while (0)
2211
2212 /* Error token number */
2213 #define YYTERROR 1
2214 #define YYERRCODE 256
2215
2216
2217
2218 /* Enable debugging if requested. */
2219 #if YYDEBUG
2220
2221 # ifndef YYFPRINTF
2222 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2223 # define YYFPRINTF fprintf
2224 # endif
2225
2226 # define YYDPRINTF(Args) \
2227 do { \
2228 if (yydebug) \
2229 YYFPRINTF Args; \
2230 } while (0)
2231
2232 /* This macro is provided for backward compatibility. */
2233 #ifndef YY_LOCATION_PRINT
2234 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2235 #endif
2236
2237
2238 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
2239 do { \
2240 if (yydebug) \
2241 { \
2242 YYFPRINTF (stderr, "%s ", Title); \
2243 yy_symbol_print (stderr, \
2244 Type, Value); \
2245 YYFPRINTF (stderr, "\n"); \
2246 } \
2247 } while (0)
2248
2249
2250 /*-----------------------------------.
2251 | Print this symbol's value on YYO. |
2252 `-----------------------------------*/
2253
2254 static void
2255 yy_symbol_value_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
2256 {
2257 FILE *yyoutput = yyo;
2258 YYUSE (yyoutput);
2259 if (!yyvaluep)
2260 return;
2261 # ifdef YYPRINT
2262 if (yytype < YYNTOKENS)
2263 YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
2264 # endif
2265 YYUSE (yytype);
2266 }
2267
2268
2269 /*---------------------------.
2270 | Print this symbol on YYO. |
2271 `---------------------------*/
2272
2273 static void
2274 yy_symbol_print (FILE *yyo, int yytype, YYSTYPE const * const yyvaluep)
2275 {
2276 YYFPRINTF (yyo, "%s %s (",
2277 yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
2278
2279 yy_symbol_value_print (yyo, yytype, yyvaluep);
2280 YYFPRINTF (yyo, ")");
2281 }
2282
2283 /*------------------------------------------------------------------.
2284 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2285 | TOP (included). |
2286 `------------------------------------------------------------------*/
2287
2288 static void
2289 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
2290 {
2291 YYFPRINTF (stderr, "Stack now");
2292 for (; yybottom <= yytop; yybottom++)
2293 {
2294 int yybot = *yybottom;
2295 YYFPRINTF (stderr, " %d", yybot);
2296 }
2297 YYFPRINTF (stderr, "\n");
2298 }
2299
2300 # define YY_STACK_PRINT(Bottom, Top) \
2301 do { \
2302 if (yydebug) \
2303 yy_stack_print ((Bottom), (Top)); \
2304 } while (0)
2305
2306
2307 /*------------------------------------------------.
2308 | Report that the YYRULE is going to be reduced. |
2309 `------------------------------------------------*/
2310
2311 static void
2312 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
2313 {
2314 unsigned long yylno = yyrline[yyrule];
2315 int yynrhs = yyr2[yyrule];
2316 int yyi;
2317 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2318 yyrule - 1, yylno);
2319 /* The symbols being reduced. */
2320 for (yyi = 0; yyi < yynrhs; yyi++)
2321 {
2322 YYFPRINTF (stderr, " $%d = ", yyi + 1);
2323 yy_symbol_print (stderr,
2324 yystos[yyssp[yyi + 1 - yynrhs]],
2325 &yyvsp[(yyi + 1) - (yynrhs)]
2326 );
2327 YYFPRINTF (stderr, "\n");
2328 }
2329 }
2330
2331 # define YY_REDUCE_PRINT(Rule) \
2332 do { \
2333 if (yydebug) \
2334 yy_reduce_print (yyssp, yyvsp, Rule); \
2335 } while (0)
2336
2337 /* Nonzero means print parse trace. It is left uninitialized so that
2338 multiple parsers can coexist. */
2339 int yydebug;
2340 #else /* !YYDEBUG */
2341 # define YYDPRINTF(Args)
2342 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2343 # define YY_STACK_PRINT(Bottom, Top)
2344 # define YY_REDUCE_PRINT(Rule)
2345 #endif /* !YYDEBUG */
2346
2347
2348 /* YYINITDEPTH -- initial size of the parser's stacks. */
2349 #ifndef YYINITDEPTH
2350 # define YYINITDEPTH 200
2351 #endif
2352
2353 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2354 if the built-in stack extension method is used).
2355
2356 Do not make this value too large; the results are undefined if
2357 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2358 evaluated with infinite-precision integer arithmetic. */
2359
2360 #ifndef YYMAXDEPTH
2361 # define YYMAXDEPTH 10000
2362 #endif
2363
2364
2365 #if YYERROR_VERBOSE
2366
2367 # ifndef yystrlen
2368 # if defined __GLIBC__ && defined _STRING_H
2369 # define yystrlen strlen
2370 # else
2371 /* Return the length of YYSTR. */
2372 static YYSIZE_T
2373 yystrlen (const char *yystr)
2374 {
2375 YYSIZE_T yylen;
2376 for (yylen = 0; yystr[yylen]; yylen++)
2377 continue;
2378 return yylen;
2379 }
2380 # endif
2381 # endif
2382
2383 # ifndef yystpcpy
2384 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2385 # define yystpcpy stpcpy
2386 # else
2387 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2388 YYDEST. */
2389 static char *
2390 yystpcpy (char *yydest, const char *yysrc)
2391 {
2392 char *yyd = yydest;
2393 const char *yys = yysrc;
2394
2395 while ((*yyd++ = *yys++) != '\0')
2396 continue;
2397
2398 return yyd - 1;
2399 }
2400 # endif
2401 # endif
2402
2403 # ifndef yytnamerr
2404 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2405 quotes and backslashes, so that it's suitable for yyerror. The
2406 heuristic is that double-quoting is unnecessary unless the string
2407 contains an apostrophe, a comma, or backslash (other than
2408 backslash-backslash). YYSTR is taken from yytname. If YYRES is
2409 null, do not copy; instead, return the length of what the result
2410 would have been. */
2411 static YYSIZE_T
2412 yytnamerr (char *yyres, const char *yystr)
2413 {
2414 if (*yystr == '"')
2415 {
2416 YYSIZE_T yyn = 0;
2417 char const *yyp = yystr;
2418
2419 for (;;)
2420 switch (*++yyp)
2421 {
2422 case '\'':
2423 case ',':
2424 goto do_not_strip_quotes;
2425
2426 case '\\':
2427 if (*++yyp != '\\')
2428 goto do_not_strip_quotes;
2429 else
2430 goto append;
2431
2432 append:
2433 default:
2434 if (yyres)
2435 yyres[yyn] = *yyp;
2436 yyn++;
2437 break;
2438
2439 case '"':
2440 if (yyres)
2441 yyres[yyn] = '\0';
2442 return yyn;
2443 }
2444 do_not_strip_quotes: ;
2445 }
2446
2447 if (! yyres)
2448 return yystrlen (yystr);
2449
2450 return (YYSIZE_T) (yystpcpy (yyres, yystr) - yyres);
2451 }
2452 # endif
2453
2454 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
2455 about the unexpected token YYTOKEN for the state stack whose top is
2456 YYSSP.
2457
2458 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
2459 not large enough to hold the message. In that case, also set
2460 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
2461 required number of bytes is too large to store. */
2462 static int
2463 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
2464 yytype_int16 *yyssp, int yytoken)
2465 {
2466 YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
2467 YYSIZE_T yysize = yysize0;
2468 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2469 /* Internationalized format string. */
2470 const char *yyformat = YY_NULLPTR;
2471 /* Arguments of yyformat. */
2472 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2473 /* Number of reported tokens (one for the "unexpected", one per
2474 "expected"). */
2475 int yycount = 0;
2476
2477 /* There are many possibilities here to consider:
2478 - If this state is a consistent state with a default action, then
2479 the only way this function was invoked is if the default action
2480 is an error action. In that case, don't check for expected
2481 tokens because there are none.
2482 - The only way there can be no lookahead present (in yychar) is if
2483 this state is a consistent state with a default action. Thus,
2484 detecting the absence of a lookahead is sufficient to determine
2485 that there is no unexpected or expected token to report. In that
2486 case, just report a simple "syntax error".
2487 - Don't assume there isn't a lookahead just because this state is a
2488 consistent state with a default action. There might have been a
2489 previous inconsistent state, consistent state with a non-default
2490 action, or user semantic action that manipulated yychar.
2491 - Of course, the expected token list depends on states to have
2492 correct lookahead information, and it depends on the parser not
2493 to perform extra reductions after fetching a lookahead from the
2494 scanner and before detecting a syntax error. Thus, state merging
2495 (from LALR or IELR) and default reductions corrupt the expected
2496 token list. However, the list is correct for canonical LR with
2497 one exception: it will still contain any token that will not be
2498 accepted due to an error action in a later state.
2499 */
2500 if (yytoken != YYEMPTY)
2501 {
2502 int yyn = yypact[*yyssp];
2503 yyarg[yycount++] = yytname[yytoken];
2504 if (!yypact_value_is_default (yyn))
2505 {
2506 /* Start YYX at -YYN if negative to avoid negative indexes in
2507 YYCHECK. In other words, skip the first -YYN actions for
2508 this state because they are default actions. */
2509 int yyxbegin = yyn < 0 ? -yyn : 0;
2510 /* Stay within bounds of both yycheck and yytname. */
2511 int yychecklim = YYLAST - yyn + 1;
2512 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2513 int yyx;
2514
2515 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2516 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2517 && !yytable_value_is_error (yytable[yyx + yyn]))
2518 {
2519 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2520 {
2521 yycount = 1;
2522 yysize = yysize0;
2523 break;
2524 }
2525 yyarg[yycount++] = yytname[yyx];
2526 {
2527 YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
2528 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
2529 yysize = yysize1;
2530 else
2531 return 2;
2532 }
2533 }
2534 }
2535 }
2536
2537 switch (yycount)
2538 {
2539 # define YYCASE_(N, S) \
2540 case N: \
2541 yyformat = S; \
2542 break
2543 default: /* Avoid compiler warnings. */
2544 YYCASE_(0, YY_("syntax error"));
2545 YYCASE_(1, YY_("syntax error, unexpected %s"));
2546 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2547 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2548 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2549 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2550 # undef YYCASE_
2551 }
2552
2553 {
2554 YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
2555 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
2556 yysize = yysize1;
2557 else
2558 return 2;
2559 }
2560
2561 if (*yymsg_alloc < yysize)
2562 {
2563 *yymsg_alloc = 2 * yysize;
2564 if (! (yysize <= *yymsg_alloc
2565 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2566 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2567 return 1;
2568 }
2569
2570 /* Avoid sprintf, as that infringes on the user's name space.
2571 Don't have undefined behavior even if the translation
2572 produced a string with the wrong number of "%s"s. */
2573 {
2574 char *yyp = *yymsg;
2575 int yyi = 0;
2576 while ((*yyp = *yyformat) != '\0')
2577 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2578 {
2579 yyp += yytnamerr (yyp, yyarg[yyi++]);
2580 yyformat += 2;
2581 }
2582 else
2583 {
2584 yyp++;
2585 yyformat++;
2586 }
2587 }
2588 return 0;
2589 }
2590 #endif /* YYERROR_VERBOSE */
2591
2592 /*-----------------------------------------------.
2593 | Release the memory associated to this symbol. |
2594 `-----------------------------------------------*/
2595
2596 static void
2597 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2598 {
2599 YYUSE (yyvaluep);
2600 if (!yymsg)
2601 yymsg = "Deleting";
2602 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2603
2604 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2605 YYUSE (yytype);
2606 YY_IGNORE_MAYBE_UNINITIALIZED_END
2607 }
2608
2609
2610
2611
2612 /* The lookahead symbol. */
2613 int yychar;
2614
2615 /* The semantic value of the lookahead symbol. */
2616 YYSTYPE yylval;
2617 /* Number of syntax errors so far. */
2618 int yynerrs;
2619
2620
2621 /*----------.
2622 | yyparse. |
2623 `----------*/
2624
2625 int
2626 yyparse (void)
2627 {
2628 int yystate;
2629 /* Number of tokens to shift before error messages enabled. */
2630 int yyerrstatus;
2631
2632 /* The stacks and their tools:
2633 'yyss': related to states.
2634 'yyvs': related to semantic values.
2635
2636 Refer to the stacks through separate pointers, to allow yyoverflow
2637 to reallocate them elsewhere. */
2638
2639 /* The state stack. */
2640 yytype_int16 yyssa[YYINITDEPTH];
2641 yytype_int16 *yyss;
2642 yytype_int16 *yyssp;
2643
2644 /* The semantic value stack. */
2645 YYSTYPE yyvsa[YYINITDEPTH];
2646 YYSTYPE *yyvs;
2647 YYSTYPE *yyvsp;
2648
2649 YYSIZE_T yystacksize;
2650
2651 int yyn;
2652 int yyresult;
2653 /* Lookahead token as an internal (translated) token number. */
2654 int yytoken = 0;
2655 /* The variables used to return semantic value and location from the
2656 action routines. */
2657 YYSTYPE yyval;
2658
2659 #if YYERROR_VERBOSE
2660 /* Buffer for error messages, and its allocated size. */
2661 char yymsgbuf[128];
2662 char *yymsg = yymsgbuf;
2663 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2664 #endif
2665
2666 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2667
2668 /* The number of symbols on the RHS of the reduced rule.
2669 Keep to zero when no symbol should be popped. */
2670 int yylen = 0;
2671
2672 yyssp = yyss = yyssa;
2673 yyvsp = yyvs = yyvsa;
2674 yystacksize = YYINITDEPTH;
2675
2676 YYDPRINTF ((stderr, "Starting parse\n"));
2677
2678 yystate = 0;
2679 yyerrstatus = 0;
2680 yynerrs = 0;
2681 yychar = YYEMPTY; /* Cause a token to be read. */
2682 goto yysetstate;
2683
2684
2685 /*------------------------------------------------------------.
2686 | yynewstate -- push a new state, which is found in yystate. |
2687 `------------------------------------------------------------*/
2688 yynewstate:
2689 /* In all cases, when you get here, the value and location stacks
2690 have just been pushed. So pushing a state here evens the stacks. */
2691 yyssp++;
2692
2693
2694 /*--------------------------------------------------------------------.
2695 | yynewstate -- set current state (the top of the stack) to yystate. |
2696 `--------------------------------------------------------------------*/
2697 yysetstate:
2698 *yyssp = (yytype_int16) yystate;
2699
2700 if (yyss + yystacksize - 1 <= yyssp)
2701 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
2702 goto yyexhaustedlab;
2703 #else
2704 {
2705 /* Get the current used size of the three stacks, in elements. */
2706 YYSIZE_T yysize = (YYSIZE_T) (yyssp - yyss + 1);
2707
2708 # if defined yyoverflow
2709 {
2710 /* Give user a chance to reallocate the stack. Use copies of
2711 these so that the &'s don't force the real ones into
2712 memory. */
2713 YYSTYPE *yyvs1 = yyvs;
2714 yytype_int16 *yyss1 = yyss;
2715
2716 /* Each stack pointer address is followed by the size of the
2717 data in use in that stack, in bytes. This used to be a
2718 conditional around just the two extra args, but that might
2719 be undefined if yyoverflow is a macro. */
2720 yyoverflow (YY_("memory exhausted"),
2721 &yyss1, yysize * sizeof (*yyssp),
2722 &yyvs1, yysize * sizeof (*yyvsp),
2723 &yystacksize);
2724 yyss = yyss1;
2725 yyvs = yyvs1;
2726 }
2727 # else /* defined YYSTACK_RELOCATE */
2728 /* Extend the stack our own way. */
2729 if (YYMAXDEPTH <= yystacksize)
2730 goto yyexhaustedlab;
2731 yystacksize *= 2;
2732 if (YYMAXDEPTH < yystacksize)
2733 yystacksize = YYMAXDEPTH;
2734
2735 {
2736 yytype_int16 *yyss1 = yyss;
2737 union yyalloc *yyptr =
2738 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2739 if (! yyptr)
2740 goto yyexhaustedlab;
2741 YYSTACK_RELOCATE (yyss_alloc, yyss);
2742 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2743 # undef YYSTACK_RELOCATE
2744 if (yyss1 != yyssa)
2745 YYSTACK_FREE (yyss1);
2746 }
2747 # endif
2748
2749 yyssp = yyss + yysize - 1;
2750 yyvsp = yyvs + yysize - 1;
2751
2752 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2753 (unsigned long) yystacksize));
2754
2755 if (yyss + yystacksize - 1 <= yyssp)
2756 YYABORT;
2757 }
2758 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
2759
2760 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2761
2762 if (yystate == YYFINAL)
2763 YYACCEPT;
2764
2765 goto yybackup;
2766
2767
2768 /*-----------.
2769 | yybackup. |
2770 `-----------*/
2771 yybackup:
2772 /* Do appropriate processing given the current state. Read a
2773 lookahead token if we need one and don't already have one. */
2774
2775 /* First try to decide what to do without reference to lookahead token. */
2776 yyn = yypact[yystate];
2777 if (yypact_value_is_default (yyn))
2778 goto yydefault;
2779
2780 /* Not known => get a lookahead token if don't already have one. */
2781
2782 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2783 if (yychar == YYEMPTY)
2784 {
2785 YYDPRINTF ((stderr, "Reading a token: "));
2786 yychar = yylex ();
2787 }
2788
2789 if (yychar <= YYEOF)
2790 {
2791 yychar = yytoken = YYEOF;
2792 YYDPRINTF ((stderr, "Now at end of input.\n"));
2793 }
2794 else
2795 {
2796 yytoken = YYTRANSLATE (yychar);
2797 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2798 }
2799
2800 /* If the proper action on seeing token YYTOKEN is to reduce or to
2801 detect an error, take that action. */
2802 yyn += yytoken;
2803 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2804 goto yydefault;
2805 yyn = yytable[yyn];
2806 if (yyn <= 0)
2807 {
2808 if (yytable_value_is_error (yyn))
2809 goto yyerrlab;
2810 yyn = -yyn;
2811 goto yyreduce;
2812 }
2813
2814 /* Count tokens shifted since error; after three, turn off error
2815 status. */
2816 if (yyerrstatus)
2817 yyerrstatus--;
2818
2819 /* Shift the lookahead token. */
2820 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2821
2822 /* Discard the shifted token. */
2823 yychar = YYEMPTY;
2824
2825 yystate = yyn;
2826 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2827 *++yyvsp = yylval;
2828 YY_IGNORE_MAYBE_UNINITIALIZED_END
2829
2830 goto yynewstate;
2831
2832
2833 /*-----------------------------------------------------------.
2834 | yydefault -- do the default action for the current state. |
2835 `-----------------------------------------------------------*/
2836 yydefault:
2837 yyn = yydefact[yystate];
2838 if (yyn == 0)
2839 goto yyerrlab;
2840 goto yyreduce;
2841
2842
2843 /*-----------------------------.
2844 | yyreduce -- do a reduction. |
2845 `-----------------------------*/
2846 yyreduce:
2847 /* yyn is the number of a rule to reduce with. */
2848 yylen = yyr2[yyn];
2849
2850 /* If YYLEN is nonzero, implement the default value of the action:
2851 '$$ = $1'.
2852
2853 Otherwise, the following line sets YYVAL to garbage.
2854 This behavior is undocumented and Bison
2855 users should not rely upon it. Assigning to YYVAL
2856 unconditionally makes the parser a bit smaller, and it avoids a
2857 GCC warning that YYVAL may be used uninitialized. */
2858 yyval = yyvsp[1-yylen];
2859
2860
2861 YY_REDUCE_PRINT (yyn);
2862 switch (yyn)
2863 {
2864 case 28:
2865 #line 405 "conf_parser.y" /* yacc.c:1652 */
2866 { (yyval.number) = 0; }
2867 #line 2868 "conf_parser.c" /* yacc.c:1652 */
2868 break;
2869
2870 case 30:
2871 #line 406 "conf_parser.y" /* yacc.c:1652 */
2872 { (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number); }
2873 #line 2874 "conf_parser.c" /* yacc.c:1652 */
2874 break;
2875
2876 case 31:
2877 #line 407 "conf_parser.y" /* yacc.c:1652 */
2878 { (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number); }
2879 #line 2880 "conf_parser.c" /* yacc.c:1652 */
2880 break;
2881
2882 case 32:
2883 #line 408 "conf_parser.y" /* yacc.c:1652 */
2884 { (yyval.number) = (yyvsp[-2].number) * 60 + (yyvsp[0].number); }
2885 #line 2886 "conf_parser.c" /* yacc.c:1652 */
2886 break;
2887
2888 case 33:
2889 #line 409 "conf_parser.y" /* yacc.c:1652 */
2890 { (yyval.number) = (yyvsp[-2].number) * 60 * 60 + (yyvsp[0].number); }
2891 #line 2892 "conf_parser.c" /* yacc.c:1652 */
2892 break;
2893
2894 case 34:
2895 #line 410 "conf_parser.y" /* yacc.c:1652 */
2896 { (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 + (yyvsp[0].number); }
2897 #line 2898 "conf_parser.c" /* yacc.c:1652 */
2898 break;
2899
2900 case 35:
2901 #line 411 "conf_parser.y" /* yacc.c:1652 */
2902 { (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 7 + (yyvsp[0].number); }
2903 #line 2904 "conf_parser.c" /* yacc.c:1652 */
2904 break;
2905
2906 case 36:
2907 #line 412 "conf_parser.y" /* yacc.c:1652 */
2908 { (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 7 * 4 + (yyvsp[0].number); }
2909 #line 2910 "conf_parser.c" /* yacc.c:1652 */
2910 break;
2911
2912 case 37:
2913 #line 413 "conf_parser.y" /* yacc.c:1652 */
2914 { (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 365 + (yyvsp[0].number); }
2915 #line 2916 "conf_parser.c" /* yacc.c:1652 */
2916 break;
2917
2918 case 38:
2919 #line 416 "conf_parser.y" /* yacc.c:1652 */
2920 { (yyval.number) = 0; }
2921 #line 2922 "conf_parser.c" /* yacc.c:1652 */
2922 break;
2923
2924 case 40:
2925 #line 417 "conf_parser.y" /* yacc.c:1652 */
2926 { (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number); }
2927 #line 2928 "conf_parser.c" /* yacc.c:1652 */
2928 break;
2929
2930 case 41:
2931 #line 418 "conf_parser.y" /* yacc.c:1652 */
2932 { (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number); }
2933 #line 2934 "conf_parser.c" /* yacc.c:1652 */
2934 break;
2935
2936 case 42:
2937 #line 419 "conf_parser.y" /* yacc.c:1652 */
2938 { (yyval.number) = (yyvsp[-2].number) * 1024 + (yyvsp[0].number); }
2939 #line 2940 "conf_parser.c" /* yacc.c:1652 */
2940 break;
2941
2942 case 43:
2943 #line 420 "conf_parser.y" /* yacc.c:1652 */
2944 { (yyval.number) = (yyvsp[-2].number) * 1024 * 1024 + (yyvsp[0].number); }
2945 #line 2946 "conf_parser.c" /* yacc.c:1652 */
2946 break;
2947
2948 case 50:
2949 #line 433 "conf_parser.y" /* yacc.c:1652 */
2950 {
2951 if (conf_parser_ctx.pass == 2)
2952 add_conf_module(libio_basename(yylval.string));
2953 }
2954 #line 2955 "conf_parser.c" /* yacc.c:1652 */
2955 break;
2956
2957 case 51:
2958 #line 439 "conf_parser.y" /* yacc.c:1652 */
2959 {
2960 if (conf_parser_ctx.pass == 2)
2961 mod_add_path(yylval.string);
2962 }
2963 #line 2964 "conf_parser.c" /* yacc.c:1652 */
2964 break;
2965
2966 case 71:
2967 #line 470 "conf_parser.y" /* yacc.c:1652 */
2968 {
2969 if (conf_parser_ctx.pass == 2)
2970 {
2971 xfree(ConfigServerInfo.ssl_certificate_file);
2972 ConfigServerInfo.ssl_certificate_file = xstrdup(yylval.string);
2973 }
2974 }
2975 #line 2976 "conf_parser.c" /* yacc.c:1652 */
2976 break;
2977
2978 case 72:
2979 #line 479 "conf_parser.y" /* yacc.c:1652 */
2980 {
2981 if (conf_parser_ctx.pass == 2)
2982 {
2983 xfree(ConfigServerInfo.rsa_private_key_file);
2984 ConfigServerInfo.rsa_private_key_file = xstrdup(yylval.string);
2985 }
2986 }
2987 #line 2988 "conf_parser.c" /* yacc.c:1652 */
2988 break;
2989
2990 case 73:
2991 #line 488 "conf_parser.y" /* yacc.c:1652 */
2992 {
2993 if (conf_parser_ctx.pass == 2)
2994 {
2995 xfree(ConfigServerInfo.ssl_dh_param_file);
2996 ConfigServerInfo.ssl_dh_param_file = xstrdup(yylval.string);
2997 }
2998 }
2999 #line 3000 "conf_parser.c" /* yacc.c:1652 */
3000 break;
3001
3002 case 74:
3003 #line 497 "conf_parser.y" /* yacc.c:1652 */
3004 {
3005 if (conf_parser_ctx.pass == 2)
3006 {
3007 xfree(ConfigServerInfo.ssl_cipher_list);
3008 ConfigServerInfo.ssl_cipher_list = xstrdup(yylval.string);
3009 }
3010 }
3011 #line 3012 "conf_parser.c" /* yacc.c:1652 */
3012 break;
3013
3014 case 75:
3015 #line 506 "conf_parser.y" /* yacc.c:1652 */
3016 {
3017 if (conf_parser_ctx.pass == 2)
3018 {
3019 xfree(ConfigServerInfo.ssl_message_digest_algorithm);
3020 ConfigServerInfo.ssl_message_digest_algorithm = xstrdup(yylval.string);
3021 }
3022 }
3023 #line 3024 "conf_parser.c" /* yacc.c:1652 */
3024 break;
3025
3026 case 76:
3027 #line 515 "conf_parser.y" /* yacc.c:1652 */
3028 {
3029 if (conf_parser_ctx.pass == 2)
3030 {
3031 xfree(ConfigServerInfo.ssl_dh_elliptic_curve);
3032 ConfigServerInfo.ssl_dh_elliptic_curve = xstrdup(yylval.string);
3033 }
3034 }
3035 #line 3036 "conf_parser.c" /* yacc.c:1652 */
3036 break;
3037
3038 case 77:
3039 #line 524 "conf_parser.y" /* yacc.c:1652 */
3040 {
3041 /* This isn't rehashable */
3042 if (conf_parser_ctx.pass == 2 && ConfigServerInfo.name == NULL)
3043 {
3044 if (server_valid_name(yylval.string) == true)
3045 ConfigServerInfo.name = xstrdup(yylval.string);
3046 else
3047 {
3048 conf_error_report("Ignoring serverinfo::name -- invalid name. Aborting.");
3049 exit(EXIT_FAILURE);
3050 }
3051 }
3052 }
3053 #line 3054 "conf_parser.c" /* yacc.c:1652 */
3054 break;
3055
3056 case 78:
3057 #line 539 "conf_parser.y" /* yacc.c:1652 */
3058 {
3059 /* This isn't rehashable */
3060 if (conf_parser_ctx.pass == 2 && ConfigServerInfo.sid == NULL)
3061 {
3062 if (valid_sid(yylval.string))
3063 ConfigServerInfo.sid = xstrdup(yylval.string);
3064 else
3065 {
3066 conf_error_report("Ignoring serverinfo::sid -- invalid SID. Aborting.");
3067 exit(EXIT_FAILURE);
3068 }
3069 }
3070 }
3071 #line 3072 "conf_parser.c" /* yacc.c:1652 */
3072 break;
3073
3074 case 79:
3075 #line 554 "conf_parser.y" /* yacc.c:1652 */
3076 {
3077 if (conf_parser_ctx.pass == 2)
3078 {
3079 xfree(ConfigServerInfo.description);
3080 ConfigServerInfo.description = xstrdup(yylval.string);
3081 strlcpy(me.info, ConfigServerInfo.description, sizeof(me.info));
3082 }
3083 }
3084 #line 3085 "conf_parser.c" /* yacc.c:1652 */
3085 break;
3086
3087 case 80:
3088 #line 564 "conf_parser.y" /* yacc.c:1652 */
3089 {
3090 if (conf_parser_ctx.pass == 2)
3091 {
3092 char *p;
3093
3094 if ((p = strchr(yylval.string, ' ')))
3095 *p = '\0';
3096
3097 xfree(ConfigServerInfo.network_name);
3098 ConfigServerInfo.network_name = xstrdup(yylval.string);
3099 }
3100 }
3101 #line 3102 "conf_parser.c" /* yacc.c:1652 */
3102 break;
3103
3104 case 81:
3105 #line 578 "conf_parser.y" /* yacc.c:1652 */
3106 {
3107 if (conf_parser_ctx.pass != 2)
3108 break;
3109
3110 xfree(ConfigServerInfo.network_desc);
3111 ConfigServerInfo.network_desc = xstrdup(yylval.string);
3112 }
3113 #line 3114 "conf_parser.c" /* yacc.c:1652 */
3114 break;
3115
3116 case 82:
3117 #line 587 "conf_parser.y" /* yacc.c:1652 */
3118 {
3119 if (conf_parser_ctx.pass != 2)
3120 break;
3121
3122 if ((yyvsp[-1].number) < 1)
3123 {
3124 conf_error_report("default_max_clients too low, setting to 1");
3125 ConfigServerInfo.default_max_clients = 1;
3126 }
3127 else if ((yyvsp[-1].number) > MAXCLIENTS_MAX)
3128 {
3129 char buf[IRCD_BUFSIZE] = "";
3130
3131 snprintf(buf, sizeof(buf), "default_max_clients too high, setting to %d", MAXCLIENTS_MAX);
3132 conf_error_report(buf);
3133
3134 ConfigServerInfo.default_max_clients = MAXCLIENTS_MAX;
3135 }
3136 else
3137 ConfigServerInfo.default_max_clients = (yyvsp[-1].number);
3138 }
3139 #line 3140 "conf_parser.c" /* yacc.c:1652 */
3140 break;
3141
3142 case 83:
3143 #line 610 "conf_parser.y" /* yacc.c:1652 */
3144 {
3145 if (conf_parser_ctx.pass != 2)
3146 break;
3147
3148 if ((yyvsp[-1].number) < 9)
3149 {
3150 conf_error_report("max_nick_length too low, setting to 9");
3151 ConfigServerInfo.max_nick_length = 9;
3152 }
3153 else if ((yyvsp[-1].number) > NICKLEN)
3154 {
3155 char buf[IRCD_BUFSIZE] = "";
3156
3157 snprintf(buf, sizeof(buf), "max_nick_length too high, setting to %d", NICKLEN);
3158 conf_error_report(buf);
3159
3160 ConfigServerInfo.max_nick_length = NICKLEN;
3161 }
3162 else
3163 ConfigServerInfo.max_nick_length = (yyvsp[-1].number);
3164 }
3165 #line 3166 "conf_parser.c" /* yacc.c:1652 */
3166 break;
3167
3168 case 84:
3169 #line 633 "conf_parser.y" /* yacc.c:1652 */
3170 {
3171 if (conf_parser_ctx.pass != 2)
3172 break;
3173
3174 if ((yyvsp[-1].number) < 80)
3175 {
3176 conf_error_report("max_topic_length too low, setting to 80");
3177 ConfigServerInfo.max_topic_length = 80;
3178 }
3179 else if ((yyvsp[-1].number) > TOPICLEN)
3180 {
3181 char buf[IRCD_BUFSIZE] = "";
3182
3183 snprintf(buf, sizeof(buf), "max_topic_length too high, setting to %d", TOPICLEN);
3184 conf_error_report(buf);
3185
3186 ConfigServerInfo.max_topic_length = TOPICLEN;
3187 }
3188 else
3189 ConfigServerInfo.max_topic_length = (yyvsp[-1].number);
3190 }
3191 #line 3192 "conf_parser.c" /* yacc.c:1652 */
3192 break;
3193
3194 case 85:
3195 #line 656 "conf_parser.y" /* yacc.c:1652 */
3196 {
3197 if (conf_parser_ctx.pass == 2)
3198 ConfigServerInfo.hub = yylval.number;
3199 }
3200 #line 3201 "conf_parser.c" /* yacc.c:1652 */
3201 break;
3202
3203 case 93:
3204 #line 674 "conf_parser.y" /* yacc.c:1652 */
3205 {
3206 if (conf_parser_ctx.pass != 2)
3207 break;
3208
3209 xfree(ConfigAdminInfo.name);
3210 ConfigAdminInfo.name = xstrdup(yylval.string);
3211 }
3212 #line 3213 "conf_parser.c" /* yacc.c:1652 */
3213 break;
3214
3215 case 94:
3216 #line 683 "conf_parser.y" /* yacc.c:1652 */
3217 {
3218 if (conf_parser_ctx.pass != 2)
3219 break;
3220
3221 xfree(ConfigAdminInfo.email);
3222 ConfigAdminInfo.email = xstrdup(yylval.string);
3223 }
3224 #line 3225 "conf_parser.c" /* yacc.c:1652 */
3225 break;
3226
3227 case 95:
3228 #line 692 "conf_parser.y" /* yacc.c:1652 */
3229 {
3230 if (conf_parser_ctx.pass != 2)
3231 break;
3232
3233 xfree(ConfigAdminInfo.description);
3234 ConfigAdminInfo.description = xstrdup(yylval.string);
3235 }
3236 #line 3237 "conf_parser.c" /* yacc.c:1652 */
3237 break;
3238
3239 case 96:
3240 #line 705 "conf_parser.y" /* yacc.c:1652 */
3241 {
3242 if (conf_parser_ctx.pass == 2)
3243 reset_block_state();
3244 }
3245 #line 3246 "conf_parser.c" /* yacc.c:1652 */
3246 break;
3247
3248 case 97:
3249 #line 709 "conf_parser.y" /* yacc.c:1652 */
3250 {
3251 dlink_node *node = NULL;
3252
3253 if (conf_parser_ctx.pass != 2)
3254 break;
3255
3256 if (!block_state.file.buf[0])
3257 break;
3258
3259 DLINK_FOREACH(node, block_state.mask.list.head)
3260 motd_add(node->data, block_state.file.buf);
3261 }
3262 #line 3263 "conf_parser.c" /* yacc.c:1652 */
3263 break;
3264
3265 case 103:
3266 #line 726 "conf_parser.y" /* yacc.c:1652 */
3267 {
3268 if (conf_parser_ctx.pass == 2)
3269 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
3270 }
3271 #line 3272 "conf_parser.c" /* yacc.c:1652 */
3272 break;
3273
3274 case 104:
3275 #line 732 "conf_parser.y" /* yacc.c:1652 */
3276 {
3277 if (conf_parser_ctx.pass == 2)
3278 strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
3279 }
3280 #line 3281 "conf_parser.c" /* yacc.c:1652 */
3281 break;
3282
3283 case 105:
3284 #line 742 "conf_parser.y" /* yacc.c:1652 */
3285 {
3286 if (conf_parser_ctx.pass == 2)
3287 reset_block_state();
3288 }
3289 #line 3290 "conf_parser.c" /* yacc.c:1652 */
3290 break;
3291
3292 case 106:
3293 #line 746 "conf_parser.y" /* yacc.c:1652 */
3294 {
3295 if (conf_parser_ctx.pass != 2)
3296 break;
3297
3298 if (!block_state.command.buf[0] ||
3299 !block_state.name.buf[0] ||
3300 !block_state.nick.buf[0] ||
3301 !block_state.host.buf[0])
3302 break;
3303
3304 pseudo_register(block_state.name.buf, block_state.nick.buf, block_state.host.buf,
3305 block_state.prepend.buf, block_state.command.buf);
3306 }
3307 #line 3308 "conf_parser.c" /* yacc.c:1652 */
3308 break;
3309
3310 case 114:
3311 #line 764 "conf_parser.y" /* yacc.c:1652 */
3312 {
3313 if (conf_parser_ctx.pass == 2)
3314 strlcpy(block_state.command.buf, yylval.string, sizeof(block_state.command.buf));
3315 }
3316 #line 3317 "conf_parser.c" /* yacc.c:1652 */
3317 break;
3318
3319 case 115:
3320 #line 770 "conf_parser.y" /* yacc.c:1652 */
3321 {
3322 if (conf_parser_ctx.pass == 2)
3323 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
3324 }
3325 #line 3326 "conf_parser.c" /* yacc.c:1652 */
3326 break;
3327
3328 case 116:
3329 #line 776 "conf_parser.y" /* yacc.c:1652 */
3330 {
3331 if (conf_parser_ctx.pass == 2)
3332 strlcpy(block_state.prepend.buf, yylval.string, sizeof(block_state.prepend.buf));
3333 }
3334 #line 3335 "conf_parser.c" /* yacc.c:1652 */
3335 break;
3336
3337 case 117:
3338 #line 782 "conf_parser.y" /* yacc.c:1652 */
3339 {
3340 if (conf_parser_ctx.pass == 2)
3341 {
3342 struct split_nuh_item nuh;
3343
3344 nuh.nuhmask = yylval.string;
3345 nuh.nickptr = NULL;
3346 nuh.userptr = block_state.nick.buf;
3347 nuh.hostptr = block_state.host.buf;
3348 nuh.nicksize = 0;
3349 nuh.usersize = sizeof(block_state.nick.buf);
3350 nuh.hostsize = sizeof(block_state.host.buf);
3351
3352 split_nuh(&nuh);
3353 }
3354 }
3355 #line 3356 "conf_parser.c" /* yacc.c:1652 */
3356 break;
3357
3358 case 124:
3359 #line 810 "conf_parser.y" /* yacc.c:1652 */
3360 {
3361 if (conf_parser_ctx.pass == 2)
3362 ConfigLog.use_logging = yylval.number;
3363 }
3364 #line 3365 "conf_parser.c" /* yacc.c:1652 */
3365 break;
3366
3367 case 125:
3368 #line 816 "conf_parser.y" /* yacc.c:1652 */
3369 {
3370 if (conf_parser_ctx.pass == 2)
3371 reset_block_state();
3372 }
3373 #line 3374 "conf_parser.c" /* yacc.c:1652 */
3374 break;
3375
3376 case 126:
3377 #line 820 "conf_parser.y" /* yacc.c:1652 */
3378 {
3379 if (conf_parser_ctx.pass != 2)
3380 break;
3381
3382 if (block_state.type.value && block_state.file.buf[0])
3383 log_set_file(block_state.type.value, block_state.size.value,
3384 block_state.file.buf);
3385 }
3386 #line 3387 "conf_parser.c" /* yacc.c:1652 */
3387 break;
3388
3389 case 133:
3390 #line 836 "conf_parser.y" /* yacc.c:1652 */
3391 {
3392 if (conf_parser_ctx.pass != 2)
3393 break;
3394
3395 strlcpy(block_state.file.buf, yylval.string, sizeof(block_state.file.buf));
3396 }
3397 #line 3398 "conf_parser.c" /* yacc.c:1652 */
3398 break;
3399
3400 case 134:
3401 #line 844 "conf_parser.y" /* yacc.c:1652 */
3402 {
3403 block_state.size.value = (yyvsp[-1].number);
3404 }
3405 #line 3406 "conf_parser.c" /* yacc.c:1652 */
3406 break;
3407
3408 case 135:
3409 #line 847 "conf_parser.y" /* yacc.c:1652 */
3410 {
3411 block_state.size.value = 0;
3412 }
3413 #line 3414 "conf_parser.c" /* yacc.c:1652 */
3414 break;
3415
3416 case 136:
3417 #line 852 "conf_parser.y" /* yacc.c:1652 */
3418 {
3419 if (conf_parser_ctx.pass == 2)
3420 block_state.type.value = 0;
3421 }
3422 #line 3423 "conf_parser.c" /* yacc.c:1652 */
3423 break;
3424
3425 case 140:
3426 #line 859 "conf_parser.y" /* yacc.c:1652 */
3427 {
3428 if (conf_parser_ctx.pass == 2)
3429 block_state.type.value = LOG_TYPE_USER;
3430 }
3431 #line 3432 "conf_parser.c" /* yacc.c:1652 */
3432 break;
3433
3434 case 141:
3435 #line 863 "conf_parser.y" /* yacc.c:1652 */
3436 {
3437 if (conf_parser_ctx.pass == 2)
3438 block_state.type.value = LOG_TYPE_OPER;
3439 }
3440 #line 3441 "conf_parser.c" /* yacc.c:1652 */
3441 break;
3442
3443 case 142:
3444 #line 867 "conf_parser.y" /* yacc.c:1652 */
3445 {
3446 if (conf_parser_ctx.pass == 2)
3447 block_state.type.value = LOG_TYPE_XLINE;
3448 }
3449 #line 3450 "conf_parser.c" /* yacc.c:1652 */
3450 break;
3451
3452 case 143:
3453 #line 871 "conf_parser.y" /* yacc.c:1652 */
3454 {
3455 if (conf_parser_ctx.pass == 2)
3456 block_state.type.value = LOG_TYPE_RESV;
3457 }
3458 #line 3459 "conf_parser.c" /* yacc.c:1652 */
3459 break;
3460
3461 case 144:
3462 #line 875 "conf_parser.y" /* yacc.c:1652 */
3463 {
3464 if (conf_parser_ctx.pass == 2)
3465 block_state.type.value = LOG_TYPE_DLINE;
3466 }
3467 #line 3468 "conf_parser.c" /* yacc.c:1652 */
3468 break;
3469
3470 case 145:
3471 #line 879 "conf_parser.y" /* yacc.c:1652 */
3472 {
3473 if (conf_parser_ctx.pass == 2)
3474 block_state.type.value = LOG_TYPE_KLINE;
3475 }
3476 #line 3477 "conf_parser.c" /* yacc.c:1652 */
3477 break;
3478
3479 case 146:
3480 #line 883 "conf_parser.y" /* yacc.c:1652 */
3481 {
3482 if (conf_parser_ctx.pass == 2)
3483 block_state.type.value = LOG_TYPE_KILL;
3484 }
3485 #line 3486 "conf_parser.c" /* yacc.c:1652 */
3486 break;
3487
3488 case 147:
3489 #line 887 "conf_parser.y" /* yacc.c:1652 */
3490 {
3491 if (conf_parser_ctx.pass == 2)
3492 block_state.type.value = LOG_TYPE_DEBUG;
3493 }
3494 #line 3495 "conf_parser.c" /* yacc.c:1652 */
3495 break;
3496
3497 case 148:
3498 #line 897 "conf_parser.y" /* yacc.c:1652 */
3499 {
3500 if (conf_parser_ctx.pass != 2)
3501 break;
3502
3503 reset_block_state();
3504 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
3505 }
3506 #line 3507 "conf_parser.c" /* yacc.c:1652 */
3507 break;
3508
3509 case 149:
3510 #line 904 "conf_parser.y" /* yacc.c:1652 */
3511 {
3512 dlink_node *node = NULL;
3513
3514 if (conf_parser_ctx.pass != 2)
3515 break;
3516
3517 if (!block_state.name.buf[0])
3518 break;
3519
3520 if (!block_state.rpass.buf[0])
3521 break;
3522
3523 DLINK_FOREACH(node, block_state.mask.list.head)
3524 {
3525 struct split_nuh_item nuh;
3526 char *s = node->data;
3527
3528 if (EmptyString(s))
3529 continue;
3530
3531 nuh.nuhmask = s;
3532 nuh.nickptr = NULL;
3533 nuh.userptr = block_state.user.buf;
3534 nuh.hostptr = block_state.host.buf;
3535
3536 nuh.nicksize = 0;
3537 nuh.usersize = sizeof(block_state.user.buf);
3538 nuh.hostsize = sizeof(block_state.host.buf);
3539
3540 split_nuh(&nuh);
3541
3542 struct MaskItem *conf = conf_make(CONF_OPER);
3543 conf->addr = xcalloc(sizeof(*conf->addr));
3544 conf->name = xstrdup(block_state.name.buf);
3545 conf->user = xstrdup(block_state.user.buf);
3546 conf->host = xstrdup(block_state.host.buf);
3547
3548 if (block_state.cert.buf[0])
3549 conf->certfp = xstrdup(block_state.cert.buf);
3550
3551 if (block_state.rpass.buf[0])
3552 conf->passwd = xstrdup(block_state.rpass.buf);
3553
3554 if (block_state.whois.buf[0])
3555 conf->whois = xstrdup(block_state.whois.buf);
3556
3557 conf->flags = block_state.flags.value;
3558 conf->modes = block_state.modes.value;
3559 conf->port = block_state.port.value;
3560 conf->htype = parse_netmask(conf->host, conf->addr, &conf->bits);
3561
3562 conf_add_class_to_conf(conf, block_state.class.buf);
3563 }
3564 }
3565 #line 3566 "conf_parser.c" /* yacc.c:1652 */
3566 break;
3567
3568 case 163:
3569 #line 973 "conf_parser.y" /* yacc.c:1652 */
3570 {
3571 if (conf_parser_ctx.pass == 2)
3572 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
3573 }
3574 #line 3575 "conf_parser.c" /* yacc.c:1652 */
3575 break;
3576
3577 case 164:
3578 #line 979 "conf_parser.y" /* yacc.c:1652 */
3579 {
3580 if (conf_parser_ctx.pass == 2)
3581 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
3582 }
3583 #line 3584 "conf_parser.c" /* yacc.c:1652 */
3584 break;
3585
3586 case 165:
3587 #line 985 "conf_parser.y" /* yacc.c:1652 */
3588 {
3589 if (conf_parser_ctx.pass == 2)
3590 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
3591 }
3592 #line 3593 "conf_parser.c" /* yacc.c:1652 */
3593 break;
3594
3595 case 166:
3596 #line 991 "conf_parser.y" /* yacc.c:1652 */
3597 {
3598 if (conf_parser_ctx.pass == 2)
3599 strlcpy(block_state.whois.buf, yylval.string, sizeof(block_state.whois.buf));
3600 }
3601 #line 3602 "conf_parser.c" /* yacc.c:1652 */
3602 break;
3603
3604 case 167:
3605 #line 997 "conf_parser.y" /* yacc.c:1652 */
3606 {
3607 if (conf_parser_ctx.pass != 2)
3608 break;
3609
3610 if (yylval.number)
3611 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
3612 else
3613 block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
3614 }
3615 #line 3616 "conf_parser.c" /* yacc.c:1652 */
3616 break;
3617
3618 case 168:
3619 #line 1008 "conf_parser.y" /* yacc.c:1652 */
3620 {
3621 if (conf_parser_ctx.pass == 2)
3622 strlcpy(block_state.cert.buf, yylval.string, sizeof(block_state.cert.buf));
3623 }
3624 #line 3625 "conf_parser.c" /* yacc.c:1652 */
3625 break;
3626
3627 case 169:
3628 #line 1014 "conf_parser.y" /* yacc.c:1652 */
3629 {
3630 if (conf_parser_ctx.pass != 2)
3631 break;
3632
3633 if (yylval.number)
3634 block_state.flags.value |= CONF_FLAGS_SSL;
3635 else
3636 block_state.flags.value &= ~CONF_FLAGS_SSL;
3637 }
3638 #line 3639 "conf_parser.c" /* yacc.c:1652 */
3639 break;
3640
3641 case 170:
3642 #line 1025 "conf_parser.y" /* yacc.c:1652 */
3643 {
3644 if (conf_parser_ctx.pass == 2)
3645 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
3646 }
3647 #line 3648 "conf_parser.c" /* yacc.c:1652 */
3648 break;
3649
3650 case 171:
3651 #line 1031 "conf_parser.y" /* yacc.c:1652 */
3652 {
3653 if (conf_parser_ctx.pass == 2)
3654 block_state.modes.value = 0;
3655 }
3656 #line 3657 "conf_parser.c" /* yacc.c:1652 */
3657 break;
3658
3659 case 175:
3660 #line 1038 "conf_parser.y" /* yacc.c:1652 */
3661 {
3662 if (conf_parser_ctx.pass == 2)
3663 block_state.modes.value |= UMODE_BOTS;
3664 }
3665 #line 3666 "conf_parser.c" /* yacc.c:1652 */
3666 break;
3667
3668 case 176:
3669 #line 1042 "conf_parser.y" /* yacc.c:1652 */
3670 {
3671 if (conf_parser_ctx.pass == 2)
3672 block_state.modes.value |= UMODE_CCONN;
3673 }
3674 #line 3675 "conf_parser.c" /* yacc.c:1652 */
3675 break;
3676
3677 case 177:
3678 #line 1046 "conf_parser.y" /* yacc.c:1652 */
3679 {
3680 if (conf_parser_ctx.pass == 2)
3681 block_state.modes.value |= UMODE_DEAF;
3682 }
3683 #line 3684 "conf_parser.c" /* yacc.c:1652 */
3684 break;
3685
3686 case 178:
3687 #line 1050 "conf_parser.y" /* yacc.c:1652 */
3688 {
3689 if (conf_parser_ctx.pass == 2)
3690 block_state.modes.value |= UMODE_DEBUG;
3691 }
3692 #line 3693 "conf_parser.c" /* yacc.c:1652 */
3693 break;
3694
3695 case 179:
3696 #line 1054 "conf_parser.y" /* yacc.c:1652 */
3697 {
3698 if (conf_parser_ctx.pass == 2)
3699 block_state.modes.value |= UMODE_FULL;
3700 }
3701 #line 3702 "conf_parser.c" /* yacc.c:1652 */
3702 break;
3703
3704 case 180:
3705 #line 1058 "conf_parser.y" /* yacc.c:1652 */
3706 {
3707 if (conf_parser_ctx.pass == 2)
3708 block_state.modes.value |= UMODE_HIDDEN;
3709 }
3710 #line 3711 "conf_parser.c" /* yacc.c:1652 */
3711 break;
3712
3713 case 181:
3714 #line 1062 "conf_parser.y" /* yacc.c:1652 */
3715 {
3716 if (conf_parser_ctx.pass == 2)
3717 block_state.modes.value |= UMODE_HIDECHANS;
3718 }
3719 #line 3720 "conf_parser.c" /* yacc.c:1652 */
3720 break;
3721
3722 case 182:
3723 #line 1066 "conf_parser.y" /* yacc.c:1652 */
3724 {
3725 if (conf_parser_ctx.pass == 2)
3726 block_state.modes.value |= UMODE_HIDEIDLE;
3727 }
3728 #line 3729 "conf_parser.c" /* yacc.c:1652 */
3729 break;
3730
3731 case 183:
3732 #line 1070 "conf_parser.y" /* yacc.c:1652 */
3733 {
3734 if (conf_parser_ctx.pass == 2)
3735 block_state.modes.value |= UMODE_SKILL;
3736 }
3737 #line 3738 "conf_parser.c" /* yacc.c:1652 */
3738 break;
3739
3740 case 184:
3741 #line 1074 "conf_parser.y" /* yacc.c:1652 */
3742 {
3743 if (conf_parser_ctx.pass == 2)
3744 block_state.modes.value |= UMODE_NCHANGE;
3745 }
3746 #line 3747 "conf_parser.c" /* yacc.c:1652 */
3747 break;
3748
3749 case 185:
3750 #line 1078 "conf_parser.y" /* yacc.c:1652 */
3751 {
3752 if (conf_parser_ctx.pass == 2)
3753 block_state.modes.value |= UMODE_REJ;
3754 }
3755 #line 3756 "conf_parser.c" /* yacc.c:1652 */
3756 break;
3757
3758 case 186:
3759 #line 1082 "conf_parser.y" /* yacc.c:1652 */
3760 {
3761 if (conf_parser_ctx.pass == 2)
3762 block_state.modes.value |= UMODE_UNAUTH;
3763 }
3764 #line 3765 "conf_parser.c" /* yacc.c:1652 */
3765 break;
3766
3767 case 187:
3768 #line 1086 "conf_parser.y" /* yacc.c:1652 */
3769 {
3770 if (conf_parser_ctx.pass == 2)
3771 block_state.modes.value |= UMODE_SPY;
3772 }
3773 #line 3774 "conf_parser.c" /* yacc.c:1652 */
3774 break;
3775
3776 case 188:
3777 #line 1090 "conf_parser.y" /* yacc.c:1652 */
3778 {
3779 if (conf_parser_ctx.pass == 2)
3780 block_state.modes.value |= UMODE_EXTERNAL;
3781 }
3782 #line 3783 "conf_parser.c" /* yacc.c:1652 */
3783 break;
3784
3785 case 189:
3786 #line 1094 "conf_parser.y" /* yacc.c:1652 */
3787 {
3788 if (conf_parser_ctx.pass == 2)
3789 block_state.modes.value |= UMODE_SERVNOTICE;
3790 }
3791 #line 3792 "conf_parser.c" /* yacc.c:1652 */
3792 break;
3793
3794 case 190:
3795 #line 1098 "conf_parser.y" /* yacc.c:1652 */
3796 {
3797 if (conf_parser_ctx.pass == 2)
3798 block_state.modes.value |= UMODE_INVISIBLE;
3799 }
3800 #line 3801 "conf_parser.c" /* yacc.c:1652 */
3801 break;
3802
3803 case 191:
3804 #line 1102 "conf_parser.y" /* yacc.c:1652 */
3805 {
3806 if (conf_parser_ctx.pass == 2)
3807 block_state.modes.value |= UMODE_WALLOP;
3808 }
3809 #line 3810 "conf_parser.c" /* yacc.c:1652 */
3810 break;
3811
3812 case 192:
3813 #line 1106 "conf_parser.y" /* yacc.c:1652 */
3814 {
3815 if (conf_parser_ctx.pass == 2)
3816 block_state.modes.value |= UMODE_SOFTCALLERID;
3817 }
3818 #line 3819 "conf_parser.c" /* yacc.c:1652 */
3819 break;
3820
3821 case 193:
3822 #line 1110 "conf_parser.y" /* yacc.c:1652 */
3823 {
3824 if (conf_parser_ctx.pass == 2)
3825 block_state.modes.value |= UMODE_CALLERID;
3826 }
3827 #line 3828 "conf_parser.c" /* yacc.c:1652 */
3828 break;
3829
3830 case 194:
3831 #line 1114 "conf_parser.y" /* yacc.c:1652 */
3832 {
3833 if (conf_parser_ctx.pass == 2)
3834 block_state.modes.value |= UMODE_LOCOPS;
3835 }
3836 #line 3837 "conf_parser.c" /* yacc.c:1652 */
3837 break;
3838
3839 case 195:
3840 #line 1118 "conf_parser.y" /* yacc.c:1652 */
3841 {
3842 if (conf_parser_ctx.pass == 2)
3843 block_state.modes.value |= UMODE_REGONLY;
3844 }
3845 #line 3846 "conf_parser.c" /* yacc.c:1652 */
3846 break;
3847
3848 case 196:
3849 #line 1122 "conf_parser.y" /* yacc.c:1652 */
3850 {
3851 if (conf_parser_ctx.pass == 2)
3852 block_state.modes.value |= UMODE_FARCONNECT;
3853 }
3854 #line 3855 "conf_parser.c" /* yacc.c:1652 */
3855 break;
3856
3857 case 197:
3858 #line 1126 "conf_parser.y" /* yacc.c:1652 */
3859 {
3860 if (conf_parser_ctx.pass == 2)
3861 block_state.modes.value |= UMODE_EXPIRATION;
3862 }
3863 #line 3864 "conf_parser.c" /* yacc.c:1652 */
3864 break;
3865
3866 case 198:
3867 #line 1132 "conf_parser.y" /* yacc.c:1652 */
3868 {
3869 if (conf_parser_ctx.pass == 2)
3870 block_state.port.value = 0;
3871 }
3872 #line 3873 "conf_parser.c" /* yacc.c:1652 */
3873 break;
3874
3875 case 202:
3876 #line 1139 "conf_parser.y" /* yacc.c:1652 */
3877 {
3878 if (conf_parser_ctx.pass == 2)
3879 block_state.port.value |= OPER_FLAG_KILL_REMOTE;
3880 }
3881 #line 3882 "conf_parser.c" /* yacc.c:1652 */
3882 break;
3883
3884 case 203:
3885 #line 1143 "conf_parser.y" /* yacc.c:1652 */
3886 {
3887 if (conf_parser_ctx.pass == 2)
3888 block_state.port.value |= OPER_FLAG_KILL;
3889 }
3890 #line 3891 "conf_parser.c" /* yacc.c:1652 */
3891 break;
3892
3893 case 204:
3894 #line 1147 "conf_parser.y" /* yacc.c:1652 */
3895 {
3896 if (conf_parser_ctx.pass == 2)
3897 block_state.port.value |= OPER_FLAG_CONNECT_REMOTE;
3898 }
3899 #line 3900 "conf_parser.c" /* yacc.c:1652 */
3900 break;
3901
3902 case 205:
3903 #line 1151 "conf_parser.y" /* yacc.c:1652 */
3904 {
3905 if (conf_parser_ctx.pass == 2)
3906 block_state.port.value |= OPER_FLAG_CONNECT;
3907 }
3908 #line 3909 "conf_parser.c" /* yacc.c:1652 */
3909 break;
3910
3911 case 206:
3912 #line 1155 "conf_parser.y" /* yacc.c:1652 */
3913 {
3914 if (conf_parser_ctx.pass == 2)
3915 block_state.port.value |= OPER_FLAG_SQUIT_REMOTE;
3916 }
3917 #line 3918 "conf_parser.c" /* yacc.c:1652 */
3918 break;
3919
3920 case 207:
3921 #line 1159 "conf_parser.y" /* yacc.c:1652 */
3922 {
3923 if (conf_parser_ctx.pass == 2)
3924 block_state.port.value |= OPER_FLAG_SQUIT;
3925 }
3926 #line 3927 "conf_parser.c" /* yacc.c:1652 */
3927 break;
3928
3929 case 208:
3930 #line 1163 "conf_parser.y" /* yacc.c:1652 */
3931 {
3932 if (conf_parser_ctx.pass == 2)
3933 block_state.port.value |= OPER_FLAG_KLINE;
3934 }
3935 #line 3936 "conf_parser.c" /* yacc.c:1652 */
3936 break;
3937
3938 case 209:
3939 #line 1167 "conf_parser.y" /* yacc.c:1652 */
3940 {
3941 if (conf_parser_ctx.pass == 2)
3942 block_state.port.value |= OPER_FLAG_UNKLINE;
3943 }
3944 #line 3945 "conf_parser.c" /* yacc.c:1652 */
3945 break;
3946
3947 case 210:
3948 #line 1171 "conf_parser.y" /* yacc.c:1652 */
3949 {
3950 if (conf_parser_ctx.pass == 2)
3951 block_state.port.value |= OPER_FLAG_DLINE;
3952 }
3953 #line 3954 "conf_parser.c" /* yacc.c:1652 */
3954 break;
3955
3956 case 211:
3957 #line 1175 "conf_parser.y" /* yacc.c:1652 */
3958 {
3959 if (conf_parser_ctx.pass == 2)
3960 block_state.port.value |= OPER_FLAG_UNDLINE;
3961 }
3962 #line 3963 "conf_parser.c" /* yacc.c:1652 */
3963 break;
3964
3965 case 212:
3966 #line 1179 "conf_parser.y" /* yacc.c:1652 */
3967 {
3968 if (conf_parser_ctx.pass == 2)
3969 block_state.port.value |= OPER_FLAG_XLINE;
3970 }
3971 #line 3972 "conf_parser.c" /* yacc.c:1652 */
3972 break;
3973
3974 case 213:
3975 #line 1183 "conf_parser.y" /* yacc.c:1652 */
3976 {
3977 if (conf_parser_ctx.pass == 2)
3978 block_state.port.value |= OPER_FLAG_UNXLINE;
3979 }
3980 #line 3981 "conf_parser.c" /* yacc.c:1652 */
3981 break;
3982
3983 case 214:
3984 #line 1187 "conf_parser.y" /* yacc.c:1652 */
3985 {
3986 if (conf_parser_ctx.pass == 2)
3987 block_state.port.value |= OPER_FLAG_DIE;
3988 }
3989 #line 3990 "conf_parser.c" /* yacc.c:1652 */
3990 break;
3991
3992 case 215:
3993 #line 1191 "conf_parser.y" /* yacc.c:1652 */
3994 {
3995 if (conf_parser_ctx.pass == 2)
3996 block_state.port.value |= OPER_FLAG_RESTART;
3997 }
3998 #line 3999 "conf_parser.c" /* yacc.c:1652 */
3999 break;
4000
4001 case 216:
4002 #line 1195 "conf_parser.y" /* yacc.c:1652 */
4003 {
4004 if (conf_parser_ctx.pass == 2)
4005 block_state.port.value |= OPER_FLAG_REHASH_REMOTE;
4006 }
4007 #line 4008 "conf_parser.c" /* yacc.c:1652 */
4008 break;
4009
4010 case 217:
4011 #line 1199 "conf_parser.y" /* yacc.c:1652 */
4012 {
4013 if (conf_parser_ctx.pass == 2)
4014 block_state.port.value |= OPER_FLAG_REHASH;
4015 }
4016 #line 4017 "conf_parser.c" /* yacc.c:1652 */
4017 break;
4018
4019 case 218:
4020 #line 1203 "conf_parser.y" /* yacc.c:1652 */
4021 {
4022 if (conf_parser_ctx.pass == 2)
4023 block_state.port.value |= OPER_FLAG_ADMIN;
4024 }
4025 #line 4026 "conf_parser.c" /* yacc.c:1652 */
4026 break;
4027
4028 case 219:
4029 #line 1207 "conf_parser.y" /* yacc.c:1652 */
4030 {
4031 if (conf_parser_ctx.pass == 2)
4032 block_state.port.value |= OPER_FLAG_GLOBOPS;
4033 }
4034 #line 4035 "conf_parser.c" /* yacc.c:1652 */
4035 break;
4036
4037 case 220:
4038 #line 1211 "conf_parser.y" /* yacc.c:1652 */
4039 {
4040 if (conf_parser_ctx.pass == 2)
4041 block_state.port.value |= OPER_FLAG_WALLOPS;
4042 }
4043 #line 4044 "conf_parser.c" /* yacc.c:1652 */
4044 break;
4045
4046 case 221:
4047 #line 1215 "conf_parser.y" /* yacc.c:1652 */
4048 {
4049 if (conf_parser_ctx.pass == 2)
4050 block_state.port.value |= OPER_FLAG_LOCOPS;
4051 }
4052 #line 4053 "conf_parser.c" /* yacc.c:1652 */
4053 break;
4054
4055 case 222:
4056 #line 1219 "conf_parser.y" /* yacc.c:1652 */
4057 {
4058 if (conf_parser_ctx.pass == 2)
4059 block_state.port.value |= OPER_FLAG_REMOTEBAN;
4060 }
4061 #line 4062 "conf_parser.c" /* yacc.c:1652 */
4062 break;
4063
4064 case 223:
4065 #line 1223 "conf_parser.y" /* yacc.c:1652 */
4066 {
4067 if (conf_parser_ctx.pass == 2)
4068 block_state.port.value |= OPER_FLAG_SET;
4069 }
4070 #line 4071 "conf_parser.c" /* yacc.c:1652 */
4071 break;
4072
4073 case 224:
4074 #line 1227 "conf_parser.y" /* yacc.c:1652 */
4075 {
4076 if (conf_parser_ctx.pass == 2)
4077 block_state.port.value |= OPER_FLAG_MODULE;
4078 }
4079 #line 4080 "conf_parser.c" /* yacc.c:1652 */
4080 break;
4081
4082 case 225:
4083 #line 1231 "conf_parser.y" /* yacc.c:1652 */
4084 {
4085 if (conf_parser_ctx.pass == 2)
4086 block_state.port.value |= OPER_FLAG_OPME;
4087 }
4088 #line 4089 "conf_parser.c" /* yacc.c:1652 */
4089 break;
4090
4091 case 226:
4092 #line 1235 "conf_parser.y" /* yacc.c:1652 */
4093 {
4094 if (conf_parser_ctx.pass == 2)
4095 block_state.port.value |= OPER_FLAG_NICK_RESV;
4096 }
4097 #line 4098 "conf_parser.c" /* yacc.c:1652 */
4098 break;
4099
4100 case 227:
4101 #line 1239 "conf_parser.y" /* yacc.c:1652 */
4102 {
4103 if (conf_parser_ctx.pass == 2)
4104 block_state.port.value |= OPER_FLAG_JOIN_RESV;
4105 }
4106 #line 4107 "conf_parser.c" /* yacc.c:1652 */
4107 break;
4108
4109 case 228:
4110 #line 1243 "conf_parser.y" /* yacc.c:1652 */
4111 {
4112 if (conf_parser_ctx.pass == 2)
4113 block_state.port.value |= OPER_FLAG_RESV;
4114 }
4115 #line 4116 "conf_parser.c" /* yacc.c:1652 */
4116 break;
4117
4118 case 229:
4119 #line 1247 "conf_parser.y" /* yacc.c:1652 */
4120 {
4121 if (conf_parser_ctx.pass == 2)
4122 block_state.port.value |= OPER_FLAG_UNRESV;
4123 }
4124 #line 4125 "conf_parser.c" /* yacc.c:1652 */
4125 break;
4126
4127 case 230:
4128 #line 1251 "conf_parser.y" /* yacc.c:1652 */
4129 {
4130 if (conf_parser_ctx.pass == 2)
4131 block_state.port.value |= OPER_FLAG_CLOSE;
4132 }
4133 #line 4134 "conf_parser.c" /* yacc.c:1652 */
4134 break;
4135
4136 case 231:
4137 #line 1261 "conf_parser.y" /* yacc.c:1652 */
4138 {
4139 if (conf_parser_ctx.pass != 1)
4140 break;
4141
4142 reset_block_state();
4143
4144 block_state.ping_freq.value = DEFAULT_PINGFREQUENCY;
4145 block_state.con_freq.value = DEFAULT_CONNECTFREQUENCY;
4146 block_state.max_total.value = MAXIMUM_LINKS_DEFAULT;
4147 block_state.max_sendq.value = DEFAULT_SENDQ;
4148 block_state.max_recvq.value = DEFAULT_RECVQ;
4149 }
4150 #line 4151 "conf_parser.c" /* yacc.c:1652 */
4151 break;
4152
4153 case 232:
4154 #line 1273 "conf_parser.y" /* yacc.c:1652 */
4155 {
4156 if (conf_parser_ctx.pass != 1)
4157 break;
4158
4159 if (!block_state.class.buf[0])
4160 break;
4161
4162 struct ClassItem *class = class_find(block_state.class.buf, false);
4163 if (class == NULL)
4164 class = class_make();
4165
4166 class->active = true;
4167 xfree(class->name);
4168 class->name = xstrdup(block_state.class.buf);
4169 class->ping_freq = block_state.ping_freq.value;
4170 class->max_perip_local = block_state.max_perip_local.value;
4171 class->max_perip_global = block_state.max_perip_global.value;
4172 class->con_freq = block_state.con_freq.value;
4173 class->max_total = block_state.max_total.value;
4174 class->max_sendq = block_state.max_sendq.value;
4175 class->max_recvq = block_state.max_recvq.value;
4176 class->max_channels = block_state.max_channels.value;
4177
4178 if (block_state.min_idle.value > block_state.max_idle.value)
4179 {
4180 block_state.min_idle.value = 0;
4181 block_state.max_idle.value = 0;
4182 block_state.flags.value &= ~CLASS_FLAGS_FAKE_IDLE;
4183 }
4184
4185 class->flags = block_state.flags.value;
4186 class->min_idle = block_state.min_idle.value;
4187 class->max_idle = block_state.max_idle.value;
4188
4189 bool diff = (class->cidr_bitlen_ipv4 != block_state.cidr_bitlen_ipv4.value ||
4190 class->cidr_bitlen_ipv6 != block_state.cidr_bitlen_ipv6.value);
4191 class->cidr_bitlen_ipv4 = block_state.cidr_bitlen_ipv4.value;
4192 class->cidr_bitlen_ipv6 = block_state.cidr_bitlen_ipv6.value;
4193 class->number_per_cidr = block_state.number_per_cidr.value;
4194
4195 if (diff)
4196 class_ip_limit_rebuild(class);
4197 }
4198 #line 4199 "conf_parser.c" /* yacc.c:1652 */
4199 break;
4200
4201 case 251:
4202 #line 1336 "conf_parser.y" /* yacc.c:1652 */
4203 {
4204 if (conf_parser_ctx.pass == 1)
4205 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
4206 }
4207 #line 4208 "conf_parser.c" /* yacc.c:1652 */
4208 break;
4209
4210 case 252:
4211 #line 1342 "conf_parser.y" /* yacc.c:1652 */
4212 {
4213 if (conf_parser_ctx.pass == 1)
4214 block_state.ping_freq.value = (yyvsp[-1].number);
4215 }
4216 #line 4217 "conf_parser.c" /* yacc.c:1652 */
4217 break;
4218
4219 case 253:
4220 #line 1348 "conf_parser.y" /* yacc.c:1652 */
4221 {
4222 if (conf_parser_ctx.pass == 1)
4223 block_state.max_perip_local.value = (yyvsp[-1].number);
4224 }
4225 #line 4226 "conf_parser.c" /* yacc.c:1652 */
4226 break;
4227
4228 case 254:
4229 #line 1354 "conf_parser.y" /* yacc.c:1652 */
4230 {
4231 if (conf_parser_ctx.pass == 1)
4232 block_state.max_perip_global.value = (yyvsp[-1].number);
4233 }
4234 #line 4235 "conf_parser.c" /* yacc.c:1652 */
4235 break;
4236
4237 case 255:
4238 #line 1360 "conf_parser.y" /* yacc.c:1652 */
4239 {
4240 if (conf_parser_ctx.pass == 1)
4241 block_state.con_freq.value = (yyvsp[-1].number);
4242 }
4243 #line 4244 "conf_parser.c" /* yacc.c:1652 */
4244 break;
4245
4246 case 256:
4247 #line 1366 "conf_parser.y" /* yacc.c:1652 */
4248 {
4249 if (conf_parser_ctx.pass == 1)
4250 block_state.max_channels.value = (yyvsp[-1].number);
4251 }
4252 #line 4253 "conf_parser.c" /* yacc.c:1652 */
4253 break;
4254
4255 case 257:
4256 #line 1372 "conf_parser.y" /* yacc.c:1652 */
4257 {
4258 if (conf_parser_ctx.pass == 1)
4259 block_state.max_total.value = (yyvsp[-1].number);
4260 }
4261 #line 4262 "conf_parser.c" /* yacc.c:1652 */
4262 break;
4263
4264 case 258:
4265 #line 1378 "conf_parser.y" /* yacc.c:1652 */
4266 {
4267 if (conf_parser_ctx.pass == 1)
4268 block_state.max_sendq.value = (yyvsp[-1].number);
4269 }
4270 #line 4271 "conf_parser.c" /* yacc.c:1652 */
4271 break;
4272
4273 case 259:
4274 #line 1384 "conf_parser.y" /* yacc.c:1652 */
4275 {
4276 if (conf_parser_ctx.pass == 1)
4277 if ((yyvsp[-1].number) >= CLIENT_FLOOD_MIN && (yyvsp[-1].number) <= CLIENT_FLOOD_MAX)
4278 block_state.max_recvq.value = (yyvsp[-1].number);
4279 }
4280 #line 4281 "conf_parser.c" /* yacc.c:1652 */
4281 break;
4282
4283 case 260:
4284 #line 1391 "conf_parser.y" /* yacc.c:1652 */
4285 {
4286 if (conf_parser_ctx.pass == 1)
4287 block_state.cidr_bitlen_ipv4.value = (yyvsp[-1].number) > 32 ? 32 : (yyvsp[-1].number);
4288 }
4289 #line 4290 "conf_parser.c" /* yacc.c:1652 */
4290 break;
4291
4292 case 261:
4293 #line 1397 "conf_parser.y" /* yacc.c:1652 */
4294 {
4295 if (conf_parser_ctx.pass == 1)
4296 block_state.cidr_bitlen_ipv6.value = (yyvsp[-1].number) > 128 ? 128 : (yyvsp[-1].number);
4297 }
4298 #line 4299 "conf_parser.c" /* yacc.c:1652 */
4299 break;
4300
4301 case 262:
4302 #line 1403 "conf_parser.y" /* yacc.c:1652 */
4303 {
4304 if (conf_parser_ctx.pass == 1)
4305 block_state.number_per_cidr.value = (yyvsp[-1].number);
4306 }
4307 #line 4308 "conf_parser.c" /* yacc.c:1652 */
4308 break;
4309
4310 case 263:
4311 #line 1409 "conf_parser.y" /* yacc.c:1652 */
4312 {
4313 if (conf_parser_ctx.pass != 1)
4314 break;
4315
4316 block_state.min_idle.value = (yyvsp[-1].number);
4317 block_state.flags.value |= CLASS_FLAGS_FAKE_IDLE;
4318 }
4319 #line 4320 "conf_parser.c" /* yacc.c:1652 */
4320 break;
4321
4322 case 264:
4323 #line 1418 "conf_parser.y" /* yacc.c:1652 */
4324 {
4325 if (conf_parser_ctx.pass != 1)
4326 break;
4327
4328 block_state.max_idle.value = (yyvsp[-1].number);
4329 block_state.flags.value |= CLASS_FLAGS_FAKE_IDLE;
4330 }
4331 #line 4332 "conf_parser.c" /* yacc.c:1652 */
4332 break;
4333
4334 case 265:
4335 #line 1427 "conf_parser.y" /* yacc.c:1652 */
4336 {
4337 if (conf_parser_ctx.pass == 1)
4338 block_state.flags.value &= CLASS_FLAGS_FAKE_IDLE;
4339 }
4340 #line 4341 "conf_parser.c" /* yacc.c:1652 */
4341 break;
4342
4343 case 269:
4344 #line 1434 "conf_parser.y" /* yacc.c:1652 */
4345 {
4346 if (conf_parser_ctx.pass == 1)
4347 block_state.flags.value |= CLASS_FLAGS_RANDOM_IDLE;
4348 }
4349 #line 4350 "conf_parser.c" /* yacc.c:1652 */
4350 break;
4351
4352 case 270:
4353 #line 1438 "conf_parser.y" /* yacc.c:1652 */
4354 {
4355 if (conf_parser_ctx.pass == 1)
4356 block_state.flags.value |= CLASS_FLAGS_HIDE_IDLE_FROM_OPERS;
4357 }
4358 #line 4359 "conf_parser.c" /* yacc.c:1652 */
4359 break;
4360
4361 case 271:
4362 #line 1448 "conf_parser.y" /* yacc.c:1652 */
4363 {
4364 if (conf_parser_ctx.pass == 2)
4365 reset_block_state();
4366 }
4367 #line 4368 "conf_parser.c" /* yacc.c:1652 */
4368 break;
4369
4370 case 273:
4371 #line 1454 "conf_parser.y" /* yacc.c:1652 */
4372 {
4373 block_state.flags.value = 0;
4374 }
4375 #line 4376 "conf_parser.c" /* yacc.c:1652 */
4376 break;
4377
4378 case 277:
4379 #line 1460 "conf_parser.y" /* yacc.c:1652 */
4380 {
4381 if (conf_parser_ctx.pass == 2)
4382 block_state.flags.value |= LISTENER_SSL;
4383 }
4384 #line 4385 "conf_parser.c" /* yacc.c:1652 */
4385 break;
4386
4387 case 278:
4388 #line 1464 "conf_parser.y" /* yacc.c:1652 */
4389 {
4390 if (conf_parser_ctx.pass == 2)
4391 block_state.flags.value |= LISTENER_HIDDEN;
4392 }
4393 #line 4394 "conf_parser.c" /* yacc.c:1652 */
4394 break;
4395
4396 case 279:
4397 #line 1468 "conf_parser.y" /* yacc.c:1652 */
4398 {
4399 if (conf_parser_ctx.pass == 2)
4400 block_state.flags.value |= LISTENER_SERVER;
4401 }
4402 #line 4403 "conf_parser.c" /* yacc.c:1652 */
4403 break;
4404
4405 case 287:
4406 #line 1476 "conf_parser.y" /* yacc.c:1652 */
4407 { block_state.flags.value = 0; }
4408 #line 4409 "conf_parser.c" /* yacc.c:1652 */
4409 break;
4410
4411 case 291:
4412 #line 1481 "conf_parser.y" /* yacc.c:1652 */
4413 {
4414 if (conf_parser_ctx.pass == 2)
4415 {
4416 #ifndef HAVE_TLS
4417 if (block_state.flags.value & LISTENER_SSL)
4418 {
4419 conf_error_report("TLS not available - port closed");
4420 break;
4421 }
4422 #endif
4423 listener_add((yyvsp[0].number), block_state.addr.buf, block_state.flags.value);
4424 }
4425 }
4426 #line 4427 "conf_parser.c" /* yacc.c:1652 */
4427 break;
4428
4429 case 292:
4430 #line 1494 "conf_parser.y" /* yacc.c:1652 */
4431 {
4432 if (conf_parser_ctx.pass == 2)
4433 {
4434 #ifndef HAVE_TLS
4435 if (block_state.flags.value & LISTENER_SSL)
4436 {
4437 conf_error_report("TLS not available - port closed");
4438 break;
4439 }
4440 #endif
4441
4442 for (int i = (yyvsp[-2].number); i <= (yyvsp[0].number); ++i)
4443 listener_add(i, block_state.addr.buf, block_state.flags.value);
4444 }
4445 }
4446 #line 4447 "conf_parser.c" /* yacc.c:1652 */
4447 break;
4448
4449 case 293:
4450 #line 1511 "conf_parser.y" /* yacc.c:1652 */
4451 {
4452 if (conf_parser_ctx.pass == 2)
4453 strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
4454 }
4455 #line 4456 "conf_parser.c" /* yacc.c:1652 */
4456 break;
4457
4458 case 294:
4459 #line 1517 "conf_parser.y" /* yacc.c:1652 */
4460 {
4461 if (conf_parser_ctx.pass == 2)
4462 strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
4463 }
4464 #line 4465 "conf_parser.c" /* yacc.c:1652 */
4465 break;
4466
4467 case 295:
4468 #line 1527 "conf_parser.y" /* yacc.c:1652 */
4469 {
4470 if (conf_parser_ctx.pass == 2)
4471 reset_block_state();
4472 }
4473 #line 4474 "conf_parser.c" /* yacc.c:1652 */
4474 break;
4475
4476 case 296:
4477 #line 1531 "conf_parser.y" /* yacc.c:1652 */
4478 {
4479 dlink_node *node = NULL;
4480
4481 if (conf_parser_ctx.pass != 2)
4482 break;
4483
4484 DLINK_FOREACH(node, block_state.mask.list.head)
4485 {
4486 struct split_nuh_item nuh;
4487 char *s = node->data;
4488
4489 if (EmptyString(s))
4490 continue;
4491
4492 nuh.nuhmask = s;
4493 nuh.nickptr = NULL;
4494 nuh.userptr = block_state.user.buf;
4495 nuh.hostptr = block_state.host.buf;
4496
4497 nuh.nicksize = 0;
4498 nuh.usersize = sizeof(block_state.user.buf);
4499 nuh.hostsize = sizeof(block_state.host.buf);
4500
4501 split_nuh(&nuh);
4502
4503 struct MaskItem *conf = conf_make(CONF_CLIENT);
4504 conf->user = xstrdup(block_state.user.buf);
4505 conf->host = xstrdup(block_state.host.buf);
4506
4507 if (block_state.rpass.buf[0])
4508 conf->passwd = xstrdup(block_state.rpass.buf);
4509 if (block_state.name.buf[0])
4510 conf->name = xstrdup(block_state.name.buf);
4511
4512 conf->flags = block_state.flags.value;
4513 conf->port = block_state.port.value;
4514
4515 conf_add_class_to_conf(conf, block_state.class.buf);
4516 add_conf_by_address(CONF_CLIENT, conf);
4517 }
4518 }
4519 #line 4520 "conf_parser.c" /* yacc.c:1652 */
4520 break;
4521
4522 case 308:
4523 #line 1585 "conf_parser.y" /* yacc.c:1652 */
4524 {
4525 if (conf_parser_ctx.pass == 2)
4526 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
4527 }
4528 #line 4529 "conf_parser.c" /* yacc.c:1652 */
4529 break;
4530
4531 case 309:
4532 #line 1591 "conf_parser.y" /* yacc.c:1652 */
4533 {
4534 if (conf_parser_ctx.pass == 2)
4535 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
4536 }
4537 #line 4538 "conf_parser.c" /* yacc.c:1652 */
4538 break;
4539
4540 case 310:
4541 #line 1597 "conf_parser.y" /* yacc.c:1652 */
4542 {
4543 if (conf_parser_ctx.pass == 2)
4544 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
4545 }
4546 #line 4547 "conf_parser.c" /* yacc.c:1652 */
4547 break;
4548
4549 case 311:
4550 #line 1603 "conf_parser.y" /* yacc.c:1652 */
4551 {
4552 if (conf_parser_ctx.pass == 2)
4553 {
4554 if (yylval.number)
4555 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
4556 else
4557 block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
4558 }
4559 }
4560 #line 4561 "conf_parser.c" /* yacc.c:1652 */
4561 break;
4562
4563 case 312:
4564 #line 1614 "conf_parser.y" /* yacc.c:1652 */
4565 {
4566 if (conf_parser_ctx.pass == 2)
4567 block_state.flags.value &= (CONF_FLAGS_ENCRYPTED | CONF_FLAGS_SPOOF_IP);
4568 }
4569 #line 4570 "conf_parser.c" /* yacc.c:1652 */
4570 break;
4571
4572 case 316:
4573 #line 1621 "conf_parser.y" /* yacc.c:1652 */
4574 {
4575 if (conf_parser_ctx.pass == 2)
4576 block_state.flags.value |= CONF_FLAGS_SPOOF_NOTICE;
4577 }
4578 #line 4579 "conf_parser.c" /* yacc.c:1652 */
4579 break;
4580
4581 case 317:
4582 #line 1625 "conf_parser.y" /* yacc.c:1652 */
4583 {
4584 if (conf_parser_ctx.pass == 2)
4585 block_state.flags.value |= CONF_FLAGS_NOLIMIT;
4586 }
4587 #line 4588 "conf_parser.c" /* yacc.c:1652 */
4588 break;
4589
4590 case 318:
4591 #line 1629 "conf_parser.y" /* yacc.c:1652 */
4592 {
4593 if (conf_parser_ctx.pass == 2)
4594 block_state.flags.value |= CONF_FLAGS_EXEMPTKLINE;
4595 }
4596 #line 4597 "conf_parser.c" /* yacc.c:1652 */
4597 break;
4598
4599 case 319:
4600 #line 1633 "conf_parser.y" /* yacc.c:1652 */
4601 {
4602 if (conf_parser_ctx.pass == 2)
4603 block_state.flags.value |= CONF_FLAGS_EXEMPTXLINE;
4604 }
4605 #line 4606 "conf_parser.c" /* yacc.c:1652 */
4606 break;
4607
4608 case 320:
4609 #line 1637 "conf_parser.y" /* yacc.c:1652 */
4610 {
4611 if (conf_parser_ctx.pass == 2)
4612 block_state.flags.value |= CONF_FLAGS_NEED_IDENTD;
4613 }
4614 #line 4615 "conf_parser.c" /* yacc.c:1652 */
4615 break;
4616
4617 case 321:
4618 #line 1641 "conf_parser.y" /* yacc.c:1652 */
4619 {
4620 if (conf_parser_ctx.pass == 2)
4621 block_state.flags.value |= CONF_FLAGS_CAN_FLOOD;
4622 }
4623 #line 4624 "conf_parser.c" /* yacc.c:1652 */
4624 break;
4625
4626 case 322:
4627 #line 1645 "conf_parser.y" /* yacc.c:1652 */
4628 {
4629 if (conf_parser_ctx.pass == 2)
4630 block_state.flags.value |= CONF_FLAGS_NO_TILDE;
4631 }
4632 #line 4633 "conf_parser.c" /* yacc.c:1652 */
4633 break;
4634
4635 case 323:
4636 #line 1649 "conf_parser.y" /* yacc.c:1652 */
4637 {
4638 if (conf_parser_ctx.pass == 2)
4639 block_state.flags.value |= CONF_FLAGS_EXEMPTRESV;
4640 }
4641 #line 4642 "conf_parser.c" /* yacc.c:1652 */
4642 break;
4643
4644 case 324:
4645 #line 1653 "conf_parser.y" /* yacc.c:1652 */
4646 {
4647 if (conf_parser_ctx.pass == 2)
4648 block_state.flags.value |= CONF_FLAGS_WEBIRC;
4649 }
4650 #line 4651 "conf_parser.c" /* yacc.c:1652 */
4651 break;
4652
4653 case 325:
4654 #line 1657 "conf_parser.y" /* yacc.c:1652 */
4655 {
4656 if (conf_parser_ctx.pass == 2)
4657 block_state.flags.value |= CONF_FLAGS_NEED_PASSWORD;
4658 }
4659 #line 4660 "conf_parser.c" /* yacc.c:1652 */
4660 break;
4661
4662 case 326:
4663 #line 1663 "conf_parser.y" /* yacc.c:1652 */
4664 {
4665 if (conf_parser_ctx.pass != 2)
4666 break;
4667
4668 if (valid_hostname(yylval.string))
4669 {
4670 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4671 block_state.flags.value |= CONF_FLAGS_SPOOF_IP;
4672 }
4673 else
4674 ilog(LOG_TYPE_IRCD, "Spoof either is too long or contains invalid characters. Ignoring it.");
4675 }
4676 #line 4677 "conf_parser.c" /* yacc.c:1652 */
4677 break;
4678
4679 case 327:
4680 #line 1677 "conf_parser.y" /* yacc.c:1652 */
4681 {
4682 if (conf_parser_ctx.pass != 2)
4683 break;
4684
4685 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4686 block_state.flags.value |= CONF_FLAGS_REDIR;
4687 }
4688 #line 4689 "conf_parser.c" /* yacc.c:1652 */
4689 break;
4690
4691 case 328:
4692 #line 1686 "conf_parser.y" /* yacc.c:1652 */
4693 {
4694 if (conf_parser_ctx.pass != 2)
4695 break;
4696
4697 block_state.flags.value |= CONF_FLAGS_REDIR;
4698 block_state.port.value = (yyvsp[-1].number);
4699 }
4700 #line 4701 "conf_parser.c" /* yacc.c:1652 */
4701 break;
4702
4703 case 329:
4704 #line 1699 "conf_parser.y" /* yacc.c:1652 */
4705 {
4706 if (conf_parser_ctx.pass != 2)
4707 break;
4708
4709 reset_block_state();
4710 strlcpy(block_state.rpass.buf, CONF_NOREASON, sizeof(block_state.rpass.buf));
4711 }
4712 #line 4713 "conf_parser.c" /* yacc.c:1652 */
4713 break;
4714
4715 case 330:
4716 #line 1706 "conf_parser.y" /* yacc.c:1652 */
4717 {
4718 if (conf_parser_ctx.pass != 2)
4719 break;
4720
4721 resv_make(block_state.name.buf, block_state.rpass.buf, &block_state.mask.list);
4722 }
4723 #line 4724 "conf_parser.c" /* yacc.c:1652 */
4724 break;
4725
4726 case 337:
4727 #line 1717 "conf_parser.y" /* yacc.c:1652 */
4728 {
4729 if (conf_parser_ctx.pass == 2)
4730 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4731 }
4732 #line 4733 "conf_parser.c" /* yacc.c:1652 */
4733 break;
4734
4735 case 338:
4736 #line 1723 "conf_parser.y" /* yacc.c:1652 */
4737 {
4738 if (conf_parser_ctx.pass == 2)
4739 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
4740 }
4741 #line 4742 "conf_parser.c" /* yacc.c:1652 */
4742 break;
4743
4744 case 339:
4745 #line 1729 "conf_parser.y" /* yacc.c:1652 */
4746 {
4747 if (conf_parser_ctx.pass == 2)
4748 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.mask.list);
4749 }
4750 #line 4751 "conf_parser.c" /* yacc.c:1652 */
4751 break;
4752
4753 case 345:
4754 #line 1744 "conf_parser.y" /* yacc.c:1652 */
4755 {
4756 if (conf_parser_ctx.pass != 2)
4757 break;
4758
4759 if (server_valid_name(yylval.string) == true)
4760 {
4761 struct ServiceItem *service = service_make();
4762 service->name = xstrdup(yylval.string);
4763 }
4764 }
4765 #line 4766 "conf_parser.c" /* yacc.c:1652 */
4766 break;
4767
4768 case 346:
4769 #line 1760 "conf_parser.y" /* yacc.c:1652 */
4770 {
4771 if (conf_parser_ctx.pass != 2)
4772 break;
4773
4774 reset_block_state();
4775
4776 strlcpy(block_state.name.buf, "*", sizeof(block_state.name.buf));
4777 strlcpy(block_state.user.buf, "*", sizeof(block_state.user.buf));
4778 strlcpy(block_state.host.buf, "*", sizeof(block_state.host.buf));
4779 block_state.flags.value = SHARED_ALL;
4780 }
4781 #line 4782 "conf_parser.c" /* yacc.c:1652 */
4782 break;
4783
4784 case 347:
4785 #line 1771 "conf_parser.y" /* yacc.c:1652 */
4786 {
4787 if (conf_parser_ctx.pass != 2)
4788 break;
4789
4790 struct SharedItem *shared = shared_make();
4791 shared->type = block_state.flags.value;
4792 shared->server = xstrdup(block_state.name.buf);
4793 shared->user = xstrdup(block_state.user.buf);
4794 shared->host = xstrdup(block_state.host.buf);
4795 }
4796 #line 4797 "conf_parser.c" /* yacc.c:1652 */
4797 break;
4798
4799 case 354:
4800 #line 1786 "conf_parser.y" /* yacc.c:1652 */
4801 {
4802 if (conf_parser_ctx.pass == 2)
4803 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4804 }
4805 #line 4806 "conf_parser.c" /* yacc.c:1652 */
4806 break;
4807
4808 case 355:
4809 #line 1792 "conf_parser.y" /* yacc.c:1652 */
4810 {
4811 if (conf_parser_ctx.pass == 2)
4812 {
4813 struct split_nuh_item nuh;
4814
4815 nuh.nuhmask = yylval.string;
4816 nuh.nickptr = NULL;
4817 nuh.userptr = block_state.user.buf;
4818 nuh.hostptr = block_state.host.buf;
4819
4820 nuh.nicksize = 0;
4821 nuh.usersize = sizeof(block_state.user.buf);
4822 nuh.hostsize = sizeof(block_state.host.buf);
4823
4824 split_nuh(&nuh);
4825 }
4826 }
4827 #line 4828 "conf_parser.c" /* yacc.c:1652 */
4828 break;
4829
4830 case 356:
4831 #line 1811 "conf_parser.y" /* yacc.c:1652 */
4832 {
4833 if (conf_parser_ctx.pass == 2)
4834 block_state.flags.value = 0;
4835 }
4836 #line 4837 "conf_parser.c" /* yacc.c:1652 */
4837 break;
4838
4839 case 360:
4840 #line 1818 "conf_parser.y" /* yacc.c:1652 */
4841 {
4842 if (conf_parser_ctx.pass == 2)
4843 block_state.flags.value |= SHARED_KLINE;
4844 }
4845 #line 4846 "conf_parser.c" /* yacc.c:1652 */
4846 break;
4847
4848 case 361:
4849 #line 1822 "conf_parser.y" /* yacc.c:1652 */
4850 {
4851 if (conf_parser_ctx.pass == 2)
4852 block_state.flags.value |= SHARED_UNKLINE;
4853 }
4854 #line 4855 "conf_parser.c" /* yacc.c:1652 */
4855 break;
4856
4857 case 362:
4858 #line 1826 "conf_parser.y" /* yacc.c:1652 */
4859 {
4860 if (conf_parser_ctx.pass == 2)
4861 block_state.flags.value |= SHARED_DLINE;
4862 }
4863 #line 4864 "conf_parser.c" /* yacc.c:1652 */
4864 break;
4865
4866 case 363:
4867 #line 1830 "conf_parser.y" /* yacc.c:1652 */
4868 {
4869 if (conf_parser_ctx.pass == 2)
4870 block_state.flags.value |= SHARED_UNDLINE;
4871 }
4872 #line 4873 "conf_parser.c" /* yacc.c:1652 */
4873 break;
4874
4875 case 364:
4876 #line 1834 "conf_parser.y" /* yacc.c:1652 */
4877 {
4878 if (conf_parser_ctx.pass == 2)
4879 block_state.flags.value |= SHARED_XLINE;
4880 }
4881 #line 4882 "conf_parser.c" /* yacc.c:1652 */
4882 break;
4883
4884 case 365:
4885 #line 1838 "conf_parser.y" /* yacc.c:1652 */
4886 {
4887 if (conf_parser_ctx.pass == 2)
4888 block_state.flags.value |= SHARED_UNXLINE;
4889 }
4890 #line 4891 "conf_parser.c" /* yacc.c:1652 */
4891 break;
4892
4893 case 366:
4894 #line 1842 "conf_parser.y" /* yacc.c:1652 */
4895 {
4896 if (conf_parser_ctx.pass == 2)
4897 block_state.flags.value |= SHARED_RESV;
4898 }
4899 #line 4900 "conf_parser.c" /* yacc.c:1652 */
4900 break;
4901
4902 case 367:
4903 #line 1846 "conf_parser.y" /* yacc.c:1652 */
4904 {
4905 if (conf_parser_ctx.pass == 2)
4906 block_state.flags.value |= SHARED_UNRESV;
4907 }
4908 #line 4909 "conf_parser.c" /* yacc.c:1652 */
4909 break;
4910
4911 case 368:
4912 #line 1850 "conf_parser.y" /* yacc.c:1652 */
4913 {
4914 if (conf_parser_ctx.pass == 2)
4915 block_state.flags.value |= SHARED_LOCOPS;
4916 }
4917 #line 4918 "conf_parser.c" /* yacc.c:1652 */
4918 break;
4919
4920 case 369:
4921 #line 1854 "conf_parser.y" /* yacc.c:1652 */
4922 {
4923 if (conf_parser_ctx.pass == 2)
4924 block_state.flags.value = SHARED_ALL;
4925 }
4926 #line 4927 "conf_parser.c" /* yacc.c:1652 */
4927 break;
4928
4929 case 370:
4930 #line 1864 "conf_parser.y" /* yacc.c:1652 */
4931 {
4932 if (conf_parser_ctx.pass != 2)
4933 break;
4934
4935 reset_block_state();
4936
4937 strlcpy(block_state.name.buf, "*", sizeof(block_state.name.buf));
4938 block_state.flags.value = CLUSTER_ALL;
4939 }
4940 #line 4941 "conf_parser.c" /* yacc.c:1652 */
4941 break;
4942
4943 case 371:
4944 #line 1873 "conf_parser.y" /* yacc.c:1652 */
4945 {
4946 if (conf_parser_ctx.pass != 2)
4947 break;
4948
4949 struct ClusterItem *cluster = cluster_make();
4950 cluster->type = block_state.flags.value;
4951 cluster->server = xstrdup(block_state.name.buf);
4952 }
4953 #line 4954 "conf_parser.c" /* yacc.c:1652 */
4954 break;
4955
4956 case 377:
4957 #line 1886 "conf_parser.y" /* yacc.c:1652 */
4958 {
4959 if (conf_parser_ctx.pass == 2)
4960 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
4961 }
4962 #line 4963 "conf_parser.c" /* yacc.c:1652 */
4963 break;
4964
4965 case 378:
4966 #line 1892 "conf_parser.y" /* yacc.c:1652 */
4967 {
4968 if (conf_parser_ctx.pass == 2)
4969 block_state.flags.value = 0;
4970 }
4971 #line 4972 "conf_parser.c" /* yacc.c:1652 */
4972 break;
4973
4974 case 382:
4975 #line 1899 "conf_parser.y" /* yacc.c:1652 */
4976 {
4977 if (conf_parser_ctx.pass == 2)
4978 block_state.flags.value |= CLUSTER_KLINE;
4979 }
4980 #line 4981 "conf_parser.c" /* yacc.c:1652 */
4981 break;
4982
4983 case 383:
4984 #line 1903 "conf_parser.y" /* yacc.c:1652 */
4985 {
4986 if (conf_parser_ctx.pass == 2)
4987 block_state.flags.value |= CLUSTER_UNKLINE;
4988 }
4989 #line 4990 "conf_parser.c" /* yacc.c:1652 */
4990 break;
4991
4992 case 384:
4993 #line 1907 "conf_parser.y" /* yacc.c:1652 */
4994 {
4995 if (conf_parser_ctx.pass == 2)
4996 block_state.flags.value |= CLUSTER_DLINE;
4997 }
4998 #line 4999 "conf_parser.c" /* yacc.c:1652 */
4999 break;
5000
5001 case 385:
5002 #line 1911 "conf_parser.y" /* yacc.c:1652 */
5003 {
5004 if (conf_parser_ctx.pass == 2)
5005 block_state.flags.value |= CLUSTER_UNDLINE;
5006 }
5007 #line 5008 "conf_parser.c" /* yacc.c:1652 */
5008 break;
5009
5010 case 386:
5011 #line 1915 "conf_parser.y" /* yacc.c:1652 */
5012 {
5013 if (conf_parser_ctx.pass == 2)
5014 block_state.flags.value |= CLUSTER_XLINE;
5015 }
5016 #line 5017 "conf_parser.c" /* yacc.c:1652 */
5017 break;
5018
5019 case 387:
5020 #line 1919 "conf_parser.y" /* yacc.c:1652 */
5021 {
5022 if (conf_parser_ctx.pass == 2)
5023 block_state.flags.value |= CLUSTER_UNXLINE;
5024 }
5025 #line 5026 "conf_parser.c" /* yacc.c:1652 */
5026 break;
5027
5028 case 388:
5029 #line 1923 "conf_parser.y" /* yacc.c:1652 */
5030 {
5031 if (conf_parser_ctx.pass == 2)
5032 block_state.flags.value |= CLUSTER_RESV;
5033 }
5034 #line 5035 "conf_parser.c" /* yacc.c:1652 */
5035 break;
5036
5037 case 389:
5038 #line 1927 "conf_parser.y" /* yacc.c:1652 */
5039 {
5040 if (conf_parser_ctx.pass == 2)
5041 block_state.flags.value |= CLUSTER_UNRESV;
5042 }
5043 #line 5044 "conf_parser.c" /* yacc.c:1652 */
5044 break;
5045
5046 case 390:
5047 #line 1931 "conf_parser.y" /* yacc.c:1652 */
5048 {
5049 if (conf_parser_ctx.pass == 2)
5050 block_state.flags.value |= CLUSTER_LOCOPS;
5051 }
5052 #line 5053 "conf_parser.c" /* yacc.c:1652 */
5053 break;
5054
5055 case 391:
5056 #line 1935 "conf_parser.y" /* yacc.c:1652 */
5057 {
5058 if (conf_parser_ctx.pass == 2)
5059 block_state.flags.value = CLUSTER_ALL;
5060 }
5061 #line 5062 "conf_parser.c" /* yacc.c:1652 */
5062 break;
5063
5064 case 392:
5065 #line 1945 "conf_parser.y" /* yacc.c:1652 */
5066 {
5067
5068 if (conf_parser_ctx.pass != 2)
5069 break;
5070
5071 reset_block_state();
5072 block_state.aftype.value = AF_INET;
5073 block_state.port.value = PORTNUM;
5074 }
5075 #line 5076 "conf_parser.c" /* yacc.c:1652 */
5076 break;
5077
5078 case 393:
5079 #line 1954 "conf_parser.y" /* yacc.c:1652 */
5080 {
5081 struct addrinfo hints, *res;
5082
5083 if (conf_parser_ctx.pass != 2)
5084 break;
5085
5086 if (!block_state.name.buf[0] ||
5087 !block_state.host.buf[0])
5088 break;
5089
5090 if (!block_state.rpass.buf[0] ||
5091 !block_state.spass.buf[0])
5092 break;
5093
5094 if (server_valid_name(block_state.name.buf) == false)
5095 break;
5096
5097 if (has_wildcards(block_state.name.buf) ||
5098 has_wildcards(block_state.host.buf))
5099 break;
5100
5101 struct MaskItem *conf = conf_make(CONF_SERVER);
5102 conf->addr = xcalloc(sizeof(*conf->addr));
5103 conf->port = block_state.port.value;
5104 conf->flags = block_state.flags.value;
5105 conf->aftype = block_state.aftype.value;
5106 conf->host = xstrdup(block_state.host.buf);
5107 conf->name = xstrdup(block_state.name.buf);
5108 conf->passwd = xstrdup(block_state.rpass.buf);
5109 conf->spasswd = xstrdup(block_state.spass.buf);
5110
5111 if (block_state.cert.buf[0])
5112 conf->certfp = xstrdup(block_state.cert.buf);
5113
5114 if (block_state.ciph.buf[0])
5115 conf->cipher_list = xstrdup(block_state.ciph.buf);
5116
5117 dlinkMoveList(&block_state.leaf.list, &conf->leaf_list);
5118 dlinkMoveList(&block_state.hub.list, &conf->hub_list);
5119
5120 if (block_state.bind.buf[0])
5121 {
5122 memset(&hints, 0, sizeof(hints));
5123
5124 hints.ai_family = AF_UNSPEC;
5125 hints.ai_socktype = SOCK_STREAM;
5126 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
5127
5128 if (getaddrinfo(block_state.bind.buf, NULL, &hints, &res))
5129 ilog(LOG_TYPE_IRCD, "Invalid netmask for server bind(%s)", block_state.bind.buf);
5130 else
5131 {
5132 assert(res);
5133
5134 conf->bind = xcalloc(sizeof(*conf->bind));
5135
5136 memcpy(conf->bind, res->ai_addr, res->ai_addrlen);
5137 conf->bind->ss_len = res->ai_addrlen;
5138 freeaddrinfo(res);
5139 }
5140 }
5141
5142 conf_add_class_to_conf(conf, block_state.class.buf);
5143 lookup_confhost(conf);
5144 }
5145 #line 5146 "conf_parser.c" /* yacc.c:1652 */
5146 break;
5147
5148 case 411:
5149 #line 2038 "conf_parser.y" /* yacc.c:1652 */
5150 {
5151 if (conf_parser_ctx.pass == 2)
5152 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
5153 }
5154 #line 5155 "conf_parser.c" /* yacc.c:1652 */
5155 break;
5156
5157 case 412:
5158 #line 2044 "conf_parser.y" /* yacc.c:1652 */
5159 {
5160 if (conf_parser_ctx.pass == 2)
5161 strlcpy(block_state.host.buf, yylval.string, sizeof(block_state.host.buf));
5162 }
5163 #line 5164 "conf_parser.c" /* yacc.c:1652 */
5164 break;
5165
5166 case 413:
5167 #line 2050 "conf_parser.y" /* yacc.c:1652 */
5168 {
5169 if (conf_parser_ctx.pass == 2)
5170 strlcpy(block_state.bind.buf, yylval.string, sizeof(block_state.bind.buf));
5171 }
5172 #line 5173 "conf_parser.c" /* yacc.c:1652 */
5173 break;
5174
5175 case 414:
5176 #line 2056 "conf_parser.y" /* yacc.c:1652 */
5177 {
5178 if (conf_parser_ctx.pass != 2)
5179 break;
5180
5181 if (*yylval.string == ':')
5182 conf_error_report("Server passwords cannot begin with a colon");
5183 else if (strchr(yylval.string, ' '))
5184 conf_error_report("Server passwords cannot contain spaces");
5185 else
5186 strlcpy(block_state.spass.buf, yylval.string, sizeof(block_state.spass.buf));
5187 }
5188 #line 5189 "conf_parser.c" /* yacc.c:1652 */
5189 break;
5190
5191 case 415:
5192 #line 2069 "conf_parser.y" /* yacc.c:1652 */
5193 {
5194 if (conf_parser_ctx.pass != 2)
5195 break;
5196
5197 if (*yylval.string == ':')
5198 conf_error_report("Server passwords cannot begin with a colon");
5199 else if (strchr(yylval.string, ' '))
5200 conf_error_report("Server passwords cannot contain spaces");
5201 else
5202 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5203 }
5204 #line 5205 "conf_parser.c" /* yacc.c:1652 */
5205 break;
5206
5207 case 416:
5208 #line 2082 "conf_parser.y" /* yacc.c:1652 */
5209 {
5210 if (conf_parser_ctx.pass == 2)
5211 strlcpy(block_state.cert.buf, yylval.string, sizeof(block_state.cert.buf));
5212 }
5213 #line 5214 "conf_parser.c" /* yacc.c:1652 */
5214 break;
5215
5216 case 417:
5217 #line 2088 "conf_parser.y" /* yacc.c:1652 */
5218 {
5219 if (conf_parser_ctx.pass == 2)
5220 block_state.port.value = (yyvsp[-1].number);
5221 }
5222 #line 5223 "conf_parser.c" /* yacc.c:1652 */
5223 break;
5224
5225 case 418:
5226 #line 2094 "conf_parser.y" /* yacc.c:1652 */
5227 {
5228 if (conf_parser_ctx.pass == 2)
5229 block_state.aftype.value = AF_INET;
5230 }
5231 #line 5232 "conf_parser.c" /* yacc.c:1652 */
5232 break;
5233
5234 case 419:
5235 #line 2098 "conf_parser.y" /* yacc.c:1652 */
5236 {
5237 if (conf_parser_ctx.pass == 2)
5238 block_state.aftype.value = AF_INET6;
5239 }
5240 #line 5241 "conf_parser.c" /* yacc.c:1652 */
5241 break;
5242
5243 case 420:
5244 #line 2104 "conf_parser.y" /* yacc.c:1652 */
5245 {
5246 block_state.flags.value &= CONF_FLAGS_ENCRYPTED;
5247 }
5248 #line 5249 "conf_parser.c" /* yacc.c:1652 */
5249 break;
5250
5251 case 424:
5252 #line 2110 "conf_parser.y" /* yacc.c:1652 */
5253 {
5254 if (conf_parser_ctx.pass == 2)
5255 block_state.flags.value |= CONF_FLAGS_ALLOW_AUTO_CONN;
5256 }
5257 #line 5258 "conf_parser.c" /* yacc.c:1652 */
5258 break;
5259
5260 case 425:
5261 #line 2114 "conf_parser.y" /* yacc.c:1652 */
5262 {
5263 if (conf_parser_ctx.pass == 2)
5264 block_state.flags.value |= CONF_FLAGS_SSL;
5265 }
5266 #line 5267 "conf_parser.c" /* yacc.c:1652 */
5267 break;
5268
5269 case 426:
5270 #line 2120 "conf_parser.y" /* yacc.c:1652 */
5271 {
5272 if (conf_parser_ctx.pass == 2)
5273 {
5274 if (yylval.number)
5275 block_state.flags.value |= CONF_FLAGS_ENCRYPTED;
5276 else
5277 block_state.flags.value &= ~CONF_FLAGS_ENCRYPTED;
5278 }
5279 }
5280 #line 5281 "conf_parser.c" /* yacc.c:1652 */
5281 break;
5282
5283 case 427:
5284 #line 2131 "conf_parser.y" /* yacc.c:1652 */
5285 {
5286 if (conf_parser_ctx.pass == 2)
5287 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.hub.list);
5288 }
5289 #line 5290 "conf_parser.c" /* yacc.c:1652 */
5290 break;
5291
5292 case 428:
5293 #line 2137 "conf_parser.y" /* yacc.c:1652 */
5294 {
5295 if (conf_parser_ctx.pass == 2)
5296 dlinkAdd(xstrdup(yylval.string), make_dlink_node(), &block_state.leaf.list);
5297 }
5298 #line 5299 "conf_parser.c" /* yacc.c:1652 */
5299 break;
5300
5301 case 429:
5302 #line 2143 "conf_parser.y" /* yacc.c:1652 */
5303 {
5304 if (conf_parser_ctx.pass == 2)
5305 strlcpy(block_state.class.buf, yylval.string, sizeof(block_state.class.buf));
5306 }
5307 #line 5308 "conf_parser.c" /* yacc.c:1652 */
5308 break;
5309
5310 case 430:
5311 #line 2149 "conf_parser.y" /* yacc.c:1652 */
5312 {
5313 #ifdef HAVE_TLS
5314 if (conf_parser_ctx.pass == 2)
5315 strlcpy(block_state.ciph.buf, yylval.string, sizeof(block_state.ciph.buf));
5316 #else
5317 if (conf_parser_ctx.pass == 2)
5318 conf_error_report("Ignoring connect::ciphers -- no TLS support");
5319 #endif
5320 }
5321 #line 5322 "conf_parser.c" /* yacc.c:1652 */
5322 break;
5323
5324 case 431:
5325 #line 2164 "conf_parser.y" /* yacc.c:1652 */
5326 {
5327 if (conf_parser_ctx.pass == 2)
5328 reset_block_state();
5329 }
5330 #line 5331 "conf_parser.c" /* yacc.c:1652 */
5331 break;
5332
5333 case 432:
5334 #line 2168 "conf_parser.y" /* yacc.c:1652 */
5335 {
5336 if (conf_parser_ctx.pass != 2)
5337 break;
5338
5339 if (!block_state.user.buf[0] ||
5340 !block_state.host.buf[0])
5341 break;
5342
5343 struct MaskItem *conf = conf_make(CONF_KLINE);
5344 conf->user = xstrdup(block_state.user.buf);
5345 conf->host = xstrdup(block_state.host.buf);
5346
5347 if (block_state.rpass.buf[0])
5348 conf->reason = xstrdup(block_state.rpass.buf);
5349 else
5350 conf->reason = xstrdup(CONF_NOREASON);
5351 add_conf_by_address(CONF_KLINE, conf);
5352 }
5353 #line 5354 "conf_parser.c" /* yacc.c:1652 */
5354 break;
5355
5356 case 438:
5357 #line 2191 "conf_parser.y" /* yacc.c:1652 */
5358 {
5359
5360 if (conf_parser_ctx.pass == 2)
5361 {
5362 struct split_nuh_item nuh;
5363
5364 nuh.nuhmask = yylval.string;
5365 nuh.nickptr = NULL;
5366 nuh.userptr = block_state.user.buf;
5367 nuh.hostptr = block_state.host.buf;
5368
5369 nuh.nicksize = 0;
5370 nuh.usersize = sizeof(block_state.user.buf);
5371 nuh.hostsize = sizeof(block_state.host.buf);
5372
5373 split_nuh(&nuh);
5374 }
5375 }
5376 #line 5377 "conf_parser.c" /* yacc.c:1652 */
5377 break;
5378
5379 case 439:
5380 #line 2211 "conf_parser.y" /* yacc.c:1652 */
5381 {
5382 if (conf_parser_ctx.pass == 2)
5383 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5384 }
5385 #line 5386 "conf_parser.c" /* yacc.c:1652 */
5386 break;
5387
5388 case 440:
5389 #line 2221 "conf_parser.y" /* yacc.c:1652 */
5390 {
5391 if (conf_parser_ctx.pass == 2)
5392 reset_block_state();
5393 }
5394 #line 5395 "conf_parser.c" /* yacc.c:1652 */
5395 break;
5396
5397 case 441:
5398 #line 2225 "conf_parser.y" /* yacc.c:1652 */
5399 {
5400 if (conf_parser_ctx.pass != 2)
5401 break;
5402
5403 if (!block_state.addr.buf[0])
5404 break;
5405
5406 if (parse_netmask(block_state.addr.buf, NULL, NULL) != HM_HOST)
5407 {
5408 struct MaskItem *conf = conf_make(CONF_DLINE);
5409 conf->host = xstrdup(block_state.addr.buf);
5410
5411 if (block_state.rpass.buf[0])
5412 conf->reason = xstrdup(block_state.rpass.buf);
5413 else
5414 conf->reason = xstrdup(CONF_NOREASON);
5415 add_conf_by_address(CONF_DLINE, conf);
5416 }
5417 }
5418 #line 5419 "conf_parser.c" /* yacc.c:1652 */
5419 break;
5420
5421 case 447:
5422 #line 2249 "conf_parser.y" /* yacc.c:1652 */
5423 {
5424 if (conf_parser_ctx.pass == 2)
5425 strlcpy(block_state.addr.buf, yylval.string, sizeof(block_state.addr.buf));
5426 }
5427 #line 5428 "conf_parser.c" /* yacc.c:1652 */
5428 break;
5429
5430 case 448:
5431 #line 2255 "conf_parser.y" /* yacc.c:1652 */
5432 {
5433 if (conf_parser_ctx.pass == 2)
5434 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5435 }
5436 #line 5437 "conf_parser.c" /* yacc.c:1652 */
5437 break;
5438
5439 case 454:
5440 #line 2270 "conf_parser.y" /* yacc.c:1652 */
5441 {
5442 if (conf_parser_ctx.pass == 2)
5443 {
5444 if (*yylval.string && parse_netmask(yylval.string, NULL, NULL) != HM_HOST)
5445 {
5446 struct MaskItem *conf = conf_make(CONF_EXEMPT);
5447 conf->host = xstrdup(yylval.string);
5448
5449 add_conf_by_address(CONF_EXEMPT, conf);
5450 }
5451 }
5452 }
5453 #line 5454 "conf_parser.c" /* yacc.c:1652 */
5454 break;
5455
5456 case 455:
5457 #line 2287 "conf_parser.y" /* yacc.c:1652 */
5458 {
5459 if (conf_parser_ctx.pass == 2)
5460 reset_block_state();
5461 }
5462 #line 5463 "conf_parser.c" /* yacc.c:1652 */
5463 break;
5464
5465 case 456:
5466 #line 2291 "conf_parser.y" /* yacc.c:1652 */
5467 {
5468 if (conf_parser_ctx.pass != 2)
5469 break;
5470
5471 if (!block_state.name.buf[0])
5472 break;
5473
5474 struct GecosItem *gecos = gecos_make();
5475 gecos->mask = xstrdup(block_state.name.buf);
5476
5477 if (block_state.rpass.buf[0])
5478 gecos->reason = xstrdup(block_state.rpass.buf);
5479 else
5480 gecos->reason = xstrdup(CONF_NOREASON);
5481 }
5482 #line 5483 "conf_parser.c" /* yacc.c:1652 */
5483 break;
5484
5485 case 462:
5486 #line 2311 "conf_parser.y" /* yacc.c:1652 */
5487 {
5488 if (conf_parser_ctx.pass == 2)
5489 strlcpy(block_state.name.buf, yylval.string, sizeof(block_state.name.buf));
5490 }
5491 #line 5492 "conf_parser.c" /* yacc.c:1652 */
5492 break;
5493
5494 case 463:
5495 #line 2317 "conf_parser.y" /* yacc.c:1652 */
5496 {
5497 if (conf_parser_ctx.pass == 2)
5498 strlcpy(block_state.rpass.buf, yylval.string, sizeof(block_state.rpass.buf));
5499 }
5500 #line 5501 "conf_parser.c" /* yacc.c:1652 */
5501 break;
5502
5503 case 513:
5504 #line 2378 "conf_parser.y" /* yacc.c:1652 */
5505 {
5506 ConfigGeneral.away_count = (yyvsp[-1].number);
5507 }
5508 #line 5509 "conf_parser.c" /* yacc.c:1652 */
5509 break;
5510
5511 case 514:
5512 #line 2383 "conf_parser.y" /* yacc.c:1652 */
5513 {
5514 ConfigGeneral.away_time = (yyvsp[-1].number);
5515 }
5516 #line 5517 "conf_parser.c" /* yacc.c:1652 */
5517 break;
5518
5519 case 515:
5520 #line 2388 "conf_parser.y" /* yacc.c:1652 */
5521 {
5522 ConfigGeneral.max_watch = (yyvsp[-1].number);
5523 }
5524 #line 5525 "conf_parser.c" /* yacc.c:1652 */
5525 break;
5526
5527 case 516:
5528 #line 2393 "conf_parser.y" /* yacc.c:1652 */
5529 {
5530 ConfigGeneral.whowas_history_length = (yyvsp[-1].number);
5531 }
5532 #line 5533 "conf_parser.c" /* yacc.c:1652 */
5533 break;
5534
5535 case 517:
5536 #line 2398 "conf_parser.y" /* yacc.c:1652 */
5537 {
5538 ConfigGeneral.cycle_on_host_change = yylval.number;
5539 }
5540 #line 5541 "conf_parser.c" /* yacc.c:1652 */
5541 break;
5542
5543 case 518:
5544 #line 2403 "conf_parser.y" /* yacc.c:1652 */
5545 {
5546 ConfigGeneral.dline_min_cidr = (yyvsp[-1].number);
5547 }
5548 #line 5549 "conf_parser.c" /* yacc.c:1652 */
5549 break;
5550
5551 case 519:
5552 #line 2408 "conf_parser.y" /* yacc.c:1652 */
5553 {
5554 ConfigGeneral.dline_min_cidr6 = (yyvsp[-1].number);
5555 }
5556 #line 5557 "conf_parser.c" /* yacc.c:1652 */
5557 break;
5558
5559 case 520:
5560 #line 2413 "conf_parser.y" /* yacc.c:1652 */
5561 {
5562 ConfigGeneral.kline_min_cidr = (yyvsp[-1].number);
5563 }
5564 #line 5565 "conf_parser.c" /* yacc.c:1652 */
5565 break;
5566
5567 case 521:
5568 #line 2418 "conf_parser.y" /* yacc.c:1652 */
5569 {
5570 ConfigGeneral.kline_min_cidr6 = (yyvsp[-1].number);
5571 }
5572 #line 5573 "conf_parser.c" /* yacc.c:1652 */
5573 break;
5574
5575 case 522:
5576 #line 2423 "conf_parser.y" /* yacc.c:1652 */
5577 {
5578 ConfigGeneral.kill_chase_time_limit = (yyvsp[-1].number);
5579 }
5580 #line 5581 "conf_parser.c" /* yacc.c:1652 */
5581 break;
5582
5583 case 523:
5584 #line 2428 "conf_parser.y" /* yacc.c:1652 */
5585 {
5586 ConfigGeneral.failed_oper_notice = yylval.number;
5587 }
5588 #line 5589 "conf_parser.c" /* yacc.c:1652 */
5589 break;
5590
5591 case 524:
5592 #line 2433 "conf_parser.y" /* yacc.c:1652 */
5593 {
5594 ConfigGeneral.anti_nick_flood = yylval.number;
5595 }
5596 #line 5597 "conf_parser.c" /* yacc.c:1652 */
5597 break;
5598
5599 case 525:
5600 #line 2438 "conf_parser.y" /* yacc.c:1652 */
5601 {
5602 ConfigGeneral.max_nick_time = (yyvsp[-1].number);
5603 }
5604 #line 5605 "conf_parser.c" /* yacc.c:1652 */
5605 break;
5606
5607 case 526:
5608 #line 2443 "conf_parser.y" /* yacc.c:1652 */
5609 {
5610 ConfigGeneral.max_nick_changes = (yyvsp[-1].number);
5611 }
5612 #line 5613 "conf_parser.c" /* yacc.c:1652 */
5613 break;
5614
5615 case 527:
5616 #line 2448 "conf_parser.y" /* yacc.c:1652 */
5617 {
5618 ConfigGeneral.max_accept = (yyvsp[-1].number);
5619 }
5620 #line 5621 "conf_parser.c" /* yacc.c:1652 */
5621 break;
5622
5623 case 528:
5624 #line 2453 "conf_parser.y" /* yacc.c:1652 */
5625 {
5626 ConfigGeneral.anti_spam_exit_message_time = (yyvsp[-1].number);
5627 }
5628 #line 5629 "conf_parser.c" /* yacc.c:1652 */
5629 break;
5630
5631 case 529:
5632 #line 2458 "conf_parser.y" /* yacc.c:1652 */
5633 {
5634 ConfigGeneral.ts_warn_delta = (yyvsp[-1].number);
5635 }
5636 #line 5637 "conf_parser.c" /* yacc.c:1652 */
5637 break;
5638
5639 case 530:
5640 #line 2463 "conf_parser.y" /* yacc.c:1652 */
5641 {
5642 ConfigGeneral.ts_max_delta = (yyvsp[-1].number);
5643 }
5644 #line 5645 "conf_parser.c" /* yacc.c:1652 */
5645 break;
5646
5647 case 531:
5648 #line 2468 "conf_parser.y" /* yacc.c:1652 */
5649 {
5650 ConfigGeneral.invisible_on_connect = yylval.number;
5651 }
5652 #line 5653 "conf_parser.c" /* yacc.c:1652 */
5653 break;
5654
5655 case 532:
5656 #line 2473 "conf_parser.y" /* yacc.c:1652 */
5657 {
5658 ConfigGeneral.warn_no_connect_block = yylval.number;
5659 }
5660 #line 5661 "conf_parser.c" /* yacc.c:1652 */
5661 break;
5662
5663 case 533:
5664 #line 2478 "conf_parser.y" /* yacc.c:1652 */
5665 {
5666 ConfigGeneral.stats_e_disabled = yylval.number;
5667 }
5668 #line 5669 "conf_parser.c" /* yacc.c:1652 */
5669 break;
5670
5671 case 534:
5672 #line 2483 "conf_parser.y" /* yacc.c:1652 */
5673 {
5674 ConfigGeneral.stats_m_oper_only = yylval.number;
5675 }
5676 #line 5677 "conf_parser.c" /* yacc.c:1652 */
5677 break;
5678
5679 case 535:
5680 #line 2488 "conf_parser.y" /* yacc.c:1652 */
5681 {
5682 ConfigGeneral.stats_o_oper_only = yylval.number;
5683 }
5684 #line 5685 "conf_parser.c" /* yacc.c:1652 */
5685 break;
5686
5687 case 536:
5688 #line 2493 "conf_parser.y" /* yacc.c:1652 */
5689 {
5690 ConfigGeneral.stats_P_oper_only = yylval.number;
5691 }
5692 #line 5693 "conf_parser.c" /* yacc.c:1652 */
5693 break;
5694
5695 case 537:
5696 #line 2498 "conf_parser.y" /* yacc.c:1652 */
5697 {
5698 ConfigGeneral.stats_u_oper_only = yylval.number;
5699 }
5700 #line 5701 "conf_parser.c" /* yacc.c:1652 */
5701 break;
5702
5703 case 538:
5704 #line 2503 "conf_parser.y" /* yacc.c:1652 */
5705 {
5706 ConfigGeneral.stats_k_oper_only = 2 * yylval.number;
5707 }
5708 #line 5709 "conf_parser.c" /* yacc.c:1652 */
5709 break;
5710
5711 case 539:
5712 #line 2506 "conf_parser.y" /* yacc.c:1652 */
5713 {
5714 ConfigGeneral.stats_k_oper_only = 1;
5715 }
5716 #line 5717 "conf_parser.c" /* yacc.c:1652 */
5717 break;
5718
5719 case 540:
5720 #line 2511 "conf_parser.y" /* yacc.c:1652 */
5721 {
5722 ConfigGeneral.stats_i_oper_only = 2 * yylval.number;
5723 }
5724 #line 5725 "conf_parser.c" /* yacc.c:1652 */
5725 break;
5726
5727 case 541:
5728 #line 2514 "conf_parser.y" /* yacc.c:1652 */
5729 {
5730 ConfigGeneral.stats_i_oper_only = 1;
5731 }
5732 #line 5733 "conf_parser.c" /* yacc.c:1652 */
5733 break;
5734
5735 case 542:
5736 #line 2519 "conf_parser.y" /* yacc.c:1652 */
5737 {
5738 ConfigGeneral.pace_wait = (yyvsp[-1].number);
5739 }
5740 #line 5741 "conf_parser.c" /* yacc.c:1652 */
5741 break;
5742
5743 case 543:
5744 #line 2524 "conf_parser.y" /* yacc.c:1652 */
5745 {
5746 ConfigGeneral.caller_id_wait = (yyvsp[-1].number);
5747 }
5748 #line 5749 "conf_parser.c" /* yacc.c:1652 */
5749 break;
5750
5751 case 544:
5752 #line 2529 "conf_parser.y" /* yacc.c:1652 */
5753 {
5754 ConfigGeneral.opers_bypass_callerid = yylval.number;
5755 }
5756 #line 5757 "conf_parser.c" /* yacc.c:1652 */
5757 break;
5758
5759 case 545:
5760 #line 2534 "conf_parser.y" /* yacc.c:1652 */
5761 {
5762 ConfigGeneral.pace_wait_simple = (yyvsp[-1].number);
5763 }
5764 #line 5765 "conf_parser.c" /* yacc.c:1652 */
5765 break;
5766
5767 case 546:
5768 #line 2539 "conf_parser.y" /* yacc.c:1652 */
5769 {
5770 ConfigGeneral.short_motd = yylval.number;
5771 }
5772 #line 5773 "conf_parser.c" /* yacc.c:1652 */
5773 break;
5774
5775 case 547:
5776 #line 2544 "conf_parser.y" /* yacc.c:1652 */
5777 {
5778 ConfigGeneral.no_oper_flood = yylval.number;
5779 }
5780 #line 5781 "conf_parser.c" /* yacc.c:1652 */
5781 break;
5782
5783 case 548:
5784 #line 2549 "conf_parser.y" /* yacc.c:1652 */
5785 {
5786 ConfigGeneral.dots_in_ident = (yyvsp[-1].number);
5787 }
5788 #line 5789 "conf_parser.c" /* yacc.c:1652 */
5789 break;
5790
5791 case 549:
5792 #line 2554 "conf_parser.y" /* yacc.c:1652 */
5793 {
5794 ConfigGeneral.max_targets = (yyvsp[-1].number);
5795 }
5796 #line 5797 "conf_parser.c" /* yacc.c:1652 */
5797 break;
5798
5799 case 550:
5800 #line 2559 "conf_parser.y" /* yacc.c:1652 */
5801 {
5802 ConfigGeneral.ping_cookie = yylval.number;
5803 }
5804 #line 5805 "conf_parser.c" /* yacc.c:1652 */
5805 break;
5806
5807 case 551:
5808 #line 2564 "conf_parser.y" /* yacc.c:1652 */
5809 {
5810 ConfigGeneral.disable_auth = yylval.number;
5811 }
5812 #line 5813 "conf_parser.c" /* yacc.c:1652 */
5813 break;
5814
5815 case 552:
5816 #line 2569 "conf_parser.y" /* yacc.c:1652 */
5817 {
5818 ConfigGeneral.throttle_count = (yyvsp[-1].number);
5819 }
5820 #line 5821 "conf_parser.c" /* yacc.c:1652 */
5821 break;
5822
5823 case 553:
5824 #line 2574 "conf_parser.y" /* yacc.c:1652 */
5825 {
5826 ConfigGeneral.throttle_time = (yyvsp[-1].number);
5827 }
5828 #line 5829 "conf_parser.c" /* yacc.c:1652 */
5829 break;
5830
5831 case 554:
5832 #line 2579 "conf_parser.y" /* yacc.c:1652 */
5833 {
5834 ConfigGeneral.oper_umodes = 0;
5835 }
5836 #line 5837 "conf_parser.c" /* yacc.c:1652 */
5837 break;
5838
5839 case 558:
5840 #line 2585 "conf_parser.y" /* yacc.c:1652 */
5841 {
5842 ConfigGeneral.oper_umodes |= UMODE_BOTS;
5843 }
5844 #line 5845 "conf_parser.c" /* yacc.c:1652 */
5845 break;
5846
5847 case 559:
5848 #line 2588 "conf_parser.y" /* yacc.c:1652 */
5849 {
5850 ConfigGeneral.oper_umodes |= UMODE_CCONN;
5851 }
5852 #line 5853 "conf_parser.c" /* yacc.c:1652 */
5853 break;
5854
5855 case 560:
5856 #line 2591 "conf_parser.y" /* yacc.c:1652 */
5857 {
5858 ConfigGeneral.oper_umodes |= UMODE_DEAF;
5859 }
5860 #line 5861 "conf_parser.c" /* yacc.c:1652 */
5861 break;
5862
5863 case 561:
5864 #line 2594 "conf_parser.y" /* yacc.c:1652 */
5865 {
5866 ConfigGeneral.oper_umodes |= UMODE_DEBUG;
5867 }
5868 #line 5869 "conf_parser.c" /* yacc.c:1652 */
5869 break;
5870
5871 case 562:
5872 #line 2597 "conf_parser.y" /* yacc.c:1652 */
5873 {
5874 ConfigGeneral.oper_umodes |= UMODE_FULL;
5875 }
5876 #line 5877 "conf_parser.c" /* yacc.c:1652 */
5877 break;
5878
5879 case 563:
5880 #line 2600 "conf_parser.y" /* yacc.c:1652 */
5881 {
5882 ConfigGeneral.oper_umodes |= UMODE_HIDDEN;
5883 }
5884 #line 5885 "conf_parser.c" /* yacc.c:1652 */
5885 break;
5886
5887 case 564:
5888 #line 2603 "conf_parser.y" /* yacc.c:1652 */
5889 {
5890 ConfigGeneral.oper_umodes |= UMODE_HIDECHANS;
5891 }
5892 #line 5893 "conf_parser.c" /* yacc.c:1652 */
5893 break;
5894
5895 case 565:
5896 #line 2606 "conf_parser.y" /* yacc.c:1652 */
5897 {
5898 ConfigGeneral.oper_umodes |= UMODE_HIDEIDLE;
5899 }
5900 #line 5901 "conf_parser.c" /* yacc.c:1652 */
5901 break;
5902
5903 case 566:
5904 #line 2609 "conf_parser.y" /* yacc.c:1652 */
5905 {
5906 ConfigGeneral.oper_umodes |= UMODE_SKILL;
5907 }
5908 #line 5909 "conf_parser.c" /* yacc.c:1652 */
5909 break;
5910
5911 case 567:
5912 #line 2612 "conf_parser.y" /* yacc.c:1652 */
5913 {
5914 ConfigGeneral.oper_umodes |= UMODE_NCHANGE;
5915 }
5916 #line 5917 "conf_parser.c" /* yacc.c:1652 */
5917 break;
5918
5919 case 568:
5920 #line 2615 "conf_parser.y" /* yacc.c:1652 */
5921 {
5922 ConfigGeneral.oper_umodes |= UMODE_REJ;
5923 }
5924 #line 5925 "conf_parser.c" /* yacc.c:1652 */
5925 break;
5926
5927 case 569:
5928 #line 2618 "conf_parser.y" /* yacc.c:1652 */
5929 {
5930 ConfigGeneral.oper_umodes |= UMODE_UNAUTH;
5931 }
5932 #line 5933 "conf_parser.c" /* yacc.c:1652 */
5933 break;
5934
5935 case 570:
5936 #line 2621 "conf_parser.y" /* yacc.c:1652 */
5937 {
5938 ConfigGeneral.oper_umodes |= UMODE_SPY;
5939 }
5940 #line 5941 "conf_parser.c" /* yacc.c:1652 */
5941 break;
5942
5943 case 571:
5944 #line 2624 "conf_parser.y" /* yacc.c:1652 */
5945 {
5946 ConfigGeneral.oper_umodes |= UMODE_EXTERNAL;
5947 }
5948 #line 5949 "conf_parser.c" /* yacc.c:1652 */
5949 break;
5950
5951 case 572:
5952 #line 2627 "conf_parser.y" /* yacc.c:1652 */
5953 {
5954 ConfigGeneral.oper_umodes |= UMODE_SERVNOTICE;
5955 }
5956 #line 5957 "conf_parser.c" /* yacc.c:1652 */
5957 break;
5958
5959 case 573:
5960 #line 2630 "conf_parser.y" /* yacc.c:1652 */
5961 {
5962 ConfigGeneral.oper_umodes |= UMODE_INVISIBLE;
5963 }
5964 #line 5965 "conf_parser.c" /* yacc.c:1652 */
5965 break;
5966
5967 case 574:
5968 #line 2633 "conf_parser.y" /* yacc.c:1652 */
5969 {
5970 ConfigGeneral.oper_umodes |= UMODE_WALLOP;
5971 }
5972 #line 5973 "conf_parser.c" /* yacc.c:1652 */
5973 break;
5974
5975 case 575:
5976 #line 2636 "conf_parser.y" /* yacc.c:1652 */
5977 {
5978 ConfigGeneral.oper_umodes |= UMODE_SOFTCALLERID;
5979 }
5980 #line 5981 "conf_parser.c" /* yacc.c:1652 */
5981 break;
5982
5983 case 576:
5984 #line 2639 "conf_parser.y" /* yacc.c:1652 */
5985 {
5986 ConfigGeneral.oper_umodes |= UMODE_CALLERID;
5987 }
5988 #line 5989 "conf_parser.c" /* yacc.c:1652 */
5989 break;
5990
5991 case 577:
5992 #line 2642 "conf_parser.y" /* yacc.c:1652 */
5993 {
5994 ConfigGeneral.oper_umodes |= UMODE_LOCOPS;
5995 }
5996 #line 5997 "conf_parser.c" /* yacc.c:1652 */
5997 break;
5998
5999 case 578:
6000 #line 2645 "conf_parser.y" /* yacc.c:1652 */
6001 {
6002 ConfigGeneral.oper_umodes |= UMODE_REGONLY;
6003 }
6004 #line 6005 "conf_parser.c" /* yacc.c:1652 */
6005 break;
6006
6007 case 579:
6008 #line 2648 "conf_parser.y" /* yacc.c:1652 */
6009 {
6010 ConfigGeneral.oper_umodes |= UMODE_FARCONNECT;
6011 }
6012 #line 6013 "conf_parser.c" /* yacc.c:1652 */
6013 break;
6014
6015 case 580:
6016 #line 2651 "conf_parser.y" /* yacc.c:1652 */
6017 {
6018 ConfigGeneral.oper_umodes |= UMODE_EXPIRATION;
6019 }
6020 #line 6021 "conf_parser.c" /* yacc.c:1652 */
6021 break;
6022
6023 case 581:
6024 #line 2656 "conf_parser.y" /* yacc.c:1652 */
6025 {
6026 ConfigGeneral.oper_only_umodes = 0;
6027 }
6028 #line 6029 "conf_parser.c" /* yacc.c:1652 */
6029 break;
6030
6031 case 585:
6032 #line 2662 "conf_parser.y" /* yacc.c:1652 */
6033 {
6034 ConfigGeneral.oper_only_umodes |= UMODE_BOTS;
6035 }
6036 #line 6037 "conf_parser.c" /* yacc.c:1652 */
6037 break;
6038
6039 case 586:
6040 #line 2665 "conf_parser.y" /* yacc.c:1652 */
6041 {
6042 ConfigGeneral.oper_only_umodes |= UMODE_CCONN;
6043 }
6044 #line 6045 "conf_parser.c" /* yacc.c:1652 */
6045 break;
6046
6047 case 587:
6048 #line 2668 "conf_parser.y" /* yacc.c:1652 */
6049 {
6050 ConfigGeneral.oper_only_umodes |= UMODE_DEAF;
6051 }
6052 #line 6053 "conf_parser.c" /* yacc.c:1652 */
6053 break;
6054
6055 case 588:
6056 #line 2671 "conf_parser.y" /* yacc.c:1652 */
6057 {
6058 ConfigGeneral.oper_only_umodes |= UMODE_DEBUG;
6059 }
6060 #line 6061 "conf_parser.c" /* yacc.c:1652 */
6061 break;
6062
6063 case 589:
6064 #line 2674 "conf_parser.y" /* yacc.c:1652 */
6065 {
6066 ConfigGeneral.oper_only_umodes |= UMODE_FULL;
6067 }
6068 #line 6069 "conf_parser.c" /* yacc.c:1652 */
6069 break;
6070
6071 case 590:
6072 #line 2677 "conf_parser.y" /* yacc.c:1652 */
6073 {
6074 ConfigGeneral.oper_only_umodes |= UMODE_SKILL;
6075 }
6076 #line 6077 "conf_parser.c" /* yacc.c:1652 */
6077 break;
6078
6079 case 591:
6080 #line 2680 "conf_parser.y" /* yacc.c:1652 */
6081 {
6082 ConfigGeneral.oper_only_umodes |= UMODE_HIDDEN;
6083 }
6084 #line 6085 "conf_parser.c" /* yacc.c:1652 */
6085 break;
6086
6087 case 592:
6088 #line 2683 "conf_parser.y" /* yacc.c:1652 */
6089 {
6090 ConfigGeneral.oper_only_umodes |= UMODE_NCHANGE;
6091 }
6092 #line 6093 "conf_parser.c" /* yacc.c:1652 */
6093 break;
6094
6095 case 593:
6096 #line 2686 "conf_parser.y" /* yacc.c:1652 */
6097 {
6098 ConfigGeneral.oper_only_umodes |= UMODE_REJ;
6099 }
6100 #line 6101 "conf_parser.c" /* yacc.c:1652 */
6101 break;
6102
6103 case 594:
6104 #line 2689 "conf_parser.y" /* yacc.c:1652 */
6105 {
6106 ConfigGeneral.oper_only_umodes |= UMODE_UNAUTH;
6107 }
6108 #line 6109 "conf_parser.c" /* yacc.c:1652 */
6109 break;
6110
6111 case 595:
6112 #line 2692 "conf_parser.y" /* yacc.c:1652 */
6113 {
6114 ConfigGeneral.oper_only_umodes |= UMODE_SPY;
6115 }
6116 #line 6117 "conf_parser.c" /* yacc.c:1652 */
6117 break;
6118
6119 case 596:
6120 #line 2695 "conf_parser.y" /* yacc.c:1652 */
6121 {
6122 ConfigGeneral.oper_only_umodes |= UMODE_EXTERNAL;
6123 }
6124 #line 6125 "conf_parser.c" /* yacc.c:1652 */
6125 break;
6126
6127 case 597:
6128 #line 2698 "conf_parser.y" /* yacc.c:1652 */
6129 {
6130 ConfigGeneral.oper_only_umodes |= UMODE_SERVNOTICE;
6131 }
6132 #line 6133 "conf_parser.c" /* yacc.c:1652 */
6133 break;
6134
6135 case 598:
6136 #line 2701 "conf_parser.y" /* yacc.c:1652 */
6137 {
6138 ConfigGeneral.oper_only_umodes |= UMODE_INVISIBLE;
6139 }
6140 #line 6141 "conf_parser.c" /* yacc.c:1652 */
6141 break;
6142
6143 case 599:
6144 #line 2704 "conf_parser.y" /* yacc.c:1652 */
6145 {
6146 ConfigGeneral.oper_only_umodes |= UMODE_WALLOP;
6147 }
6148 #line 6149 "conf_parser.c" /* yacc.c:1652 */
6149 break;
6150
6151 case 600:
6152 #line 2707 "conf_parser.y" /* yacc.c:1652 */
6153 {
6154 ConfigGeneral.oper_only_umodes |= UMODE_SOFTCALLERID;
6155 }
6156 #line 6157 "conf_parser.c" /* yacc.c:1652 */
6157 break;
6158
6159 case 601:
6160 #line 2710 "conf_parser.y" /* yacc.c:1652 */
6161 {
6162 ConfigGeneral.oper_only_umodes |= UMODE_CALLERID;
6163 }
6164 #line 6165 "conf_parser.c" /* yacc.c:1652 */
6165 break;
6166
6167 case 602:
6168 #line 2713 "conf_parser.y" /* yacc.c:1652 */
6169 {
6170 ConfigGeneral.oper_only_umodes |= UMODE_LOCOPS;
6171 }
6172 #line 6173 "conf_parser.c" /* yacc.c:1652 */
6173 break;
6174
6175 case 603:
6176 #line 2716 "conf_parser.y" /* yacc.c:1652 */
6177 {
6178 ConfigGeneral.oper_only_umodes |= UMODE_REGONLY;
6179 }
6180 #line 6181 "conf_parser.c" /* yacc.c:1652 */
6181 break;
6182
6183 case 604:
6184 #line 2719 "conf_parser.y" /* yacc.c:1652 */
6185 {
6186 ConfigGeneral.oper_only_umodes |= UMODE_FARCONNECT;
6187 }
6188 #line 6189 "conf_parser.c" /* yacc.c:1652 */
6189 break;
6190
6191 case 605:
6192 #line 2722 "conf_parser.y" /* yacc.c:1652 */
6193 {
6194 ConfigGeneral.oper_only_umodes |= UMODE_EXPIRATION;
6195 }
6196 #line 6197 "conf_parser.c" /* yacc.c:1652 */
6197 break;
6198
6199 case 606:
6200 #line 2727 "conf_parser.y" /* yacc.c:1652 */
6201 {
6202 ConfigGeneral.min_nonwildcard = (yyvsp[-1].number);
6203 }
6204 #line 6205 "conf_parser.c" /* yacc.c:1652 */
6205 break;
6206
6207 case 607:
6208 #line 2732 "conf_parser.y" /* yacc.c:1652 */
6209 {
6210 ConfigGeneral.min_nonwildcard_simple = (yyvsp[-1].number);
6211 }
6212 #line 6213 "conf_parser.c" /* yacc.c:1652 */
6213 break;
6214
6215 case 608:
6216 #line 2737 "conf_parser.y" /* yacc.c:1652 */
6217 {
6218 ConfigGeneral.default_floodcount = (yyvsp[-1].number);
6219 }
6220 #line 6221 "conf_parser.c" /* yacc.c:1652 */
6221 break;
6222
6223 case 609:
6224 #line 2742 "conf_parser.y" /* yacc.c:1652 */
6225 {
6226 ConfigGeneral.default_floodtime = (yyvsp[-1].number);
6227 }
6228 #line 6229 "conf_parser.c" /* yacc.c:1652 */
6229 break;
6230
6231 case 628:
6232 #line 2770 "conf_parser.y" /* yacc.c:1652 */
6233 {
6234 ConfigChannel.disable_fake_channels = yylval.number;
6235 }
6236 #line 6237 "conf_parser.c" /* yacc.c:1652 */
6237 break;
6238
6239 case 629:
6240 #line 2775 "conf_parser.y" /* yacc.c:1652 */
6241 {
6242 ConfigChannel.invite_client_count = (yyvsp[-1].number);
6243 }
6244 #line 6245 "conf_parser.c" /* yacc.c:1652 */
6245 break;
6246
6247 case 630:
6248 #line 2780 "conf_parser.y" /* yacc.c:1652 */
6249 {
6250 ConfigChannel.invite_client_time = (yyvsp[-1].number);
6251 }
6252 #line 6253 "conf_parser.c" /* yacc.c:1652 */
6253 break;
6254
6255 case 631:
6256 #line 2785 "conf_parser.y" /* yacc.c:1652 */
6257 {
6258 ConfigChannel.invite_delay_channel = (yyvsp[-1].number);
6259 }
6260 #line 6261 "conf_parser.c" /* yacc.c:1652 */
6261 break;
6262
6263 case 632:
6264 #line 2790 "conf_parser.y" /* yacc.c:1652 */
6265 {
6266 ConfigChannel.invite_expire_time = (yyvsp[-1].number);
6267 }
6268 #line 6269 "conf_parser.c" /* yacc.c:1652 */
6269 break;
6270
6271 case 633:
6272 #line 2795 "conf_parser.y" /* yacc.c:1652 */
6273 {
6274 ConfigChannel.knock_client_count = (yyvsp[-1].number);
6275 }
6276 #line 6277 "conf_parser.c" /* yacc.c:1652 */
6277 break;
6278
6279 case 634:
6280 #line 2800 "conf_parser.y" /* yacc.c:1652 */
6281 {
6282 ConfigChannel.knock_client_time = (yyvsp[-1].number);
6283 }
6284 #line 6285 "conf_parser.c" /* yacc.c:1652 */
6285 break;
6286
6287 case 635:
6288 #line 2805 "conf_parser.y" /* yacc.c:1652 */
6289 {
6290 ConfigChannel.knock_delay_channel = (yyvsp[-1].number);
6291 }
6292 #line 6293 "conf_parser.c" /* yacc.c:1652 */
6293 break;
6294
6295 case 636:
6296 #line 2810 "conf_parser.y" /* yacc.c:1652 */
6297 {
6298 ConfigChannel.max_channels = (yyvsp[-1].number);
6299 }
6300 #line 6301 "conf_parser.c" /* yacc.c:1652 */
6301 break;
6302
6303 case 637:
6304 #line 2815 "conf_parser.y" /* yacc.c:1652 */
6305 {
6306 ConfigChannel.max_invites = (yyvsp[-1].number);
6307 }
6308 #line 6309 "conf_parser.c" /* yacc.c:1652 */
6309 break;
6310
6311 case 638:
6312 #line 2820 "conf_parser.y" /* yacc.c:1652 */
6313 {
6314 ConfigChannel.max_bans = (yyvsp[-1].number);
6315 }
6316 #line 6317 "conf_parser.c" /* yacc.c:1652 */
6317 break;
6318
6319 case 639:
6320 #line 2825 "conf_parser.y" /* yacc.c:1652 */
6321 {
6322 ConfigChannel.max_bans_large = (yyvsp[-1].number);
6323 }
6324 #line 6325 "conf_parser.c" /* yacc.c:1652 */
6325 break;
6326
6327 case 640:
6328 #line 2830 "conf_parser.y" /* yacc.c:1652 */
6329 {
6330 ConfigChannel.default_join_flood_count = yylval.number;
6331 }
6332 #line 6333 "conf_parser.c" /* yacc.c:1652 */
6333 break;
6334
6335 case 641:
6336 #line 2835 "conf_parser.y" /* yacc.c:1652 */
6337 {
6338 ConfigChannel.default_join_flood_time = (yyvsp[-1].number);
6339 }
6340 #line 6341 "conf_parser.c" /* yacc.c:1652 */
6341 break;
6342
6343 case 655:
6344 #line 2858 "conf_parser.y" /* yacc.c:1652 */
6345 {
6346 if (conf_parser_ctx.pass == 2)
6347 ConfigServerHide.flatten_links = yylval.number;
6348 }
6349 #line 6350 "conf_parser.c" /* yacc.c:1652 */
6350 break;
6351
6352 case 656:
6353 #line 2864 "conf_parser.y" /* yacc.c:1652 */
6354 {
6355 if (conf_parser_ctx.pass == 2)
6356 {
6357 if ((yyvsp[-1].number) > 0)
6358 {
6359 event_write_links_file.when = (yyvsp[-1].number);
6360 event_add(&event_write_links_file, NULL);
6361 }
6362 else
6363 event_delete(&event_write_links_file);
6364
6365 ConfigServerHide.flatten_links_delay = (yyvsp[-1].number);
6366 }
6367 }
6368 #line 6369 "conf_parser.c" /* yacc.c:1652 */
6369 break;
6370
6371 case 657:
6372 #line 2880 "conf_parser.y" /* yacc.c:1652 */
6373 {
6374 if (conf_parser_ctx.pass == 2)
6375 {
6376 xfree(ConfigServerHide.flatten_links_file);
6377 ConfigServerHide.flatten_links_file = xstrdup(yylval.string);
6378 }
6379 }
6380 #line 6381 "conf_parser.c" /* yacc.c:1652 */
6381 break;
6382
6383 case 658:
6384 #line 2889 "conf_parser.y" /* yacc.c:1652 */
6385 {
6386 if (conf_parser_ctx.pass == 2)
6387 ConfigServerHide.disable_remote_commands = yylval.number;
6388 }
6389 #line 6390 "conf_parser.c" /* yacc.c:1652 */
6390 break;
6391
6392 case 659:
6393 #line 2895 "conf_parser.y" /* yacc.c:1652 */
6394 {
6395 if (conf_parser_ctx.pass == 2)
6396 ConfigServerHide.hide_servers = yylval.number;
6397 }
6398 #line 6399 "conf_parser.c" /* yacc.c:1652 */
6399 break;
6400
6401 case 660:
6402 #line 2901 "conf_parser.y" /* yacc.c:1652 */
6403 {
6404 if (conf_parser_ctx.pass == 2)
6405 ConfigServerHide.hide_services = yylval.number;
6406 }
6407 #line 6408 "conf_parser.c" /* yacc.c:1652 */
6408 break;
6409
6410 case 661:
6411 #line 2907 "conf_parser.y" /* yacc.c:1652 */
6412 {
6413 if (conf_parser_ctx.pass == 2)
6414 {
6415 xfree(ConfigServerHide.hidden_name);
6416 ConfigServerHide.hidden_name = xstrdup(yylval.string);
6417 }
6418 }
6419 #line 6420 "conf_parser.c" /* yacc.c:1652 */
6420 break;
6421
6422 case 662:
6423 #line 2916 "conf_parser.y" /* yacc.c:1652 */
6424 {
6425 if (conf_parser_ctx.pass == 2)
6426 ConfigServerHide.hidden = yylval.number;
6427 }
6428 #line 6429 "conf_parser.c" /* yacc.c:1652 */
6429 break;
6430
6431 case 663:
6432 #line 2922 "conf_parser.y" /* yacc.c:1652 */
6433 {
6434 if (conf_parser_ctx.pass == 2)
6435 ConfigServerHide.hide_server_ips = yylval.number;
6436 }
6437 #line 6438 "conf_parser.c" /* yacc.c:1652 */
6438 break;
6439
6440
6441 #line 6442 "conf_parser.c" /* yacc.c:1652 */
6442 default: break;
6443 }
6444 /* User semantic actions sometimes alter yychar, and that requires
6445 that yytoken be updated with the new translation. We take the
6446 approach of translating immediately before every use of yytoken.
6447 One alternative is translating here after every semantic action,
6448 but that translation would be missed if the semantic action invokes
6449 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
6450 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
6451 incorrect destructor might then be invoked immediately. In the
6452 case of YYERROR or YYBACKUP, subsequent parser actions might lead
6453 to an incorrect destructor call or verbose syntax error message
6454 before the lookahead is translated. */
6455 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
6456
6457 YYPOPSTACK (yylen);
6458 yylen = 0;
6459 YY_STACK_PRINT (yyss, yyssp);
6460
6461 *++yyvsp = yyval;
6462
6463 /* Now 'shift' the result of the reduction. Determine what state
6464 that goes to, based on the state we popped back to and the rule
6465 number reduced by. */
6466 {
6467 const int yylhs = yyr1[yyn] - YYNTOKENS;
6468 const int yyi = yypgoto[yylhs] + *yyssp;
6469 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
6470 ? yytable[yyi]
6471 : yydefgoto[yylhs]);
6472 }
6473
6474 goto yynewstate;
6475
6476
6477 /*--------------------------------------.
6478 | yyerrlab -- here on detecting error. |
6479 `--------------------------------------*/
6480 yyerrlab:
6481 /* Make sure we have latest lookahead translation. See comments at
6482 user semantic actions for why this is necessary. */
6483 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
6484
6485 /* If not already recovering from an error, report this error. */
6486 if (!yyerrstatus)
6487 {
6488 ++yynerrs;
6489 #if ! YYERROR_VERBOSE
6490 yyerror (YY_("syntax error"));
6491 #else
6492 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
6493 yyssp, yytoken)
6494 {
6495 char const *yymsgp = YY_("syntax error");
6496 int yysyntax_error_status;
6497 yysyntax_error_status = YYSYNTAX_ERROR;
6498 if (yysyntax_error_status == 0)
6499 yymsgp = yymsg;
6500 else if (yysyntax_error_status == 1)
6501 {
6502 if (yymsg != yymsgbuf)
6503 YYSTACK_FREE (yymsg);
6504 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
6505 if (!yymsg)
6506 {
6507 yymsg = yymsgbuf;
6508 yymsg_alloc = sizeof yymsgbuf;
6509 yysyntax_error_status = 2;
6510 }
6511 else
6512 {
6513 yysyntax_error_status = YYSYNTAX_ERROR;
6514 yymsgp = yymsg;
6515 }
6516 }
6517 yyerror (yymsgp);
6518 if (yysyntax_error_status == 2)
6519 goto yyexhaustedlab;
6520 }
6521 # undef YYSYNTAX_ERROR
6522 #endif
6523 }
6524
6525
6526
6527 if (yyerrstatus == 3)
6528 {
6529 /* If just tried and failed to reuse lookahead token after an
6530 error, discard it. */
6531
6532 if (yychar <= YYEOF)
6533 {
6534 /* Return failure if at end of input. */
6535 if (yychar == YYEOF)
6536 YYABORT;
6537 }
6538 else
6539 {
6540 yydestruct ("Error: discarding",
6541 yytoken, &yylval);
6542 yychar = YYEMPTY;
6543 }
6544 }
6545
6546 /* Else will try to reuse lookahead token after shifting the error
6547 token. */
6548 goto yyerrlab1;
6549
6550
6551 /*---------------------------------------------------.
6552 | yyerrorlab -- error raised explicitly by YYERROR. |
6553 `---------------------------------------------------*/
6554 yyerrorlab:
6555 /* Pacify compilers when the user code never invokes YYERROR and the
6556 label yyerrorlab therefore never appears in user code. */
6557 if (0)
6558 YYERROR;
6559
6560 /* Do not reclaim the symbols of the rule whose action triggered
6561 this YYERROR. */
6562 YYPOPSTACK (yylen);
6563 yylen = 0;
6564 YY_STACK_PRINT (yyss, yyssp);
6565 yystate = *yyssp;
6566 goto yyerrlab1;
6567
6568
6569 /*-------------------------------------------------------------.
6570 | yyerrlab1 -- common code for both syntax error and YYERROR. |
6571 `-------------------------------------------------------------*/
6572 yyerrlab1:
6573 yyerrstatus = 3; /* Each real token shifted decrements this. */
6574
6575 for (;;)
6576 {
6577 yyn = yypact[yystate];
6578 if (!yypact_value_is_default (yyn))
6579 {
6580 yyn += YYTERROR;
6581 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6582 {
6583 yyn = yytable[yyn];
6584 if (0 < yyn)
6585 break;
6586 }
6587 }
6588
6589 /* Pop the current state because it cannot handle the error token. */
6590 if (yyssp == yyss)
6591 YYABORT;
6592
6593
6594 yydestruct ("Error: popping",
6595 yystos[yystate], yyvsp);
6596 YYPOPSTACK (1);
6597 yystate = *yyssp;
6598 YY_STACK_PRINT (yyss, yyssp);
6599 }
6600
6601 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
6602 *++yyvsp = yylval;
6603 YY_IGNORE_MAYBE_UNINITIALIZED_END
6604
6605
6606 /* Shift the error token. */
6607 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6608
6609 yystate = yyn;
6610 goto yynewstate;
6611
6612
6613 /*-------------------------------------.
6614 | yyacceptlab -- YYACCEPT comes here. |
6615 `-------------------------------------*/
6616 yyacceptlab:
6617 yyresult = 0;
6618 goto yyreturn;
6619
6620
6621 /*-----------------------------------.
6622 | yyabortlab -- YYABORT comes here. |
6623 `-----------------------------------*/
6624 yyabortlab:
6625 yyresult = 1;
6626 goto yyreturn;
6627
6628
6629 #if !defined yyoverflow || YYERROR_VERBOSE
6630 /*-------------------------------------------------.
6631 | yyexhaustedlab -- memory exhaustion comes here. |
6632 `-------------------------------------------------*/
6633 yyexhaustedlab:
6634 yyerror (YY_("memory exhausted"));
6635 yyresult = 2;
6636 /* Fall through. */
6637 #endif
6638
6639
6640 /*-----------------------------------------------------.
6641 | yyreturn -- parsing is finished, return the result. |
6642 `-----------------------------------------------------*/
6643 yyreturn:
6644 if (yychar != YYEMPTY)
6645 {
6646 /* Make sure we have latest lookahead translation. See comments at
6647 user semantic actions for why this is necessary. */
6648 yytoken = YYTRANSLATE (yychar);
6649 yydestruct ("Cleanup: discarding lookahead",
6650 yytoken, &yylval);
6651 }
6652 /* Do not reclaim the symbols of the rule whose action triggered
6653 this YYABORT or YYACCEPT. */
6654 YYPOPSTACK (yylen);
6655 YY_STACK_PRINT (yyss, yyssp);
6656 while (yyssp != yyss)
6657 {
6658 yydestruct ("Cleanup: popping",
6659 yystos[*yyssp], yyvsp);
6660 YYPOPSTACK (1);
6661 }
6662 #ifndef yyoverflow
6663 if (yyss != yyssa)
6664 YYSTACK_FREE (yyss);
6665 #endif
6666 #if YYERROR_VERBOSE
6667 if (yymsg != yymsgbuf)
6668 YYSTACK_FREE (yymsg);
6669 #endif
6670 return yyresult;
6671 }

Properties

Name Value
svn:eol-style native