ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.c
Revision: 6010
Committed: Sat May 30 19:19:22 2015 UTC (10 years, 3 months ago) by michael
Content type: text/x-csrc
File size: 223724 byte(s)
Log Message: 
- Re-built parser files

File Contents

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

Properties

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