ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/branches/8.2.x/src/conf_parser.c
Revision: 4163
Committed: Thu Jul 3 19:45:30 2014 UTC (12 years, 1 month ago) by michael
Content type: text/x-csrc
File size: 220273 byte(s)
Log Message: 
- Removed ssl_server_method and ssl_client_method configuration options.
  ircd now only allows TLSv1, TLSv1.1 and TLSv1.2 protocols depending
  on the OpenSSL version.

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

Properties

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