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

Properties

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