1 /* A Bison parser, made by GNU Bison 2.3. */
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
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 2, or (at your option)
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.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
23 /* As a special exception, you may create a larger work that contains
24 part or all of the Bison parser skeleton and distribute that work
25 under terms of your choice, so long as that work isn't itself a
26 parser generator using the skeleton or a modified version thereof
27 as a parser skeleton. Alternatively, if you modify or redistribute
28 the parser skeleton itself, you may (at your option) remove this
29 special exception, which will cause the skeleton and the resulting
30 Bison output files to be licensed under the GNU General Public
31 License without this special exception.
33 This special exception was added by the Free Software Foundation in
34 version 2.2 of Bison. */
36 /* C LALR(1) parser skeleton written by Richard Stallman, by
37 simplifying the original so-called "semantic" parser. */
39 /* All symbols defined below should begin with yy or YY, to avoid
40 infringing on user name space. This should be done even for local
41 variables, as they might otherwise be expanded by user macros.
42 There are some unavoidable exceptions within include files to
43 define necessary library symbols; they are noted "INFRINGES ON
44 USER NAME SPACE" below. */
46 /* Identify Bison output. */
50 #define YYBISON_VERSION "2.3"
53 #define YYSKELETON_NAME "yacc.c"
58 /* Using locations. */
59 #define YYLSP_NEEDED 0
66 /* Put the tokens into the symbol table, so that GDB and other debuggers
148 TPRIV_CHAN_LIMIT = 337,
149 TPRIV_MODE_LCHAN = 338,
150 TPRIV_DEOP_LCHAN = 339,
151 TPRIV_WALK_LCHAN = 340,
152 TPRIV_LOCAL_KILL = 341,
157 TPRIV_LOCAL_GLINE = 346,
158 TPRIV_LOCAL_JUPE = 347,
159 TPRIV_LOCAL_BADCHAN = 348,
160 TPRIV_LOCAL_OPMODE = 349,
165 TPRIV_SEE_CHAN = 354,
166 TPRIV_SHOW_INVIS = 355,
167 TPRIV_SHOW_ALL_INVIS = 356,
168 TPRIV_PROPAGATE = 357,
169 TPRIV_UNLIMIT_QUERY = 358,
171 TPRIV_SEE_OPERS = 360,
172 TPRIV_WIDE_GLINE = 361,
173 TPRIV_FORCE_OPMODE = 362,
174 TPRIV_FORCE_LOCAL_OPMODE = 363,
175 TPRIV_APASS_OPMODE = 364,
176 TPRIV_LIST_CHAN = 365,
177 TPRIV_SEE_IDLETIME = 366,
178 TPRIV_UMODE_NETSERV = 367,
179 TPRIV_UMODE_NOCHAN = 368,
180 TPRIV_UMODE_NOIDLE = 369,
181 TPRIV_UMODE_CHSERV = 370,
182 TPRIV_UMODE_XTRAOP = 371,
184 TPRIV_HALFFLOOD = 373,
185 TPRIV_UNLIMITED_TARGET = 374,
186 TPRIV_UMODE_OVERRIDECC = 375,
187 TPRIV_HIDE_IDLETIME = 376,
188 TPRIV_NOAMSG_OVERRIDE = 377
202 #define CONNECTFREQ 268
240 #define DESCRIPTION 306
250 #define QUARANTINE 316
257 #define AUTOCONNECT 323
271 #define TPRIV_CHAN_LIMIT 337
272 #define TPRIV_MODE_LCHAN 338
273 #define TPRIV_DEOP_LCHAN 339
274 #define TPRIV_WALK_LCHAN 340
275 #define TPRIV_LOCAL_KILL 341
276 #define TPRIV_REHASH 342
277 #define TPRIV_RESTART 343
278 #define TPRIV_DIE 344
279 #define TPRIV_GLINE 345
280 #define TPRIV_LOCAL_GLINE 346
281 #define TPRIV_LOCAL_JUPE 347
282 #define TPRIV_LOCAL_BADCHAN 348
283 #define TPRIV_LOCAL_OPMODE 349
284 #define TPRIV_OPMODE 350
285 #define TPRIV_SET 351
286 #define TPRIV_WHOX 352
287 #define TPRIV_BADCHAN 353
288 #define TPRIV_SEE_CHAN 354
289 #define TPRIV_SHOW_INVIS 355
290 #define TPRIV_SHOW_ALL_INVIS 356
291 #define TPRIV_PROPAGATE 357
292 #define TPRIV_UNLIMIT_QUERY 358
293 #define TPRIV_DISPLAY 359
294 #define TPRIV_SEE_OPERS 360
295 #define TPRIV_WIDE_GLINE 361
296 #define TPRIV_FORCE_OPMODE 362
297 #define TPRIV_FORCE_LOCAL_OPMODE 363
298 #define TPRIV_APASS_OPMODE 364
299 #define TPRIV_LIST_CHAN 365
300 #define TPRIV_SEE_IDLETIME 366
301 #define TPRIV_UMODE_NETSERV 367
302 #define TPRIV_UMODE_NOCHAN 368
303 #define TPRIV_UMODE_NOIDLE 369
304 #define TPRIV_UMODE_CHSERV 370
305 #define TPRIV_UMODE_XTRAOP 371
306 #define TPRIV_FLOOD 372
307 #define TPRIV_HALFFLOOD 373
308 #define TPRIV_UNLIMITED_TARGET 374
309 #define TPRIV_UMODE_OVERRIDECC 375
310 #define TPRIV_HIDE_IDLETIME 376
311 #define TPRIV_NOAMSG_OVERRIDE 377
316 /* Copy the first part of user declarations. */
317 #line 22 "./ircd_parser.y"
325 #include "ircd_features.h"
330 #include "ircd_alloc.h"
331 #include "ircd_chattr.h"
332 #include "ircd_log.h"
333 #include "ircd_reply.h"
334 #include "ircd_snprintf.h"
335 #include "ircd_string.h"
337 #include "listener.h"
341 #include "numnicks.h"
342 #include "opercmds.h"
356 #include <arpa/inet.h>
358 #define MAX_STRINGS 80 /* Maximum number of feature params. */
359 #define USE_IPV4 (1 << 16)
360 #define USE_IPV6 (1 << 17)
362 extern struct LocalConf localConf;
363 extern struct DenyConf* denyConfList;
364 extern struct CRuleConf* cruleConfList;
365 extern struct ServerConf* serverConfList;
366 extern struct s_map* GlobalServiceMapList;
367 extern struct qline* GlobalQuarantineList;
370 /* Now all the globals we need :/... */
371 int tping, tconn, maxlinks, sendq, port, invert, stringno, flags, maxchans, iauth_required = 0;
372 char *name, *pass, *host, *ip, *username, *origin, *hub_limit;
374 char *stringlist[MAX_STRINGS];
375 struct ListenerFlags listen_flags;
376 struct ConnectionClass *c_class;
377 struct DenyConf *dconf;
378 struct ServerConf *sconf;
381 struct Privs privs_dirty;
382 struct webirc_block *webirc;
384 static void parse_error(char *pattern,...) {
385 static char error_buffer[1024];
387 va_start(vl,pattern);
388 ircd_vsnprintf(NULL, error_buffer, sizeof(error_buffer), pattern, vl);
390 yyerror(error_buffer);
393 static void free_slist(struct SLink **link) {
395 while (*link != NULL) {
396 next = (*link)->next;
397 MyFree((*link)->value.cp);
405 /* Enabling traces. */
410 /* Enabling verbose error messages. */
411 #ifdef YYERROR_VERBOSE
412 # undef YYERROR_VERBOSE
413 # define YYERROR_VERBOSE 1
415 # define YYERROR_VERBOSE 0
418 /* Enabling the token table. */
419 #ifndef YYTOKEN_TABLE
420 # define YYTOKEN_TABLE 0
423 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
424 typedef union YYSTYPE
425 #line 207 "./ircd_parser.y"
430 /* Line 187 of yacc.c. */
433 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
434 # define YYSTYPE_IS_DECLARED 1
435 # define YYSTYPE_IS_TRIVIAL 1
440 /* Copy the second part of user declarations. */
443 /* Line 216 of yacc.c. */
451 typedef YYTYPE_UINT8 yytype_uint8;
453 typedef unsigned char yytype_uint8;
457 typedef YYTYPE_INT8 yytype_int8;
458 #elif (defined __STDC__ || defined __C99__FUNC__ \
459 || defined __cplusplus || defined _MSC_VER)
460 typedef signed char yytype_int8;
462 typedef short int yytype_int8;
466 typedef YYTYPE_UINT16 yytype_uint16;
468 typedef unsigned short int yytype_uint16;
472 typedef YYTYPE_INT16 yytype_int16;
474 typedef short int yytype_int16;
478 # ifdef __SIZE_TYPE__
479 # define YYSIZE_T __SIZE_TYPE__
480 # elif defined size_t
481 # define YYSIZE_T size_t
482 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
483 || defined __cplusplus || defined _MSC_VER)
484 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
485 # define YYSIZE_T size_t
487 # define YYSIZE_T unsigned int
491 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
496 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
497 # define YY_(msgid) dgettext ("bison-runtime", msgid)
501 # define YY_(msgid) msgid
505 /* Suppress unused-variable warnings by "using" E. */
506 #if ! defined lint || defined __GNUC__
507 # define YYUSE(e) ((void) (e))
509 # define YYUSE(e) /* empty */
512 /* Identity function, used to suppress warnings about constant conditions. */
516 #if (defined __STDC__ || defined __C99__FUNC__ \
517 || defined __cplusplus || defined _MSC_VER)
530 #if ! defined yyoverflow || YYERROR_VERBOSE
532 /* The parser invokes alloca or malloc; define the necessary symbols. */
534 # ifdef YYSTACK_USE_ALLOCA
535 # if YYSTACK_USE_ALLOCA
537 # define YYSTACK_ALLOC __builtin_alloca
538 # elif defined __BUILTIN_VA_ARG_INCR
539 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
541 # define YYSTACK_ALLOC __alloca
542 # elif defined _MSC_VER
543 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
544 # define alloca _alloca
546 # define YYSTACK_ALLOC alloca
547 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
548 || defined __cplusplus || defined _MSC_VER)
549 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
558 # ifdef YYSTACK_ALLOC
559 /* Pacify GCC's `empty if-body' warning. */
560 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
561 # ifndef YYSTACK_ALLOC_MAXIMUM
562 /* The OS might guarantee only one guard page at the bottom of the stack,
563 and a page size can be as small as 4096 bytes. So we cannot safely
564 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
565 to allow for a few compiler-allocated temporary stack slots. */
566 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
569 # define YYSTACK_ALLOC YYMALLOC
570 # define YYSTACK_FREE YYFREE
571 # ifndef YYSTACK_ALLOC_MAXIMUM
572 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
574 # if (defined __cplusplus && ! defined _STDLIB_H \
575 && ! ((defined YYMALLOC || defined malloc) \
576 && (defined YYFREE || defined free)))
577 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
583 # define YYMALLOC malloc
584 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
585 || defined __cplusplus || defined _MSC_VER)
586 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
591 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
592 || defined __cplusplus || defined _MSC_VER)
593 void free (void *); /* INFRINGES ON USER NAME SPACE */
597 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
600 #if (! defined yyoverflow \
601 && (! defined __cplusplus \
602 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
604 /* A type that is properly aligned for any stack member. */
611 /* The size of the maximum gap between one aligned stack and the next. */
612 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
614 /* The size of an array large to enough to hold all stacks, each with
616 # define YYSTACK_BYTES(N) \
617 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
618 + YYSTACK_GAP_MAXIMUM)
620 /* Copy COUNT objects from FROM to TO. The source and destination do
623 # if defined __GNUC__ && 1 < __GNUC__
624 # define YYCOPY(To, From, Count) \
625 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
627 # define YYCOPY(To, From, Count) \
631 for (yyi = 0; yyi < (Count); yyi++) \
632 (To)[yyi] = (From)[yyi]; \
638 /* Relocate STACK from its old location to the new one. The
639 local variables YYSIZE and YYSTACKSIZE give the old and new number of
640 elements in the stack, and YYPTR gives the new location of the
641 stack. Advance YYPTR to a properly aligned location for the next
643 # define YYSTACK_RELOCATE(Stack) \
646 YYSIZE_T yynewbytes; \
647 YYCOPY (&yyptr->Stack, Stack, yysize); \
648 Stack = &yyptr->Stack; \
649 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
650 yyptr += yynewbytes / sizeof (*yyptr); \
656 /* YYFINAL -- State number of the termination state. */
658 /* YYLAST -- Last index in YYTABLE. */
661 /* YYNTOKENS -- Number of terminals. */
662 #define YYNTOKENS 134
663 /* YYNNTS -- Number of nonterminals. */
665 /* YYNRULES -- Number of rules. */
667 /* YYNRULES -- Number of states. */
668 #define YYNSTATES 637
670 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
672 #define YYMAXUTOK 377
674 #define YYTRANSLATE(YYX) \
675 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
677 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
678 static const yytype_uint8 yytranslate[] =
680 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
681 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
682 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
683 2, 2, 2, 133, 2, 2, 2, 2, 2, 2,
684 128, 129, 125, 123, 2, 124, 2, 126, 2, 2,
685 2, 2, 2, 2, 2, 2, 2, 2, 2, 127,
686 2, 132, 2, 2, 2, 2, 2, 2, 2, 2,
687 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
688 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
689 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
690 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
691 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
692 2, 2, 2, 130, 2, 131, 2, 2, 2, 2,
693 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
694 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
695 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
696 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
697 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
698 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
699 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
700 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
701 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
702 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
703 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
704 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
705 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
706 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
707 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
708 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
709 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
710 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
711 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
712 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
713 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
714 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
715 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
716 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
717 115, 116, 117, 118, 119, 120, 121, 122
721 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
723 static const yytype_uint16 yyprhs[] =
725 0, 0, 3, 6, 8, 10, 12, 14, 16, 18,
726 20, 22, 24, 26, 28, 30, 32, 34, 36, 38,
727 40, 42, 44, 46, 49, 51, 53, 56, 58, 61,
728 63, 65, 67, 69, 71, 73, 75, 77, 79, 82,
729 85, 88, 91, 94, 96, 100, 104, 108, 112, 116,
730 122, 125, 127, 129, 134, 135, 142, 145, 147, 149,
731 151, 153, 155, 157, 159, 164, 169, 174, 179, 186,
732 192, 193, 200, 203, 205, 207, 209, 214, 219, 220,
733 227, 230, 232, 234, 236, 238, 240, 242, 244, 246,
734 248, 253, 258, 263, 268, 273, 278, 283, 284, 291,
735 294, 296, 298, 300, 302, 304, 306, 308, 310, 312,
736 314, 316, 318, 320, 325, 330, 335, 340, 345, 350,
737 353, 356, 361, 366, 371, 376, 381, 386, 392, 395,
738 397, 399, 404, 410, 412, 415, 417, 419, 421, 423,
739 425, 430, 435, 440, 445, 450, 452, 454, 456, 458,
740 460, 462, 464, 466, 468, 470, 472, 474, 476, 478,
741 480, 482, 484, 486, 488, 490, 492, 494, 496, 498,
742 500, 502, 504, 506, 508, 510, 512, 514, 516, 518,
743 520, 522, 524, 526, 528, 530, 532, 534, 536, 538,
744 540, 542, 543, 545, 547, 550, 553, 559, 562, 564,
745 566, 568, 570, 572, 574, 576, 578, 584, 590, 597,
746 602, 607, 612, 617, 622, 627, 632, 633, 640, 643,
747 645, 647, 649, 651, 653, 655, 657, 659, 664, 669,
748 674, 679, 684, 689, 694, 695, 702, 705, 707, 709,
749 711, 713, 715, 717, 722, 727, 732, 737, 742, 743,
750 750, 753, 755, 757, 759, 761, 766, 771, 776, 781,
751 787, 790, 792, 794, 796, 801, 806, 812, 815, 817,
752 818, 824, 827, 829, 831, 837, 840, 842, 847, 848,
753 856, 859, 861, 863, 865, 867, 869, 874, 879, 884,
754 887, 893, 896, 898, 900, 902, 903, 909, 914, 915,
755 922, 925, 927, 932, 933, 940, 943, 945, 947, 949,
756 951, 953, 955, 957, 962, 967, 973, 978, 984, 989,
757 995, 998, 1000, 1002, 1004, 1009
760 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
761 static const yytype_int16 yyrhs[] =
763 135, 0, -1, 135, 136, -1, 136, -1, 157, -1,
764 147, -1, 163, -1, 174, -1, 190, -1, 194, -1,
765 205, -1, 143, -1, 215, -1, 226, -1, 235, -1,
766 242, -1, 247, -1, 253, -1, 256, -1, 264, -1,
767 270, -1, 274, -1, 284, -1, 1, 127, -1, 142,
768 -1, 138, -1, 138, 139, -1, 139, -1, 142, 140,
769 -1, 23, -1, 24, -1, 25, -1, 26, -1, 27,
770 -1, 28, -1, 29, -1, 30, -1, 142, -1, 142,
771 31, -1, 142, 32, -1, 142, 33, -1, 142, 34,
772 -1, 142, 35, -1, 4, -1, 142, 123, 142, -1,
773 142, 124, 142, -1, 142, 125, 142, -1, 142, 126,
774 142, -1, 128, 142, 129, -1, 48, 130, 144, 131,
775 127, -1, 145, 144, -1, 145, -1, 146, -1, 49,
776 132, 3, 127, -1, -1, 5, 148, 130, 149, 131,
777 127, -1, 150, 149, -1, 150, -1, 151, -1, 152,
778 -1, 154, -1, 153, -1, 155, -1, 156, -1, 50,
779 132, 4, 127, -1, 17, 132, 3, 127, -1, 51,
780 132, 3, 127, -1, 45, 132, 3, 127, -1, 72,
781 45, 132, 204, 3, 127, -1, 72, 36, 132, 3,
782 127, -1, -1, 6, 158, 130, 159, 131, 127, -1,
783 159, 160, -1, 160, -1, 161, -1, 162, -1, 7,
784 132, 3, 127, -1, 8, 132, 3, 127, -1, -1,
785 10, 164, 130, 165, 131, 127, -1, 166, 165, -1,
786 166, -1, 167, -1, 169, -1, 170, -1, 171, -1,
787 172, -1, 173, -1, 201, -1, 168, -1, 17, 132,
788 3, 127, -1, 77, 132, 142, 127, -1, 12, 132,
789 137, 127, -1, 13, 132, 137, 127, -1, 14, 132,
790 142, 127, -1, 16, 132, 141, 127, -1, 64, 132,
791 3, 127, -1, -1, 9, 175, 130, 176, 131, 127,
792 -1, 177, 176, -1, 177, -1, 178, -1, 179, -1,
793 180, -1, 181, -1, 182, -1, 183, -1, 184, -1,
794 185, -1, 186, -1, 187, -1, 188, -1, 189, -1,
795 17, 132, 3, 127, -1, 21, 132, 3, 127, -1,
796 10, 132, 3, 127, -1, 18, 132, 3, 127, -1,
797 37, 132, 4, 127, -1, 45, 132, 3, 127, -1,
798 40, 127, -1, 39, 127, -1, 39, 132, 3, 127,
799 -1, 15, 132, 142, 127, -1, 68, 132, 42, 127,
800 -1, 68, 132, 43, 127, -1, 74, 132, 42, 127,
801 -1, 74, 132, 43, 127, -1, 41, 130, 191, 131,
802 127, -1, 192, 191, -1, 192, -1, 193, -1, 17,
803 132, 3, 127, -1, 44, 130, 195, 131, 127, -1,
804 196, -1, 195, 196, -1, 197, -1, 198, -1, 199,
805 -1, 200, -1, 201, -1, 17, 132, 3, 127, -1,
806 21, 132, 3, 127, -1, 18, 132, 3, 127, -1,
807 10, 132, 3, 127, -1, 202, 132, 203, 127, -1,
808 82, -1, 83, -1, 84, -1, 85, -1, 111, -1,
809 121, -1, 113, -1, 114, -1, 115, -1, 116, -1,
810 112, -1, 117, -1, 118, -1, 119, -1, 120, -1,
811 53, -1, 86, -1, 87, -1, 88, -1, 89, -1,
812 90, -1, 91, -1, 48, -1, 92, -1, 94, -1,
813 95, -1, 96, -1, 97, -1, 98, -1, 93, -1,
814 99, -1, 100, -1, 101, -1, 102, -1, 103, -1,
815 104, -1, 105, -1, 106, -1, 110, -1, 22, -1,
816 107, -1, 108, -1, 122, -1, 109, -1, 42, -1,
817 43, -1, -1, 70, -1, 71, -1, 70, 71, -1,
818 71, 70, -1, 37, 130, 206, 131, 127, -1, 207,
819 206, -1, 207, -1, 208, -1, 209, -1, 210, -1,
820 211, -1, 212, -1, 213, -1, 214, -1, 37, 132,
821 204, 4, 127, -1, 45, 132, 204, 3, 127, -1,
822 45, 132, 204, 3, 4, 127, -1, 38, 132, 3,
823 127, -1, 36, 132, 42, 127, -1, 36, 132, 43,
824 127, -1, 46, 132, 42, 127, -1, 46, 132, 43,
825 127, -1, 74, 132, 42, 127, -1, 74, 132, 43,
826 127, -1, -1, 52, 216, 130, 217, 131, 127, -1,
827 218, 217, -1, 218, -1, 219, -1, 220, -1, 221,
828 -1, 222, -1, 223, -1, 224, -1, 225, -1, 18,
829 132, 3, 127, -1, 19, 132, 3, 127, -1, 20,
830 132, 3, 127, -1, 10, 132, 3, 127, -1, 21,
831 132, 3, 127, -1, 14, 132, 142, 127, -1, 37,
832 132, 142, 127, -1, -1, 53, 227, 130, 228, 131,
833 127, -1, 229, 228, -1, 229, -1, 230, -1, 232,
834 -1, 231, -1, 234, -1, 233, -1, 18, 132, 3,
835 127, -1, 20, 132, 3, 127, -1, 55, 132, 3,
836 127, -1, 56, 132, 3, 127, -1, 57, 132, 3,
837 127, -1, -1, 54, 236, 130, 237, 131, 127, -1,
838 238, 237, -1, 238, -1, 239, -1, 240, -1, 241,
839 -1, 36, 132, 3, 127, -1, 58, 132, 3, 127,
840 -1, 59, 132, 42, 127, -1, 59, 132, 43, 127,
841 -1, 47, 130, 243, 131, 127, -1, 244, 243, -1,
842 244, -1, 245, -1, 246, -1, 18, 132, 3, 127,
843 -1, 57, 132, 3, 127, -1, 60, 130, 248, 131,
844 127, -1, 248, 249, -1, 249, -1, -1, 3, 250,
845 132, 251, 127, -1, 251, 252, -1, 252, -1, 3,
846 -1, 61, 130, 254, 131, 127, -1, 254, 255, -1,
847 255, -1, 3, 132, 3, 127, -1, -1, 62, 3,
848 130, 257, 258, 131, 127, -1, 259, 258, -1, 259,
849 -1, 260, -1, 261, -1, 262, -1, 263, -1, 17,
850 132, 3, 127, -1, 63, 132, 3, 127, -1, 49,
851 132, 3, 127, -1, 67, 127, -1, 65, 130, 265,
852 131, 127, -1, 266, 265, -1, 266, -1, 267, -1,
853 269, -1, -1, 69, 132, 268, 251, 127, -1, 78,
854 132, 203, 127, -1, -1, 73, 271, 130, 272, 131,
855 127, -1, 272, 273, -1, 273, -1, 3, 132, 3,
856 127, -1, -1, 75, 275, 130, 276, 131, 127, -1,
857 276, 277, -1, 277, -1, 278, -1, 279, -1, 280,
858 -1, 281, -1, 282, -1, 283, -1, 21, 132, 3,
859 127, -1, 18, 132, 3, 127, -1, 18, 133, 132,
860 3, 127, -1, 76, 132, 3, 127, -1, 76, 133,
861 132, 3, 127, -1, 17, 132, 3, 127, -1, 79,
862 130, 285, 131, 127, -1, 285, 286, -1, 286, -1,
863 287, -1, 288, -1, 80, 132, 3, 127, -1, 81,
867 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
868 static const yytype_uint16 yyrline[] =
870 0, 214, 214, 214, 215, 215, 215, 215, 216, 216,
871 216, 216, 216, 217, 217, 217, 217, 217, 218, 218,
872 218, 218, 218, 218, 222, 222, 224, 227, 229, 234,
873 235, 236, 237, 238, 239, 240, 241, 244, 247, 250,
874 253, 256, 259, 265, 269, 272, 275, 278, 285, 290,
875 291, 291, 292, 293, 300, 299, 310, 310, 311, 311,
876 311, 311, 312, 312, 314, 323, 335, 342, 359, 381,
877 390, 389, 405, 405, 406, 406, 407, 416, 422, 422,
878 448, 448, 449, 449, 449, 449, 450, 450, 450, 450,
879 451, 456, 460, 464, 468, 472, 476, 483, 482, 527,
880 527, 528, 528, 528, 528, 529, 529, 529, 529, 530,
881 530, 530, 530, 531, 536, 541, 548, 553, 557, 562,
882 566, 571, 576, 580, 581, 582, 583, 585, 586, 586,
883 587, 588, 593, 627, 627, 628, 628, 628, 628, 628,
884 629, 634, 639, 655, 663, 673, 674, 675, 676, 677,
885 678, 679, 680, 681, 682, 683, 684, 685, 686, 687,
886 688, 689, 690, 691, 692, 693, 694, 695, 696, 697,
887 698, 699, 700, 701, 702, 703, 704, 705, 706, 707,
888 708, 709, 710, 711, 712, 713, 714, 715, 716, 718,
889 718, 724, 725, 726, 727, 728, 732, 767, 767, 768,
890 768, 768, 768, 768, 768, 768, 769, 780, 790, 804,
891 810, 813, 818, 821, 826, 829, 835, 834, 880, 880,
892 881, 881, 881, 881, 881, 881, 881, 882, 895, 909,
893 914, 921, 926, 930, 936, 935, 955, 955, 956, 956,
894 956, 956, 956, 957, 976, 982, 988, 995, 1003, 1002,
895 1035, 1035, 1036, 1036, 1036, 1038, 1047, 1053, 1056, 1061,
896 1072, 1072, 1073, 1073, 1074, 1083, 1089, 1090, 1090, 1093,
897 1092, 1103, 1103, 1104, 1112, 1113, 1113, 1114, 1124, 1123,
898 1152, 1152, 1153, 1153, 1153, 1153, 1154, 1159, 1164, 1178,
899 1183, 1194, 1194, 1195, 1195, 1197, 1196, 1205, 1210, 1210,
900 1216, 1216, 1217, 1225, 1225, 1241, 1241, 1242, 1242, 1242,
901 1242, 1242, 1242, 1243, 1249, 1255, 1261, 1267, 1273, 1292,
902 1293, 1293, 1294, 1294, 1295, 1299
906 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
907 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
908 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
909 static const char *const yytname[] =
911 "$end", "error", "$undefined", "QSTRING", "NUMBER", "GENERAL", "ADMIN",
912 "LOCATION", "CONTACT", "CONNECT", "CLASS", "CHANNEL", "PINGFREQ",
913 "CONNECTFREQ", "MAXLINKS", "MAXHOPS", "SENDQ", "NAME", "HOST", "IP",
914 "USERNAME", "PASS", "LOCAL", "SECONDS", "MINUTES", "HOURS", "DAYS",
915 "WEEKS", "MONTHS", "YEARS", "DECADES", "BYTES", "KBYTES", "MBYTES",
916 "GBYTES", "TBYTES", "SERVER", "PORT", "MASK", "HUB", "LEAF", "UWORLD",
917 "YES", "NO", "OPER", "VHOST", "HIDDEN", "MOTD", "JUPE", "NICK",
918 "NUMERIC", "DESCRIPTION", "CLIENT", "KILL", "CRULE", "REAL", "REASON",
919 "TFILE", "RULE", "ALL", "FEATURES", "QUARANTINE", "PSEUDO", "PREPEND",
920 "USERMODE", "IAUTH", "TIMEOUT", "FAST", "AUTOCONNECT", "PROGRAM",
921 "TOK_IPV4", "TOK_IPV6", "DNS", "FORWARDS", "SECURE", "WEBIRC", "SPOOF",
922 "MAXCHANS", "REQUIRED", "SSL", "CERT", "CACERT", "TPRIV_CHAN_LIMIT",
923 "TPRIV_MODE_LCHAN", "TPRIV_DEOP_LCHAN", "TPRIV_WALK_LCHAN",
924 "TPRIV_LOCAL_KILL", "TPRIV_REHASH", "TPRIV_RESTART", "TPRIV_DIE",
925 "TPRIV_GLINE", "TPRIV_LOCAL_GLINE", "TPRIV_LOCAL_JUPE",
926 "TPRIV_LOCAL_BADCHAN", "TPRIV_LOCAL_OPMODE", "TPRIV_OPMODE", "TPRIV_SET",
927 "TPRIV_WHOX", "TPRIV_BADCHAN", "TPRIV_SEE_CHAN", "TPRIV_SHOW_INVIS",
928 "TPRIV_SHOW_ALL_INVIS", "TPRIV_PROPAGATE", "TPRIV_UNLIMIT_QUERY",
929 "TPRIV_DISPLAY", "TPRIV_SEE_OPERS", "TPRIV_WIDE_GLINE",
930 "TPRIV_FORCE_OPMODE", "TPRIV_FORCE_LOCAL_OPMODE", "TPRIV_APASS_OPMODE",
931 "TPRIV_LIST_CHAN", "TPRIV_SEE_IDLETIME", "TPRIV_UMODE_NETSERV",
932 "TPRIV_UMODE_NOCHAN", "TPRIV_UMODE_NOIDLE", "TPRIV_UMODE_CHSERV",
933 "TPRIV_UMODE_XTRAOP", "TPRIV_FLOOD", "TPRIV_HALFFLOOD",
934 "TPRIV_UNLIMITED_TARGET", "TPRIV_UMODE_OVERRIDECC",
935 "TPRIV_HIDE_IDLETIME", "TPRIV_NOAMSG_OVERRIDE", "'+'", "'-'", "'*'",
936 "'/'", "';'", "'('", "')'", "'{'", "'}'", "'='", "'!'", "$accept",
937 "blocks", "block", "timespec", "factoredtimes", "factoredtime",
938 "timefactor", "sizespec", "expr", "jupeblock", "jupeitems", "jupeitem",
939 "jupenick", "generalblock", "@1", "generalitems", "generalitem",
940 "generalnumeric", "generalname", "generaldesc", "generalvhost",
941 "generaldnsvhost", "generaldnsserver", "adminblock", "@2", "adminitems",
942 "adminitem", "adminlocation", "admincontact", "classblock", "@3",
943 "classitems", "classitem", "classname", "maxchans", "classpingfreq",
944 "classconnfreq", "classmaxlinks", "classsendq", "classusermode",
945 "connectblock", "@4", "connectitems", "connectitem", "connectname",
946 "connectpass", "connectclass", "connecthost", "connectport",
947 "connectvhost", "connectleaf", "connecthub", "connecthublimit",
948 "connectmaxhops", "connectauto", "connectsecure", "uworldblock",
949 "uworlditems", "uworlditem", "uworldname", "operblock", "operitems",
950 "operitem", "opername", "operpass", "operhost", "operclass", "priv",
951 "privtype", "yesorno", "address_family", "portblock", "portitems",
952 "portitem", "portnumber", "portvhost", "portvhostnumber", "portmask",
953 "portserver", "porthidden", "portsecure", "clientblock", "@5",
954 "clientitems", "clientitem", "clienthost", "clientip", "clientusername",
955 "clientclass", "clientpass", "clientmaxlinks", "clientport", "killblock",
956 "@6", "killitems", "killitem", "killuhost", "killusername", "killreal",
957 "killreason", "killreasonfile", "cruleblock", "@7", "cruleitems",
958 "cruleitem", "cruleserver", "crulerule", "cruleall", "motdblock",
959 "motditems", "motditem", "motdhost", "motdfile", "featuresblock",
960 "featureitems", "featureitem", "@8", "stringlist", "extrastring",
961 "quarantineblock", "quarantineitems", "quarantineitem", "pseudoblock",
962 "@9", "pseudoitems", "pseudoitem", "pseudoname", "pseudoprepend",
963 "pseudonick", "pseudoflags", "iauthblock", "iauthitems", "iauthitem",
964 "iauthprogram", "@10", "iauthrequired", "forwardsblock", "@11",
965 "forwarditems", "forwarditem", "webircblock", "@12", "webircitems",
966 "webircitem", "webircpass", "webirchost", "webircnhost", "webircspoof",
967 "webircnspoof", "webircname", "sslblock", "sslitems", "sslitem",
968 "sslcert", "sslcacert", 0
973 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
975 static const yytype_uint16 yytoknum[] =
977 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
978 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
979 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
980 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
981 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
982 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
983 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
984 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
985 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
986 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
987 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
988 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
989 375, 376, 377, 43, 45, 42, 47, 59, 40, 41,
994 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
995 static const yytype_uint16 yyr1[] =
997 0, 134, 135, 135, 136, 136, 136, 136, 136, 136,
998 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
999 136, 136, 136, 136, 137, 137, 138, 138, 139, 140,
1000 140, 140, 140, 140, 140, 140, 140, 141, 141, 141,
1001 141, 141, 141, 142, 142, 142, 142, 142, 142, 143,
1002 144, 144, 145, 146, 148, 147, 149, 149, 150, 150,
1003 150, 150, 150, 150, 151, 152, 153, 154, 155, 156,
1004 158, 157, 159, 159, 160, 160, 161, 162, 164, 163,
1005 165, 165, 166, 166, 166, 166, 166, 166, 166, 166,
1006 167, 168, 169, 170, 171, 172, 173, 175, 174, 176,
1007 176, 177, 177, 177, 177, 177, 177, 177, 177, 177,
1008 177, 177, 177, 178, 179, 180, 181, 182, 183, 184,
1009 185, 186, 187, 188, 188, 189, 189, 190, 191, 191,
1010 192, 193, 194, 195, 195, 196, 196, 196, 196, 196,
1011 197, 198, 199, 200, 201, 202, 202, 202, 202, 202,
1012 202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
1013 202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
1014 202, 202, 202, 202, 202, 202, 202, 202, 202, 202,
1015 202, 202, 202, 202, 202, 202, 202, 202, 202, 203,
1016 203, 204, 204, 204, 204, 204, 205, 206, 206, 207,
1017 207, 207, 207, 207, 207, 207, 208, 209, 210, 211,
1018 212, 212, 213, 213, 214, 214, 216, 215, 217, 217,
1019 218, 218, 218, 218, 218, 218, 218, 219, 220, 221,
1020 222, 223, 224, 225, 227, 226, 228, 228, 229, 229,
1021 229, 229, 229, 230, 231, 232, 233, 234, 236, 235,
1022 237, 237, 238, 238, 238, 239, 240, 241, 241, 242,
1023 243, 243, 244, 244, 245, 246, 247, 248, 248, 250,
1024 249, 251, 251, 252, 253, 254, 254, 255, 257, 256,
1025 258, 258, 259, 259, 259, 259, 260, 261, 262, 263,
1026 264, 265, 265, 266, 266, 268, 267, 269, 271, 270,
1027 272, 272, 273, 275, 274, 276, 276, 277, 277, 277,
1028 277, 277, 277, 278, 279, 280, 281, 282, 283, 284,
1029 285, 285, 286, 286, 287, 288
1032 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1033 static const yytype_uint8 yyr2[] =
1035 0, 2, 2, 1, 1, 1, 1, 1, 1, 1,
1036 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1037 1, 1, 1, 2, 1, 1, 2, 1, 2, 1,
1038 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
1039 2, 2, 2, 1, 3, 3, 3, 3, 3, 5,
1040 2, 1, 1, 4, 0, 6, 2, 1, 1, 1,
1041 1, 1, 1, 1, 4, 4, 4, 4, 6, 5,
1042 0, 6, 2, 1, 1, 1, 4, 4, 0, 6,
1043 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1044 4, 4, 4, 4, 4, 4, 4, 0, 6, 2,
1045 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1046 1, 1, 1, 4, 4, 4, 4, 4, 4, 2,
1047 2, 4, 4, 4, 4, 4, 4, 5, 2, 1,
1048 1, 4, 5, 1, 2, 1, 1, 1, 1, 1,
1049 4, 4, 4, 4, 4, 1, 1, 1, 1, 1,
1050 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1051 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1052 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1053 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1054 1, 0, 1, 1, 2, 2, 5, 2, 1, 1,
1055 1, 1, 1, 1, 1, 1, 5, 5, 6, 4,
1056 4, 4, 4, 4, 4, 4, 0, 6, 2, 1,
1057 1, 1, 1, 1, 1, 1, 1, 4, 4, 4,
1058 4, 4, 4, 4, 0, 6, 2, 1, 1, 1,
1059 1, 1, 1, 4, 4, 4, 4, 4, 0, 6,
1060 2, 1, 1, 1, 1, 4, 4, 4, 4, 5,
1061 2, 1, 1, 1, 4, 4, 5, 2, 1, 0,
1062 5, 2, 1, 1, 5, 2, 1, 4, 0, 7,
1063 2, 1, 1, 1, 1, 1, 4, 4, 4, 2,
1064 5, 2, 1, 1, 1, 0, 5, 4, 0, 6,
1065 2, 1, 4, 0, 6, 2, 1, 1, 1, 1,
1066 1, 1, 1, 4, 4, 5, 4, 5, 4, 5,
1070 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1071 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1072 means the default is an error. */
1073 static const yytype_uint16 yydefact[] =
1075 0, 0, 54, 70, 97, 78, 0, 0, 0, 0,
1076 0, 216, 234, 248, 0, 0, 0, 0, 298, 303,
1077 0, 0, 3, 11, 5, 4, 6, 7, 8, 9,
1078 10, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1079 21, 22, 23, 0, 0, 0, 0, 0, 0, 0,
1080 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1081 0, 0, 1, 2, 0, 0, 0, 0, 0, 0,
1082 0, 0, 0, 0, 0, 198, 199, 200, 201, 202,
1083 203, 204, 205, 0, 0, 129, 130, 0, 0, 0,
1084 0, 184, 167, 160, 145, 146, 147, 148, 161, 162,
1085 163, 164, 165, 166, 168, 174, 169, 170, 171, 172,
1086 173, 175, 176, 177, 178, 179, 180, 181, 182, 185,
1087 186, 188, 183, 149, 155, 151, 152, 153, 154, 156,
1088 157, 158, 159, 150, 187, 0, 133, 135, 136, 137,
1089 138, 139, 0, 0, 0, 0, 261, 262, 263, 0,
1090 0, 51, 52, 0, 0, 0, 269, 0, 268, 0,
1091 0, 276, 278, 0, 0, 0, 292, 293, 294, 0,
1092 0, 0, 0, 0, 321, 322, 323, 0, 0, 0,
1093 0, 0, 0, 57, 58, 59, 61, 60, 62, 63,
1094 0, 0, 0, 73, 74, 75, 0, 0, 0, 0,
1095 0, 0, 0, 0, 0, 0, 0, 0, 100, 101,
1096 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1097 112, 0, 0, 0, 0, 0, 0, 0, 0, 81,
1098 82, 89, 83, 84, 85, 86, 87, 88, 0, 191,
1099 0, 191, 0, 0, 0, 197, 0, 0, 128, 0,
1100 0, 0, 0, 0, 134, 0, 0, 0, 0, 260,
1101 0, 0, 50, 0, 0, 0, 0, 0, 0, 0,
1102 0, 219, 220, 221, 222, 223, 224, 225, 226, 0,
1103 0, 0, 0, 0, 0, 237, 238, 240, 239, 242,
1104 241, 0, 0, 0, 0, 251, 252, 253, 254, 0,
1105 0, 267, 0, 0, 275, 0, 295, 0, 0, 291,
1106 0, 0, 301, 0, 0, 0, 0, 0, 306, 307,
1107 308, 309, 310, 311, 312, 0, 0, 0, 320, 0,
1108 0, 0, 0, 0, 0, 0, 56, 0, 0, 0,
1109 72, 0, 0, 0, 0, 0, 0, 120, 0, 119,
1110 0, 0, 0, 0, 99, 0, 0, 0, 0, 0,
1111 0, 0, 0, 80, 0, 0, 192, 193, 0, 0,
1112 0, 0, 0, 0, 0, 196, 0, 127, 0, 0,
1113 0, 0, 132, 189, 190, 0, 0, 0, 259, 0,
1114 49, 0, 0, 0, 0, 0, 0, 0, 0, 218,
1115 0, 0, 0, 0, 0, 0, 236, 0, 0, 0,
1116 0, 250, 0, 266, 0, 274, 0, 0, 0, 0,
1117 0, 281, 282, 283, 284, 285, 0, 0, 290, 0,
1118 0, 300, 0, 0, 0, 0, 0, 0, 0, 305,
1119 0, 0, 319, 0, 0, 0, 0, 0, 191, 55,
1120 0, 0, 71, 0, 43, 0, 0, 0, 0, 0,
1121 0, 0, 0, 0, 0, 0, 0, 98, 0, 25,
1122 27, 24, 0, 0, 0, 37, 0, 0, 0, 79,
1123 210, 211, 194, 195, 0, 209, 0, 212, 213, 214,
1124 215, 131, 143, 140, 142, 141, 144, 264, 265, 53,
1125 0, 0, 0, 0, 0, 0, 0, 217, 0, 0,
1126 0, 0, 0, 235, 0, 0, 0, 0, 249, 273,
1127 0, 272, 277, 0, 0, 0, 289, 0, 280, 0,
1128 297, 0, 299, 0, 0, 0, 0, 0, 0, 304,
1129 324, 325, 65, 67, 64, 66, 0, 0, 76, 77,
1130 115, 0, 0, 0, 0, 0, 122, 113, 116, 114,
1131 117, 121, 118, 123, 124, 125, 126, 92, 26, 0,
1132 29, 30, 31, 32, 33, 34, 35, 36, 28, 93,
1133 94, 95, 38, 39, 40, 41, 42, 90, 96, 91,
1134 206, 0, 207, 230, 232, 227, 228, 229, 231, 233,
1135 243, 244, 245, 246, 247, 255, 256, 257, 258, 270,
1136 271, 0, 0, 0, 279, 296, 302, 318, 314, 0,
1137 313, 316, 0, 69, 0, 48, 44, 45, 46, 47,
1138 208, 286, 288, 287, 315, 317, 68
1141 /* YYDEFGOTO[NTERM-NUM]. */
1142 static const yytype_int16 yydefgoto[] =
1144 -1, 21, 22, 468, 469, 470, 578, 474, 471, 23,
1145 150, 151, 152, 24, 43, 182, 183, 184, 185, 186,
1146 187, 188, 189, 25, 44, 192, 193, 194, 195, 26,
1147 46, 228, 229, 230, 231, 232, 233, 234, 235, 236,
1148 27, 45, 207, 208, 209, 210, 211, 212, 213, 214,
1149 215, 216, 217, 218, 219, 220, 28, 84, 85, 86,
1150 29, 135, 136, 137, 138, 139, 140, 141, 142, 385,
1151 368, 30, 74, 75, 76, 77, 78, 79, 80, 81,
1152 82, 31, 52, 270, 271, 272, 273, 274, 275, 276,
1153 277, 278, 32, 53, 284, 285, 286, 287, 288, 289,
1154 290, 33, 54, 294, 295, 296, 297, 298, 34, 145,
1155 146, 147, 148, 35, 157, 158, 299, 520, 521, 36,
1156 160, 161, 37, 305, 420, 421, 422, 423, 424, 425,
1157 38, 165, 166, 167, 426, 168, 39, 59, 311, 312,
1158 40, 60, 317, 318, 319, 320, 321, 322, 323, 324,
1159 41, 173, 174, 175, 176
1162 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1164 #define YYPACT_NINF -454
1165 static const yytype_int16 yypact[] =
1167 480, -104, -454, -454, -454, -454, -103, -96, -64, -53,
1168 -34, -454, -454, -454, -27, -23, 97, -21, -454, -454,
1169 -19, 37, -454, -454, -454, -454, -454, -454, -454, -454,
1170 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1171 -454, -454, -454, -16, -10, 16, 22, 34, 122, 247,
1172 -5, 92, 25, 41, 56, 190, 191, 66, 4, 67,
1173 77, -72, -454, -454, 3, 57, 130, 358, 73, 74,
1174 124, 134, 148, 149, 78, 34, -454, -454, -454, -454,
1175 -454, -454, -454, 150, 136, 122, -454, 151, 153, 154,
1176 155, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1177 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1178 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1179 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1180 -454, -454, -454, -454, -454, 132, -454, -454, -454, -454,
1181 -454, -454, 156, 157, 159, 161, -5, -454, -454, 162,
1182 165, 92, -454, 158, 31, -14, -454, 0, -454, 166,
1183 1, -454, -454, 167, 169, 171, 4, -454, -454, 252,
1184 18, 172, 173, -63, -454, -454, -454, 174, 175, 176,
1185 177, 59, 179, 3, -454, -454, -454, -454, -454, -454,
1186 180, 181, -1, -454, -454, -454, 182, 183, 184, 185,
1187 186, 187, -106, 163, 188, 189, 192, 194, 130, -454,
1188 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1189 -454, 195, 196, 241, 244, 245, 246, 249, 248, 358,
1190 -454, -454, -454, -454, -454, -454, -454, -454, 50, -30,
1191 281, -30, 63, 75, 170, -454, 290, 199, -454, 300,
1192 308, 319, 320, 255, -454, 83, 380, 381, 258, -454,
1193 383, 260, -454, 256, 257, 259, 261, 262, 263, 264,
1194 266, 158, -454, -454, -454, -454, -454, -454, -454, 267,
1195 268, 269, 270, 271, 273, 31, -454, -454, -454, -454,
1196 -454, 275, 276, 277, 274, -14, -454, -454, -454, 278,
1197 265, -454, 387, 285, -454, 52, -454, 83, 286, -454,
1198 282, 2, -454, 283, -4, 284, 11, 7, -454, -454,
1199 -454, -454, -454, -454, -454, 395, 414, 291, -454, 416,
1200 417, 419, 418, 292, 293, 299, -454, 424, 425, 302,
1201 -454, 427, 6, 428, 429, 430, 432, -454, 431, -454,
1202 434, 118, 120, 311, -454, 6, 6, 6, 6, 436,
1203 479, 6, 356, -454, 357, 360, 420, 422, 484, 366,
1204 491, 368, 369, 370, 371, -454, 372, -454, 373, 374,
1205 375, 376, -454, -454, -454, 377, 378, 379, -454, 382,
1206 -454, 504, 6, 505, 507, 508, 509, 6, 386, -454,
1207 511, 512, 513, 515, 516, 393, -454, 519, 520, 123,
1208 398, -454, 523, -454, 402, -454, 399, 403, 404, 410,
1209 407, 52, -454, -454, -454, -454, 523, 412, -454, 527,
1210 421, -454, 540, 541, 415, 543, 546, 426, 423, -454,
1211 433, 435, -454, 437, 438, 439, 440, 548, -30, -454,
1212 441, 442, -454, 443, -454, 6, 65, 444, 445, 446,
1213 447, 448, 449, 450, 451, 452, 453, -454, 454, 6,
1214 -454, 33, 455, 76, 456, -2, 457, 458, 135, -454,
1215 -454, -454, -454, -454, 459, -454, 10, -454, -454, -454,
1216 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1217 460, 147, 461, 462, 463, 464, 152, -454, 465, 466,
1218 467, 468, 469, -454, 470, 471, 472, 473, -454, -454,
1219 8, -454, -454, 549, 551, 553, -454, 474, -454, 9,
1220 -454, 475, -454, 476, 477, 554, 478, 481, 558, -454,
1221 -454, -454, -454, -454, -454, -454, 482, 560, -454, -454,
1222 -454, 58, 6, 6, 6, 6, -454, -454, -454, -454,
1223 -454, -454, -454, -454, -454, -454, -454, -454, -454, 33,
1224 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1225 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1226 -454, 483, -454, -454, -454, -454, -454, -454, -454, -454,
1227 -454, -454, -454, -454, -454, -454, -454, -454, -454, -454,
1228 -454, 485, 486, 487, -454, -454, -454, -454, -454, 488,
1229 -454, -454, 489, -454, 490, -454, 48, 48, -454, -454,
1230 -454, -454, -454, -454, -454, -454, -454
1233 /* YYPGOTO[NTERM-NUM]. */
1234 static const yytype_int16 yypgoto[] =
1236 -454, -454, 585, 251, -454, 142, -454, -454, -342, -454,
1237 492, -454, -454, -454, -454, 493, -454, -454, -454, -454,
1238 -454, -454, -454, -454, -454, -454, 494, -454, -454, -454,
1239 -454, 389, -454, -454, -454, -454, -454, -454, -454, -454,
1240 -454, -454, 411, -454, -454, -454, -454, -454, -454, -454,
1241 -454, -454, -454, -454, -454, -454, -454, 535, -454, -454,
1242 -454, -454, 495, -454, -454, -454, -454, -65, -454, 314,
1243 -240, -454, 547, -454, -454, -454, -454, -454, -454, -454,
1244 -454, -454, -454, 352, -454, -454, -454, -454, -454, -454,
1245 -454, -454, -454, -454, 339, -454, -454, -454, -454, -454,
1246 -454, -454, -454, 330, -454, -454, -454, -454, -454, 496,
1247 -454, -454, -454, -454, -454, 497, -454, 200, -453, -454,
1248 -454, 498, -454, -454, 206, -454, -454, -454, -454, -454,
1249 -454, 499, -454, -454, -454, -454, -454, -454, -454, 317,
1250 -454, -454, -454, 312, -454, -454, -454, -454, -454, -454,
1251 -454, -454, 500, -454, -454
1254 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1255 positive, shift that token. If negative, reduce the rule which
1256 number is the opposite. If zero, do what YYDEFACT says.
1257 If YYTABLE_NINF, syntax error. */
1258 #define YYTABLE_NINF -1
1259 static const yytype_uint16 yytable[] =
1261 456, 370, 237, 156, 159, 310, 190, 191, 171, 172,
1262 454, 519, 519, 143, 591, 473, 475, 171, 172, 478,
1263 177, 347, 291, 42, 313, 314, 348, 47, 315, 582,
1264 583, 584, 585, 586, 48, 313, 314, 62, 1, 315,
1265 366, 367, 2, 3, 292, 293, 4, 5, 178, 279,
1266 501, 280, 144, 179, 180, 506, 570, 571, 572, 573,
1267 574, 575, 576, 577, 190, 191, 49, 610, 327, 416,
1268 68, 69, 70, 163, 6, 181, 610, 50, 7, 71,
1269 72, 8, 164, 316, 9, 10, 281, 282, 283, 11,
1270 12, 13, 364, 365, 316, 333, 51, 14, 15, 16,
1271 57, 417, 17, 55, 334, 371, 372, 56, 73, 58,
1272 18, 61, 19, 551, 64, 418, 20, 373, 374, 419,
1273 65, 552, 553, 554, 555, 383, 384, 569, 433, 434,
1274 339, 300, 303, 430, 455, 609, 615, 592, 438, 83,
1275 196, 149, 87, 436, 437, 197, 66, 198, 199, 88,
1276 89, 200, 67, 90, 91, 153, 552, 553, 554, 555,
1277 463, 464, 465, 466, 237, 516, 517, 201, 263, 202,
1278 203, 154, 264, 554, 555, 204, 265, 266, 267, 268,
1279 92, 552, 553, 554, 555, 93, 155, 625, 552, 553,
1280 554, 555, 556, 156, 159, 269, 162, 169, 205, 552,
1281 553, 554, 555, 580, 206, 238, 239, 170, 547, 244,
1282 626, 627, 628, 629, 94, 95, 96, 97, 98, 99,
1283 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
1284 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
1285 120, 121, 122, 123, 124, 125, 126, 127, 128, 129,
1286 130, 131, 132, 133, 134, 310, 240, 87, 552, 553,
1287 554, 555, 589, 253, 88, 89, 241, 247, 90, 91,
1288 552, 553, 554, 555, 594, 552, 553, 554, 555, 599,
1289 242, 243, 246, 249, 369, 250, 251, 252, 255, 256,
1290 349, 257, 258, 376, 260, 92, 261, 375, 302, 306,
1291 93, 307, 308, 378, 325, 326, 329, 330, 331, 332,
1292 335, 379, 337, 338, 341, 342, 343, 344, 345, 346,
1293 350, 351, 380, 381, 352, 353, 377, 355, 356, 94,
1294 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
1295 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
1296 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
1297 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
1298 221, 222, 223, 357, 224, 225, 358, 359, 360, 362,
1299 91, 361, 382, 386, 387, 388, 389, 390, 391, 392,
1300 414, 393, 413, 394, 395, 396, 397, 398, 440, 400,
1301 401, 402, 403, 404, 405, 410, 92, 407, 408, 409,
1302 412, 93, 415, 428, 429, 432, 435, 441, 442, 443,
1303 444, 446, 226, 445, 447, 448, 449, 450, 451, 452,
1304 453, 457, 458, 459, 461, 227, 460, 462, 467, 476,
1305 94, 95, 96, 97, 98, 99, 100, 101, 102, 103,
1306 104, 105, 106, 107, 108, 109, 110, 111, 112, 113,
1307 114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
1308 124, 125, 126, 127, 128, 129, 130, 131, 132, 133,
1309 134, 1, 477, 479, 480, 2, 3, 481, 484, 4,
1310 5, 482, 483, 485, 486, 487, 488, 489, 490, 491,
1311 492, 493, 494, 495, 496, 497, 498, 500, 502, 499,
1312 503, 504, 505, 507, 508, 509, 510, 6, 511, 512,
1313 513, 7, 514, 515, 8, 518, 519, 9, 10, 522,
1314 531, 523, 11, 12, 13, 524, 525, 526, 527, 530,
1315 14, 15, 16, 533, 534, 17, 536, 535, 532, 537,
1316 539, 546, 611, 18, 612, 19, 613, 619, 538, 20,
1317 540, 622, 541, 624, 542, 543, 544, 545, 548, 549,
1318 550, 557, 558, 559, 560, 561, 562, 563, 564, 565,
1319 566, 567, 579, 581, 587, 588, 590, 593, 595, 596,
1320 597, 598, 600, 601, 602, 603, 604, 605, 606, 607,
1321 608, 614, 616, 617, 618, 620, 63, 472, 621, 623,
1322 630, 568, 631, 632, 633, 634, 635, 636, 363, 354,
1323 248, 427, 245, 399, 406, 411, 529, 528, 431, 439,
1324 254, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1325 0, 0, 259, 262, 0, 0, 0, 0, 0, 0,
1326 0, 0, 0, 0, 301, 0, 0, 0, 304, 0,
1327 0, 0, 0, 0, 0, 309, 0, 0, 0, 0,
1328 0, 0, 0, 328, 0, 0, 336, 0, 0, 0,
1329 0, 0, 0, 0, 0, 0, 340
1332 static const yytype_int16 yycheck[] =
1334 342, 241, 67, 3, 3, 3, 7, 8, 80, 81,
1335 4, 3, 3, 18, 4, 357, 358, 80, 81, 361,
1336 17, 127, 36, 127, 17, 18, 132, 130, 21, 31,
1337 32, 33, 34, 35, 130, 17, 18, 0, 1, 21,
1338 70, 71, 5, 6, 58, 59, 9, 10, 45, 18,
1339 392, 20, 57, 50, 51, 397, 23, 24, 25, 26,
1340 27, 28, 29, 30, 7, 8, 130, 520, 131, 17,
1341 36, 37, 38, 69, 37, 72, 529, 130, 41, 45,
1342 46, 44, 78, 76, 47, 48, 55, 56, 57, 52,
1343 53, 54, 42, 43, 76, 36, 130, 60, 61, 62,
1344 3, 49, 65, 130, 45, 42, 43, 130, 74, 130,
1345 73, 130, 75, 455, 130, 63, 79, 42, 43, 67,
1346 130, 123, 124, 125, 126, 42, 43, 469, 132, 133,
1347 131, 131, 131, 131, 128, 127, 127, 127, 131, 17,
1348 10, 49, 10, 132, 133, 15, 130, 17, 18, 17,
1349 18, 21, 130, 21, 22, 130, 123, 124, 125, 126,
1350 42, 43, 42, 43, 229, 42, 43, 37, 10, 39,
1351 40, 130, 14, 125, 126, 45, 18, 19, 20, 21,
1352 48, 123, 124, 125, 126, 53, 130, 129, 123, 124,
1353 125, 126, 127, 3, 3, 37, 130, 130, 68, 123,
1354 124, 125, 126, 127, 74, 132, 132, 130, 448, 131,
1355 552, 553, 554, 555, 82, 83, 84, 85, 86, 87,
1356 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
1357 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
1358 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
1359 118, 119, 120, 121, 122, 3, 132, 10, 123, 124,
1360 125, 126, 127, 131, 17, 18, 132, 131, 21, 22,
1361 123, 124, 125, 126, 127, 123, 124, 125, 126, 127,
1362 132, 132, 132, 132, 3, 132, 132, 132, 132, 132,
1363 127, 132, 131, 3, 132, 48, 131, 127, 132, 132,
1364 53, 132, 131, 3, 132, 132, 132, 132, 132, 132,
1365 131, 3, 132, 132, 132, 132, 132, 132, 132, 132,
1366 132, 132, 3, 3, 132, 131, 127, 132, 132, 82,
1367 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
1368 93, 94, 95, 96, 97, 98, 99, 100, 101, 102,
1369 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
1370 113, 114, 115, 116, 117, 118, 119, 120, 121, 122,
1371 12, 13, 14, 132, 16, 17, 132, 132, 132, 131,
1372 22, 132, 127, 3, 3, 127, 3, 127, 132, 132,
1373 3, 132, 127, 132, 132, 132, 132, 131, 3, 132,
1374 132, 132, 132, 132, 131, 131, 48, 132, 132, 132,
1375 132, 53, 127, 127, 132, 132, 132, 3, 127, 3,
1376 3, 3, 64, 4, 132, 132, 127, 3, 3, 127,
1377 3, 3, 3, 3, 3, 77, 4, 3, 127, 3,
1378 82, 83, 84, 85, 86, 87, 88, 89, 90, 91,
1379 92, 93, 94, 95, 96, 97, 98, 99, 100, 101,
1380 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
1381 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
1382 122, 1, 3, 127, 127, 5, 6, 127, 4, 9,
1383 10, 71, 70, 127, 3, 127, 127, 127, 127, 127,
1384 127, 127, 127, 127, 127, 127, 127, 3, 3, 127,
1385 3, 3, 3, 127, 3, 3, 3, 37, 3, 3,
1386 127, 41, 3, 3, 44, 127, 3, 47, 48, 127,
1387 3, 132, 52, 53, 54, 132, 132, 127, 131, 127,
1388 60, 61, 62, 3, 3, 65, 3, 132, 127, 3,
1389 127, 3, 3, 73, 3, 75, 3, 3, 132, 79,
1390 127, 3, 127, 3, 127, 127, 127, 127, 127, 127,
1391 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
1392 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
1393 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
1394 127, 127, 127, 127, 127, 127, 21, 356, 127, 127,
1395 127, 469, 127, 127, 127, 127, 127, 127, 229, 208,
1396 85, 307, 75, 271, 285, 295, 426, 421, 311, 317,
1397 135, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1398 -1, -1, 146, 151, -1, -1, -1, -1, -1, -1,
1399 -1, -1, -1, -1, 157, -1, -1, -1, 160, -1,
1400 -1, -1, -1, -1, -1, 166, -1, -1, -1, -1,
1401 -1, -1, -1, 173, -1, -1, 183, -1, -1, -1,
1402 -1, -1, -1, -1, -1, -1, 192
1405 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1406 symbol of state STATE-NUM. */
1407 static const yytype_uint16 yystos[] =
1409 0, 1, 5, 6, 9, 10, 37, 41, 44, 47,
1410 48, 52, 53, 54, 60, 61, 62, 65, 73, 75,
1411 79, 135, 136, 143, 147, 157, 163, 174, 190, 194,
1412 205, 215, 226, 235, 242, 247, 253, 256, 264, 270,
1413 274, 284, 127, 148, 158, 175, 164, 130, 130, 130,
1414 130, 130, 216, 227, 236, 130, 130, 3, 130, 271,
1415 275, 130, 0, 136, 130, 130, 130, 130, 36, 37,
1416 38, 45, 46, 74, 206, 207, 208, 209, 210, 211,
1417 212, 213, 214, 17, 191, 192, 193, 10, 17, 18,
1418 21, 22, 48, 53, 82, 83, 84, 85, 86, 87,
1419 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
1420 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
1421 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
1422 118, 119, 120, 121, 122, 195, 196, 197, 198, 199,
1423 200, 201, 202, 18, 57, 243, 244, 245, 246, 49,
1424 144, 145, 146, 130, 130, 130, 3, 248, 249, 3,
1425 254, 255, 130, 69, 78, 265, 266, 267, 269, 130,
1426 130, 80, 81, 285, 286, 287, 288, 17, 45, 50,
1427 51, 72, 149, 150, 151, 152, 153, 154, 155, 156,
1428 7, 8, 159, 160, 161, 162, 10, 15, 17, 18,
1429 21, 37, 39, 40, 45, 68, 74, 176, 177, 178,
1430 179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
1431 189, 12, 13, 14, 16, 17, 64, 77, 165, 166,
1432 167, 168, 169, 170, 171, 172, 173, 201, 132, 132,
1433 132, 132, 132, 132, 131, 206, 132, 131, 191, 132,
1434 132, 132, 132, 131, 196, 132, 132, 132, 131, 243,
1435 132, 131, 144, 10, 14, 18, 19, 20, 21, 37,
1436 217, 218, 219, 220, 221, 222, 223, 224, 225, 18,
1437 20, 55, 56, 57, 228, 229, 230, 231, 232, 233,
1438 234, 36, 58, 59, 237, 238, 239, 240, 241, 250,
1439 131, 249, 132, 131, 255, 257, 132, 132, 131, 265,
1440 3, 272, 273, 17, 18, 21, 76, 276, 277, 278,
1441 279, 280, 281, 282, 283, 132, 132, 131, 286, 132,
1442 132, 132, 132, 36, 45, 131, 149, 132, 132, 131,
1443 160, 132, 132, 132, 132, 132, 132, 127, 132, 127,
1444 132, 132, 132, 131, 176, 132, 132, 132, 132, 132,
1445 132, 132, 131, 165, 42, 43, 70, 71, 204, 3,
1446 204, 42, 43, 42, 43, 127, 3, 127, 3, 3,
1447 3, 3, 127, 42, 43, 203, 3, 3, 127, 3,
1448 127, 132, 132, 132, 132, 132, 132, 132, 131, 217,
1449 132, 132, 132, 132, 132, 131, 228, 132, 132, 132,
1450 131, 237, 132, 127, 3, 127, 17, 49, 63, 67,
1451 258, 259, 260, 261, 262, 263, 268, 203, 127, 132,
1452 131, 273, 132, 132, 133, 132, 132, 133, 131, 277,
1453 3, 3, 127, 3, 3, 4, 3, 132, 132, 127,
1454 3, 3, 127, 3, 4, 128, 142, 3, 3, 3,
1455 4, 3, 3, 42, 43, 42, 43, 127, 137, 138,
1456 139, 142, 137, 142, 141, 142, 3, 3, 142, 127,
1457 127, 127, 71, 70, 4, 127, 3, 127, 127, 127,
1458 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
1459 3, 142, 3, 3, 3, 3, 142, 127, 3, 3,
1460 3, 3, 3, 127, 3, 3, 42, 43, 127, 3,
1461 251, 252, 127, 132, 132, 132, 127, 131, 258, 251,
1462 127, 3, 127, 3, 3, 132, 3, 3, 132, 127,
1463 127, 127, 127, 127, 127, 127, 3, 204, 127, 127,
1464 127, 142, 123, 124, 125, 126, 127, 127, 127, 127,
1465 127, 127, 127, 127, 127, 127, 127, 127, 139, 142,
1466 23, 24, 25, 26, 27, 28, 29, 30, 140, 127,
1467 127, 127, 31, 32, 33, 34, 35, 127, 127, 127,
1468 127, 4, 127, 127, 127, 127, 127, 127, 127, 127,
1469 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
1470 252, 3, 3, 3, 127, 127, 127, 127, 127, 3,
1471 127, 127, 3, 127, 3, 129, 142, 142, 142, 142,
1472 127, 127, 127, 127, 127, 127, 127
1475 #define yyerrok (yyerrstatus = 0)
1476 #define yyclearin (yychar = YYEMPTY)
1477 #define YYEMPTY (-2)
1480 #define YYACCEPT goto yyacceptlab
1481 #define YYABORT goto yyabortlab
1482 #define YYERROR goto yyerrorlab
1485 /* Like YYERROR except do call yyerror. This remains here temporarily
1486 to ease the transition to the new meaning of YYERROR, for GCC.
1487 Once GCC version 2 has supplanted version 1, this can go. */
1489 #define YYFAIL goto yyerrlab
1491 #define YYRECOVERING() (!!yyerrstatus)
1493 #define YYBACKUP(Token, Value) \
1495 if (yychar == YYEMPTY && yylen == 1) \
1499 yytoken = YYTRANSLATE (yychar); \
1505 yyerror (YY_("syntax error: cannot back up")); \
1512 #define YYERRCODE 256
1515 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1516 If N is 0, then set CURRENT to the empty location which ends
1517 the previous symbol: RHS[0] (always defined). */
1519 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1520 #ifndef YYLLOC_DEFAULT
1521 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1525 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1526 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1527 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1528 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1532 (Current).first_line = (Current).last_line = \
1533 YYRHSLOC (Rhs, 0).last_line; \
1534 (Current).first_column = (Current).last_column = \
1535 YYRHSLOC (Rhs, 0).last_column; \
1541 /* YY_LOCATION_PRINT -- Print the location on the stream.
1542 This macro was not mandated originally: define only if we know
1543 we won't break user code: when these are the locations we know. */
1545 #ifndef YY_LOCATION_PRINT
1546 # if YYLTYPE_IS_TRIVIAL
1547 # define YY_LOCATION_PRINT(File, Loc) \
1548 fprintf (File, "%d.%d-%d.%d", \
1549 (Loc).first_line, (Loc).first_column, \
1550 (Loc).last_line, (Loc).last_column)
1552 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1557 /* YYLEX -- calling `yylex' with the right arguments. */
1560 # define YYLEX yylex (YYLEX_PARAM)
1562 # define YYLEX yylex ()
1565 /* Enable debugging if requested. */
1569 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1570 # define YYFPRINTF fprintf
1573 # define YYDPRINTF(Args) \
1579 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1583 YYFPRINTF (stderr, "%s ", Title); \
1584 yy_symbol_print (stderr, \
1586 YYFPRINTF (stderr, "\n"); \
1591 /*--------------------------------.
1592 | Print this symbol on YYOUTPUT. |
1593 `--------------------------------*/
1596 #if (defined __STDC__ || defined __C99__FUNC__ \
1597 || defined __cplusplus || defined _MSC_VER)
1599 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1602 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1605 YYSTYPE const * const yyvaluep;
1611 if (yytype < YYNTOKENS)
1612 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1624 /*--------------------------------.
1625 | Print this symbol on YYOUTPUT. |
1626 `--------------------------------*/
1628 #if (defined __STDC__ || defined __C99__FUNC__ \
1629 || defined __cplusplus || defined _MSC_VER)
1631 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1634 yy_symbol_print (yyoutput, yytype, yyvaluep)
1637 YYSTYPE const * const yyvaluep;
1640 if (yytype < YYNTOKENS)
1641 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1643 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1645 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1646 YYFPRINTF (yyoutput, ")");
1649 /*------------------------------------------------------------------.
1650 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1652 `------------------------------------------------------------------*/
1654 #if (defined __STDC__ || defined __C99__FUNC__ \
1655 || defined __cplusplus || defined _MSC_VER)
1657 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1660 yy_stack_print (bottom, top)
1661 yytype_int16 *bottom;
1665 YYFPRINTF (stderr, "Stack now");
1666 for (; bottom <= top; ++bottom)
1667 YYFPRINTF (stderr, " %d", *bottom);
1668 YYFPRINTF (stderr, "\n");
1671 # define YY_STACK_PRINT(Bottom, Top) \
1674 yy_stack_print ((Bottom), (Top)); \
1678 /*------------------------------------------------.
1679 | Report that the YYRULE is going to be reduced. |
1680 `------------------------------------------------*/
1682 #if (defined __STDC__ || defined __C99__FUNC__ \
1683 || defined __cplusplus || defined _MSC_VER)
1685 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1688 yy_reduce_print (yyvsp, yyrule)
1693 int yynrhs = yyr2[yyrule];
1695 unsigned long int yylno = yyrline[yyrule];
1696 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1698 /* The symbols being reduced. */
1699 for (yyi = 0; yyi < yynrhs; yyi++)
1701 fprintf (stderr, " $%d = ", yyi + 1);
1702 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1703 &(yyvsp[(yyi + 1) - (yynrhs)])
1705 fprintf (stderr, "\n");
1709 # define YY_REDUCE_PRINT(Rule) \
1712 yy_reduce_print (yyvsp, Rule); \
1715 /* Nonzero means print parse trace. It is left uninitialized so that
1716 multiple parsers can coexist. */
1718 #else /* !YYDEBUG */
1719 # define YYDPRINTF(Args)
1720 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1721 # define YY_STACK_PRINT(Bottom, Top)
1722 # define YY_REDUCE_PRINT(Rule)
1723 #endif /* !YYDEBUG */
1726 /* YYINITDEPTH -- initial size of the parser's stacks. */
1728 # define YYINITDEPTH 200
1731 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1732 if the built-in stack extension method is used).
1734 Do not make this value too large; the results are undefined if
1735 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1736 evaluated with infinite-precision integer arithmetic. */
1739 # define YYMAXDEPTH 10000
1747 # if defined __GLIBC__ && defined _STRING_H
1748 # define yystrlen strlen
1750 /* Return the length of YYSTR. */
1751 #if (defined __STDC__ || defined __C99__FUNC__ \
1752 || defined __cplusplus || defined _MSC_VER)
1754 yystrlen (const char *yystr)
1762 for (yylen = 0; yystr[yylen]; yylen++)
1770 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1771 # define yystpcpy stpcpy
1773 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1775 #if (defined __STDC__ || defined __C99__FUNC__ \
1776 || defined __cplusplus || defined _MSC_VER)
1778 yystpcpy (char *yydest, const char *yysrc)
1781 yystpcpy (yydest, yysrc)
1787 const char *yys = yysrc;
1789 while ((*yyd++ = *yys++) != '\0')
1798 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1799 quotes and backslashes, so that it's suitable for yyerror. The
1800 heuristic is that double-quoting is unnecessary unless the string
1801 contains an apostrophe, a comma, or backslash (other than
1802 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1803 null, do not copy; instead, return the length of what the result
1806 yytnamerr (char *yyres, const char *yystr)
1811 char const *yyp = yystr;
1818 goto do_not_strip_quotes;
1822 goto do_not_strip_quotes;
1835 do_not_strip_quotes: ;
1839 return yystrlen (yystr);
1841 return yystpcpy (yyres, yystr) - yyres;
1845 /* Copy into YYRESULT an error message about the unexpected token
1846 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1847 including the terminating null byte. If YYRESULT is null, do not
1848 copy anything; just return the number of bytes that would be
1849 copied. As a special case, return 0 if an ordinary "syntax error"
1850 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1851 size calculation. */
1853 yysyntax_error (char *yyresult, int yystate, int yychar)
1855 int yyn = yypact[yystate];
1857 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1861 int yytype = YYTRANSLATE (yychar);
1862 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1863 YYSIZE_T yysize = yysize0;
1865 int yysize_overflow = 0;
1866 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1867 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1871 /* This is so xgettext sees the translatable formats that are
1872 constructed on the fly. */
1873 YY_("syntax error, unexpected %s");
1874 YY_("syntax error, unexpected %s, expecting %s");
1875 YY_("syntax error, unexpected %s, expecting %s or %s");
1876 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1877 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1881 static char const yyunexpected[] = "syntax error, unexpected %s";
1882 static char const yyexpecting[] = ", expecting %s";
1883 static char const yyor[] = " or %s";
1884 char yyformat[sizeof yyunexpected
1885 + sizeof yyexpecting - 1
1886 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1887 * (sizeof yyor - 1))];
1888 char const *yyprefix = yyexpecting;
1890 /* Start YYX at -YYN if negative to avoid negative indexes in
1892 int yyxbegin = yyn < 0 ? -yyn : 0;
1894 /* Stay within bounds of both yycheck and yytname. */
1895 int yychecklim = YYLAST - yyn + 1;
1896 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1899 yyarg[0] = yytname[yytype];
1900 yyfmt = yystpcpy (yyformat, yyunexpected);
1902 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1903 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1905 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1909 yyformat[sizeof yyunexpected - 1] = '\0';
1912 yyarg[yycount++] = yytname[yyx];
1913 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1914 yysize_overflow |= (yysize1 < yysize);
1916 yyfmt = yystpcpy (yyfmt, yyprefix);
1920 yyf = YY_(yyformat);
1921 yysize1 = yysize + yystrlen (yyf);
1922 yysize_overflow |= (yysize1 < yysize);
1925 if (yysize_overflow)
1926 return YYSIZE_MAXIMUM;
1930 /* Avoid sprintf, as that infringes on the user's name space.
1931 Don't have undefined behavior even if the translation
1932 produced a string with the wrong number of "%s"s. */
1933 char *yyp = yyresult;
1935 while ((*yyp = *yyf) != '\0')
1937 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1939 yyp += yytnamerr (yyp, yyarg[yyi++]);
1952 #endif /* YYERROR_VERBOSE */
1955 /*-----------------------------------------------.
1956 | Release the memory associated to this symbol. |
1957 `-----------------------------------------------*/
1960 #if (defined __STDC__ || defined __C99__FUNC__ \
1961 || defined __cplusplus || defined _MSC_VER)
1963 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1966 yydestruct (yymsg, yytype, yyvaluep)
1976 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1987 /* Prevent warnings from -Wmissing-prototypes. */
1989 #ifdef YYPARSE_PARAM
1990 #if defined __STDC__ || defined __cplusplus
1991 int yyparse (void *YYPARSE_PARAM);
1995 #else /* ! YYPARSE_PARAM */
1996 #if defined __STDC__ || defined __cplusplus
2001 #endif /* ! YYPARSE_PARAM */
2005 /* The look-ahead symbol. */
2008 /* The semantic value of the look-ahead symbol. */
2011 /* Number of syntax errors so far. */
2020 #ifdef YYPARSE_PARAM
2021 #if (defined __STDC__ || defined __C99__FUNC__ \
2022 || defined __cplusplus || defined _MSC_VER)
2024 yyparse (void *YYPARSE_PARAM)
2027 yyparse (YYPARSE_PARAM)
2028 void *YYPARSE_PARAM;
2030 #else /* ! YYPARSE_PARAM */
2031 #if (defined __STDC__ || defined __C99__FUNC__ \
2032 || defined __cplusplus || defined _MSC_VER)
2046 /* Number of tokens to shift before error messages enabled. */
2048 /* Look-ahead token as an internal (translated) token number. */
2051 /* Buffer for error messages, and its allocated size. */
2053 char *yymsg = yymsgbuf;
2054 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2057 /* Three stacks and their tools:
2058 `yyss': related to states,
2059 `yyvs': related to semantic values,
2060 `yyls': related to locations.
2062 Refer to the stacks thru separate pointers, to allow yyoverflow
2063 to reallocate them elsewhere. */
2065 /* The state stack. */
2066 yytype_int16 yyssa[YYINITDEPTH];
2067 yytype_int16 *yyss = yyssa;
2068 yytype_int16 *yyssp;
2070 /* The semantic value stack. */
2071 YYSTYPE yyvsa[YYINITDEPTH];
2072 YYSTYPE *yyvs = yyvsa;
2077 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2079 YYSIZE_T yystacksize = YYINITDEPTH;
2081 /* The variables used to return semantic value and location from the
2086 /* The number of symbols on the RHS of the reduced rule.
2087 Keep to zero when no symbol should be popped. */
2090 YYDPRINTF ((stderr, "Starting parse\n"));
2095 yychar = YYEMPTY; /* Cause a token to be read. */
2097 /* Initialize stack pointers.
2098 Waste one element of value and location stack
2099 so that they stay on the same level as the state stack.
2100 The wasted elements are never initialized. */
2107 /*------------------------------------------------------------.
2108 | yynewstate -- Push a new state, which is found in yystate. |
2109 `------------------------------------------------------------*/
2111 /* In all cases, when you get here, the value and location stacks
2112 have just been pushed. So pushing a state here evens the stacks. */
2118 if (yyss + yystacksize - 1 <= yyssp)
2120 /* Get the current used size of the three stacks, in elements. */
2121 YYSIZE_T yysize = yyssp - yyss + 1;
2125 /* Give user a chance to reallocate the stack. Use copies of
2126 these so that the &'s don't force the real ones into
2128 YYSTYPE *yyvs1 = yyvs;
2129 yytype_int16 *yyss1 = yyss;
2132 /* Each stack pointer address is followed by the size of the
2133 data in use in that stack, in bytes. This used to be a
2134 conditional around just the two extra args, but that might
2135 be undefined if yyoverflow is a macro. */
2136 yyoverflow (YY_("memory exhausted"),
2137 &yyss1, yysize * sizeof (*yyssp),
2138 &yyvs1, yysize * sizeof (*yyvsp),
2145 #else /* no yyoverflow */
2146 # ifndef YYSTACK_RELOCATE
2147 goto yyexhaustedlab;
2149 /* Extend the stack our own way. */
2150 if (YYMAXDEPTH <= yystacksize)
2151 goto yyexhaustedlab;
2153 if (YYMAXDEPTH < yystacksize)
2154 yystacksize = YYMAXDEPTH;
2157 yytype_int16 *yyss1 = yyss;
2158 union yyalloc *yyptr =
2159 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2161 goto yyexhaustedlab;
2162 YYSTACK_RELOCATE (yyss);
2163 YYSTACK_RELOCATE (yyvs);
2165 # undef YYSTACK_RELOCATE
2167 YYSTACK_FREE (yyss1);
2170 #endif /* no yyoverflow */
2172 yyssp = yyss + yysize - 1;
2173 yyvsp = yyvs + yysize - 1;
2176 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2177 (unsigned long int) yystacksize));
2179 if (yyss + yystacksize - 1 <= yyssp)
2183 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2192 /* Do appropriate processing given the current state. Read a
2193 look-ahead token if we need one and don't already have one. */
2195 /* First try to decide what to do without reference to look-ahead token. */
2196 yyn = yypact[yystate];
2197 if (yyn == YYPACT_NINF)
2200 /* Not known => get a look-ahead token if don't already have one. */
2202 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2203 if (yychar == YYEMPTY)
2205 YYDPRINTF ((stderr, "Reading a token: "));
2209 if (yychar <= YYEOF)
2211 yychar = yytoken = YYEOF;
2212 YYDPRINTF ((stderr, "Now at end of input.\n"));
2216 yytoken = YYTRANSLATE (yychar);
2217 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2220 /* If the proper action on seeing token YYTOKEN is to reduce or to
2221 detect an error, take that action. */
2223 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2228 if (yyn == 0 || yyn == YYTABLE_NINF)
2237 /* Count tokens shifted since error; after three, turn off error
2242 /* Shift the look-ahead token. */
2243 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2245 /* Discard the shifted token unless it is eof. */
2246 if (yychar != YYEOF)
2255 /*-----------------------------------------------------------.
2256 | yydefault -- do the default action for the current state. |
2257 `-----------------------------------------------------------*/
2259 yyn = yydefact[yystate];
2265 /*-----------------------------.
2266 | yyreduce -- Do a reduction. |
2267 `-----------------------------*/
2269 /* yyn is the number of a rule to reduce with. */
2272 /* If YYLEN is nonzero, implement the default value of the action:
2275 Otherwise, the following line sets YYVAL to garbage.
2276 This behavior is undocumented and Bison
2277 users should not rely upon it. Assigning to YYVAL
2278 unconditionally makes the parser a bit smaller, and it avoids a
2279 GCC warning that YYVAL may be used uninitialized. */
2280 yyval = yyvsp[1-yylen];
2283 YY_REDUCE_PRINT (yyn);
2287 #line 225 "./ircd_parser.y"
2289 (yyval.num) = (yyvsp[(1) - (2)].num) + (yyvsp[(2) - (2)].num);
2294 #line 230 "./ircd_parser.y"
2296 (yyval.num) = (yyvsp[(1) - (2)].num) * (yyvsp[(2) - (2)].num);
2301 #line 234 "./ircd_parser.y"
2302 { (yyval.num) = 1; }
2306 #line 235 "./ircd_parser.y"
2307 { (yyval.num) = 60; }
2311 #line 236 "./ircd_parser.y"
2312 { (yyval.num) = 60 * 60; }
2316 #line 237 "./ircd_parser.y"
2317 { (yyval.num) = 60 * 60 * 24; }
2321 #line 238 "./ircd_parser.y"
2322 { (yyval.num) = 60 * 60 * 24 * 7; }
2326 #line 239 "./ircd_parser.y"
2327 { (yyval.num) = 60 * 60 * 24 * 7 * 4; }
2331 #line 240 "./ircd_parser.y"
2332 { (yyval.num) = 60 * 60 * 24 * 365; }
2336 #line 241 "./ircd_parser.y"
2337 { (yyval.num) = 60 * 60 * 24 * 365 * 10; }
2341 #line 244 "./ircd_parser.y"
2343 (yyval.num) = (yyvsp[(1) - (1)].num);
2348 #line 247 "./ircd_parser.y"
2350 (yyval.num) = (yyvsp[(1) - (2)].num);
2355 #line 250 "./ircd_parser.y"
2357 (yyval.num) = (yyvsp[(1) - (2)].num) * 1024;
2362 #line 253 "./ircd_parser.y"
2364 (yyval.num) = (yyvsp[(1) - (2)].num) * 1024 * 1024;
2369 #line 256 "./ircd_parser.y"
2371 (yyval.num) = (yyvsp[(1) - (2)].num) * 1024 * 1024 * 1024;
2376 #line 259 "./ircd_parser.y"
2378 (yyval.num) = (yyvsp[(1) - (2)].num) * 1024 * 1024 * 1024;
2383 #line 266 "./ircd_parser.y"
2385 (yyval.num) = (yyvsp[(1) - (1)].num);
2390 #line 269 "./ircd_parser.y"
2392 (yyval.num) = (yyvsp[(1) - (3)].num) + (yyvsp[(3) - (3)].num);
2397 #line 272 "./ircd_parser.y"
2399 (yyval.num) = (yyvsp[(1) - (3)].num) - (yyvsp[(3) - (3)].num);
2404 #line 275 "./ircd_parser.y"
2406 (yyval.num) = (yyvsp[(1) - (3)].num) * (yyvsp[(3) - (3)].num);
2411 #line 278 "./ircd_parser.y"
2413 (yyval.num) = (yyvsp[(1) - (3)].num) / (yyvsp[(3) - (3)].num);
2418 #line 285 "./ircd_parser.y"
2420 (yyval.num) = (yyvsp[(2) - (3)].num);
2425 #line 294 "./ircd_parser.y"
2427 addNickJupes((yyvsp[(3) - (4)].text));
2428 MyFree((yyvsp[(3) - (4)].text));
2433 #line 300 "./ircd_parser.y"
2435 /* Zero out the vhost addresses, in case they were removed. */
2436 memset(&VirtualHost_v4.addr, 0, sizeof(VirtualHost_v4.addr));
2437 memset(&VirtualHost_v6.addr, 0, sizeof(VirtualHost_v6.addr));
2442 #line 304 "./ircd_parser.y"
2444 if (localConf.name == NULL)
2445 parse_error("Your General block must contain a name.");
2446 if (localConf.numeric == 0)
2447 parse_error("Your General block must contain a numeric (between 1 and 4095).");
2452 #line 315 "./ircd_parser.y"
2454 if (localConf.numeric == 0)
2455 localConf.numeric = (yyvsp[(3) - (4)].num);
2456 else if (localConf.numeric != (yyvsp[(3) - (4)].num))
2457 parse_error("Redefinition of server numeric %i (%i)", (yyvsp[(3) - (4)].num),
2463 #line 324 "./ircd_parser.y"
2465 if (localConf.name == NULL)
2466 localConf.name = (yyvsp[(3) - (4)].text);
2468 if (strcmp(localConf.name, (yyvsp[(3) - (4)].text)))
2469 parse_error("Redefinition of server name %s (%s)", (yyvsp[(3) - (4)].text),
2471 MyFree((yyvsp[(3) - (4)].text));
2477 #line 336 "./ircd_parser.y"
2479 MyFree(localConf.description);
2480 localConf.description = (yyvsp[(3) - (4)].text);
2481 ircd_strncpy(cli_info(&me), (yyvsp[(3) - (4)].text), REALLEN);
2486 #line 343 "./ircd_parser.y"
2488 struct irc_in_addr addr;
2489 char *vhost = (yyvsp[(3) - (4)].text);
2491 if (!strcmp(vhost, "*")) {
2492 /* This traditionally meant bind to all interfaces and connect
2493 * from the default. */
2494 } else if (!ircd_aton(&addr, vhost))
2495 parse_error("Invalid virtual host '%s'.", vhost);
2496 else if (irc_in_addr_is_ipv4(&addr))
2497 memcpy(&VirtualHost_v4.addr, &addr, sizeof(addr));
2499 memcpy(&VirtualHost_v6.addr, &addr, sizeof(addr));
2505 #line 360 "./ircd_parser.y"
2507 struct irc_in_addr addr;
2508 int families = (yyvsp[(4) - (6)].num);
2509 char *vhost = (yyvsp[(5) - (6)].text);
2511 if (!strcmp(vhost, "*")) {
2512 /* Let the operating system assign the default. */
2513 } else if (!ircd_aton(&addr, vhost))
2514 parse_error("Invalid DNS virtual host '%s'.", vhost);
2517 if ((families & USE_IPV4)
2518 || (!families && irc_in_addr_is_ipv4(&addr)))
2519 memcpy(&VirtualHost_dns_v4.addr, &addr, sizeof(addr));
2520 if ((families & USE_IPV6)
2521 || (!families && !irc_in_addr_is_ipv4(&addr)))
2522 memcpy(&VirtualHost_dns_v6.addr, &addr, sizeof(addr));
2529 #line 382 "./ircd_parser.y"
2531 char *server = (yyvsp[(4) - (5)].text);
2533 add_nameserver(server);
2539 #line 390 "./ircd_parser.y"
2541 MyFree(localConf.location1);
2542 MyFree(localConf.location2);
2543 MyFree(localConf.contact);
2544 localConf.location1 = localConf.location2 = localConf.contact = NULL;
2549 #line 397 "./ircd_parser.y"
2551 if (localConf.location1 == NULL)
2552 DupString(localConf.location1, "");
2553 if (localConf.location2 == NULL)
2554 DupString(localConf.location2, "");
2555 if (localConf.contact == NULL)
2556 DupString(localConf.contact, "");
2561 #line 408 "./ircd_parser.y"
2563 if (localConf.location1 == NULL)
2564 localConf.location1 = (yyvsp[(3) - (4)].text);
2565 else if (localConf.location2 == NULL)
2566 localConf.location2 = (yyvsp[(3) - (4)].text);
2567 else /* Otherwise just drop it. -A1kmm */
2568 MyFree((yyvsp[(3) - (4)].text));
2573 #line 417 "./ircd_parser.y"
2575 MyFree(localConf.contact);
2576 localConf.contact = (yyvsp[(3) - (4)].text);
2581 #line 422 "./ircd_parser.y"
2589 #line 426 "./ircd_parser.y"
2593 struct ConnectionClass *c_class;
2594 add_class(name, tping, tconn, maxlinks, sendq, maxchans);
2595 c_class = find_class(name);
2596 MyFree(c_class->default_umode);
2597 c_class->default_umode = pass;
2598 memcpy(&c_class->privs, &privs, sizeof(c_class->privs));
2599 memcpy(&c_class->privs_dirty, &privs_dirty, sizeof(c_class->privs_dirty));
2602 parse_error("Missing name in class block");
2609 memset(&privs, 0, sizeof(privs));
2610 memset(&privs_dirty, 0, sizeof(privs_dirty));
2615 #line 452 "./ircd_parser.y"
2618 name = (yyvsp[(3) - (4)].text);
2623 #line 457 "./ircd_parser.y"
2625 maxchans = (yyvsp[(3) - (4)].num);
2630 #line 461 "./ircd_parser.y"
2632 tping = (yyvsp[(3) - (4)].num);
2637 #line 465 "./ircd_parser.y"
2639 tconn = (yyvsp[(3) - (4)].num);
2644 #line 469 "./ircd_parser.y"
2646 maxlinks = (yyvsp[(3) - (4)].num);
2651 #line 473 "./ircd_parser.y"
2653 sendq = (yyvsp[(3) - (4)].num);
2658 #line 477 "./ircd_parser.y"
2661 pass = (yyvsp[(3) - (4)].text);
2666 #line 483 "./ircd_parser.y"
2668 flags = CONF_AUTOCONNECT;
2673 #line 486 "./ircd_parser.y"
2675 struct ConfItem *aconf = NULL;
2677 parse_error("Missing name in connect block");
2678 else if (pass == NULL)
2679 parse_error("Missing password in connect block");
2680 else if (strlen(pass) > PASSWDLEN)
2681 parse_error("Password too long in connect block");
2682 else if (host == NULL)
2683 parse_error("Missing host in connect block");
2684 else if (strchr(host, '*') || strchr(host, '?'))
2685 parse_error("Invalid host '%s' in connect block", host);
2686 else if (c_class == NULL)
2687 parse_error("Missing or non-existent class in connect block");
2689 aconf = make_conf(CONF_SERVER);
2691 aconf->origin_name = origin;
2692 aconf->passwd = pass;
2693 aconf->conn_class = c_class;
2694 aconf->address.port = port;
2696 /* If the user specified a hub allowance, but not maximum links,
2697 * allow an effectively unlimited number of hops.
2699 aconf->maximum = (hub_limit != NULL && maxlinks == 0) ? 65535 : maxlinks;
2700 aconf->hub_limit = hub_limit;
2701 aconf->flags = flags;
2702 lookup_confhost(aconf);
2711 name = pass = host = origin = hub_limit = NULL;
2713 port = flags = maxlinks = 0;
2718 #line 532 "./ircd_parser.y"
2721 name = (yyvsp[(3) - (4)].text);
2726 #line 537 "./ircd_parser.y"
2729 pass = (yyvsp[(3) - (4)].text);
2734 #line 542 "./ircd_parser.y"
2736 c_class = find_class((yyvsp[(3) - (4)].text));
2738 parse_error("No such connection class '%s' for Connect block", (yyvsp[(3) - (4)].text));
2739 MyFree((yyvsp[(3) - (4)].text));
2744 #line 549 "./ircd_parser.y"
2747 host = (yyvsp[(3) - (4)].text);
2752 #line 554 "./ircd_parser.y"
2754 port = (yyvsp[(3) - (4)].num);
2759 #line 558 "./ircd_parser.y"
2762 origin = (yyvsp[(3) - (4)].text);
2767 #line 563 "./ircd_parser.y"
2774 #line 567 "./ircd_parser.y"
2777 DupString(hub_limit, "*");
2782 #line 572 "./ircd_parser.y"
2785 hub_limit = (yyvsp[(3) - (4)].text);
2790 #line 577 "./ircd_parser.y"
2792 maxlinks = (yyvsp[(3) - (4)].num);
2797 #line 580 "./ircd_parser.y"
2798 { flags |= CONF_AUTOCONNECT; }
2802 #line 581 "./ircd_parser.y"
2803 { flags &= ~CONF_AUTOCONNECT; }
2807 #line 582 "./ircd_parser.y"
2808 { flags |= CONF_SECURE; }
2812 #line 583 "./ircd_parser.y"
2813 { flags &= ~CONF_SECURE; }
2817 #line 589 "./ircd_parser.y"
2819 make_conf(CONF_UWORLD)->host = (yyvsp[(3) - (4)].text);
2824 #line 594 "./ircd_parser.y"
2826 struct ConfItem *aconf = NULL;
2830 parse_error("Missing name in operator block");
2831 else if (pass == NULL)
2832 parse_error("Missing password in operator block");
2833 /* Do not check password length because it may be crypted. */
2834 else if (hosts == NULL)
2835 parse_error("Missing host(s) in operator block");
2836 else if (c_class == NULL)
2837 parse_error("Invalid or missing class in operator block");
2838 else if (!FlagHas(&privs_dirty, PRIV_PROPAGATE)
2839 && !FlagHas(&c_class->privs_dirty, PRIV_PROPAGATE))
2840 parse_error("Operator block for %s and class %s have no LOCAL setting", name, c_class->cc_name);
2841 else for (link = hosts; link != NULL; link = link->next) {
2842 aconf = make_conf(CONF_OPERATOR);
2843 DupString(aconf->name, name);
2844 DupString(aconf->passwd, pass);
2845 conf_parse_userhost(aconf, link->value.cp);
2846 aconf->conn_class = c_class;
2847 memcpy(&aconf->privs, &privs, sizeof(aconf->privs));
2848 memcpy(&aconf->privs_dirty, &privs_dirty, sizeof(aconf->privs_dirty));
2855 memset(&privs, 0, sizeof(privs));
2856 memset(&privs_dirty, 0, sizeof(privs_dirty));
2861 #line 630 "./ircd_parser.y"
2864 name = (yyvsp[(3) - (4)].text);
2869 #line 635 "./ircd_parser.y"
2872 pass = (yyvsp[(3) - (4)].text);
2877 #line 640 "./ircd_parser.y"
2881 if (!strchr((yyvsp[(3) - (4)].text), '@'))
2884 link->value.cp = (char*) MyMalloc((uh_len = strlen((yyvsp[(3) - (4)].text))+3));
2885 ircd_snprintf(0, link->value.cp, uh_len, "*@%s", (yyvsp[(3) - (4)].text));
2888 DupString(link->value.cp, (yyvsp[(3) - (4)].text));
2889 MyFree((yyvsp[(3) - (4)].text));
2896 #line 656 "./ircd_parser.y"
2898 c_class = find_class((yyvsp[(3) - (4)].text));
2900 parse_error("No such connection class '%s' for Operator block", (yyvsp[(3) - (4)].text));
2901 MyFree((yyvsp[(3) - (4)].text));
2906 #line 664 "./ircd_parser.y"
2908 FlagSet(&privs_dirty, (yyvsp[(1) - (4)].num));
2909 if (((yyvsp[(3) - (4)].num) == 1) ^ invert)
2910 FlagSet(&privs, (yyvsp[(1) - (4)].num));
2912 FlagClr(&privs, (yyvsp[(1) - (4)].num));
2918 #line 673 "./ircd_parser.y"
2919 { (yyval.num) = PRIV_CHAN_LIMIT; }
2923 #line 674 "./ircd_parser.y"
2924 { (yyval.num) = PRIV_MODE_LCHAN; }
2928 #line 675 "./ircd_parser.y"
2929 { (yyval.num) = PRIV_DEOP_LCHAN; }
2933 #line 676 "./ircd_parser.y"
2934 { (yyval.num) = PRIV_WALK_LCHAN; }
2938 #line 677 "./ircd_parser.y"
2939 { (yyval.num) = PRIV_SEE_IDLETIME; }
2943 #line 678 "./ircd_parser.y"
2944 { (yyval.num) = PRIV_HIDE_IDLETIME; }
2948 #line 679 "./ircd_parser.y"
2949 { (yyval.num) = PRIV_UMODE_NOCHAN; }
2953 #line 680 "./ircd_parser.y"
2954 { (yyval.num) = PRIV_UMODE_NOIDLE; }
2958 #line 681 "./ircd_parser.y"
2959 { (yyval.num) = PRIV_UMODE_CHSERV; }
2963 #line 682 "./ircd_parser.y"
2964 { (yyval.num) = PRIV_UMODE_XTRAOP; }
2968 #line 683 "./ircd_parser.y"
2969 { (yyval.num) = PRIV_UMODE_NETSERV; }
2973 #line 684 "./ircd_parser.y"
2974 { (yyval.num) = PRIV_FLOOD; }
2978 #line 685 "./ircd_parser.y"
2979 { (yyval.num) = PRIV_HALFFLOOD; }
2983 #line 686 "./ircd_parser.y"
2984 { (yyval.num) = PRIV_UNLIMITED_TARGET; }
2988 #line 687 "./ircd_parser.y"
2989 { (yyval.num) = PRIV_UMODE_OVERRIDECC; }
2993 #line 688 "./ircd_parser.y"
2994 { (yyval.num) = PRIV_KILL; }
2998 #line 689 "./ircd_parser.y"
2999 { (yyval.num) = PRIV_LOCAL_KILL; }
3003 #line 690 "./ircd_parser.y"
3004 { (yyval.num) = PRIV_REHASH; }
3008 #line 691 "./ircd_parser.y"
3009 { (yyval.num) = PRIV_RESTART; }
3013 #line 692 "./ircd_parser.y"
3014 { (yyval.num) = PRIV_DIE; }
3018 #line 693 "./ircd_parser.y"
3019 { (yyval.num) = PRIV_GLINE; }
3023 #line 694 "./ircd_parser.y"
3024 { (yyval.num) = PRIV_LOCAL_GLINE; }
3028 #line 695 "./ircd_parser.y"
3029 { (yyval.num) = PRIV_JUPE; }
3033 #line 696 "./ircd_parser.y"
3034 { (yyval.num) = PRIV_LOCAL_JUPE; }
3038 #line 697 "./ircd_parser.y"
3039 { (yyval.num) = PRIV_LOCAL_OPMODE; }
3043 #line 698 "./ircd_parser.y"
3044 { (yyval.num) = PRIV_OPMODE; }
3048 #line 699 "./ircd_parser.y"
3049 { (yyval.num) = PRIV_SET; }
3053 #line 700 "./ircd_parser.y"
3054 { (yyval.num) = PRIV_WHOX; }
3058 #line 701 "./ircd_parser.y"
3059 { (yyval.num) = PRIV_BADCHAN; }
3063 #line 702 "./ircd_parser.y"
3064 { (yyval.num) = PRIV_LOCAL_BADCHAN; }
3068 #line 703 "./ircd_parser.y"
3069 { (yyval.num) = PRIV_SEE_CHAN; }
3073 #line 704 "./ircd_parser.y"
3074 { (yyval.num) = PRIV_SHOW_INVIS; }
3078 #line 705 "./ircd_parser.y"
3079 { (yyval.num) = PRIV_SHOW_ALL_INVIS; }
3083 #line 706 "./ircd_parser.y"
3084 { (yyval.num) = PRIV_PROPAGATE; }
3088 #line 707 "./ircd_parser.y"
3089 { (yyval.num) = PRIV_UNLIMIT_QUERY; }
3093 #line 708 "./ircd_parser.y"
3094 { (yyval.num) = PRIV_DISPLAY; }
3098 #line 709 "./ircd_parser.y"
3099 { (yyval.num) = PRIV_SEE_OPERS; }
3103 #line 710 "./ircd_parser.y"
3104 { (yyval.num) = PRIV_WIDE_GLINE; }
3108 #line 711 "./ircd_parser.y"
3109 { (yyval.num) = PRIV_LIST_CHAN; }
3113 #line 712 "./ircd_parser.y"
3114 { (yyval.num) = PRIV_PROPAGATE; invert = 1; }
3118 #line 713 "./ircd_parser.y"
3119 { (yyval.num) = PRIV_FORCE_OPMODE; }
3123 #line 714 "./ircd_parser.y"
3124 { (yyval.num) = PRIV_FORCE_LOCAL_OPMODE; }
3128 #line 715 "./ircd_parser.y"
3129 { (yyval.num) = PRIV_NOAMSG_OVERRIDE; }
3133 #line 716 "./ircd_parser.y"
3134 { (yyval.num) = PRIV_APASS_OPMODE; }
3138 #line 718 "./ircd_parser.y"
3139 { (yyval.num) = 1; }
3143 #line 718 "./ircd_parser.y"
3144 { (yyval.num) = 0; }
3148 #line 724 "./ircd_parser.y"
3149 { (yyval.num) = 0; }
3153 #line 725 "./ircd_parser.y"
3154 { (yyval.num) = USE_IPV4; }
3158 #line 726 "./ircd_parser.y"
3159 { (yyval.num) = USE_IPV6; }
3163 #line 727 "./ircd_parser.y"
3164 { (yyval.num) = USE_IPV4 | USE_IPV6; }
3168 #line 728 "./ircd_parser.y"
3169 { (yyval.num) = USE_IPV6 | USE_IPV4; }
3173 #line 732 "./ircd_parser.y"
3175 struct ListenerFlags flags_here;
3177 if (hosts == NULL) {
3180 DupString(link->value.cp, "*");
3185 for (link = hosts; link != NULL; link = link->next) {
3186 memcpy(&flags_here, &listen_flags, sizeof(&flags_here));
3187 switch (link->flags & (USE_IPV4 | USE_IPV6)) {
3189 FlagSet(&flags_here, LISTEN_IPV4);
3192 FlagSet(&flags_here, LISTEN_IPV6);
3194 default: /* 0 or USE_IPV4|USE_IPV6 */
3195 FlagSet(&flags_here, LISTEN_IPV4);
3196 FlagSet(&flags_here, LISTEN_IPV6);
3199 if (link->flags & 65535)
3200 port = link->flags & 65535;
3201 add_listener(port, link->value.cp, pass, &flags_here);
3205 memset(&listen_flags, 0, sizeof(listen_flags));
3212 #line 770 "./ircd_parser.y"
3214 if ((yyvsp[(4) - (5)].num) < 1 || (yyvsp[(4) - (5)].num) > 65535) {
3215 parse_error("Port %d is out of range", port);
3217 port = (yyvsp[(3) - (5)].num) | (yyvsp[(4) - (5)].num);
3218 if (hosts && (0 == (hosts->flags & 65535)))
3219 hosts->flags = (hosts->flags & ~65535) | port;
3225 #line 781 "./ircd_parser.y"
3229 link->value.cp = (yyvsp[(4) - (5)].text);
3230 link->flags = (yyvsp[(3) - (5)].num) | port;
3237 #line 791 "./ircd_parser.y"
3239 if ((yyvsp[(5) - (6)].num) < 1 || (yyvsp[(5) - (6)].num) > 65535) {
3240 parse_error("Port %d is out of range", port);
3244 link->value.cp = (yyvsp[(4) - (6)].text);
3245 link->flags = (yyvsp[(3) - (6)].num) | (yyvsp[(5) - (6)].num);
3253 #line 805 "./ircd_parser.y"
3256 pass = (yyvsp[(3) - (4)].text);
3261 #line 811 "./ircd_parser.y"
3263 FlagSet(&listen_flags, LISTEN_SERVER);
3268 #line 814 "./ircd_parser.y"
3270 FlagClr(&listen_flags, LISTEN_SERVER);
3275 #line 819 "./ircd_parser.y"
3277 FlagSet(&listen_flags, LISTEN_HIDDEN);
3282 #line 822 "./ircd_parser.y"
3284 FlagClr(&listen_flags, LISTEN_HIDDEN);
3289 #line 827 "./ircd_parser.y"
3291 FlagSet(&listen_flags, LISTEN_SSL);
3296 #line 830 "./ircd_parser.y"
3298 FlagClr(&listen_flags, LISTEN_SSL);
3303 #line 835 "./ircd_parser.y"
3311 #line 840 "./ircd_parser.y"
3313 struct ConfItem *aconf = 0;
3314 struct irc_in_addr addr;
3315 unsigned char addrbits = 0;
3318 parse_error("Invalid or missing class in Client block");
3319 else if (pass && strlen(pass) > PASSWDLEN)
3320 parse_error("Password too long in connect block");
3321 else if (ip && !ipmask_parse(ip, &addr, &addrbits))
3322 parse_error("Invalid IP address %s in Client block", ip);
3324 aconf = make_conf(CONF_CLIENT);
3325 aconf->username = username;
3328 memcpy(&aconf->address.addr, &addr, sizeof(aconf->address.addr));
3330 memset(&aconf->address.addr, 0, sizeof(aconf->address.addr));
3331 aconf->address.port = port;
3332 aconf->addrbits = addrbits;
3334 aconf->conn_class = c_class;
3335 aconf->maximum = maxlinks;
3336 aconf->passwd = pass;
3355 #line 883 "./ircd_parser.y"
3357 char *sep = strchr((yyvsp[(3) - (4)].text), '@');
3362 DupString(host, sep);
3363 username = (yyvsp[(3) - (4)].text);
3365 host = (yyvsp[(3) - (4)].text);
3371 #line 896 "./ircd_parser.y"
3374 sep = strchr((yyvsp[(3) - (4)].text), '@');
3380 username = (yyvsp[(3) - (4)].text);
3382 ip = (yyvsp[(3) - (4)].text);
3388 #line 910 "./ircd_parser.y"
3391 username = (yyvsp[(3) - (4)].text);
3396 #line 915 "./ircd_parser.y"
3398 c_class = find_class((yyvsp[(3) - (4)].text));
3400 parse_error("No such connection class '%s' for Client block", (yyvsp[(3) - (4)].text));
3401 MyFree((yyvsp[(3) - (4)].text));
3406 #line 922 "./ircd_parser.y"
3409 pass = (yyvsp[(3) - (4)].text);
3414 #line 927 "./ircd_parser.y"
3416 maxlinks = (yyvsp[(3) - (4)].num);
3421 #line 931 "./ircd_parser.y"
3423 port = (yyvsp[(3) - (4)].num);
3428 #line 936 "./ircd_parser.y"
3430 dconf = (struct DenyConf*) MyCalloc(1, sizeof(*dconf));
3435 #line 939 "./ircd_parser.y"
3437 if (dconf->usermask || dconf->hostmask ||dconf->realmask) {
3438 dconf->next = denyConfList;
3439 denyConfList = dconf;
3443 MyFree(dconf->usermask);
3444 MyFree(dconf->hostmask);
3445 MyFree(dconf->realmask);
3446 MyFree(dconf->message);
3448 parse_error("Kill block must match on at least one of username, host or realname");
3455 #line 958 "./ircd_parser.y"
3458 MyFree(dconf->hostmask);
3459 MyFree(dconf->usermask);
3460 if ((h = strchr((yyvsp[(3) - (4)].text), '@')) == NULL)
3462 DupString(dconf->usermask, "*");
3463 dconf->hostmask = (yyvsp[(3) - (4)].text);
3468 DupString(dconf->hostmask, h);
3469 dconf->usermask = (yyvsp[(3) - (4)].text);
3471 ipmask_parse(dconf->hostmask, &dconf->address, &dconf->bits);
3476 #line 977 "./ircd_parser.y"
3478 MyFree(dconf->usermask);
3479 dconf->usermask = (yyvsp[(3) - (4)].text);
3484 #line 983 "./ircd_parser.y"
3486 MyFree(dconf->realmask);
3487 dconf->realmask = (yyvsp[(3) - (4)].text);
3492 #line 989 "./ircd_parser.y"
3494 dconf->flags &= ~DENY_FLAGS_FILE;
3495 MyFree(dconf->message);
3496 dconf->message = (yyvsp[(3) - (4)].text);
3501 #line 996 "./ircd_parser.y"
3503 dconf->flags |= DENY_FLAGS_FILE;
3504 MyFree(dconf->message);
3505 dconf->message = (yyvsp[(3) - (4)].text);
3510 #line 1003 "./ircd_parser.y"
3517 #line 1006 "./ircd_parser.y"
3519 struct CRuleNode *node = NULL;
3523 parse_error("Missing server(s) in crule block");
3524 else if (pass == NULL)
3525 parse_error("Missing rule in crule block");
3526 else if ((node = crule_parse(pass)) == NULL)
3527 parse_error("Invalid rule '%s' in crule block", pass);
3528 else for (link = hosts; link != NULL; link = link->next)
3530 struct CRuleConf *p = (struct CRuleConf*) MyMalloc(sizeof(*p));
3532 node = crule_parse(pass);
3533 DupString(p->hostmask, link->value.cp);
3534 DupString(p->rule, pass);
3538 p->next = cruleConfList;
3549 #line 1039 "./ircd_parser.y"
3553 link->value.cp = (yyvsp[(3) - (4)].text);
3560 #line 1048 "./ircd_parser.y"
3563 pass = (yyvsp[(3) - (4)].text);
3568 #line 1054 "./ircd_parser.y"
3575 #line 1057 "./ircd_parser.y"
3582 #line 1062 "./ircd_parser.y"
3586 for (link = hosts; link != NULL; link = link->next)
3587 motd_add(link->value.cp, pass);
3595 #line 1075 "./ircd_parser.y"
3599 link->value.cp = (yyvsp[(3) - (4)].text);
3606 #line 1084 "./ircd_parser.y"
3609 pass = (yyvsp[(3) - (4)].text);
3614 #line 1093 "./ircd_parser.y"
3616 stringlist[0] = (yyvsp[(1) - (1)].text);
3622 #line 1096 "./ircd_parser.y"
3625 feature_set(NULL, (const char * const *)stringlist, stringno);
3626 for (ii = 0; ii < stringno; ++ii)
3627 MyFree(stringlist[ii]);
3632 #line 1105 "./ircd_parser.y"
3634 if (stringno < MAX_STRINGS)
3635 stringlist[stringno++] = (yyvsp[(1) - (1)].text);
3637 MyFree((yyvsp[(1) - (1)].text));
3642 #line 1115 "./ircd_parser.y"
3644 struct qline *qconf = MyCalloc(1, sizeof(*qconf));
3645 qconf->chname = (yyvsp[(1) - (4)].text);
3646 qconf->reason = (yyvsp[(3) - (4)].text);
3647 qconf->next = GlobalQuarantineList;
3648 GlobalQuarantineList = qconf;
3653 #line 1124 "./ircd_parser.y"
3655 smap = MyCalloc(1, sizeof(struct s_map));
3656 smap->command = (yyvsp[(2) - (3)].text);
3661 #line 1129 "./ircd_parser.y"
3666 parse_error("Missing name in pseudo %s block", smap->command);
3667 else if (!smap->services)
3668 parse_error("Missing nick in pseudo %s block", smap->command);
3669 else if (!strIsAlpha(smap->command))
3670 parse_error("Pseudo command %s invalid: must all be letters", smap->command);
3673 if (valid && register_mapping(smap))
3675 smap->next = GlobalServiceMapList;
3676 GlobalServiceMapList = smap;
3687 #line 1155 "./ircd_parser.y"
3690 smap->name = (yyvsp[(3) - (4)].text);
3695 #line 1160 "./ircd_parser.y"
3697 MyFree(smap->prepend);
3698 smap->prepend = (yyvsp[(3) - (4)].text);
3703 #line 1165 "./ircd_parser.y"
3705 char *sep = strchr((yyvsp[(3) - (4)].text), '@');
3708 size_t slen = strlen((yyvsp[(3) - (4)].text));
3709 struct nick_host *nh = MyMalloc(sizeof(*nh) + slen);
3710 memcpy(nh->nick, (yyvsp[(3) - (4)].text), slen + 1);
3711 nh->nicklen = sep - (yyvsp[(3) - (4)].text);
3712 nh->next = smap->services;
3713 smap->services = nh;
3715 MyFree((yyvsp[(3) - (4)].text));
3720 #line 1179 "./ircd_parser.y"
3722 smap->flags |= SMAP_FAST;
3727 #line 1184 "./ircd_parser.y"
3729 auth_spawn(stringno, stringlist, iauth_required);
3730 while (stringno > 0)
3733 MyFree(stringlist[stringno]);
3740 #line 1197 "./ircd_parser.y"
3742 while (stringno > 0)
3745 MyFree(stringlist[stringno]);
3751 #line 1206 "./ircd_parser.y"
3753 iauth_required = (yyvsp[(3) - (4)].num);
3758 #line 1210 "./ircd_parser.y"
3761 for(ii = 0; ii < 256; ++ii) {
3762 MyFree(GlobalForwards[ii]);
3768 #line 1218 "./ircd_parser.y"
3770 unsigned char ch = (yyvsp[(1) - (4)].text)[0];
3771 MyFree(GlobalForwards[ch]);
3772 GlobalForwards[ch] = (yyvsp[(3) - (4)].text);
3773 MyFree((yyvsp[(1) - (4)].text));
3778 #line 1225 "./ircd_parser.y"
3780 /* If we read a new webirc block, we create a new block. */
3781 webirc = webirc_block();
3786 #line 1228 "./ircd_parser.y"
3788 /* check for integrity */
3789 if(!webirc->name[0]) {
3790 parse_error("Every WebIRC block needs at least a name entry.");
3791 webirc_list_clear(webirc);
3796 webirc_establish(webirc);
3803 #line 1243 "./ircd_parser.y"
3806 if((len = strlen((yyvsp[(3) - (4)].text))) > 0)
3807 webirc_set(webirc, WEBIRC_PASS, (yyvsp[(3) - (4)].text), len, 0);
3808 MyFree((yyvsp[(3) - (4)].text));
3813 #line 1249 "./ircd_parser.y"
3816 if((len = strlen((yyvsp[(3) - (4)].text))) > 0)
3817 webirc_set(webirc, WEBIRC_HOST, (yyvsp[(3) - (4)].text), len, 0);
3818 MyFree((yyvsp[(3) - (4)].text));
3823 #line 1255 "./ircd_parser.y"
3826 if((len = strlen((yyvsp[(4) - (5)].text))) > 0)
3827 webirc_set(webirc, WEBIRC_HOST, (yyvsp[(4) - (5)].text), len, 1);
3828 MyFree((yyvsp[(4) - (5)].text));
3833 #line 1261 "./ircd_parser.y"
3836 if((len = strlen((yyvsp[(3) - (4)].text))) > 0)
3837 webirc_set(webirc, WEBIRC_SPOOF, (yyvsp[(3) - (4)].text), len, 0);
3838 MyFree((yyvsp[(3) - (4)].text));
3843 #line 1267 "./ircd_parser.y"
3846 if((len = strlen((yyvsp[(4) - (5)].text))) > 0)
3847 webirc_set(webirc, WEBIRC_SPOOF, (yyvsp[(4) - (5)].text), len, 1);
3848 MyFree((yyvsp[(4) - (5)].text));
3853 #line 1273 "./ircd_parser.y"
3856 if(webirc->name[0]) {
3857 MyFree((yyvsp[(3) - (4)].text));
3858 parse_error("Only one name entry per WebIRC is allowed.");
3860 else if((len = strlen((yyvsp[(3) - (4)].text))) > NICKLEN) {
3861 MyFree((yyvsp[(3) - (4)].text));
3862 parse_error("WebIRC block name length is limited to NICKLEN.");
3865 if((len = strlen((yyvsp[(3) - (4)].text))) > 0) {
3866 strcpy(webirc->name, (yyvsp[(3) - (4)].text));
3867 webirc->name[len] = '\0';
3869 MyFree((yyvsp[(3) - (4)].text));
3875 #line 1295 "./ircd_parser.y"
3877 ssl_setcert((yyvsp[(3) - (4)].text));
3878 MyFree((yyvsp[(3) - (4)].text));
3883 #line 1299 "./ircd_parser.y"
3885 ssl_addtrust((yyvsp[(3) - (4)].text));
3886 MyFree((yyvsp[(3) - (4)].text));
3891 /* Line 1267 of yacc.c. */
3892 #line 3893 "y.tab.c"
3895 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3899 YY_STACK_PRINT (yyss, yyssp);
3904 /* Now `shift' the result of the reduction. Determine what state
3905 that goes to, based on the state we popped back to and the rule
3906 number reduced by. */
3910 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3911 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3912 yystate = yytable[yystate];
3914 yystate = yydefgoto[yyn - YYNTOKENS];
3919 /*------------------------------------.
3920 | yyerrlab -- here on detecting error |
3921 `------------------------------------*/
3923 /* If not already recovering from an error, report this error. */
3927 #if ! YYERROR_VERBOSE
3928 yyerror (YY_("syntax error"));
3931 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3932 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3934 YYSIZE_T yyalloc = 2 * yysize;
3935 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3936 yyalloc = YYSTACK_ALLOC_MAXIMUM;
3937 if (yymsg != yymsgbuf)
3938 YYSTACK_FREE (yymsg);
3939 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3941 yymsg_alloc = yyalloc;
3945 yymsg_alloc = sizeof yymsgbuf;
3949 if (0 < yysize && yysize <= yymsg_alloc)
3951 (void) yysyntax_error (yymsg, yystate, yychar);
3956 yyerror (YY_("syntax error"));
3958 goto yyexhaustedlab;
3966 if (yyerrstatus == 3)
3968 /* If just tried and failed to reuse look-ahead token after an
3969 error, discard it. */
3971 if (yychar <= YYEOF)
3973 /* Return failure if at end of input. */
3974 if (yychar == YYEOF)
3979 yydestruct ("Error: discarding",
3985 /* Else will try to reuse look-ahead token after shifting the error
3990 /*---------------------------------------------------.
3991 | yyerrorlab -- error raised explicitly by YYERROR. |
3992 `---------------------------------------------------*/
3995 /* Pacify compilers like GCC when the user code never invokes
3996 YYERROR and the label yyerrorlab therefore never appears in user
3998 if (/*CONSTCOND*/ 0)
4001 /* Do not reclaim the symbols of the rule which action triggered
4005 YY_STACK_PRINT (yyss, yyssp);
4010 /*-------------------------------------------------------------.
4011 | yyerrlab1 -- common code for both syntax error and YYERROR. |
4012 `-------------------------------------------------------------*/
4014 yyerrstatus = 3; /* Each real token shifted decrements this. */
4018 yyn = yypact[yystate];
4019 if (yyn != YYPACT_NINF)
4022 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4030 /* Pop the current state because it cannot handle the error token. */
4035 yydestruct ("Error: popping",
4036 yystos[yystate], yyvsp);
4039 YY_STACK_PRINT (yyss, yyssp);
4048 /* Shift the error token. */
4049 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4055 /*-------------------------------------.
4056 | yyacceptlab -- YYACCEPT comes here. |
4057 `-------------------------------------*/
4062 /*-----------------------------------.
4063 | yyabortlab -- YYABORT comes here. |
4064 `-----------------------------------*/
4070 /*-------------------------------------------------.
4071 | yyexhaustedlab -- memory exhaustion comes here. |
4072 `-------------------------------------------------*/
4074 yyerror (YY_("memory exhausted"));
4080 if (yychar != YYEOF && yychar != YYEMPTY)
4081 yydestruct ("Cleanup: discarding lookahead",
4083 /* Do not reclaim the symbols of the rule which action triggered
4084 this YYABORT or YYACCEPT. */
4086 YY_STACK_PRINT (yyss, yyssp);
4087 while (yyssp != yyss)
4089 yydestruct ("Cleanup: popping",
4090 yystos[*yyssp], yyvsp);
4095 YYSTACK_FREE (yyss);
4098 if (yymsg != yymsgbuf)
4099 YYSTACK_FREE (yymsg);
4101 /* Make sure YYID is used. */
4102 return YYID (yyresult);
projects / ircu2.10.12-pk.git / blob