ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid-7.2/src/y.tab.c
(Generate patch)

Comparing ircd-hybrid-7.2/src/y.tab.c (file contents):
Revision 250 by adx, Tue Nov 1 11:41:52 2005 UTC vs.
Revision 251 by michael, Fri Nov 11 12:36:59 2005 UTC

# Line 1 | Line 1
1 < /* A Bison parser, made from ircd_parser.y, by GNU bison 1.75.  */
1 > /* A Bison parser, made by GNU Bison 2.1.  */
2  
3   /* Skeleton parser for Yacc-like parsing with Bison,
4 <   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software Foundation, Inc.
4 >   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5  
6     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by
# Line 15 | Line 15
15  
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18 <   Foundation, Inc., 59 Temple Place - Suite 330,
19 <   Boston, MA 02111-1307, USA.  */
18 >   Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 >   Boston, MA 02110-1301, USA.  */
20  
21   /* As a special exception, when this file is copied by Bison into a
22     Bison output file, you may use that output file without restriction.
# Line 34 | Line 34
34     USER NAME SPACE" below.  */
35  
36   /* Identify Bison output.  */
37 < #define YYBISON 1
37 > #define YYBISON 1
38 >
39 > /* Bison version.  */
40 > #define YYBISON_VERSION "2.1"
41 >
42 > /* Skeleton name.  */
43 > #define YYSKELETON_NAME "yacc.c"
44  
45   /* Pure parsers.  */
46 < #define YYPURE  0
46 > #define YYPURE 0
47  
48   /* Using locations.  */
49   #define YYLSP_NEEDED 0
# Line 304 | Line 310
310       WARN_NO_NLINE = 509
311     };
312   #endif
313 + /* Tokens.  */
314   #define ACCEPT_PASSWORD 258
315   #define ACTION 259
316   #define ADMIN 260
# Line 684 | Line 691 | unhook_hub_leaf_confs(void)
691   # define YYERROR_VERBOSE 0
692   #endif
693  
694 < #ifndef YYSTYPE
694 > /* Enabling the token table.  */
695 > #ifndef YYTOKEN_TABLE
696 > # define YYTOKEN_TABLE 0
697 > #endif
698 >
699 > #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
700   #line 134 "ircd_parser.y"
701 < typedef union {
701 > typedef union YYSTYPE {
702    int number;
703    char *string;
704 < } yystype;
705 < /* Line 193 of /usr/local/share/bison/yacc.c.  */
706 < #line 695 "y.tab.c"
707 < # define YYSTYPE yystype
704 > } YYSTYPE;
705 > /* Line 196 of yacc.c.  */
706 > #line 707 "y.tab.c"
707 > # define yystype YYSTYPE /* obsolescent; will be withdrawn */
708 > # define YYSTYPE_IS_DECLARED 1
709   # define YYSTYPE_IS_TRIVIAL 1
710   #endif
711  
712 < #ifndef YYLTYPE
700 < typedef struct yyltype
701 < {
702 <  int first_line;
703 <  int first_column;
704 <  int last_line;
705 <  int last_column;
706 < } yyltype;
707 < # define YYLTYPE yyltype
708 < # define YYLTYPE_IS_TRIVIAL 1
709 < #endif
712 >
713  
714   /* Copy the second part of user declarations.  */
715  
716  
717 < /* Line 213 of /usr/local/share/bison/yacc.c.  */
718 < #line 716 "y.tab.c"
717 > /* Line 219 of yacc.c.  */
718 > #line 719 "y.tab.c"
719 >
720 > #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
721 > # define YYSIZE_T __SIZE_TYPE__
722 > #endif
723 > #if ! defined (YYSIZE_T) && defined (size_t)
724 > # define YYSIZE_T size_t
725 > #endif
726 > #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
727 > # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
728 > # define YYSIZE_T size_t
729 > #endif
730 > #if ! defined (YYSIZE_T)
731 > # define YYSIZE_T unsigned int
732 > #endif
733 >
734 > #ifndef YY_
735 > # if YYENABLE_NLS
736 > #  if ENABLE_NLS
737 > #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
738 > #   define YY_(msgid) dgettext ("bison-runtime", msgid)
739 > #  endif
740 > # endif
741 > # ifndef YY_
742 > #  define YY_(msgid) msgid
743 > # endif
744 > #endif
745  
746   #if ! defined (yyoverflow) || YYERROR_VERBOSE
747  
748   /* The parser invokes alloca or malloc; define the necessary symbols.  */
749  
750 < # if YYSTACK_USE_ALLOCA
751 < #  define YYSTACK_ALLOC alloca
752 < # else
753 < #  ifndef YYSTACK_USE_ALLOCA
725 < #   if defined (alloca) || defined (_ALLOCA_H)
726 < #    define YYSTACK_ALLOC alloca
750 > # ifdef YYSTACK_USE_ALLOCA
751 > #  if YYSTACK_USE_ALLOCA
752 > #   ifdef __GNUC__
753 > #    define YYSTACK_ALLOC __builtin_alloca
754   #   else
755 < #    ifdef __GNUC__
756 < #     define YYSTACK_ALLOC __builtin_alloca
755 > #    define YYSTACK_ALLOC alloca
756 > #    if defined (__STDC__) || defined (__cplusplus)
757 > #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
758 > #     define YYINCLUDED_STDLIB_H
759   #    endif
760   #   endif
761   #  endif
# Line 735 | Line 764 | typedef struct yyltype
764   # ifdef YYSTACK_ALLOC
765     /* Pacify GCC's `empty if-body' warning. */
766   #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
767 + #  ifndef YYSTACK_ALLOC_MAXIMUM
768 +    /* The OS might guarantee only one guard page at the bottom of the stack,
769 +       and a page size can be as small as 4096 bytes.  So we cannot safely
770 +       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
771 +       to allow for a few compiler-allocated temporary stack slots.  */
772 + #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
773 + #  endif
774   # else
775 < #  if defined (__STDC__) || defined (__cplusplus)
776 < #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
777 < #   define YYSIZE_T size_t
775 > #  define YYSTACK_ALLOC YYMALLOC
776 > #  define YYSTACK_FREE YYFREE
777 > #  ifndef YYSTACK_ALLOC_MAXIMUM
778 > #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
779 > #  endif
780 > #  ifdef __cplusplus
781 > extern "C" {
782 > #  endif
783 > #  ifndef YYMALLOC
784 > #   define YYMALLOC malloc
785 > #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
786 >        && (defined (__STDC__) || defined (__cplusplus)))
787 > void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
788 > #   endif
789 > #  endif
790 > #  ifndef YYFREE
791 > #   define YYFREE free
792 > #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
793 >        && (defined (__STDC__) || defined (__cplusplus)))
794 > void free (void *); /* INFRINGES ON USER NAME SPACE */
795 > #   endif
796 > #  endif
797 > #  ifdef __cplusplus
798 > }
799   #  endif
743 #  define YYSTACK_ALLOC malloc
744 #  define YYSTACK_FREE free
800   # endif
801   #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
802  
803  
804   #if (! defined (yyoverflow) \
805       && (! defined (__cplusplus) \
806 <         || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
806 >         || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
807  
808   /* A type that is properly aligned for any stack member.  */
809   union yyalloc
810   {
811 <  short yyss;
811 >  short int yyss;
812    YYSTYPE yyvs;
813    };
814  
815   /* The size of the maximum gap between one aligned stack and the next.  */
816 < # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
816 > # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
817  
818   /* The size of an array large to enough to hold all stacks, each with
819     N elements.  */
820   # define YYSTACK_BYTES(N) \
821 <     ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
822 <      + YYSTACK_GAP_MAX)
821 >     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
822 >      + YYSTACK_GAP_MAXIMUM)
823  
824   /* Copy COUNT objects from FROM to TO.  The source and destination do
825     not overlap.  */
826   # ifndef YYCOPY
827 < #  if 1 < __GNUC__
827 > #  if defined (__GNUC__) && 1 < __GNUC__
828   #   define YYCOPY(To, From, Count) \
829        __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
830   #  else
831   #   define YYCOPY(To, From, Count)              \
832        do                                        \
833          {                                       \
834 <          register YYSIZE_T yyi;                \
834 >          YYSIZE_T yyi;                         \
835            for (yyi = 0; yyi < (Count); yyi++)   \
836 <            (To)[yyi] = (From)[yyi];    \
836 >            (To)[yyi] = (From)[yyi];            \
837          }                                       \
838        while (0)
839   #  endif
# Line 795 | Line 850 | union yyalloc
850          YYSIZE_T yynewbytes;                                            \
851          YYCOPY (&yyptr->Stack, Stack, yysize);                          \
852          Stack = &yyptr->Stack;                                          \
853 <        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
853 >        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
854          yyptr += yynewbytes / sizeof (*yyptr);                          \
855        }                                                                 \
856      while (0)
# Line 805 | Line 860 | union yyalloc
860   #if defined (__STDC__) || defined (__cplusplus)
861     typedef signed char yysigned_char;
862   #else
863 <   typedef short yysigned_char;
863 >   typedef short int yysigned_char;
864   #endif
865  
866   /* YYFINAL -- State number of the termination state. */
867   #define YYFINAL  2
868 + /* YYLAST -- Last index in YYTABLE.  */
869   #define YYLAST   1382
870  
871   /* YYNTOKENS -- Number of terminals. */
# Line 825 | Line 881 | union yyalloc
881   #define YYUNDEFTOK  2
882   #define YYMAXUTOK   509
883  
884 < #define YYTRANSLATE(X) \
885 <  ((unsigned)(X) <= YYMAXUTOK ? yytranslate[X] : YYUNDEFTOK)
884 > #define YYTRANSLATE(YYX)                                                \
885 >  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
886  
887   /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
888 < static const unsigned short yytranslate[] =
888 > static const unsigned short int yytranslate[] =
889   {
890         0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
891         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
# Line 887 | Line 943 | static const unsigned short yytranslate[
943   #if YYDEBUG
944   /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
945     YYRHS.  */
946 < static const unsigned short yyprhs[] =
946 > static const unsigned short int yyprhs[] =
947   {
948         0,     0,     3,     4,     7,     9,    11,    13,    15,    17,
949        19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
# Line 965 | Line 1021 | static const unsigned short yyprhs[] =
1021   };
1022  
1023   /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1024 < static const short yyrhs[] =
1024 > static const short int yyrhs[] =
1025   {
1026       261,     0,    -1,    -1,   261,   262,    -1,   286,    -1,   292,
1027        -1,   307,    -1,   567,    -1,   344,    -1,   363,    -1,   376,
# Line 1195 | Line 1251 | static const short yyrhs[] =
1251   };
1252  
1253   /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
1254 < static const unsigned short yyrline[] =
1254 > static const unsigned short int yyrline[] =
1255   {
1256         0,   392,   392,   393,   396,   397,   398,   399,   400,   401,
1257       402,   403,   404,   405,   406,   407,   408,   409,   410,   411,
1258       412,   413,   414,   415,   416,   417,   421,   421,   422,   426,
1259       430,   434,   438,   442,   448,   448,   449,   450,   451,   452,
1260       459,   462,   462,   463,   463,   463,   465,   482,   493,   496,
1261 <     496,   498,   498,   498,   499,   499,   500,   500,   501,   502,
1262 <     502,   503,   503,   506,   540,   600,   614,   632,   641,   655,
1263 <     664,   692,   722,   745,   795,   797,   797,   798,   798,   798,
1264 <     799,   801,   810,   819,   832,   834,   834,   837,   837,   837,
1265 <     838,   839,   839,   840,   840,   841,   841,   842,   842,   843,
1261 >     497,   498,   498,   499,   499,   500,   500,   501,   502,   502,
1262 >     503,   503,   504,   506,   540,   600,   614,   632,   641,   655,
1263 >     664,   692,   722,   745,   795,   797,   797,   798,   798,   799,
1264 >     799,   801,   810,   819,   832,   834,   835,   837,   837,   838,
1265 >     839,   839,   840,   840,   841,   841,   842,   842,   843,   844,
1266       846,   850,   854,   861,   868,   875,   882,   889,   896,   903,
1267       910,   914,   918,   922,   926,   930,   934,   940,   950,   949,
1268 <    1043,  1043,  1044,  1044,  1045,  1045,  1045,  1045,  1045,  1046,
1269 <    1046,  1047,  1047,  1047,  1048,  1048,  1048,  1049,  1049,  1049,
1270 <    1050,  1050,  1050,  1050,  1051,  1051,  1052,  1054,  1066,  1078,
1268 >    1043,  1043,  1044,  1044,  1045,  1045,  1045,  1045,  1046,  1046,
1269 >    1047,  1047,  1047,  1048,  1048,  1048,  1049,  1049,  1049,  1050,
1270 >    1050,  1050,  1050,  1051,  1051,  1052,  1052,  1054,  1066,  1078,
1271      1097,  1109,  1120,  1162,  1172,  1171,  1176,  1176,  1177,  1180,
1272      1183,  1186,  1189,  1192,  1195,  1198,  1201,  1204,  1207,  1210,
1273      1213,  1216,  1219,  1222,  1225,  1228,  1233,  1244,  1255,  1266,
# Line 1219 | Line 1275 | static const unsigned short yyrline[] =
1275      1388,  1387,  1391,  1391,  1392,  1392,  1393,  1393,  1395,  1402,
1276      1409,  1416,  1423,  1430,  1437,  1444,  1451,  1458,  1465,  1472,
1277      1479,  1486,  1493,  1500,  1514,  1513,  1555,  1555,  1557,  1557,
1278 <    1558,  1558,  1559,  1559,  1560,  1561,  1562,  1563,  1564,  1565,
1279 <    1566,  1567,  1568,  1569,  1572,  1581,  1590,  1596,  1602,  1608,
1278 >    1558,  1559,  1559,  1560,  1561,  1562,  1563,  1564,  1565,  1566,
1279 >    1567,  1568,  1569,  1570,  1572,  1581,  1590,  1596,  1602,  1608,
1280      1614,  1620,  1626,  1632,  1638,  1644,  1650,  1656,  1666,  1665,
1281      1682,  1681,  1685,  1685,  1686,  1690,  1696,  1696,  1697,  1697,
1282      1697,  1697,  1697,  1699,  1701,  1701,  1703,  1718,  1740,  1749,
1283 <    1762,  1761,  1830,  1830,  1831,  1831,  1831,  1831,  1831,  1832,
1284 <    1832,  1833,  1833,  1833,  1834,  1834,  1835,  1835,  1835,  1836,
1283 >    1762,  1761,  1830,  1830,  1831,  1831,  1831,  1831,  1832,  1832,
1284 >    1833,  1833,  1833,  1834,  1834,  1835,  1835,  1835,  1836,  1836,
1285      1836,  1838,  1857,  1870,  1881,  1890,  1902,  1901,  1905,  1905,
1286      1906,  1906,  1907,  1907,  1909,  1917,  1924,  1931,  1938,  1945,
1287      1952,  1959,  1966,  1973,  1982,  1993,  2004,  2015,  2026,  2037,
# Line 1236 | Line 1292 | static const unsigned short yyrline[] =
1292      2251,  2250,  2267,  2267,  2268,  2268,  2268,  2270,  2277,  2276,
1293      2282,  2282,  2283,  2287,  2291,  2295,  2299,  2303,  2307,  2311,
1294      2315,  2319,  2323,  2333,  2332,  2482,  2482,  2483,  2483,  2484,
1295 <    2484,  2484,  2484,  2485,  2485,  2486,  2486,  2487,  2487,  2487,
1296 <    2488,  2488,  2488,  2489,  2489,  2489,  2490,  2490,  2493,  2505,
1295 >    2484,  2484,  2485,  2485,  2486,  2486,  2487,  2487,  2487,  2488,
1296 >    2488,  2488,  2489,  2489,  2489,  2490,  2490,  2491,  2493,  2505,
1297      2517,  2526,  2552,  2570,  2588,  2594,  2598,  2606,  2616,  2615,
1298      2619,  2619,  2620,  2620,  2621,  2621,  2623,  2630,  2641,  2648,
1299      2655,  2662,  2672,  2713,  2724,  2735,  2750,  2761,  2774,  2787,
# Line 1246 | Line 1302 | static const unsigned short yyrline[] =
1302      2954,  2954,  2954,  2956,  2965,  2977,  2979,  2979,  2980,  2980,
1303      2982,  3004,  3003,  3045,  3044,  3048,  3048,  3049,  3055,  3055,
1304      3056,  3056,  3056,  3056,  3058,  3064,  3073,  3076,  3076,  3077,
1305 <    3077,  3077,  3078,  3078,  3079,  3079,  3080,  3080,  3081,  3081,
1306 <    3082,  3082,  3083,  3083,  3084,  3084,  3085,  3085,  3086,  3086,
1307 <    3087,  3087,  3088,  3088,  3089,  3089,  3090,  3090,  3091,  3091,
1308 <    3092,  3092,  3093,  3093,  3094,  3094,  3095,  3095,  3096,  3096,
1309 <    3097,  3098,  3098,  3099,  3099,  3100,  3100,  3101,  3101,  3102,
1310 <    3102,  3103,  3103,  3104,  3109,  3114,  3119,  3124,  3129,  3134,
1305 >    3077,  3078,  3078,  3079,  3079,  3080,  3080,  3081,  3081,  3082,
1306 >    3082,  3083,  3083,  3084,  3084,  3085,  3085,  3086,  3086,  3087,
1307 >    3087,  3088,  3088,  3089,  3089,  3090,  3090,  3091,  3091,  3092,
1308 >    3092,  3093,  3093,  3094,  3094,  3095,  3095,  3096,  3096,  3097,
1309 >    3098,  3098,  3099,  3099,  3100,  3100,  3101,  3101,  3102,  3102,
1310 >    3103,  3103,  3104,  3105,  3109,  3114,  3119,  3124,  3129,  3134,
1311      3139,  3144,  3149,  3154,  3159,  3164,  3169,  3174,  3179,  3184,
1312      3189,  3194,  3200,  3211,  3216,  3225,  3230,  3235,  3240,  3245,
1313      3248,  3253,  3256,  3261,  3266,  3271,  3276,  3281,  3286,  3291,
# Line 1261 | Line 1317 | static const unsigned short yyrline[] =
1317      3460,  3463,  3466,  3469,  3472,  3478,  3477,  3482,  3482,  3483,
1318      3486,  3489,  3492,  3495,  3498,  3501,  3504,  3507,  3510,  3513,
1319      3516,  3519,  3522,  3525,  3528,  3531,  3534,  3539,  3544,  3549,
1320 <    3554,  3559,  3568,  3567,  3591,  3591,  3592,  3592,  3593,  3594,
1321 <    3595,  3596,  3597,  3600,  3606,  3613,  3612,  3617,  3617,  3618,
1320 >    3554,  3559,  3568,  3567,  3591,  3591,  3592,  3593,  3594,  3595,
1321 >    3596,  3597,  3598,  3600,  3606,  3613,  3612,  3617,  3617,  3618,
1322      3622,  3628,  3647,  3657,  3656,  3706,  3706,  3707,  3711,  3720,
1323 <    3723,  3723,  3724,  3724,  3724,  3725,  3725,  3726,  3726,  3727,
1324 <    3727,  3728,  3728,  3729,  3730,  3730,  3731,  3731,  3732,  3732,
1323 >    3723,  3723,  3724,  3724,  3725,  3725,  3726,  3726,  3727,  3727,
1324 >    3728,  3728,  3729,  3730,  3730,  3731,  3731,  3732,  3732,  3733,
1325      3735,  3740,  3745,  3750,  3755,  3760,  3765,  3770,  3775,  3780,
1326      3785,  3790,  3795,  3800,  3805,  3810,  3815,  3823,  3826,  3826,
1327 <    3827,  3827,  3827,  3828,  3829,  3830,  3830,  3831,  3834,  3840,
1327 >    3827,  3827,  3828,  3829,  3830,  3830,  3831,  3832,  3834,  3840,
1328      3846,  3855,  3869,  3875,  3881
1329   };
1330   #endif
1331  
1332 < #if YYDEBUG || YYERROR_VERBOSE
1333 < /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1332 > #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1333 > /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1334     First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1335   static const char *const yytname[] =
1336   {
1337 <  "$end", "error", "$undefined", "ACCEPT_PASSWORD", "ACTION", "ADMIN",
1338 <  "AFTYPE", "T_ALLOW", "ANTI_NICK_FLOOD", "ANTI_SPAM_EXIT_MESSAGE_TIME",
1339 <  "AUTOCONN", "T_BLOCK", "BURST_AWAY", "BURST_TOPICWHO", "BYTES",
1340 <  "KBYTES", "MBYTES", "GBYTES", "TBYTES", "CALLER_ID_WAIT", "CAN_FLOOD",
1341 <  "CAN_IDLE", "CHANNEL", "CIDR_BITLEN_IPV4", "CIDR_BITLEN_IPV6",
1342 <  "CIPHER_PREFERENCE", "CLASS", "COMPRESSED", "COMPRESSION_LEVEL",
1343 <  "CONNECT", "CONNECTFREQ", "CRYPTLINK", "DEFAULT_CIPHER_PREFERENCE",
1344 <  "DEFAULT_FLOODCOUNT", "DEFAULT_SPLIT_SERVER_COUNT",
1345 <  "DEFAULT_SPLIT_USER_COUNT", "DENY", "DESCRIPTION", "DIE",
1346 <  "DISABLE_AUTH", "DISABLE_HIDDEN", "DISABLE_LOCAL_CHANNELS",
1347 <  "DISABLE_REMOTE_COMMANDS", "DOT_IN_IP6_ADDR", "DOTS_IN_IDENT",
1348 <  "DURATION", "EGDPOOL_PATH", "EMAIL", "ENABLE", "ENCRYPTED",
1349 <  "EXCEED_LIMIT", "EXEMPT", "FAILED_OPER_NOTICE", "FAKENAME",
1350 <  "IRCD_FLAGS", "FLATTEN_LINKS", "FFAILED_OPERLOG", "FKILLLOG",
1351 <  "FKLINELOG", "FGLINELOG", "FIOERRLOG", "FOPERLOG", "FOPERSPYLOG",
1352 <  "FUSERLOG", "GECOS", "GENERAL", "GLINE", "GLINES", "GLINE_EXEMPT",
1353 <  "GLINE_LOG", "GLINE_TIME", "GLINE_MIN_CIDR", "GLINE_MIN_CIDR6",
1354 <  "GLOBAL_KILL", "IRCD_AUTH", "NEED_IDENT", "HAVENT_READ_CONF", "HIDDEN",
1355 <  "HIDDEN_ADMIN", "HIDDEN_NAME", "HIDDEN_OPER", "HIDE_SERVER_IPS",
1356 <  "HIDE_SERVERS", "HIDE_SPOOF_IPS", "HOST", "HUB", "HUB_MASK", "IDLETIME",
1357 <  "IGNORE_BOGUS_TS", "INVISIBLE_ON_CONNECT", "IP", "KILL",
1358 <  "KILL_CHASE_TIME_LIMIT", "KLINE", "KLINE_EXEMPT", "KLINE_REASON",
1359 <  "KLINE_WITH_REASON", "KNOCK_DELAY", "KNOCK_DELAY_CHANNEL", "LAZYLINK",
1360 <  "LEAF_MASK", "LINKS_DELAY", "LISTEN", "T_LOG", "LOGGING", "LOG_LEVEL",
1361 <  "MAX_ACCEPT", "MAX_BANS", "MAX_CHANS_PER_USER", "MAX_GLOBAL",
1362 <  "MAX_IDENT", "MAX_LOCAL", "MAX_NICK_CHANGES", "MAX_NICK_TIME",
1363 <  "MAX_NUMBER", "MAX_TARGETS", "MESSAGE_LOCALE", "MIN_NONWILDCARD",
1364 <  "MIN_NONWILDCARD_SIMPLE", "MODULE", "MODULES", "NAME", "NEED_PASSWORD",
1365 <  "NETWORK_DESC", "NETWORK_NAME", "NICK", "NICK_CHANGES",
1366 <  "NO_CREATE_ON_SPLIT", "NO_JOIN_ON_SPLIT", "NO_OPER_FLOOD", "NO_TILDE",
1367 <  "NOT", "NUMBER", "NUMBER_PER_IDENT", "NUMBER_PER_CIDR", "NUMBER_PER_IP",
1368 <  "NUMBER_PER_IP_GLOBAL", "OPERATOR", "OPERS_BYPASS_CALLERID", "OPER_LOG",
1369 <  "OPER_ONLY_UMODES", "OPER_PASS_RESV", "OPER_SPY_T", "OPER_UMODES",
1370 <  "JOIN_FLOOD_COUNT", "JOIN_FLOOD_TIME", "PACE_WAIT", "PACE_WAIT_SIMPLE",
1371 <  "PASSWORD", "PATH", "PING_COOKIE", "PING_TIME", "PING_WARNING", "PORT",
1372 <  "QSTRING", "QUIET_ON_BAN", "REASON", "REDIRPORT", "REDIRSERV",
1373 <  "REGEX_T", "REHASH", "TREJECT_HOLD_TIME", "REMOTE", "REMOTEBAN",
1374 <  "RESTRICT_CHANNELS", "RESTRICTED", "RSA_PRIVATE_KEY_FILE",
1375 <  "RSA_PUBLIC_KEY_FILE", "SSL_CERTIFICATE_FILE", "RESV", "RESV_EXEMPT",
1376 <  "SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS", "SENDQ",
1377 <  "SEND_PASSWORD", "SERVERHIDE", "SERVERINFO", "SERVLINK_PATH",
1378 <  "IRCD_SID", "TKLINE_EXPIRE_NOTICES", "T_SHARED", "T_CLUSTER", "TYPE",
1379 <  "SHORT_MOTD", "SILENT", "SPOOF", "SPOOF_NOTICE", "STATS_I_OPER_ONLY",
1380 <  "STATS_K_OPER_ONLY", "STATS_O_OPER_ONLY", "STATS_P_OPER_ONLY", "TBOOL",
1381 <  "TMASKED", "T_REJECT", "TS_MAX_DELTA", "TS_WARN_DELTA", "TWODOTS",
1382 <  "T_ALL", "T_BOTS", "T_SOFTCALLERID", "T_CALLERID", "T_CCONN",
1383 <  "T_CLIENT_FLOOD", "T_DEAF", "T_DEBUG", "T_DRONE", "T_EXTERNAL",
1384 <  "T_FULL", "T_INVISIBLE", "T_IPV4", "T_IPV6", "T_LOCOPS", "T_LOGPATH",
1385 <  "T_L_CRIT", "T_L_DEBUG", "T_L_ERROR", "T_L_INFO", "T_L_NOTICE",
1386 <  "T_L_TRACE", "T_L_WARN", "T_MAX_CLIENTS", "T_NCHANGE", "T_OPERWALL",
1387 <  "T_REJ", "T_SERVNOTICE", "T_SKILL", "T_SPY", "T_SSL", "T_UMODES",
1388 <  "T_UNAUTH", "T_UNRESV", "T_UNXLINE", "T_WALLOP", "THROTTLE_TIME",
1389 <  "TOPICBURST", "TRUE_NO_OPER_FLOOD", "TKLINE", "TXLINE", "TRESV",
1390 <  "UNKLINE", "USER", "USE_EGD", "USE_EXCEPT", "USE_INVEX", "USE_KNOCK",
1391 <  "USE_LOGGING", "USE_WHOIS_ACTUALLY", "VHOST", "VHOST6", "XLINE", "WARN",
1392 <  "WARN_NO_NLINE", "';'", "'}'", "'{'", "'='", "','", "$accept", "conf",
1393 <  "conf_item", "timespec_", "timespec", "sizespec_", "sizespec",
1394 <  "modules_entry", "modules_items", "modules_item", "modules_module",
1395 <  "modules_path", "serverinfo_entry", "serverinfo_items",
1396 <  "serverinfo_item", "serverinfo_ssl_certificate_file",
1397 <  "serverinfo_rsa_private_key_file", "serverinfo_name", "serverinfo_sid",
1398 <  "serverinfo_description", "serverinfo_network_name",
1399 <  "serverinfo_network_desc", "serverinfo_vhost", "serverinfo_vhost6",
1400 <  "serverinfo_max_clients", "serverinfo_hub", "admin_entry",
1401 <  "admin_items", "admin_item", "admin_name", "admin_email",
1402 <  "admin_description", "logging_entry", "logging_items", "logging_item",
1403 <  "logging_path", "logging_oper_log", "logging_fuserlog",
1404 <  "logging_ffailed_operlog", "logging_foperlog", "logging_foperspylog",
1405 <  "logging_fglinelog", "logging_fklinelog", "logging_ioerrlog",
1406 <  "logging_killlog", "logging_log_level", "logging_use_logging",
1407 <  "oper_entry", "@1", "oper_name_b", "oper_items", "oper_item",
1408 <  "oper_name", "oper_name_t", "oper_user", "oper_password",
1409 <  "oper_encrypted", "oper_rsa_public_key_file", "oper_class",
1410 <  "oper_umodes", "@2", "oper_umodes_items", "oper_umodes_item",
1411 <  "oper_global_kill", "oper_remote", "oper_remoteban", "oper_kline",
1412 <  "oper_xline", "oper_unkline", "oper_gline", "oper_nick_changes",
1413 <  "oper_die", "oper_rehash", "oper_admin", "oper_hidden_admin",
1414 <  "oper_hidden_oper", "oper_operwall", "oper_flags", "@3",
1415 <  "oper_flags_items", "oper_flags_item", "@4", "@5",
1416 <  "oper_flags_item_atom", "class_entry", "@6", "class_name_b",
1417 <  "class_items", "class_item", "class_name", "class_name_t",
1418 <  "class_ping_time", "class_ping_warning", "class_number_per_ip",
1419 <  "class_connectfreq", "class_max_number", "class_max_global",
1420 <  "class_max_local", "class_max_ident", "class_sendq",
1421 <  "class_cidr_bitlen_ipv4", "class_cidr_bitlen_ipv6",
1422 <  "class_number_per_cidr", "listen_entry", "@7", "listen_flags", "@8",
1423 <  "listen_flags_items", "listen_flags_item", "listen_items",
1424 <  "listen_item", "listen_port", "port_items", "port_item",
1425 <  "listen_address", "listen_host", "auth_entry", "@9", "auth_items",
1426 <  "auth_item", "auth_user", "auth_passwd", "auth_spoof_notice",
1427 <  "auth_class", "auth_encrypted", "auth_flags", "@10", "auth_flags_items",
1428 <  "auth_flags_item", "@11", "@12", "auth_flags_item_atom",
1429 <  "auth_kline_exempt", "auth_need_ident", "auth_exceed_limit",
1430 <  "auth_can_flood", "auth_no_tilde", "auth_gline_exempt", "auth_spoof",
1431 <  "auth_redir_serv", "auth_redir_port", "auth_need_password",
1432 <  "resv_entry", "@13", "resv_items", "resv_item", "resv_creason",
1433 <  "resv_channel", "resv_nick", "shared_entry", "@14", "shared_items",
1434 <  "shared_item", "shared_name", "shared_user", "shared_type", "@15",
1435 <  "shared_types", "shared_type_item", "cluster_entry", "@16",
1436 <  "cluster_items", "cluster_item", "cluster_name", "cluster_type", "@17",
1437 <  "cluster_types", "cluster_type_item", "connect_entry", "@18",
1438 <  "connect_name_b", "connect_items", "connect_item", "connect_name",
1439 <  "connect_name_t", "connect_host", "connect_vhost",
1440 <  "connect_send_password", "connect_accept_password", "connect_port",
1441 <  "connect_aftype", "connect_fakename", "connect_flags", "@19",
1442 <  "connect_flags_items", "connect_flags_item", "@20", "@21",
1443 <  "connect_flags_item_atom", "connect_rsa_public_key_file",
1444 <  "connect_encrypted", "connect_cryptlink", "connect_compressed",
1445 <  "connect_auto", "connect_hub_mask", "connect_leaf_mask",
1446 <  "connect_class", "connect_cipher_preference", "kill_entry", "@22",
1447 <  "kill_type", "@23", "kill_type_items", "kill_type_item", "kill_items",
1448 <  "kill_item", "kill_user", "kill_reason", "deny_entry", "@24",
1449 <  "deny_items", "deny_item", "deny_ip", "deny_reason", "exempt_entry",
1450 <  "exempt_items", "exempt_item", "exempt_ip", "gecos_entry", "@25",
1451 <  "gecos_flags", "@26", "gecos_flags_items", "gecos_flags_item",
1452 <  "gecos_items", "gecos_item", "gecos_name", "gecos_reason",
1453 <  "general_entry", "general_items", "general_item",
1454 <  "general_gline_min_cidr", "general_gline_min_cidr6",
1455 <  "general_burst_away", "general_use_whois_actually",
1456 <  "general_reject_hold_time", "general_tkline_expire_notices",
1457 <  "general_kill_chase_time_limit", "general_hide_spoof_ips",
1458 <  "general_ignore_bogus_ts", "general_disable_remote_commands",
1459 <  "general_failed_oper_notice", "general_anti_nick_flood",
1460 <  "general_max_nick_time", "general_max_nick_changes",
1461 <  "general_max_accept", "general_anti_spam_exit_message_time",
1462 <  "general_ts_warn_delta", "general_ts_max_delta",
1463 <  "general_havent_read_conf", "general_kline_with_reason",
1464 <  "general_kline_reason", "general_invisible_on_connect",
1465 <  "general_warn_no_nline", "general_stats_o_oper_only",
1466 <  "general_stats_P_oper_only", "general_stats_k_oper_only",
1467 <  "general_stats_i_oper_only", "general_pace_wait",
1468 <  "general_caller_id_wait", "general_opers_bypass_callerid",
1469 <  "general_pace_wait_simple", "general_short_motd",
1470 <  "general_no_oper_flood", "general_true_no_oper_flood",
1471 <  "general_oper_pass_resv", "general_message_locale", "general_idletime",
1472 <  "general_dots_in_ident", "general_max_targets", "general_servlink_path",
1473 <  "general_default_cipher_preference", "general_compression_level",
1474 <  "general_use_egd", "general_egdpool_path", "general_ping_cookie",
1475 <  "general_disable_auth", "general_throttle_time", "general_oper_umodes",
1476 <  "@27", "umode_oitems", "umode_oitem", "general_oper_only_umodes", "@28",
1477 <  "umode_items", "umode_item", "general_min_nonwildcard",
1478 <  "general_min_nonwildcard_simple", "general_default_floodcount",
1479 <  "general_client_flood", "general_dot_in_ip6_addr", "gline_entry", "@29",
1480 <  "gline_items", "gline_item", "gline_enable", "gline_duration",
1481 <  "gline_logging", "@30", "gline_logging_types",
1482 <  "gline_logging_type_item", "gline_user", "gline_server", "gline_action",
1483 <  "@31", "gdeny_types", "gdeny_type_item", "channel_entry",
1484 <  "channel_items", "channel_item", "channel_restrict_channels",
1485 <  "channel_disable_local_channels", "channel_use_except",
1486 <  "channel_use_invex", "channel_use_knock", "channel_knock_delay",
1487 <  "channel_knock_delay_channel", "channel_max_chans_per_user",
1488 <  "channel_quiet_on_ban", "channel_max_bans",
1489 <  "channel_default_split_user_count",
1490 <  "channel_default_split_server_count", "channel_no_create_on_split",
1435 <  "channel_no_join_on_split", "channel_burst_topicwho",
1436 <  "channel_jflood_count", "channel_jflood_time", "serverhide_entry",
1437 <  "serverhide_items", "serverhide_item", "serverhide_flatten_links",
1438 <  "serverhide_hide_servers", "serverhide_hidden_name",
1439 <  "serverhide_links_delay", "serverhide_hidden",
1337 >  "$end", "error", "$undefined", "ACCEPT_PASSWORD", "ACTION", "ADMIN",
1338 >  "AFTYPE", "T_ALLOW", "ANTI_NICK_FLOOD", "ANTI_SPAM_EXIT_MESSAGE_TIME",
1339 >  "AUTOCONN", "T_BLOCK", "BURST_AWAY", "BURST_TOPICWHO", "BYTES", "KBYTES",
1340 >  "MBYTES", "GBYTES", "TBYTES", "CALLER_ID_WAIT", "CAN_FLOOD", "CAN_IDLE",
1341 >  "CHANNEL", "CIDR_BITLEN_IPV4", "CIDR_BITLEN_IPV6", "CIPHER_PREFERENCE",
1342 >  "CLASS", "COMPRESSED", "COMPRESSION_LEVEL", "CONNECT", "CONNECTFREQ",
1343 >  "CRYPTLINK", "DEFAULT_CIPHER_PREFERENCE", "DEFAULT_FLOODCOUNT",
1344 >  "DEFAULT_SPLIT_SERVER_COUNT", "DEFAULT_SPLIT_USER_COUNT", "DENY",
1345 >  "DESCRIPTION", "DIE", "DISABLE_AUTH", "DISABLE_HIDDEN",
1346 >  "DISABLE_LOCAL_CHANNELS", "DISABLE_REMOTE_COMMANDS", "DOT_IN_IP6_ADDR",
1347 >  "DOTS_IN_IDENT", "DURATION", "EGDPOOL_PATH", "EMAIL", "ENABLE",
1348 >  "ENCRYPTED", "EXCEED_LIMIT", "EXEMPT", "FAILED_OPER_NOTICE", "FAKENAME",
1349 >  "IRCD_FLAGS", "FLATTEN_LINKS", "FFAILED_OPERLOG", "FKILLLOG",
1350 >  "FKLINELOG", "FGLINELOG", "FIOERRLOG", "FOPERLOG", "FOPERSPYLOG",
1351 >  "FUSERLOG", "GECOS", "GENERAL", "GLINE", "GLINES", "GLINE_EXEMPT",
1352 >  "GLINE_LOG", "GLINE_TIME", "GLINE_MIN_CIDR", "GLINE_MIN_CIDR6",
1353 >  "GLOBAL_KILL", "IRCD_AUTH", "NEED_IDENT", "HAVENT_READ_CONF", "HIDDEN",
1354 >  "HIDDEN_ADMIN", "HIDDEN_NAME", "HIDDEN_OPER", "HIDE_SERVER_IPS",
1355 >  "HIDE_SERVERS", "HIDE_SPOOF_IPS", "HOST", "HUB", "HUB_MASK", "IDLETIME",
1356 >  "IGNORE_BOGUS_TS", "INVISIBLE_ON_CONNECT", "IP", "KILL",
1357 >  "KILL_CHASE_TIME_LIMIT", "KLINE", "KLINE_EXEMPT", "KLINE_REASON",
1358 >  "KLINE_WITH_REASON", "KNOCK_DELAY", "KNOCK_DELAY_CHANNEL", "LAZYLINK",
1359 >  "LEAF_MASK", "LINKS_DELAY", "LISTEN", "T_LOG", "LOGGING", "LOG_LEVEL",
1360 >  "MAX_ACCEPT", "MAX_BANS", "MAX_CHANS_PER_USER", "MAX_GLOBAL",
1361 >  "MAX_IDENT", "MAX_LOCAL", "MAX_NICK_CHANGES", "MAX_NICK_TIME",
1362 >  "MAX_NUMBER", "MAX_TARGETS", "MESSAGE_LOCALE", "MIN_NONWILDCARD",
1363 >  "MIN_NONWILDCARD_SIMPLE", "MODULE", "MODULES", "NAME", "NEED_PASSWORD",
1364 >  "NETWORK_DESC", "NETWORK_NAME", "NICK", "NICK_CHANGES",
1365 >  "NO_CREATE_ON_SPLIT", "NO_JOIN_ON_SPLIT", "NO_OPER_FLOOD", "NO_TILDE",
1366 >  "NOT", "NUMBER", "NUMBER_PER_IDENT", "NUMBER_PER_CIDR", "NUMBER_PER_IP",
1367 >  "NUMBER_PER_IP_GLOBAL", "OPERATOR", "OPERS_BYPASS_CALLERID", "OPER_LOG",
1368 >  "OPER_ONLY_UMODES", "OPER_PASS_RESV", "OPER_SPY_T", "OPER_UMODES",
1369 >  "JOIN_FLOOD_COUNT", "JOIN_FLOOD_TIME", "PACE_WAIT", "PACE_WAIT_SIMPLE",
1370 >  "PASSWORD", "PATH", "PING_COOKIE", "PING_TIME", "PING_WARNING", "PORT",
1371 >  "QSTRING", "QUIET_ON_BAN", "REASON", "REDIRPORT", "REDIRSERV", "REGEX_T",
1372 >  "REHASH", "TREJECT_HOLD_TIME", "REMOTE", "REMOTEBAN",
1373 >  "RESTRICT_CHANNELS", "RESTRICTED", "RSA_PRIVATE_KEY_FILE",
1374 >  "RSA_PUBLIC_KEY_FILE", "SSL_CERTIFICATE_FILE", "RESV", "RESV_EXEMPT",
1375 >  "SECONDS", "MINUTES", "HOURS", "DAYS", "WEEKS", "SENDQ", "SEND_PASSWORD",
1376 >  "SERVERHIDE", "SERVERINFO", "SERVLINK_PATH", "IRCD_SID",
1377 >  "TKLINE_EXPIRE_NOTICES", "T_SHARED", "T_CLUSTER", "TYPE", "SHORT_MOTD",
1378 >  "SILENT", "SPOOF", "SPOOF_NOTICE", "STATS_I_OPER_ONLY",
1379 >  "STATS_K_OPER_ONLY", "STATS_O_OPER_ONLY", "STATS_P_OPER_ONLY", "TBOOL",
1380 >  "TMASKED", "T_REJECT", "TS_MAX_DELTA", "TS_WARN_DELTA", "TWODOTS",
1381 >  "T_ALL", "T_BOTS", "T_SOFTCALLERID", "T_CALLERID", "T_CCONN",
1382 >  "T_CLIENT_FLOOD", "T_DEAF", "T_DEBUG", "T_DRONE", "T_EXTERNAL", "T_FULL",
1383 >  "T_INVISIBLE", "T_IPV4", "T_IPV6", "T_LOCOPS", "T_LOGPATH", "T_L_CRIT",
1384 >  "T_L_DEBUG", "T_L_ERROR", "T_L_INFO", "T_L_NOTICE", "T_L_TRACE",
1385 >  "T_L_WARN", "T_MAX_CLIENTS", "T_NCHANGE", "T_OPERWALL", "T_REJ",
1386 >  "T_SERVNOTICE", "T_SKILL", "T_SPY", "T_SSL", "T_UMODES", "T_UNAUTH",
1387 >  "T_UNRESV", "T_UNXLINE", "T_WALLOP", "THROTTLE_TIME", "TOPICBURST",
1388 >  "TRUE_NO_OPER_FLOOD", "TKLINE", "TXLINE", "TRESV", "UNKLINE", "USER",
1389 >  "USE_EGD", "USE_EXCEPT", "USE_INVEX", "USE_KNOCK", "USE_LOGGING",
1390 >  "USE_WHOIS_ACTUALLY", "VHOST", "VHOST6", "XLINE", "WARN",
1391 >  "WARN_NO_NLINE", "';'", "'}'", "'{'", "'='", "','", "$accept", "conf",
1392 >  "conf_item", "timespec_", "timespec", "sizespec_", "sizespec",
1393 >  "modules_entry", "modules_items", "modules_item", "modules_module",
1394 >  "modules_path", "serverinfo_entry", "serverinfo_items",
1395 >  "serverinfo_item", "serverinfo_ssl_certificate_file",
1396 >  "serverinfo_rsa_private_key_file", "serverinfo_name", "serverinfo_sid",
1397 >  "serverinfo_description", "serverinfo_network_name",
1398 >  "serverinfo_network_desc", "serverinfo_vhost", "serverinfo_vhost6",
1399 >  "serverinfo_max_clients", "serverinfo_hub", "admin_entry", "admin_items",
1400 >  "admin_item", "admin_name", "admin_email", "admin_description",
1401 >  "logging_entry", "logging_items", "logging_item", "logging_path",
1402 >  "logging_oper_log", "logging_fuserlog", "logging_ffailed_operlog",
1403 >  "logging_foperlog", "logging_foperspylog", "logging_fglinelog",
1404 >  "logging_fklinelog", "logging_ioerrlog", "logging_killlog",
1405 >  "logging_log_level", "logging_use_logging", "oper_entry", "@1",
1406 >  "oper_name_b", "oper_items", "oper_item", "oper_name", "oper_name_t",
1407 >  "oper_user", "oper_password", "oper_encrypted",
1408 >  "oper_rsa_public_key_file", "oper_class", "oper_umodes", "@2",
1409 >  "oper_umodes_items", "oper_umodes_item", "oper_global_kill",
1410 >  "oper_remote", "oper_remoteban", "oper_kline", "oper_xline",
1411 >  "oper_unkline", "oper_gline", "oper_nick_changes", "oper_die",
1412 >  "oper_rehash", "oper_admin", "oper_hidden_admin", "oper_hidden_oper",
1413 >  "oper_operwall", "oper_flags", "@3", "oper_flags_items",
1414 >  "oper_flags_item", "@4", "@5", "oper_flags_item_atom", "class_entry",
1415 >  "@6", "class_name_b", "class_items", "class_item", "class_name",
1416 >  "class_name_t", "class_ping_time", "class_ping_warning",
1417 >  "class_number_per_ip", "class_connectfreq", "class_max_number",
1418 >  "class_max_global", "class_max_local", "class_max_ident", "class_sendq",
1419 >  "class_cidr_bitlen_ipv4", "class_cidr_bitlen_ipv6",
1420 >  "class_number_per_cidr", "listen_entry", "@7", "listen_flags", "@8",
1421 >  "listen_flags_items", "listen_flags_item", "listen_items", "listen_item",
1422 >  "listen_port", "port_items", "port_item", "listen_address",
1423 >  "listen_host", "auth_entry", "@9", "auth_items", "auth_item",
1424 >  "auth_user", "auth_passwd", "auth_spoof_notice", "auth_class",
1425 >  "auth_encrypted", "auth_flags", "@10", "auth_flags_items",
1426 >  "auth_flags_item", "@11", "@12", "auth_flags_item_atom",
1427 >  "auth_kline_exempt", "auth_need_ident", "auth_exceed_limit",
1428 >  "auth_can_flood", "auth_no_tilde", "auth_gline_exempt", "auth_spoof",
1429 >  "auth_redir_serv", "auth_redir_port", "auth_need_password", "resv_entry",
1430 >  "@13", "resv_items", "resv_item", "resv_creason", "resv_channel",
1431 >  "resv_nick", "shared_entry", "@14", "shared_items", "shared_item",
1432 >  "shared_name", "shared_user", "shared_type", "@15", "shared_types",
1433 >  "shared_type_item", "cluster_entry", "@16", "cluster_items",
1434 >  "cluster_item", "cluster_name", "cluster_type", "@17", "cluster_types",
1435 >  "cluster_type_item", "connect_entry", "@18", "connect_name_b",
1436 >  "connect_items", "connect_item", "connect_name", "connect_name_t",
1437 >  "connect_host", "connect_vhost", "connect_send_password",
1438 >  "connect_accept_password", "connect_port", "connect_aftype",
1439 >  "connect_fakename", "connect_flags", "@19", "connect_flags_items",
1440 >  "connect_flags_item", "@20", "@21", "connect_flags_item_atom",
1441 >  "connect_rsa_public_key_file", "connect_encrypted", "connect_cryptlink",
1442 >  "connect_compressed", "connect_auto", "connect_hub_mask",
1443 >  "connect_leaf_mask", "connect_class", "connect_cipher_preference",
1444 >  "kill_entry", "@22", "kill_type", "@23", "kill_type_items",
1445 >  "kill_type_item", "kill_items", "kill_item", "kill_user", "kill_reason",
1446 >  "deny_entry", "@24", "deny_items", "deny_item", "deny_ip", "deny_reason",
1447 >  "exempt_entry", "exempt_items", "exempt_item", "exempt_ip",
1448 >  "gecos_entry", "@25", "gecos_flags", "@26", "gecos_flags_items",
1449 >  "gecos_flags_item", "gecos_items", "gecos_item", "gecos_name",
1450 >  "gecos_reason", "general_entry", "general_items", "general_item",
1451 >  "general_gline_min_cidr", "general_gline_min_cidr6",
1452 >  "general_burst_away", "general_use_whois_actually",
1453 >  "general_reject_hold_time", "general_tkline_expire_notices",
1454 >  "general_kill_chase_time_limit", "general_hide_spoof_ips",
1455 >  "general_ignore_bogus_ts", "general_disable_remote_commands",
1456 >  "general_failed_oper_notice", "general_anti_nick_flood",
1457 >  "general_max_nick_time", "general_max_nick_changes",
1458 >  "general_max_accept", "general_anti_spam_exit_message_time",
1459 >  "general_ts_warn_delta", "general_ts_max_delta",
1460 >  "general_havent_read_conf", "general_kline_with_reason",
1461 >  "general_kline_reason", "general_invisible_on_connect",
1462 >  "general_warn_no_nline", "general_stats_o_oper_only",
1463 >  "general_stats_P_oper_only", "general_stats_k_oper_only",
1464 >  "general_stats_i_oper_only", "general_pace_wait",
1465 >  "general_caller_id_wait", "general_opers_bypass_callerid",
1466 >  "general_pace_wait_simple", "general_short_motd",
1467 >  "general_no_oper_flood", "general_true_no_oper_flood",
1468 >  "general_oper_pass_resv", "general_message_locale", "general_idletime",
1469 >  "general_dots_in_ident", "general_max_targets", "general_servlink_path",
1470 >  "general_default_cipher_preference", "general_compression_level",
1471 >  "general_use_egd", "general_egdpool_path", "general_ping_cookie",
1472 >  "general_disable_auth", "general_throttle_time", "general_oper_umodes",
1473 >  "@27", "umode_oitems", "umode_oitem", "general_oper_only_umodes", "@28",
1474 >  "umode_items", "umode_item", "general_min_nonwildcard",
1475 >  "general_min_nonwildcard_simple", "general_default_floodcount",
1476 >  "general_client_flood", "general_dot_in_ip6_addr", "gline_entry", "@29",
1477 >  "gline_items", "gline_item", "gline_enable", "gline_duration",
1478 >  "gline_logging", "@30", "gline_logging_types", "gline_logging_type_item",
1479 >  "gline_user", "gline_server", "gline_action", "@31", "gdeny_types",
1480 >  "gdeny_type_item", "channel_entry", "channel_items", "channel_item",
1481 >  "channel_restrict_channels", "channel_disable_local_channels",
1482 >  "channel_use_except", "channel_use_invex", "channel_use_knock",
1483 >  "channel_knock_delay", "channel_knock_delay_channel",
1484 >  "channel_max_chans_per_user", "channel_quiet_on_ban", "channel_max_bans",
1485 >  "channel_default_split_user_count", "channel_default_split_server_count",
1486 >  "channel_no_create_on_split", "channel_no_join_on_split",
1487 >  "channel_burst_topicwho", "channel_jflood_count", "channel_jflood_time",
1488 >  "serverhide_entry", "serverhide_items", "serverhide_item",
1489 >  "serverhide_flatten_links", "serverhide_hide_servers",
1490 >  "serverhide_hidden_name", "serverhide_links_delay", "serverhide_hidden",
1491    "serverhide_disable_hidden", "serverhide_hide_server_ips", 0
1492   };
1493   #endif
# Line 1444 | Line 1495 | static const char *const yytname[] =
1495   # ifdef YYPRINT
1496   /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1497     token YYLEX-NUM.  */
1498 < static const unsigned short yytoknum[] =
1498 > static const unsigned short int yytoknum[] =
1499   {
1500         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1501       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
# Line 1476 | Line 1527 | static const unsigned short yytoknum[] =
1527   # endif
1528  
1529   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1530 < static const unsigned short yyr1[] =
1530 > static const unsigned short int yyr1[] =
1531   {
1532         0,   260,   261,   261,   262,   262,   262,   262,   262,   262,
1533       262,   262,   262,   262,   262,   262,   262,   262,   262,   262,
# Line 1634 | Line 1685 | static const unsigned char yyr2[] =
1685   /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1686     STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
1687     means the default is an error.  */
1688 < static const unsigned short yydefact[] =
1688 > static const unsigned short int yydefact[] =
1689   {
1690         2,     0,     1,     0,     0,     0,   214,   383,   456,     0,
1691       471,     0,   642,   270,   441,   248,     0,     0,   118,   324,
# Line 1785 | Line 1836 | static const unsigned short yydefact[] =
1836   };
1837  
1838   /* YYDEFGOTO[NTERM-NUM]. */
1839 < static const short yydefgoto[] =
1839 > static const short int yydefgoto[] =
1840   {
1841        -1,     1,    24,   881,   882,  1032,  1033,    25,   271,   272,
1842       273,   274,    26,   308,   309,   310,   311,   312,   313,   314,
# Line 1826 | Line 1877 | static const short yydefgoto[] =
1877   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1878     STATE-NUM.  */
1879   #define YYPACT_NINF -876
1880 < static const short yypact[] =
1880 > static const short int yypact[] =
1881   {
1882      -876,   822,  -876,  -236,  -248,  -246,  -876,  -876,  -876,  -240,
1883      -876,  -228,  -876,  -876,  -876,  -876,  -223,  -221,  -876,  -876,
# Line 1977 | Line 2028 | static const short yypact[] =
2028   };
2029  
2030   /* YYPGOTO[NTERM-NUM].  */
2031 < static const short yypgoto[] =
2031 > static const short int yypgoto[] =
2032   {
2033      -876,  -876,  -876,  -428,  -333,  -875,  -415,  -876,  -876,  1093,
2034      -876,  -876,  -876,  -876,   980,  -876,  -876,  -876,  -876,  -876,
# Line 2018 | Line 2069 | static const short yypgoto[] =
2069   /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
2070     positive, shift that token.  If negative, reduce the rule which
2071     number is the opposite.  If zero, do what YYDEFACT says.
2072 <   If YYTABLE_NINF, parse error.  */
2072 >   If YYTABLE_NINF, syntax error.  */
2073   #define YYTABLE_NINF -1
2074 < static const unsigned short yytable[] =
2074 > static const unsigned short int yytable[] =
2075   {
2076       573,   574,   717,   557,  1416,   548,  1417,   580,   120,    47,
2077      1202,    48,   475,   425,  1208,  1238,   426,    52,   120,    45,
# Line 2163 | Line 2214 | static const unsigned short yytable[] =
2214         0,     0,   533
2215   };
2216  
2217 < static const short yycheck[] =
2217 > static const short int yycheck[] =
2218   {
2219       333,   334,   417,     1,    10,     1,    12,   340,     1,   257,
2220        11,   257,     1,     1,    11,    77,     4,   257,     1,   255,
# Line 2308 | Line 2359 | static const short yycheck[] =
2359  
2360   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2361     symbol of state STATE-NUM.  */
2362 < static const unsigned short yystos[] =
2362 > static const unsigned short int yystos[] =
2363   {
2364         0,   261,     0,     1,     5,    22,    26,    29,    36,    51,
2365        64,    65,    67,    74,    91,   102,   104,   120,   137,   169,
# Line 2458 | Line 2509 | static const unsigned short yystos[] =
2509       255,   259,   418,   427,   448,   445,   343,   340,   322
2510   };
2511  
2461 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
2462 # define YYSIZE_T __SIZE_TYPE__
2463 #endif
2464 #if ! defined (YYSIZE_T) && defined (size_t)
2465 # define YYSIZE_T size_t
2466 #endif
2467 #if ! defined (YYSIZE_T)
2468 # if defined (__STDC__) || defined (__cplusplus)
2469 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
2470 #  define YYSIZE_T size_t
2471 # endif
2472 #endif
2473 #if ! defined (YYSIZE_T)
2474 # define YYSIZE_T unsigned int
2475 #endif
2476
2512   #define yyerrok         (yyerrstatus = 0)
2513   #define yyclearin       (yychar = YYEMPTY)
2514 < #define YYEMPTY         -2
2514 > #define YYEMPTY         (-2)
2515   #define YYEOF           0
2516  
2517   #define YYACCEPT        goto yyacceptlab
2518   #define YYABORT         goto yyabortlab
2519 < #define YYERROR         goto yyerrlab1
2519 > #define YYERROR         goto yyerrorlab
2520 >
2521  
2522   /* Like YYERROR except do call yyerror.  This remains here temporarily
2523     to ease the transition to the new meaning of YYERROR, for GCC.
# Line 2497 | Line 2533 | do                                                             \
2533      {                                                           \
2534        yychar = (Token);                                         \
2535        yylval = (Value);                                         \
2536 <      yychar1 = YYTRANSLATE (yychar);                           \
2536 >      yytoken = YYTRANSLATE (yychar);                           \
2537        YYPOPSTACK;                                               \
2538        goto yybackup;                                            \
2539      }                                                           \
2540    else                                                          \
2541 <    {                                                           \
2542 <      yyerror ("syntax error: cannot back up");                 \
2541 >    {                                                           \
2542 >      yyerror (YY_("syntax error: cannot back up")); \
2543        YYERROR;                                                  \
2544      }                                                           \
2545   while (0)
2546  
2547 +
2548   #define YYTERROR        1
2549   #define YYERRCODE       256
2550  
2514 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
2515   are run).  */
2551  
2552 + /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
2553 +   If N is 0, then set CURRENT to the empty location which ends
2554 +   the previous symbol: RHS[0] (always defined).  */
2555 +
2556 + #define YYRHSLOC(Rhs, K) ((Rhs)[K])
2557   #ifndef YYLLOC_DEFAULT
2558 < # define YYLLOC_DEFAULT(Current, Rhs, N)           \
2559 <  Current.first_line   = Rhs[1].first_line;      \
2560 <  Current.first_column = Rhs[1].first_column;    \
2561 <  Current.last_line    = Rhs[N].last_line;       \
2562 <  Current.last_column  = Rhs[N].last_column;
2558 > # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
2559 >    do                                                                  \
2560 >      if (N)                                                            \
2561 >        {                                                               \
2562 >          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
2563 >          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
2564 >          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
2565 >          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
2566 >        }                                                               \
2567 >      else                                                              \
2568 >        {                                                               \
2569 >          (Current).first_line   = (Current).last_line   =              \
2570 >            YYRHSLOC (Rhs, 0).last_line;                                \
2571 >          (Current).first_column = (Current).last_column =              \
2572 >            YYRHSLOC (Rhs, 0).last_column;                              \
2573 >        }                                                               \
2574 >    while (0)
2575 > #endif
2576 >
2577 >
2578 > /* YY_LOCATION_PRINT -- Print the location on the stream.
2579 >   This macro was not mandated originally: define only if we know
2580 >   we won't break user code: when these are the locations we know.  */
2581 >
2582 > #ifndef YY_LOCATION_PRINT
2583 > # if YYLTYPE_IS_TRIVIAL
2584 > #  define YY_LOCATION_PRINT(File, Loc)                  \
2585 >     fprintf (File, "%d.%d-%d.%d",                      \
2586 >              (Loc).first_line, (Loc).first_column,     \
2587 >              (Loc).last_line,  (Loc).last_column)
2588 > # else
2589 > #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2590 > # endif
2591   #endif
2592  
2593 +
2594   /* YYLEX -- calling `yylex' with the right arguments.  */
2595  
2596 < #define YYLEX   yylex ()
2596 > #ifdef YYLEX_PARAM
2597 > # define YYLEX yylex (YYLEX_PARAM)
2598 > #else
2599 > # define YYLEX yylex ()
2600 > #endif
2601  
2602   /* Enable debugging if requested.  */
2603   #if YYDEBUG
# Line 2539 | Line 2612 | do {                                           \
2612    if (yydebug)                                  \
2613      YYFPRINTF Args;                             \
2614   } while (0)
2615 < # define YYDSYMPRINT(Args)                      \
2616 < do {                                            \
2617 <  if (yydebug)                                  \
2618 <    yysymprint Args;                            \
2615 >
2616 > # define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
2617 > do {                                                            \
2618 >  if (yydebug)                                                  \
2619 >    {                                                           \
2620 >      YYFPRINTF (stderr, "%s ", Title);                         \
2621 >      yysymprint (stderr,                                       \
2622 >                  Type, Value); \
2623 >      YYFPRINTF (stderr, "\n");                                 \
2624 >    }                                                           \
2625   } while (0)
2626 +
2627 + /*------------------------------------------------------------------.
2628 + | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2629 + | TOP (included).                                                   |
2630 + `------------------------------------------------------------------*/
2631 +
2632 + #if defined (__STDC__) || defined (__cplusplus)
2633 + static void
2634 + yy_stack_print (short int *bottom, short int *top)
2635 + #else
2636 + static void
2637 + yy_stack_print (bottom, top)
2638 +    short int *bottom;
2639 +    short int *top;
2640 + #endif
2641 + {
2642 +  YYFPRINTF (stderr, "Stack now");
2643 +  for (/* Nothing. */; bottom <= top; ++bottom)
2644 +    YYFPRINTF (stderr, " %d", *bottom);
2645 +  YYFPRINTF (stderr, "\n");
2646 + }
2647 +
2648 + # define YY_STACK_PRINT(Bottom, Top)                            \
2649 + do {                                                            \
2650 +  if (yydebug)                                                  \
2651 +    yy_stack_print ((Bottom), (Top));                           \
2652 + } while (0)
2653 +
2654 +
2655 + /*------------------------------------------------.
2656 + | Report that the YYRULE is going to be reduced.  |
2657 + `------------------------------------------------*/
2658 +
2659 + #if defined (__STDC__) || defined (__cplusplus)
2660 + static void
2661 + yy_reduce_print (int yyrule)
2662 + #else
2663 + static void
2664 + yy_reduce_print (yyrule)
2665 +    int yyrule;
2666 + #endif
2667 + {
2668 +  int yyi;
2669 +  unsigned long int yylno = yyrline[yyrule];
2670 +  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
2671 +             yyrule - 1, yylno);
2672 +  /* Print the symbols being reduced, and their result.  */
2673 +  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
2674 +    YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
2675 +  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
2676 + }
2677 +
2678 + # define YY_REDUCE_PRINT(Rule)          \
2679 + do {                                    \
2680 +  if (yydebug)                          \
2681 +    yy_reduce_print (Rule);             \
2682 + } while (0)
2683 +
2684   /* Nonzero means print parse trace.  It is left uninitialized so that
2685     multiple parsers can coexist.  */
2686   int yydebug;
2687   #else /* !YYDEBUG */
2688   # define YYDPRINTF(Args)
2689 < # define YYDSYMPRINT(Args)
2689 > # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2690 > # define YY_STACK_PRINT(Bottom, Top)
2691 > # define YY_REDUCE_PRINT(Rule)
2692   #endif /* !YYDEBUG */
2693  
2694 +
2695   /* YYINITDEPTH -- initial size of the parser's stacks.  */
2696   #ifndef YYINITDEPTH
2697   # define YYINITDEPTH 200
# Line 2561 | Line 2701 | int yydebug;
2701     if the built-in stack extension method is used).
2702  
2703     Do not make this value too large; the results are undefined if
2704 <   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
2704 >   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2705     evaluated with infinite-precision integer arithmetic.  */
2706  
2567 #if YYMAXDEPTH == 0
2568 # undef YYMAXDEPTH
2569 #endif
2570
2707   #ifndef YYMAXDEPTH
2708   # define YYMAXDEPTH 10000
2709   #endif
# Line 2589 | Line 2725 | yystrlen (yystr)
2725       const char *yystr;
2726   #   endif
2727   {
2728 <  register const char *yys = yystr;
2728 >  const char *yys = yystr;
2729  
2730    while (*yys++ != '\0')
2731      continue;
# Line 2614 | Line 2750 | yystpcpy (yydest, yysrc)
2750       const char *yysrc;
2751   #   endif
2752   {
2753 <  register char *yyd = yydest;
2754 <  register const char *yys = yysrc;
2753 >  char *yyd = yydest;
2754 >  const char *yys = yysrc;
2755  
2756    while ((*yyd++ = *yys++) != '\0')
2757      continue;
# Line 2625 | Line 2761 | yystpcpy (yydest, yysrc)
2761   #  endif
2762   # endif
2763  
2764 < #endif /* !YYERROR_VERBOSE */
2764 > # ifndef yytnamerr
2765 > /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2766 >   quotes and backslashes, so that it's suitable for yyerror.  The
2767 >   heuristic is that double-quoting is unnecessary unless the string
2768 >   contains an apostrophe, a comma, or backslash (other than
2769 >   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
2770 >   null, do not copy; instead, return the length of what the result
2771 >   would have been.  */
2772 > static YYSIZE_T
2773 > yytnamerr (char *yyres, const char *yystr)
2774 > {
2775 >  if (*yystr == '"')
2776 >    {
2777 >      size_t yyn = 0;
2778 >      char const *yyp = yystr;
2779 >
2780 >      for (;;)
2781 >        switch (*++yyp)
2782 >          {
2783 >          case '\'':
2784 >          case ',':
2785 >            goto do_not_strip_quotes;
2786 >
2787 >          case '\\':
2788 >            if (*++yyp != '\\')
2789 >              goto do_not_strip_quotes;
2790 >            /* Fall through.  */
2791 >          default:
2792 >            if (yyres)
2793 >              yyres[yyn] = *yyp;
2794 >            yyn++;
2795 >            break;
2796 >
2797 >          case '"':
2798 >            if (yyres)
2799 >              yyres[yyn] = '\0';
2800 >            return yyn;
2801 >          }
2802 >    do_not_strip_quotes: ;
2803 >    }
2804 >
2805 >  if (! yyres)
2806 >    return yystrlen (yystr);
2807 >
2808 >  return yystpcpy (yyres, yystr) - yyres;
2809 > }
2810 > # endif
2811 >
2812 > #endif /* YYERROR_VERBOSE */
2813  
2814  
2815  
2816   #if YYDEBUG
2817 < /*-----------------------------.
2818 < | Print this symbol on YYOUT.  |
2819 < `-----------------------------*/
2817 > /*--------------------------------.
2818 > | Print this symbol on YYOUTPUT.  |
2819 > `--------------------------------*/
2820  
2637 static void
2821   #if defined (__STDC__) || defined (__cplusplus)
2822 < yysymprint (FILE* yyout, int yytype, YYSTYPE yyvalue)
2822 > static void
2823 > yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
2824   #else
2825 < yysymprint (yyout, yytype, yyvalue)
2826 <    FILE* yyout;
2825 > static void
2826 > yysymprint (yyoutput, yytype, yyvaluep)
2827 >    FILE *yyoutput;
2828      int yytype;
2829 <    YYSTYPE yyvalue;
2829 >    YYSTYPE *yyvaluep;
2830   #endif
2831   {
2832    /* Pacify ``unused variable'' warnings.  */
2833 <  (void) yyvalue;
2833 >  (void) yyvaluep;
2834  
2835    if (yytype < YYNTOKENS)
2836 <    {
2652 <      YYFPRINTF (yyout, "token %s (", yytname[yytype]);
2653 < # ifdef YYPRINT
2654 <      YYPRINT (yyout, yytoknum[yytype], yyvalue);
2655 < # endif
2656 <    }
2836 >    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2837    else
2838 <    YYFPRINTF (yyout, "nterm %s (", yytname[yytype]);
2838 >    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2839  
2840 +
2841 + # ifdef YYPRINT
2842 +  if (yytype < YYNTOKENS)
2843 +    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2844 + # endif
2845    switch (yytype)
2846      {
2847        default:
2848          break;
2849      }
2850 <  YYFPRINTF (yyout, ")");
2850 >  YYFPRINTF (yyoutput, ")");
2851   }
2667 #endif /* YYDEBUG. */
2668
2852  
2853 + #endif /* ! YYDEBUG */
2854   /*-----------------------------------------------.
2855   | Release the memory associated to this symbol.  |
2856   `-----------------------------------------------*/
2857  
2674 static void
2858   #if defined (__STDC__) || defined (__cplusplus)
2859 < yydestruct (int yytype, YYSTYPE yyvalue)
2859 > static void
2860 > yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2861   #else
2862 < yydestruct (yytype, yyvalue)
2862 > static void
2863 > yydestruct (yymsg, yytype, yyvaluep)
2864 >    const char *yymsg;
2865      int yytype;
2866 <    YYSTYPE yyvalue;
2866 >    YYSTYPE *yyvaluep;
2867   #endif
2868   {
2869    /* Pacify ``unused variable'' warnings.  */
2870 <  (void) yyvalue;
2870 >  (void) yyvaluep;
2871 >
2872 >  if (!yymsg)
2873 >    yymsg = "Deleting";
2874 >  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2875  
2876    switch (yytype)
2877      {
2878 +
2879        default:
2880          break;
2881      }
2882   }
2692
2883  
2884  
2885 < /* The user can define YYPARSE_PARAM as the name of an argument to be passed
2696 <   into yyparse.  The argument should have type void *.
2697 <   It should actually point to an object.
2698 <   Grammar actions can access the variable by casting it
2699 <   to the proper pointer type.  */
2885 > /* Prevent warnings from -Wmissing-prototypes.  */
2886  
2887   #ifdef YYPARSE_PARAM
2888   # if defined (__STDC__) || defined (__cplusplus)
2889 < #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
2704 < #  define YYPARSE_PARAM_DECL
2889 > int yyparse (void *YYPARSE_PARAM);
2890   # else
2891 < #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
2707 < #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
2891 > int yyparse ();
2892   # endif
2893 < #else /* !YYPARSE_PARAM */
2894 < # define YYPARSE_PARAM_ARG
2711 < # define YYPARSE_PARAM_DECL
2712 < #endif /* !YYPARSE_PARAM */
2713 <
2714 < /* Prevent warning if -Wstrict-prototypes.  */
2715 < #ifdef __GNUC__
2716 < # ifdef YYPARSE_PARAM
2717 < int yyparse (void *);
2718 < # else
2893 > #else /* ! YYPARSE_PARAM */
2894 > #if defined (__STDC__) || defined (__cplusplus)
2895   int yyparse (void);
2896 < # endif
2896 > #else
2897 > int yyparse ();
2898   #endif
2899 + #endif /* ! YYPARSE_PARAM */
2900  
2901  
2902 < /* The lookahead symbol.  */
2902 >
2903 > /* The look-ahead symbol.  */
2904   int yychar;
2905  
2906 < /* The semantic value of the lookahead symbol.  */
2906 > /* The semantic value of the look-ahead symbol.  */
2907   YYSTYPE yylval;
2908  
2909 < /* Number of parse errors so far.  */
2909 > /* Number of syntax errors so far.  */
2910   int yynerrs;
2911  
2912  
2913 +
2914 + /*----------.
2915 + | yyparse.  |
2916 + `----------*/
2917 +
2918 + #ifdef YYPARSE_PARAM
2919 + # if defined (__STDC__) || defined (__cplusplus)
2920 + int yyparse (void *YYPARSE_PARAM)
2921 + # else
2922 + int yyparse (YYPARSE_PARAM)
2923 +  void *YYPARSE_PARAM;
2924 + # endif
2925 + #else /* ! YYPARSE_PARAM */
2926 + #if defined (__STDC__) || defined (__cplusplus)
2927   int
2928 < yyparse (YYPARSE_PARAM_ARG)
2929 <     YYPARSE_PARAM_DECL
2928 > yyparse (void)
2929 > #else
2930 > int
2931 > yyparse ()
2932 >    ;
2933 > #endif
2934 > #endif
2935   {
2936    
2937 <  register int yystate;
2938 <  register int yyn;
2937 >  int yystate;
2938 >  int yyn;
2939    int yyresult;
2940    /* Number of tokens to shift before error messages enabled.  */
2941    int yyerrstatus;
2942 <  /* Lookahead token as an internal (translated) token number.  */
2943 <  int yychar1 = 0;
2942 >  /* Look-ahead token as an internal (translated) token number.  */
2943 >  int yytoken = 0;
2944  
2945    /* Three stacks and their tools:
2946       `yyss': related to states,
# Line 2753 | Line 2951 | yyparse (YYPARSE_PARAM_ARG)
2951       to reallocate them elsewhere.  */
2952  
2953    /* The state stack.  */
2954 <  short yyssa[YYINITDEPTH];
2955 <  short *yyss = yyssa;
2956 <  register short *yyssp;
2954 >  short int yyssa[YYINITDEPTH];
2955 >  short int *yyss = yyssa;
2956 >  short int *yyssp;
2957  
2958    /* The semantic value stack.  */
2959    YYSTYPE yyvsa[YYINITDEPTH];
2960    YYSTYPE *yyvs = yyvsa;
2961 <  register YYSTYPE *yyvsp;
2961 >  YYSTYPE *yyvsp;
2962  
2963  
2964  
# Line 2806 | Line 3004 | yyparse (YYPARSE_PARAM_ARG)
3004   yysetstate:
3005    *yyssp = yystate;
3006  
3007 <  if (yyssp >= yyss + yystacksize - 1)
3007 >  if (yyss + yystacksize - 1 <= yyssp)
3008      {
3009        /* Get the current used size of the three stacks, in elements.  */
3010        YYSIZE_T yysize = yyssp - yyss + 1;
# Line 2817 | Line 3015 | yyparse (YYPARSE_PARAM_ARG)
3015             these so that the &'s don't force the real ones into
3016             memory.  */
3017          YYSTYPE *yyvs1 = yyvs;
3018 <        short *yyss1 = yyss;
3018 >        short int *yyss1 = yyss;
3019  
3020  
3021          /* Each stack pointer address is followed by the size of the
3022             data in use in that stack, in bytes.  This used to be a
3023             conditional around just the two extra args, but that might
3024             be undefined if yyoverflow is a macro.  */
3025 <        yyoverflow ("parser stack overflow",
3025 >        yyoverflow (YY_("memory exhausted"),
3026                      &yyss1, yysize * sizeof (*yyssp),
3027                      &yyvs1, yysize * sizeof (*yyvsp),
3028  
# Line 2835 | Line 3033 | yyparse (YYPARSE_PARAM_ARG)
3033        }
3034   #else /* no yyoverflow */
3035   # ifndef YYSTACK_RELOCATE
3036 <      goto yyoverflowlab;
3036 >      goto yyexhaustedlab;
3037   # else
3038        /* Extend the stack our own way.  */
3039 <      if (yystacksize >= YYMAXDEPTH)
3040 <        goto yyoverflowlab;
3039 >      if (YYMAXDEPTH <= yystacksize)
3040 >        goto yyexhaustedlab;
3041        yystacksize *= 2;
3042 <      if (yystacksize > YYMAXDEPTH)
3042 >      if (YYMAXDEPTH < yystacksize)
3043          yystacksize = YYMAXDEPTH;
3044  
3045        {
3046 <        short *yyss1 = yyss;
3046 >        short int *yyss1 = yyss;
3047          union yyalloc *yyptr =
3048            (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3049          if (! yyptr)
3050 <          goto yyoverflowlab;
3050 >          goto yyexhaustedlab;
3051          YYSTACK_RELOCATE (yyss);
3052          YYSTACK_RELOCATE (yyvs);
3053  
# Line 2867 | Line 3065 | yyparse (YYPARSE_PARAM_ARG)
3065        YYDPRINTF ((stderr, "Stack size increased to %lu\n",
3066                    (unsigned long int) yystacksize));
3067  
3068 <      if (yyssp >= yyss + yystacksize - 1)
3068 >      if (yyss + yystacksize - 1 <= yyssp)
3069          YYABORT;
3070      }
3071  
# Line 2881 | Line 3079 | yyparse (YYPARSE_PARAM_ARG)
3079   yybackup:
3080  
3081   /* Do appropriate processing given the current state.  */
3082 < /* Read a lookahead token if we need one and don't already have one.  */
3082 > /* Read a look-ahead token if we need one and don't already have one.  */
3083   /* yyresume: */
3084  
3085 <  /* First try to decide what to do without reference to lookahead token.  */
3085 >  /* First try to decide what to do without reference to look-ahead token.  */
3086  
3087    yyn = yypact[yystate];
3088    if (yyn == YYPACT_NINF)
3089      goto yydefault;
3090  
3091 <  /* Not known => get a lookahead token if don't already have one.  */
2894 <
2895 <  /* yychar is either YYEMPTY or YYEOF
2896 <     or a valid token in external form.  */
3091 >  /* Not known => get a look-ahead token if don't already have one.  */
3092  
3093 +  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
3094    if (yychar == YYEMPTY)
3095      {
3096        YYDPRINTF ((stderr, "Reading a token: "));
3097        yychar = YYLEX;
3098      }
3099  
3100 <  /* Convert token to internal form (in yychar1) for indexing tables with.  */
2905 <
2906 <  if (yychar <= 0)              /* This means end of input.  */
3100 >  if (yychar <= YYEOF)
3101      {
3102 <      yychar1 = 0;
2909 <      yychar = YYEOF;           /* Don't call YYLEX any more.  */
2910 <
3102 >      yychar = yytoken = YYEOF;
3103        YYDPRINTF ((stderr, "Now at end of input.\n"));
3104      }
3105    else
3106      {
3107 <      yychar1 = YYTRANSLATE (yychar);
3108 <
2917 <      /* We have to keep this `#if YYDEBUG', since we use variables
2918 <         which are defined only if `YYDEBUG' is set.  */
2919 <      YYDPRINTF ((stderr, "Next token is "));
2920 <      YYDSYMPRINT ((stderr, yychar1, yylval));
2921 <      YYDPRINTF ((stderr, "\n"));
3107 >      yytoken = YYTRANSLATE (yychar);
3108 >      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3109      }
3110  
3111 <  /* If the proper action on seeing token YYCHAR1 is to reduce or to
3111 >  /* If the proper action on seeing token YYTOKEN is to reduce or to
3112       detect an error, take that action.  */
3113 <  yyn += yychar1;
3114 <  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
3113 >  yyn += yytoken;
3114 >  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3115      goto yydefault;
3116    yyn = yytable[yyn];
3117    if (yyn <= 0)
# Line 2938 | Line 3125 | yybackup:
3125    if (yyn == YYFINAL)
3126      YYACCEPT;
3127  
3128 <  /* Shift the lookahead token.  */
3129 <  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
2943 <              yychar, yytname[yychar1]));
3128 >  /* Shift the look-ahead token.  */
3129 >  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3130  
3131    /* Discard the token being shifted unless it is eof.  */
3132    if (yychar != YYEOF)
# Line 2986 | Line 3172 | yyreduce:
3172    yyval = yyvsp[1-yylen];
3173  
3174  
3175 <
2990 < #if YYDEBUG
2991 <  /* We have to keep this `#if YYDEBUG', since we use variables which
2992 <     are defined only if `YYDEBUG' is set.  */
2993 <  if (yydebug)
2994 <    {
2995 <      int yyi;
2996 <
2997 <      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
2998 <                 yyn - 1, yyrline[yyn]);
2999 <
3000 <      /* Print the symbols being reduced, and their result.  */
3001 <      for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
3002 <        YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
3003 <      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
3004 <    }
3005 < #endif
3175 >  YY_REDUCE_PRINT (yyn);
3176    switch (yyn)
3177      {
3178          case 26:
3179   #line 421 "ircd_parser.y"
3180 <    { yyval.number = 0; }
3180 >    { (yyval.number) = 0; }
3181      break;
3182  
3183    case 28:
3184   #line 423 "ircd_parser.y"
3185      {
3186 <                        yyval.number = yyvsp[-1].number + yyvsp[0].number;
3186 >                        (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number);
3187                  }
3188      break;
3189  
3190    case 29:
3191   #line 427 "ircd_parser.y"
3192      {
3193 <                        yyval.number = yyvsp[-2].number + yyvsp[0].number;
3193 >                        (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number);
3194                  }
3195      break;
3196  
3197    case 30:
3198   #line 431 "ircd_parser.y"
3199      {
3200 <                        yyval.number = yyvsp[-2].number * 60 + yyvsp[0].number;
3200 >                        (yyval.number) = (yyvsp[-2].number) * 60 + (yyvsp[0].number);
3201                  }
3202      break;
3203  
3204    case 31:
3205   #line 435 "ircd_parser.y"
3206      {
3207 <                        yyval.number = yyvsp[-2].number * 60 * 60 + yyvsp[0].number;
3207 >                        (yyval.number) = (yyvsp[-2].number) * 60 * 60 + (yyvsp[0].number);
3208                  }
3209      break;
3210  
3211    case 32:
3212   #line 439 "ircd_parser.y"
3213      {
3214 <                        yyval.number = yyvsp[-2].number * 60 * 60 * 24 + yyvsp[0].number;
3214 >                        (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 + (yyvsp[0].number);
3215                  }
3216      break;
3217  
3218    case 33:
3219   #line 443 "ircd_parser.y"
3220      {
3221 <                        yyval.number = yyvsp[-2].number * 60 * 60 * 24 * 7 + yyvsp[0].number;
3221 >                        (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 7 + (yyvsp[0].number);
3222                  }
3223      break;
3224  
3225    case 34:
3226   #line 448 "ircd_parser.y"
3227 <    { yyval.number = 0; }
3227 >    { (yyval.number) = 0; }
3228      break;
3229  
3230    case 36:
3231   #line 449 "ircd_parser.y"
3232 <    { yyval.number = yyvsp[-1].number + yyvsp[0].number; }
3232 >    { (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number); }
3233      break;
3234  
3235    case 37:
3236   #line 450 "ircd_parser.y"
3237 <    { yyval.number = yyvsp[-2].number + yyvsp[0].number; }
3237 >    { (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number); }
3238      break;
3239  
3240    case 38:
3241   #line 451 "ircd_parser.y"
3242 <    { yyval.number = yyvsp[-2].number * 1024 + yyvsp[0].number; }
3242 >    { (yyval.number) = (yyvsp[-2].number) * 1024 + (yyvsp[0].number); }
3243      break;
3244  
3245    case 39:
3246   #line 452 "ircd_parser.y"
3247 <    { yyval.number = yyvsp[-2].number * 1024 * 1024 + yyvsp[0].number; }
3247 >    { (yyval.number) = (yyvsp[-2].number) * 1024 * 1024 + (yyvsp[0].number); }
3248      break;
3249  
3250    case 46:
# Line 3347 | Line 3517 | yyreduce:
3517    {
3518      recalc_fdlimit(NULL);
3519  
3520 <    if (yyvsp[-1].number < MAXCLIENTS_MIN)
3520 >    if ((yyvsp[-1].number) < MAXCLIENTS_MIN)
3521      {
3522        char buf[IRCD_BUFSIZE];
3523        ircsprintf(buf, "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
3524        yyerror(buf);
3525      }
3526 <    else if (yyvsp[-1].number > MAXCLIENTS_MAX)
3526 >    else if ((yyvsp[-1].number) > MAXCLIENTS_MAX)
3527      {
3528        char buf[IRCD_BUFSIZE];
3529        ircsprintf(buf, "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
3530        yyerror(buf);
3531      }
3532      else
3533 <      ServerInfo.max_clients = yyvsp[-1].number;
3533 >      ServerInfo.max_clients = (yyvsp[-1].number);
3534    }
3535   }
3536      break;
# Line 4407 | Line 4577 | yyreduce:
4577   #line 1591 "ircd_parser.y"
4578      {
4579    if (ypass == 1)
4580 <    PingFreq(yy_class) = yyvsp[-1].number;
4580 >    PingFreq(yy_class) = (yyvsp[-1].number);
4581   }
4582      break;
4583  
# Line 4415 | Line 4585 | yyreduce:
4585   #line 1597 "ircd_parser.y"
4586      {
4587    if (ypass == 1)
4588 <    PingWarning(yy_class) = yyvsp[-1].number;
4588 >    PingWarning(yy_class) = (yyvsp[-1].number);
4589   }
4590      break;
4591  
# Line 4423 | Line 4593 | yyreduce:
4593   #line 1603 "ircd_parser.y"
4594      {
4595    if (ypass == 1)
4596 <    MaxPerIp(yy_class) = yyvsp[-1].number;
4596 >    MaxPerIp(yy_class) = (yyvsp[-1].number);
4597   }
4598      break;
4599  
# Line 4431 | Line 4601 | yyreduce:
4601   #line 1609 "ircd_parser.y"
4602      {
4603    if (ypass == 1)
4604 <    ConFreq(yy_class) = yyvsp[-1].number;
4604 >    ConFreq(yy_class) = (yyvsp[-1].number);
4605   }
4606      break;
4607  
# Line 4439 | Line 4609 | yyreduce:
4609   #line 1615 "ircd_parser.y"
4610      {
4611    if (ypass == 1)
4612 <    MaxTotal(yy_class) = yyvsp[-1].number;
4612 >    MaxTotal(yy_class) = (yyvsp[-1].number);
4613   }
4614      break;
4615  
# Line 4447 | Line 4617 | yyreduce:
4617   #line 1621 "ircd_parser.y"
4618      {
4619    if (ypass == 1)
4620 <    MaxGlobal(yy_class) = yyvsp[-1].number;
4620 >    MaxGlobal(yy_class) = (yyvsp[-1].number);
4621   }
4622      break;
4623  
# Line 4455 | Line 4625 | yyreduce:
4625   #line 1627 "ircd_parser.y"
4626      {
4627    if (ypass == 1)
4628 <    MaxLocal(yy_class) = yyvsp[-1].number;
4628 >    MaxLocal(yy_class) = (yyvsp[-1].number);
4629   }
4630      break;
4631  
# Line 4463 | Line 4633 | yyreduce:
4633   #line 1633 "ircd_parser.y"
4634      {
4635    if (ypass == 1)
4636 <    MaxIdent(yy_class) = yyvsp[-1].number;
4636 >    MaxIdent(yy_class) = (yyvsp[-1].number);
4637   }
4638      break;
4639  
# Line 4471 | Line 4641 | yyreduce:
4641   #line 1639 "ircd_parser.y"
4642      {
4643    if (ypass == 1)
4644 <    MaxSendq(yy_class) = yyvsp[-1].number;
4644 >    MaxSendq(yy_class) = (yyvsp[-1].number);
4645   }
4646      break;
4647  
# Line 4479 | Line 4649 | yyreduce:
4649   #line 1645 "ircd_parser.y"
4650      {
4651    if (ypass == 1)
4652 <    CidrBitlenIPV4(yy_class) = yyvsp[-1].number;
4652 >    CidrBitlenIPV4(yy_class) = (yyvsp[-1].number);
4653   }
4654      break;
4655  
# Line 4487 | Line 4657 | yyreduce:
4657   #line 1651 "ircd_parser.y"
4658      {
4659    if (ypass == 1)
4660 <    CidrBitlenIPV6(yy_class) = yyvsp[-1].number;
4660 >    CidrBitlenIPV6(yy_class) = (yyvsp[-1].number);
4661   }
4662      break;
4663  
# Line 4495 | Line 4665 | yyreduce:
4665   #line 1657 "ircd_parser.y"
4666      {
4667    if (ypass == 1)
4668 <    NumberPerCidr(yy_class) = yyvsp[-1].number;
4668 >    NumberPerCidr(yy_class) = (yyvsp[-1].number);
4669   }
4670      break;
4671  
# Line 4556 | Line 4726 | yyreduce:
4726          yyerror("SSL not available - port closed");
4727          break;
4728        }
4729 <    add_listener(yyvsp[0].number, listener_address, listener_flags);
4729 >    add_listener((yyvsp[0].number), listener_address, listener_flags);
4730      listener_flags = 0;
4731    }
4732   }
# Line 4578 | Line 4748 | yyreduce:
4748          break;
4749        }
4750  
4751 <    for (i = yyvsp[-2].number; i <= yyvsp[0].number; ++i)
4751 >    for (i = (yyvsp[-2].number); i <= (yyvsp[0].number); ++i)
4752        add_listener(i, listener_address, listener_flags);
4753  
4754      listener_flags = 0;
# Line 4998 | Line 5168 | yyreduce:
5168    if (ypass == 2)
5169    {
5170      yy_aconf->flags |= CONF_FLAGS_REDIR;
5171 <    yy_aconf->port = yyvsp[-1].number;
5171 >    yy_aconf->port = (yyvsp[-1].number);
5172    }
5173   }
5174      break;
# Line 5572 | Line 5742 | yyreduce:
5742      {
5743    if (ypass == 2)
5744    {
5745 <    if (yyvsp[-1].string[0] == ':')
5745 >    if ((yyvsp[-1].string)[0] == ':')
5746        yyerror("Server passwords cannot begin with a colon");
5747 <    else if (strchr(yyvsp[-1].string, ' ') != NULL)
5747 >    else if (strchr((yyvsp[-1].string), ' ') != NULL)
5748        yyerror("Server passwords cannot contain spaces");
5749      else {
5750        if (yy_aconf->spasswd != NULL)
# Line 5592 | Line 5762 | yyreduce:
5762      {
5763    if (ypass == 2)
5764    {
5765 <    if (yyvsp[-1].string[0] == ':')
5765 >    if ((yyvsp[-1].string)[0] == ':')
5766        yyerror("Server passwords cannot begin with a colon");
5767 <    else if (strchr(yyvsp[-1].string, ' ') != NULL)
5767 >    else if (strchr((yyvsp[-1].string), ' ') != NULL)
5768        yyerror("Server passwords cannot contain spaces");
5769      else {
5770        if (yy_aconf->passwd != NULL)
# Line 5611 | Line 5781 | yyreduce:
5781   #line 2589 "ircd_parser.y"
5782      {
5783    if (ypass == 2)
5784 <    yy_aconf->port = yyvsp[-1].number;
5784 >    yy_aconf->port = (yyvsp[-1].number);
5785   }
5786      break;
5787  
# Line 6161 | Line 6331 | yyreduce:
6331    case 544:
6332   #line 3110 "ircd_parser.y"
6333      {
6334 <  ConfigFileEntry.gline_min_cidr = yyvsp[-1].number;
6334 >  ConfigFileEntry.gline_min_cidr = (yyvsp[-1].number);
6335   }
6336      break;
6337  
6338    case 545:
6339   #line 3115 "ircd_parser.y"
6340      {
6341 <  ConfigFileEntry.gline_min_cidr6 = yyvsp[-1].number;
6341 >  ConfigFileEntry.gline_min_cidr6 = (yyvsp[-1].number);
6342   }
6343      break;
6344  
# Line 6203 | Line 6373 | yyreduce:
6373    case 550:
6374   #line 3140 "ircd_parser.y"
6375      {
6376 <  ConfigFileEntry.kill_chase_time_limit = yyvsp[-1].number;
6376 >  ConfigFileEntry.kill_chase_time_limit = (yyvsp[-1].number);
6377   }
6378      break;
6379  
# Line 6245 | Line 6415 | yyreduce:
6415    case 556:
6416   #line 3170 "ircd_parser.y"
6417      {
6418 <  ConfigFileEntry.max_nick_time = yyvsp[-1].number;
6418 >  ConfigFileEntry.max_nick_time = (yyvsp[-1].number);
6419   }
6420      break;
6421  
6422    case 557:
6423   #line 3175 "ircd_parser.y"
6424      {
6425 <  ConfigFileEntry.max_nick_changes = yyvsp[-1].number;
6425 >  ConfigFileEntry.max_nick_changes = (yyvsp[-1].number);
6426   }
6427      break;
6428  
6429    case 558:
6430   #line 3180 "ircd_parser.y"
6431      {
6432 <  ConfigFileEntry.max_accept = yyvsp[-1].number;
6432 >  ConfigFileEntry.max_accept = (yyvsp[-1].number);
6433   }
6434      break;
6435  
6436    case 559:
6437   #line 3185 "ircd_parser.y"
6438      {
6439 <  ConfigFileEntry.anti_spam_exit_message_time = yyvsp[-1].number;
6439 >  ConfigFileEntry.anti_spam_exit_message_time = (yyvsp[-1].number);
6440   }
6441      break;
6442  
6443    case 560:
6444   #line 3190 "ircd_parser.y"
6445      {
6446 <  ConfigFileEntry.ts_warn_delta = yyvsp[-1].number;
6446 >  ConfigFileEntry.ts_warn_delta = (yyvsp[-1].number);
6447   }
6448      break;
6449  
# Line 6281 | Line 6451 | yyreduce:
6451   #line 3195 "ircd_parser.y"
6452      {
6453    if (ypass == 2)
6454 <    ConfigFileEntry.ts_max_delta = yyvsp[-1].number;
6454 >    ConfigFileEntry.ts_max_delta = (yyvsp[-1].number);
6455   }
6456      break;
6457  
6458    case 562:
6459   #line 3201 "ircd_parser.y"
6460      {
6461 <  if ((yyvsp[-1].number > 0) && ypass == 1)
6461 >  if (((yyvsp[-1].number) > 0) && ypass == 1)
6462    {
6463      ilog(L_CRIT, "You haven't read your config file properly.");
6464      ilog(L_CRIT, "There is a line in the example conf that will kill your server if not removed.");
# Line 6375 | Line 6545 | yyreduce:
6545    case 573:
6546   #line 3262 "ircd_parser.y"
6547      {
6548 <  ConfigFileEntry.pace_wait = yyvsp[-1].number;
6548 >  ConfigFileEntry.pace_wait = (yyvsp[-1].number);
6549   }
6550      break;
6551  
6552    case 574:
6553   #line 3267 "ircd_parser.y"
6554      {
6555 <  ConfigFileEntry.caller_id_wait = yyvsp[-1].number;
6555 >  ConfigFileEntry.caller_id_wait = (yyvsp[-1].number);
6556   }
6557      break;
6558  
# Line 6396 | Line 6566 | yyreduce:
6566    case 576:
6567   #line 3277 "ircd_parser.y"
6568      {
6569 <  ConfigFileEntry.pace_wait_simple = yyvsp[-1].number;
6569 >  ConfigFileEntry.pace_wait_simple = (yyvsp[-1].number);
6570   }
6571      break;
6572  
# Line 6444 | Line 6614 | yyreduce:
6614    case 582:
6615   #line 3313 "ircd_parser.y"
6616      {
6617 <  ConfigFileEntry.idletime = yyvsp[-1].number;
6617 >  ConfigFileEntry.idletime = (yyvsp[-1].number);
6618   }
6619      break;
6620  
6621    case 583:
6622   #line 3318 "ircd_parser.y"
6623      {
6624 <  ConfigFileEntry.dots_in_ident = yyvsp[-1].number;
6624 >  ConfigFileEntry.dots_in_ident = (yyvsp[-1].number);
6625   }
6626      break;
6627  
6628    case 584:
6629   #line 3323 "ircd_parser.y"
6630      {
6631 <  ConfigFileEntry.max_targets = yyvsp[-1].number;
6631 >  ConfigFileEntry.max_targets = (yyvsp[-1].number);
6632   }
6633      break;
6634  
# Line 6512 | Line 6682 | yyreduce:
6682      {
6683    if (ypass == 2)
6684    {
6685 <    ConfigFileEntry.compression_level = yyvsp[-1].number;
6685 >    ConfigFileEntry.compression_level = (yyvsp[-1].number);
6686   #ifndef HAVE_LIBZ
6687      yyerror("Ignoring compression_level -- no zlib support");
6688   #else
# Line 6835 | Line 7005 | yyreduce:
7005    case 637:
7006   #line 3540 "ircd_parser.y"
7007      {
7008 <  ConfigFileEntry.min_nonwildcard = yyvsp[-1].number;
7008 >  ConfigFileEntry.min_nonwildcard = (yyvsp[-1].number);
7009   }
7010      break;
7011  
7012    case 638:
7013   #line 3545 "ircd_parser.y"
7014      {
7015 <  ConfigFileEntry.min_nonwildcard_simple = yyvsp[-1].number;
7015 >  ConfigFileEntry.min_nonwildcard_simple = (yyvsp[-1].number);
7016   }
7017      break;
7018  
7019    case 639:
7020   #line 3550 "ircd_parser.y"
7021      {
7022 <  ConfigFileEntry.default_floodcount = yyvsp[-1].number;
7022 >  ConfigFileEntry.default_floodcount = (yyvsp[-1].number);
7023   }
7024      break;
7025  
7026    case 640:
7027   #line 3555 "ircd_parser.y"
7028      {
7029 <  ConfigFileEntry.client_flood = yyvsp[-1].number;
7029 >  ConfigFileEntry.client_flood = (yyvsp[-1].number);
7030   }
7031      break;
7032  
# Line 6909 | Line 7079 | yyreduce:
7079   #line 3607 "ircd_parser.y"
7080      {
7081    if (ypass == 2)
7082 <    ConfigFileEntry.gline_time = yyvsp[-1].number;
7082 >    ConfigFileEntry.gline_time = (yyvsp[-1].number);
7083   }
7084      break;
7085  
# Line 7079 | Line 7249 | yyreduce:
7249    case 695:
7250   #line 3761 "ircd_parser.y"
7251      {
7252 <  ConfigChannel.knock_delay = yyvsp[-1].number;
7252 >  ConfigChannel.knock_delay = (yyvsp[-1].number);
7253   }
7254      break;
7255  
7256    case 696:
7257   #line 3766 "ircd_parser.y"
7258      {
7259 <  ConfigChannel.knock_delay_channel = yyvsp[-1].number;
7259 >  ConfigChannel.knock_delay_channel = (yyvsp[-1].number);
7260   }
7261      break;
7262  
7263    case 697:
7264   #line 3771 "ircd_parser.y"
7265      {
7266 <  ConfigChannel.max_chans_per_user = yyvsp[-1].number;
7266 >  ConfigChannel.max_chans_per_user = (yyvsp[-1].number);
7267   }
7268      break;
7269  
# Line 7107 | Line 7277 | yyreduce:
7277    case 699:
7278   #line 3781 "ircd_parser.y"
7279      {
7280 <  ConfigChannel.max_bans = yyvsp[-1].number;
7280 >  ConfigChannel.max_bans = (yyvsp[-1].number);
7281   }
7282      break;
7283  
7284    case 700:
7285   #line 3786 "ircd_parser.y"
7286      {
7287 <  ConfigChannel.default_split_user_count = yyvsp[-1].number;
7287 >  ConfigChannel.default_split_user_count = (yyvsp[-1].number);
7288   }
7289      break;
7290  
7291    case 701:
7292   #line 3791 "ircd_parser.y"
7293      {
7294 <  ConfigChannel.default_split_server_count = yyvsp[-1].number;
7294 >  ConfigChannel.default_split_server_count = (yyvsp[-1].number);
7295   }
7296      break;
7297  
# Line 7192 | Line 7362 | yyreduce:
7362      {
7363    if (ypass == 2)
7364    {
7365 <    if ((yyvsp[-1].number > 0) && ConfigServerHide.links_disabled == 1)
7365 >    if (((yyvsp[-1].number) > 0) && ConfigServerHide.links_disabled == 1)
7366      {
7367 <      eventAddIsh("write_links_file", write_links_file, NULL, yyvsp[-1].number);
7367 >      eventAddIsh("write_links_file", write_links_file, NULL, (yyvsp[-1].number));
7368        ConfigServerHide.links_disabled = 0;
7369      }
7370  
7371 <    ConfigServerHide.links_delay = yyvsp[-1].number;
7371 >    ConfigServerHide.links_delay = (yyvsp[-1].number);
7372    }
7373   }
7374      break;
# Line 7228 | Line 7398 | yyreduce:
7398      break;
7399  
7400  
7401 +      default: break;
7402      }
7403  
7404 < /* Line 1016 of /usr/local/share/bison/yacc.c.  */
7405 < #line 7235 "y.tab.c"
7404 > /* Line 1126 of yacc.c.  */
7405 > #line 7406 "y.tab.c"
7406  
7407    yyvsp -= yylen;
7408    yyssp -= yylen;
7409  
7410  
7411 < #if YYDEBUG
7241 <  if (yydebug)
7242 <    {
7243 <      short *yyssp1 = yyss - 1;
7244 <      YYFPRINTF (stderr, "state stack now");
7245 <      while (yyssp1 != yyssp)
7246 <        YYFPRINTF (stderr, " %d", *++yyssp1);
7247 <      YYFPRINTF (stderr, "\n");
7248 <    }
7249 < #endif
7411 >  YY_STACK_PRINT (yyss, yyssp);
7412  
7413    *++yyvsp = yyval;
7414  
# Line 7279 | Line 7441 | yyerrlab:
7441  
7442        if (YYPACT_NINF < yyn && yyn < YYLAST)
7443          {
7282          YYSIZE_T yysize = 0;
7444            int yytype = YYTRANSLATE (yychar);
7445 <          char *yymsg;
7446 <          int yyx, yycount;
7445 >          YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
7446 >          YYSIZE_T yysize = yysize0;
7447 >          YYSIZE_T yysize1;
7448 >          int yysize_overflow = 0;
7449 >          char *yymsg = 0;
7450 > #         define YYERROR_VERBOSE_ARGS_MAXIMUM 5
7451 >          char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
7452 >          int yyx;
7453 >
7454 > #if 0
7455 >          /* This is so xgettext sees the translatable formats that are
7456 >             constructed on the fly.  */
7457 >          YY_("syntax error, unexpected %s");
7458 >          YY_("syntax error, unexpected %s, expecting %s");
7459 >          YY_("syntax error, unexpected %s, expecting %s or %s");
7460 >          YY_("syntax error, unexpected %s, expecting %s or %s or %s");
7461 >          YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
7462 > #endif
7463 >          char *yyfmt;
7464 >          char const *yyf;
7465 >          static char const yyunexpected[] = "syntax error, unexpected %s";
7466 >          static char const yyexpecting[] = ", expecting %s";
7467 >          static char const yyor[] = " or %s";
7468 >          char yyformat[sizeof yyunexpected
7469 >                        + sizeof yyexpecting - 1
7470 >                        + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
7471 >                           * (sizeof yyor - 1))];
7472 >          char const *yyprefix = yyexpecting;
7473  
7287          yycount = 0;
7474            /* Start YYX at -YYN if negative to avoid negative indexes in
7475               YYCHECK.  */
7476 <          for (yyx = yyn < 0 ? -yyn : 0;
7477 <               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
7476 >          int yyxbegin = yyn < 0 ? -yyn : 0;
7477 >
7478 >          /* Stay within bounds of both yycheck and yytname.  */
7479 >          int yychecklim = YYLAST - yyn;
7480 >          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
7481 >          int yycount = 1;
7482 >
7483 >          yyarg[0] = yytname[yytype];
7484 >          yyfmt = yystpcpy (yyformat, yyunexpected);
7485 >
7486 >          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
7487              if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
7488 <              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
7489 <          yysize += yystrlen ("parse error, unexpected ") + 1;
7490 <          yysize += yystrlen (yytname[yytype]);
7491 <          yymsg = (char *) YYSTACK_ALLOC (yysize);
7492 <          if (yymsg != 0)
7488 >              {
7489 >                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
7490 >                  {
7491 >                    yycount = 1;
7492 >                    yysize = yysize0;
7493 >                    yyformat[sizeof yyunexpected - 1] = '\0';
7494 >                    break;
7495 >                  }
7496 >                yyarg[yycount++] = yytname[yyx];
7497 >                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
7498 >                yysize_overflow |= yysize1 < yysize;
7499 >                yysize = yysize1;
7500 >                yyfmt = yystpcpy (yyfmt, yyprefix);
7501 >                yyprefix = yyor;
7502 >              }
7503 >
7504 >          yyf = YY_(yyformat);
7505 >          yysize1 = yysize + yystrlen (yyf);
7506 >          yysize_overflow |= yysize1 < yysize;
7507 >          yysize = yysize1;
7508 >
7509 >          if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
7510 >            yymsg = (char *) YYSTACK_ALLOC (yysize);
7511 >          if (yymsg)
7512              {
7513 <              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
7514 <              yyp = yystpcpy (yyp, yytname[yytype]);
7515 <
7516 <              if (yycount < 5)
7513 >              /* Avoid sprintf, as that infringes on the user's name space.
7514 >                 Don't have undefined behavior even if the translation
7515 >                 produced a string with the wrong number of "%s"s.  */
7516 >              char *yyp = yymsg;
7517 >              int yyi = 0;
7518 >              while ((*yyp = *yyf))
7519                  {
7520 <                  yycount = 0;
7521 <                  for (yyx = yyn < 0 ? -yyn : 0;
7522 <                       yyx < (int) (sizeof (yytname) / sizeof (char *));
7523 <                       yyx++)
7524 <                    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
7525 <                      {
7526 <                        const char *yyq = ! yycount ? ", expecting " : " or ";
7527 <                        yyp = yystpcpy (yyp, yyq);
7528 <                        yyp = yystpcpy (yyp, yytname[yyx]);
7529 <                        yycount++;
7314 <                      }
7520 >                  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
7521 >                    {
7522 >                      yyp += yytnamerr (yyp, yyarg[yyi++]);
7523 >                      yyf += 2;
7524 >                    }
7525 >                  else
7526 >                    {
7527 >                      yyp++;
7528 >                      yyf++;
7529 >                    }
7530                  }
7531                yyerror (yymsg);
7532                YYSTACK_FREE (yymsg);
7533              }
7534            else
7535 <            yyerror ("parse error; also virtual memory exhausted");
7535 >            {
7536 >              yyerror (YY_("syntax error"));
7537 >              goto yyexhaustedlab;
7538 >            }
7539          }
7540        else
7541   #endif /* YYERROR_VERBOSE */
7542 <        yyerror ("parse error");
7542 >        yyerror (YY_("syntax error"));
7543      }
7326  goto yyerrlab1;
7544  
7545  
7546 < /*----------------------------------------------------.
7330 < | yyerrlab1 -- error raised explicitly by an action.  |
7331 < `----------------------------------------------------*/
7332 < yyerrlab1:
7546 >
7547    if (yyerrstatus == 3)
7548      {
7549 <      /* If just tried and failed to reuse lookahead token after an
7549 >      /* If just tried and failed to reuse look-ahead token after an
7550           error, discard it.  */
7551  
7552 <      /* Return failure if at end of input.  */
7339 <      if (yychar == YYEOF)
7552 >      if (yychar <= YYEOF)
7553          {
7554 <          /* Pop the error token.  */
7555 <          YYPOPSTACK;
7556 <          /* Pop the rest of the stack.  */
7344 <          while (yyssp > yyss)
7345 <            {
7346 <              YYDPRINTF ((stderr, "Error: popping "));
7347 <              YYDSYMPRINT ((stderr,
7348 <                            yystos[*yyssp],
7349 <                            *yyvsp));
7350 <              YYDPRINTF ((stderr, "\n"));
7351 <              yydestruct (yystos[*yyssp], *yyvsp);
7352 <              YYPOPSTACK;
7353 <            }
7354 <          YYABORT;
7554 >          /* Return failure if at end of input.  */
7555 >          if (yychar == YYEOF)
7556 >            YYABORT;
7557          }
7558 <
7559 <      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
7560 <                  yychar, yytname[yychar1]));
7561 <      yydestruct (yychar1, yylval);
7562 <      yychar = YYEMPTY;
7558 >      else
7559 >        {
7560 >          yydestruct ("Error: discarding", yytoken, &yylval);
7561 >          yychar = YYEMPTY;
7562 >        }
7563      }
7564  
7565 <  /* Else will try to reuse lookahead token after shifting the error
7565 >  /* Else will try to reuse look-ahead token after shifting the error
7566       token.  */
7567 +  goto yyerrlab1;
7568 +
7569  
7570 + /*---------------------------------------------------.
7571 + | yyerrorlab -- error raised explicitly by YYERROR.  |
7572 + `---------------------------------------------------*/
7573 + yyerrorlab:
7574 +
7575 +  /* Pacify compilers like GCC when the user code never invokes
7576 +     YYERROR and the label yyerrorlab therefore never appears in user
7577 +     code.  */
7578 +  if (0)
7579 +     goto yyerrorlab;
7580 +
7581 + yyvsp -= yylen;
7582 +  yyssp -= yylen;
7583 +  yystate = *yyssp;
7584 +  goto yyerrlab1;
7585 +
7586 +
7587 + /*-------------------------------------------------------------.
7588 + | yyerrlab1 -- common code for both syntax error and YYERROR.  |
7589 + `-------------------------------------------------------------*/
7590 + yyerrlab1:
7591    yyerrstatus = 3;      /* Each real token shifted decrements this.  */
7592  
7593    for (;;)
# Line 7383 | Line 7608 | yyerrlab1:
7608        if (yyssp == yyss)
7609          YYABORT;
7610  
7386      YYDPRINTF ((stderr, "Error: popping "));
7387      YYDSYMPRINT ((stderr,
7388                    yystos[*yyssp], *yyvsp));
7389      YYDPRINTF ((stderr, "\n"));
7390
7391      yydestruct (yystos[yystate], *yyvsp);
7392      yyvsp--;
7393      yystate = *--yyssp;
7611  
7612 <
7613 < #if YYDEBUG
7614 <      if (yydebug)
7615 <        {
7399 <          short *yyssp1 = yyss - 1;
7400 <          YYFPRINTF (stderr, "Error: state stack now");
7401 <          while (yyssp1 != yyssp)
7402 <            YYFPRINTF (stderr, " %d", *++yyssp1);
7403 <          YYFPRINTF (stderr, "\n");
7404 <        }
7405 < #endif
7612 >      yydestruct ("Error: popping", yystos[yystate], yyvsp);
7613 >      YYPOPSTACK;
7614 >      yystate = *yyssp;
7615 >      YY_STACK_PRINT (yyss, yyssp);
7616      }
7617  
7618    if (yyn == YYFINAL)
7619      YYACCEPT;
7620  
7411  YYDPRINTF ((stderr, "Shifting error token, "));
7412
7621    *++yyvsp = yylval;
7622  
7623  
7624 +  /* Shift the error token. */
7625 +  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7626 +
7627    yystate = yyn;
7628    goto yynewstate;
7629  
# Line 7432 | Line 7643 | yyabortlab:
7643    goto yyreturn;
7644  
7645   #ifndef yyoverflow
7646 < /*----------------------------------------------.
7647 < | yyoverflowlab -- parser overflow comes here.  |
7648 < `----------------------------------------------*/
7649 < yyoverflowlab:
7650 <  yyerror ("parser stack overflow");
7646 > /*-------------------------------------------------.
7647 > | yyexhaustedlab -- memory exhaustion comes here.  |
7648 > `-------------------------------------------------*/
7649 > yyexhaustedlab:
7650 >  yyerror (YY_("memory exhausted"));
7651    yyresult = 2;
7652    /* Fall through.  */
7653   #endif
7654  
7655   yyreturn:
7656 +  if (yychar != YYEOF && yychar != YYEMPTY)
7657 +     yydestruct ("Cleanup: discarding lookahead",
7658 +                 yytoken, &yylval);
7659 +  while (yyssp != yyss)
7660 +    {
7661 +      yydestruct ("Cleanup: popping",
7662 +                  yystos[*yyssp], yyvsp);
7663 +      YYPOPSTACK;
7664 +    }
7665   #ifndef yyoverflow
7666    if (yyss != yyssa)
7667      YYSTACK_FREE (yyss);
# Line 7450 | Line 7670 | yyreturn:
7670   }
7671  
7672  
7453 #line 392 "ircd_parser.y"
7673  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines