ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.c
Revision: 3892
Committed: Fri Jun 6 18:42:41 2014 UTC (11 years, 2 months ago) by michael
Content type: text/x-csrc
File size: 221262 byte(s)
Log Message: 
- conf_parser.y: fixed stupid bug that has successfully has hidden itself since Feb 5, 2002

File Contents

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

Properties

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