ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.c
Revision: 7772
Committed: Sat Oct 8 16:31:25 2016 UTC (8 years, 10 months ago) by michael
Content type: text/x-csrc
File size: 223159 byte(s)
Log Message: 
- Rebuilt parser files

File Contents

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

Properties

Name Value
svn:eol-style native