ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.c
Revision: 4915
Committed: Tue Nov 25 12:37:46 2014 UTC (10 years, 9 months ago) by michael
Content type: text/x-csrc
File size: 224217 byte(s)
Log Message: 
- Style corrections; renamed variables

File Contents

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

Properties

Name Value
svn:eol-style native
svn:keywords Id Revision