ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.c
Revision: 4545
Committed: Fri Aug 22 08:46:13 2014 UTC (11 years ago) by michael
Content type: text/x-csrc
File size: 224289 byte(s)
Log Message: 
- Implemented pseudo {} blocks (service aliases)
- Fixed compile warnings with -Wmissing-field-initializers

File Contents

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

Properties

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