ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/conf_parser.c
Revision: 3867
Committed: Thu Jun 5 22:11:02 2014 UTC (12 years, 1 month ago) by michael
Content type: text/x-csrc
File size: 222269 byte(s)
Log Message: 
- Removed OPERWALL. Use GLOBOPS instead.

File Contents

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

Properties

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