ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/src/conf_parser.c
Revision: 8873
Committed: Sat Feb 16 21:51:50 2019 UTC (6 years, 6 months ago) by michael
Content type: text/x-csrc
File size: 216812 byte(s)
Log Message: 
- Recreate parser files

File Contents

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

Properties

Name Value
svn:eol-style native