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: 6377
Committed: Fri Aug 21 10:37:47 2015 UTC (10 years, 11 months ago) by michael
Content type: text/x-csrc
File size: 221282 byte(s)
Log Message: 
- Rebuild parser files

File Contents

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

Properties

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