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 618 by michael, Sat May 13 16:59:28 2006 UTC vs.
Revision 619 by michael, Tue May 23 07:22:23 2006 UTC

# Line 1 | Line 1
1 < /* A Bison parser, made by GNU Bison 2.1.  */
1 > /* A Bison parser, made by GNU Bison 2.2.  */
2  
3 < /* Skeleton parser for Yacc-like parsing with Bison,
4 <   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
3 > /* Skeleton implementation for Bison's Yacc-like parsers in C
4 >
5 >   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 >   Free Software Foundation, Inc.
7  
8     This program is free software; you can redistribute it and/or modify
9     it under the terms of the GNU General Public License as published by
# Line 18 | Line 20
20     Foundation, Inc., 51 Franklin Street, Fifth Floor,
21     Boston, MA 02110-1301, USA.  */
22  
23 < /* As a special exception, when this file is copied by Bison into a
24 <   Bison output file, you may use that output file without restriction.
25 <   This special exception was added by the Free Software Foundation
26 <   in version 1.24 of Bison.  */
23 > /* As a special exception, you may create a larger work that contains
24 >   part or all of the Bison parser skeleton and distribute that work
25 >   under terms of your choice, so long as that work isn't itself a
26 >   parser generator using the skeleton or a modified version thereof
27 >   as a parser skeleton.  Alternatively, if you modify or redistribute
28 >   the parser skeleton itself, you may (at your option) remove this
29 >   special exception, which will cause the skeleton and the resulting
30 >   Bison output files to be licensed under the GNU General Public
31 >   License without this special exception.
32 >
33 >   This special exception was added by the Free Software Foundation in
34 >   version 2.2 of Bison.  */
35  
36 < /* Written by Richard Stallman by simplifying the original so called
37 <   ``semantic'' parser.  */
36 > /* C LALR(1) parser skeleton written by Richard Stallman, by
37 >   simplifying the original so-called "semantic" parser.  */
38  
39   /* All symbols defined below should begin with yy or YY, to avoid
40     infringing on user name space.  This should be done even for local
# Line 37 | Line 47
47   #define YYBISON 1
48  
49   /* Bison version.  */
50 < #define YYBISON_VERSION "2.1"
50 > #define YYBISON_VERSION "2.2"
51  
52   /* Skeleton name.  */
53   #define YYSKELETON_NAME "yacc.c"
# Line 698 | Line 708 | unhook_hub_leaf_confs(void)
708   # define YYTOKEN_TABLE 0
709   #endif
710  
711 < #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
711 > #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
712 > typedef union YYSTYPE
713   #line 134 "ircd_parser.y"
714 < typedef union YYSTYPE {
714 > {
715    int number;
716    char *string;
717 < } YYSTYPE;
718 < /* Line 196 of yacc.c.  */
719 < #line 709 "y.tab.c"
717 > }
718 > /* Line 193 of yacc.c.  */
719 > #line 720 "y.tab.c"
720 >        YYSTYPE;
721   # define yystype YYSTYPE /* obsolescent; will be withdrawn */
722   # define YYSTYPE_IS_DECLARED 1
723   # define YYSTYPE_IS_TRIVIAL 1
# Line 716 | Line 728 | typedef union YYSTYPE {
728   /* Copy the second part of user declarations.  */
729  
730  
731 < /* Line 219 of yacc.c.  */
732 < #line 721 "y.tab.c"
731 > /* Line 216 of yacc.c.  */
732 > #line 733 "y.tab.c"
733  
734 < #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
735 < # define YYSIZE_T __SIZE_TYPE__
734 > #ifdef short
735 > # undef short
736 > #endif
737 >
738 > #ifdef YYTYPE_UINT8
739 > typedef YYTYPE_UINT8 yytype_uint8;
740 > #else
741 > typedef unsigned char yytype_uint8;
742   #endif
743 < #if ! defined (YYSIZE_T) && defined (size_t)
744 < # define YYSIZE_T size_t
743 >
744 > #ifdef YYTYPE_INT8
745 > typedef YYTYPE_INT8 yytype_int8;
746 > #elif (defined __STDC__ || defined __C99__FUNC__ \
747 >     || defined __cplusplus || defined _MSC_VER)
748 > typedef signed char yytype_int8;
749 > #else
750 > typedef short int yytype_int8;
751   #endif
752 < #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
753 < # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
754 < # define YYSIZE_T size_t
752 >
753 > #ifdef YYTYPE_UINT16
754 > typedef YYTYPE_UINT16 yytype_uint16;
755 > #else
756 > typedef unsigned short int yytype_uint16;
757   #endif
758 < #if ! defined (YYSIZE_T)
759 < # define YYSIZE_T unsigned int
758 >
759 > #ifdef YYTYPE_INT16
760 > typedef YYTYPE_INT16 yytype_int16;
761 > #else
762 > typedef short int yytype_int16;
763   #endif
764  
765 + #ifndef YYSIZE_T
766 + # ifdef __SIZE_TYPE__
767 + #  define YYSIZE_T __SIZE_TYPE__
768 + # elif defined size_t
769 + #  define YYSIZE_T size_t
770 + # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
771 +     || defined __cplusplus || defined _MSC_VER)
772 + #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
773 + #  define YYSIZE_T size_t
774 + # else
775 + #  define YYSIZE_T unsigned int
776 + # endif
777 + #endif
778 +
779 + #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
780 +
781   #ifndef YY_
782   # if YYENABLE_NLS
783   #  if ENABLE_NLS
# Line 745 | Line 790 | typedef union YYSTYPE {
790   # endif
791   #endif
792  
793 < #if ! defined (yyoverflow) || YYERROR_VERBOSE
793 > /* Suppress unused-variable warnings by "using" E.  */
794 > #if ! defined lint || defined __GNUC__
795 > # define YYUSE(e) ((void) (e))
796 > #else
797 > # define YYUSE(e) /* empty */
798 > #endif
799 >
800 > /* Identity function, used to suppress warnings about constant conditions.  */
801 > #ifndef lint
802 > # define YYID(n) (n)
803 > #else
804 > #if (defined __STDC__ || defined __C99__FUNC__ \
805 >     || defined __cplusplus || defined _MSC_VER)
806 > static int
807 > YYID (int i)
808 > #else
809 > static int
810 > YYID (i)
811 >    int i;
812 > #endif
813 > {
814 >  return i;
815 > }
816 > #endif
817 >
818 > #if ! defined yyoverflow || YYERROR_VERBOSE
819  
820   /* The parser invokes alloca or malloc; define the necessary symbols.  */
821  
# Line 753 | Line 823 | typedef union YYSTYPE {
823   #  if YYSTACK_USE_ALLOCA
824   #   ifdef __GNUC__
825   #    define YYSTACK_ALLOC __builtin_alloca
826 + #   elif defined __BUILTIN_VA_ARG_INCR
827 + #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
828 + #   elif defined _AIX
829 + #    define YYSTACK_ALLOC __alloca
830 + #   elif defined _MSC_VER
831 + #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
832 + #    define alloca _alloca
833   #   else
834   #    define YYSTACK_ALLOC alloca
835 < #    if defined (__STDC__) || defined (__cplusplus)
835 > #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
836 >     || defined __cplusplus || defined _MSC_VER)
837   #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
838 < #     define YYINCLUDED_STDLIB_H
838 > #     ifndef _STDLIB_H
839 > #      define _STDLIB_H 1
840 > #     endif
841   #    endif
842   #   endif
843   #  endif
844   # endif
845  
846   # ifdef YYSTACK_ALLOC
847 <   /* Pacify GCC's `empty if-body' warning. */
848 < #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
847 >   /* Pacify GCC's `empty if-body' warning.  */
848 > #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
849   #  ifndef YYSTACK_ALLOC_MAXIMUM
850      /* The OS might guarantee only one guard page at the bottom of the stack,
851         and a page size can be as small as 4096 bytes.  So we cannot safely
852         invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
853         to allow for a few compiler-allocated temporary stack slots.  */
854 < #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
854 > #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
855   #  endif
856   # else
857   #  define YYSTACK_ALLOC YYMALLOC
858   #  define YYSTACK_FREE YYFREE
859   #  ifndef YYSTACK_ALLOC_MAXIMUM
860 < #   define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
860 > #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
861   #  endif
862 < #  ifdef __cplusplus
863 < extern "C" {
862 > #  if (defined __cplusplus && ! defined _STDLIB_H \
863 >       && ! ((defined YYMALLOC || defined malloc) \
864 >             && (defined YYFREE || defined free)))
865 > #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
866 > #   ifndef _STDLIB_H
867 > #    define _STDLIB_H 1
868 > #   endif
869   #  endif
870   #  ifndef YYMALLOC
871   #   define YYMALLOC malloc
872 < #   if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
873 <        && (defined (__STDC__) || defined (__cplusplus)))
872 > #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
873 >     || defined __cplusplus || defined _MSC_VER)
874   void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
875   #   endif
876   #  endif
877   #  ifndef YYFREE
878   #   define YYFREE free
879 < #   if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
880 <        && (defined (__STDC__) || defined (__cplusplus)))
879 > #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
880 >     || defined __cplusplus || defined _MSC_VER)
881   void free (void *); /* INFRINGES ON USER NAME SPACE */
882   #   endif
883   #  endif
799 #  ifdef __cplusplus
800 }
801 #  endif
884   # endif
885 < #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
885 > #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
886  
887  
888 < #if (! defined (yyoverflow) \
889 <     && (! defined (__cplusplus) \
890 <         || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
888 > #if (! defined yyoverflow \
889 >     && (! defined __cplusplus \
890 >         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
891  
892   /* A type that is properly aligned for any stack member.  */
893   union yyalloc
894   {
895 <  short int yyss;
895 >  yytype_int16 yyss;
896    YYSTYPE yyvs;
897    };
898  
# Line 820 | Line 902 | union yyalloc
902   /* The size of an array large to enough to hold all stacks, each with
903     N elements.  */
904   # define YYSTACK_BYTES(N) \
905 <     ((N) * (sizeof (short int) + sizeof (YYSTYPE))                     \
905 >     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
906        + YYSTACK_GAP_MAXIMUM)
907  
908   /* Copy COUNT objects from FROM to TO.  The source and destination do
909     not overlap.  */
910   # ifndef YYCOPY
911 < #  if defined (__GNUC__) && 1 < __GNUC__
911 > #  if defined __GNUC__ && 1 < __GNUC__
912   #   define YYCOPY(To, From, Count) \
913        __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
914   #  else
# Line 837 | Line 919 | union yyalloc
919            for (yyi = 0; yyi < (Count); yyi++)   \
920              (To)[yyi] = (From)[yyi];            \
921          }                                       \
922 <      while (0)
922 >      while (YYID (0))
923   #  endif
924   # endif
925  
# Line 855 | Line 937 | union yyalloc
937          yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
938          yyptr += yynewbytes / sizeof (*yyptr);                          \
939        }                                                                 \
940 <    while (0)
859 <
860 < #endif
940 >    while (YYID (0))
941  
862 #if defined (__STDC__) || defined (__cplusplus)
863   typedef signed char yysigned_char;
864 #else
865   typedef short int yysigned_char;
942   #endif
943  
944 < /* YYFINAL -- State number of the termination state. */
944 > /* YYFINAL -- State number of the termination state.  */
945   #define YYFINAL  2
946   /* YYLAST -- Last index in YYTABLE.  */
947   #define YYLAST   1396
948  
949 < /* YYNTOKENS -- Number of terminals. */
949 > /* YYNTOKENS -- Number of terminals.  */
950   #define YYNTOKENS  261
951 < /* YYNNTS -- Number of nonterminals. */
951 > /* YYNNTS -- Number of nonterminals.  */
952   #define YYNNTS  340
953 < /* YYNRULES -- Number of rules. */
953 > /* YYNRULES -- Number of rules.  */
954   #define YYNRULES  729
955 < /* YYNRULES -- Number of states. */
955 > /* YYNRULES -- Number of states.  */
956   #define YYNSTATES  1470
957  
958   /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
# Line 887 | Line 963 | union yyalloc
963    ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
964  
965   /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
966 < static const unsigned short int yytranslate[] =
966 > static const yytype_uint16 yytranslate[] =
967   {
968         0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
969         2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
# Line 946 | Line 1022 | static const unsigned short int yytransl
1022   #if YYDEBUG
1023   /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
1024     YYRHS.  */
1025 < static const unsigned short int yyprhs[] =
1025 > static const yytype_uint16 yyprhs[] =
1026   {
1027         0,     0,     3,     4,     7,     9,    11,    13,    15,    17,
1028        19,    21,    23,    25,    27,    29,    31,    33,    35,    37,
# Line 1023 | Line 1099 | static const unsigned short int yyprhs[]
1099      2220,  2222,  2224,  2226,  2231,  2236,  2241,  2246,  2251,  2256
1100   };
1101  
1102 < /* YYRHS -- A `-1'-separated list of the rules' RHS. */
1103 < static const short int yyrhs[] =
1102 > /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
1103 > static const yytype_int16 yyrhs[] =
1104   {
1105       262,     0,    -1,    -1,   262,   263,    -1,   287,    -1,   293,
1106        -1,   308,    -1,   571,    -1,   345,    -1,   364,    -1,   378,
# Line 1256 | Line 1332 | static const short int yyrhs[] =
1332   };
1333  
1334   /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
1335 < static const unsigned short int yyrline[] =
1335 > static const yytype_uint16 yyrline[] =
1336   {
1337         0,   393,   393,   394,   397,   398,   399,   400,   401,   402,
1338       403,   404,   405,   406,   407,   408,   409,   410,   411,   412,
# Line 1336 | Line 1412 | static const unsigned short int yyrline[
1412  
1413   #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1414   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1415 <   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1415 >   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
1416   static const char *const yytname[] =
1417   {
1418    "$end", "error", "$undefined", "ACCEPT_PASSWORD", "ACTION", "ADMIN",
# Line 1501 | Line 1577 | static const char *const yytname[] =
1577   # ifdef YYPRINT
1578   /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1579     token YYLEX-NUM.  */
1580 < static const unsigned short int yytoknum[] =
1580 > static const yytype_uint16 yytoknum[] =
1581   {
1582         0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
1583       265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
# Line 1534 | Line 1610 | static const unsigned short int yytoknum
1610   # endif
1611  
1612   /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
1613 < static const unsigned short int yyr1[] =
1613 > static const yytype_uint16 yyr1[] =
1614   {
1615         0,   261,   262,   262,   263,   263,   263,   263,   263,   263,
1616       263,   263,   263,   263,   263,   263,   263,   263,   263,   263,
# Line 1612 | Line 1688 | static const unsigned short int yyr1[] =
1688   };
1689  
1690   /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
1691 < static const unsigned char yyr2[] =
1691 > static const yytype_uint8 yyr2[] =
1692   {
1693         0,     2,     0,     2,     1,     1,     1,     1,     1,     1,
1694         1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
# Line 1692 | Line 1768 | static const unsigned char yyr2[] =
1768   /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1769     STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
1770     means the default is an error.  */
1771 < static const unsigned short int yydefact[] =
1771 > static const yytype_uint16 yydefact[] =
1772   {
1773         2,     0,     1,     0,     0,     0,   214,   384,   459,     0,
1774       474,     0,   647,   271,   444,   248,     0,     0,   118,   325,
# Line 1843 | Line 1919 | static const unsigned short int yydefact
1919       197,   155,     0,   348,   371,   425,   422,   195,   192,   156
1920   };
1921  
1922 < /* YYDEFGOTO[NTERM-NUM]. */
1923 < static const short int yydefgoto[] =
1922 > /* YYDEFGOTO[NTERM-NUM].  */
1923 > static const yytype_int16 yydefgoto[] =
1924   {
1925        -1,     1,    24,   887,   888,  1040,  1041,    25,   273,   274,
1926       275,   276,    26,   310,   311,   312,   313,   314,   315,   316,
# Line 1885 | Line 1961 | static const short int yydefgoto[] =
1961   /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1962     STATE-NUM.  */
1963   #define YYPACT_NINF -796
1964 < static const short int yypact[] =
1964 > static const yytype_int16 yypact[] =
1965   {
1966      -796,   799,  -796,  -206,  -253,  -243,  -796,  -796,  -796,  -227,
1967      -796,  -218,  -796,  -796,  -796,  -796,  -195,  -185,  -796,  -796,
# Line 2037 | Line 2113 | static const short int yypact[] =
2113   };
2114  
2115   /* YYPGOTO[NTERM-NUM].  */
2116 < static const short int yypgoto[] =
2116 > static const yytype_int16 yypgoto[] =
2117   {
2118      -796,  -796,  -796,  -420,  -335,  -795,  -418,  -796,  -796,   994,
2119      -796,  -796,  -796,  -796,   527,  -796,  -796,  -796,  -796,  -796,
# Line 2080 | Line 2156 | static const short int yypgoto[] =
2156     number is the opposite.  If zero, do what YYDEFACT says.
2157     If YYTABLE_NINF, syntax error.  */
2158   #define YYTABLE_NINF -1
2159 < static const unsigned short int yytable[] =
2159 > static const yytype_uint16 yytable[] =
2160   {
2161       576,   577,   723,   270,  1211,    47,  1427,   583,  1428,  1217,
2162       362,   120,   352,   281,  1247,    48,   560,   126,    67,  1037,
# Line 2224 | Line 2300 | static const unsigned short int yytable[
2300         0,     0,     0,     0,     0,     0,   536
2301   };
2302  
2303 < static const short int yycheck[] =
2303 > static const yytype_int16 yycheck[] =
2304   {
2305       335,   336,   420,     1,    11,   258,    10,   342,    12,    11,
2306         1,     1,     1,     1,    77,   258,     1,     1,     1,    14,
# Line 2370 | Line 2446 | static const short int yycheck[] =
2446  
2447   /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
2448     symbol of state STATE-NUM.  */
2449 < static const unsigned short int yystos[] =
2449 > static const yytype_uint16 yystos[] =
2450   {
2451         0,   262,     0,     1,     5,    22,    26,    29,    36,    51,
2452        64,    65,    67,    74,    91,   102,   104,   120,   137,   169,
# Line 2546 | Line 2622 | do                                                             \
2622        yychar = (Token);                                         \
2623        yylval = (Value);                                         \
2624        yytoken = YYTRANSLATE (yychar);                           \
2625 <      YYPOPSTACK;                                               \
2625 >      YYPOPSTACK (1);                                           \
2626        goto yybackup;                                            \
2627      }                                                           \
2628    else                                                          \
# Line 2554 | Line 2630 | do                                                             \
2630        yyerror (YY_("syntax error: cannot back up")); \
2631        YYERROR;                                                  \
2632      }                                                           \
2633 < while (0)
2633 > while (YYID (0))
2634  
2635  
2636   #define YYTERROR        1
# Line 2569 | Line 2645 | while (0)
2645   #ifndef YYLLOC_DEFAULT
2646   # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
2647      do                                                                  \
2648 <      if (N)                                                            \
2648 >      if (YYID (N))                                                    \
2649          {                                                               \
2650            (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
2651            (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
# Line 2583 | Line 2659 | while (0)
2659            (Current).first_column = (Current).last_column =              \
2660              YYRHSLOC (Rhs, 0).last_column;                              \
2661          }                                                               \
2662 <    while (0)
2662 >    while (YYID (0))
2663   #endif
2664  
2665  
# Line 2595 | Line 2671 | while (0)
2671   # if YYLTYPE_IS_TRIVIAL
2672   #  define YY_LOCATION_PRINT(File, Loc)                  \
2673       fprintf (File, "%d.%d-%d.%d",                      \
2674 <              (Loc).first_line, (Loc).first_column,     \
2675 <              (Loc).last_line,  (Loc).last_column)
2674 >              (Loc).first_line, (Loc).first_column,     \
2675 >              (Loc).last_line,  (Loc).last_column)
2676   # else
2677   #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
2678   # endif
# Line 2623 | Line 2699 | while (0)
2699   do {                                            \
2700    if (yydebug)                                  \
2701      YYFPRINTF Args;                             \
2702 < } while (0)
2702 > } while (YYID (0))
2703 >
2704 > # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
2705 > do {                                                                      \
2706 >  if (yydebug)                                                            \
2707 >    {                                                                     \
2708 >      YYFPRINTF (stderr, "%s ", Title);                                   \
2709 >      yy_symbol_print (stderr,                                            \
2710 >                  Type, Value); \
2711 >      YYFPRINTF (stderr, "\n");                                           \
2712 >    }                                                                     \
2713 > } while (YYID (0))
2714  
2715 < # define YY_SYMBOL_PRINT(Title, Type, Value, Location)          \
2716 < do {                                                            \
2717 <  if (yydebug)                                                  \
2718 <    {                                                           \
2719 <      YYFPRINTF (stderr, "%s ", Title);                         \
2720 <      yysymprint (stderr,                                       \
2721 <                  Type, Value); \
2722 <      YYFPRINTF (stderr, "\n");                                 \
2723 <    }                                                           \
2724 < } while (0)
2715 >
2716 > /*--------------------------------.
2717 > | Print this symbol on YYOUTPUT.  |
2718 > `--------------------------------*/
2719 >
2720 > /*ARGSUSED*/
2721 > #if (defined __STDC__ || defined __C99__FUNC__ \
2722 >     || defined __cplusplus || defined _MSC_VER)
2723 > static void
2724 > yy_symbol_value_print (FILE *yyoutput, int yytype, const YYSTYPE * const yyvaluep)
2725 > #else
2726 > static void
2727 > yy_symbol_value_print (yyoutput, yytype, yyvaluep)
2728 >    FILE *yyoutput;
2729 >    int yytype;
2730 >    const YYSTYPE * const yyvaluep;
2731 > #endif
2732 > {
2733 >  if (!yyvaluep)
2734 >    return;
2735 > # ifdef YYPRINT
2736 >  if (yytype < YYNTOKENS)
2737 >    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2738 > # else
2739 >  YYUSE (yyoutput);
2740 > # endif
2741 >  switch (yytype)
2742 >    {
2743 >      default:
2744 >        break;
2745 >    }
2746 > }
2747 >
2748 >
2749 > /*--------------------------------.
2750 > | Print this symbol on YYOUTPUT.  |
2751 > `--------------------------------*/
2752 >
2753 > #if (defined __STDC__ || defined __C99__FUNC__ \
2754 >     || defined __cplusplus || defined _MSC_VER)
2755 > static void
2756 > yy_symbol_print (FILE *yyoutput, int yytype, const YYSTYPE * const yyvaluep)
2757 > #else
2758 > static void
2759 > yy_symbol_print (yyoutput, yytype, yyvaluep)
2760 >    FILE *yyoutput;
2761 >    int yytype;
2762 >    const YYSTYPE * const yyvaluep;
2763 > #endif
2764 > {
2765 >  if (yytype < YYNTOKENS)
2766 >    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
2767 >  else
2768 >    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
2769 >
2770 >  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
2771 >  YYFPRINTF (yyoutput, ")");
2772 > }
2773  
2774   /*------------------------------------------------------------------.
2775   | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2776   | TOP (included).                                                   |
2777   `------------------------------------------------------------------*/
2778  
2779 < #if defined (__STDC__) || defined (__cplusplus)
2779 > #if (defined __STDC__ || defined __C99__FUNC__ \
2780 >     || defined __cplusplus || defined _MSC_VER)
2781   static void
2782 < yy_stack_print (short int *bottom, short int *top)
2782 > yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
2783   #else
2784   static void
2785   yy_stack_print (bottom, top)
2786 <    short int *bottom;
2787 <    short int *top;
2786 >    yytype_int16 *bottom;
2787 >    yytype_int16 *top;
2788   #endif
2789   {
2790    YYFPRINTF (stderr, "Stack now");
2791 <  for (/* Nothing. */; bottom <= top; ++bottom)
2791 >  for (; bottom <= top; ++bottom)
2792      YYFPRINTF (stderr, " %d", *bottom);
2793    YYFPRINTF (stderr, "\n");
2794   }
# Line 2661 | Line 2797 | yy_stack_print (bottom, top)
2797   do {                                                            \
2798    if (yydebug)                                                  \
2799      yy_stack_print ((Bottom), (Top));                           \
2800 < } while (0)
2800 > } while (YYID (0))
2801  
2802  
2803   /*------------------------------------------------.
2804   | Report that the YYRULE is going to be reduced.  |
2805   `------------------------------------------------*/
2806  
2807 < #if defined (__STDC__) || defined (__cplusplus)
2807 > #if (defined __STDC__ || defined __C99__FUNC__ \
2808 >     || defined __cplusplus || defined _MSC_VER)
2809   static void
2810 < yy_reduce_print (int yyrule)
2810 > yy_reduce_print (YYSTYPE *yyvsp,
2811 >                   int yyrule)
2812   #else
2813   static void
2814 < yy_reduce_print (yyrule)
2815 <    int yyrule;
2814 > yy_reduce_print (yyvsp, yyrule
2815 >                   )
2816 >    YYSTYPE *yyvsp;
2817 >    
2818 >                   int yyrule;
2819   #endif
2820   {
2821 +  int yynrhs = yyr2[yyrule];
2822    int yyi;
2823    unsigned long int yylno = yyrline[yyrule];
2824 <  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
2825 <             yyrule - 1, yylno);
2826 <  /* Print the symbols being reduced, and their result.  */
2827 <  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
2828 <    YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
2829 <  YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
2824 >  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2825 >             yyrule - 1, yylno);
2826 >  /* The symbols being reduced.  */
2827 >  for (yyi = 0; yyi < yynrhs; yyi++)
2828 >    {
2829 >      fprintf (stderr, "   $%d = ", yyi + 1);
2830 >      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
2831 >                       &(yyvsp[(yyi + 1) - (yynrhs)])
2832 >                                       );
2833 >      fprintf (stderr, "\n");
2834 >    }
2835   }
2836  
2837   # define YY_REDUCE_PRINT(Rule)          \
2838   do {                                    \
2839    if (yydebug)                          \
2840 <    yy_reduce_print (Rule);             \
2841 < } while (0)
2840 >    yy_reduce_print (yyvsp, Rule); \
2841 > } while (YYID (0))
2842  
2843   /* Nonzero means print parse trace.  It is left uninitialized so that
2844     multiple parsers can coexist.  */
# Line 2725 | Line 2872 | int yydebug;
2872   #if YYERROR_VERBOSE
2873  
2874   # ifndef yystrlen
2875 < #  if defined (__GLIBC__) && defined (_STRING_H)
2875 > #  if defined __GLIBC__ && defined _STRING_H
2876   #   define yystrlen strlen
2877   #  else
2878   /* Return the length of YYSTR.  */
2879 + #if (defined __STDC__ || defined __C99__FUNC__ \
2880 +     || defined __cplusplus || defined _MSC_VER)
2881   static YYSIZE_T
2733 #   if defined (__STDC__) || defined (__cplusplus)
2882   yystrlen (const char *yystr)
2883 < #   else
2883 > #else
2884 > static YYSIZE_T
2885   yystrlen (yystr)
2886 <     const char *yystr;
2887 < #   endif
2886 >    const char *yystr;
2887 > #endif
2888   {
2889 <  const char *yys = yystr;
2890 <
2742 <  while (*yys++ != '\0')
2889 >  YYSIZE_T yylen;
2890 >  for (yylen = 0; yystr[yylen]; yylen++)
2891      continue;
2892 <
2745 <  return yys - yystr - 1;
2892 >  return yylen;
2893   }
2894   #  endif
2895   # endif
2896  
2897   # ifndef yystpcpy
2898 < #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
2898 > #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2899   #   define yystpcpy stpcpy
2900   #  else
2901   /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2902     YYDEST.  */
2903 + #if (defined __STDC__ || defined __C99__FUNC__ \
2904 +     || defined __cplusplus || defined _MSC_VER)
2905   static char *
2757 #   if defined (__STDC__) || defined (__cplusplus)
2906   yystpcpy (char *yydest, const char *yysrc)
2907 < #   else
2907 > #else
2908 > static char *
2909   yystpcpy (yydest, yysrc)
2910 <     char *yydest;
2911 <     const char *yysrc;
2912 < #   endif
2910 >    char *yydest;
2911 >    const char *yysrc;
2912 > #endif
2913   {
2914    char *yyd = yydest;
2915    const char *yys = yysrc;
# Line 2786 | Line 2935 | yytnamerr (char *yyres, const char *yyst
2935   {
2936    if (*yystr == '"')
2937      {
2938 <      size_t yyn = 0;
2938 >      YYSIZE_T yyn = 0;
2939        char const *yyp = yystr;
2940  
2941        for (;;)
# Line 2821 | Line 2970 | yytnamerr (char *yyres, const char *yyst
2970   }
2971   # endif
2972  
2973 < #endif /* YYERROR_VERBOSE */
2973 > /* Copy into YYRESULT an error message about the unexpected token
2974 >   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
2975 >   including the terminating null byte.  If YYRESULT is null, do not
2976 >   copy anything; just return the number of bytes that would be
2977 >   copied.  As a special case, return 0 if an ordinary "syntax error"
2978 >   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
2979 >   size calculation.  */
2980 > static YYSIZE_T
2981 > yysyntax_error (char *yyresult, int yystate, int yychar)
2982 > {
2983 >  int yyn = yypact[yystate];
2984  
2985 <
2985 >  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
2986 >    return 0;
2987 >  else
2988 >    {
2989 >      int yytype = YYTRANSLATE (yychar);
2990 >      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2991 >      YYSIZE_T yysize = yysize0;
2992 >      YYSIZE_T yysize1;
2993 >      int yysize_overflow = 0;
2994 >      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2995 >      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2996 >      int yyx;
2997 >
2998 > # if 0
2999 >      /* This is so xgettext sees the translatable formats that are
3000 >         constructed on the fly.  */
3001 >      YY_("syntax error, unexpected %s");
3002 >      YY_("syntax error, unexpected %s, expecting %s");
3003 >      YY_("syntax error, unexpected %s, expecting %s or %s");
3004 >      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
3005 >      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
3006 > # endif
3007 >      char *yyfmt;
3008 >      char const *yyf;
3009 >      static char const yyunexpected[] = "syntax error, unexpected %s";
3010 >      static char const yyexpecting[] = ", expecting %s";
3011 >      static char const yyor[] = " or %s";
3012 >      char yyformat[sizeof yyunexpected
3013 >                    + sizeof yyexpecting - 1
3014 >                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
3015 >                       * (sizeof yyor - 1))];
3016 >      char const *yyprefix = yyexpecting;
3017 >
3018 >      /* Start YYX at -YYN if negative to avoid negative indexes in
3019 >         YYCHECK.  */
3020 >      int yyxbegin = yyn < 0 ? -yyn : 0;
3021 >
3022 >      /* Stay within bounds of both yycheck and yytname.  */
3023 >      int yychecklim = YYLAST - yyn + 1;
3024 >      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
3025 >      int yycount = 1;
3026  
3027 < #if YYDEBUG
3028 < /*--------------------------------.
2830 < | Print this symbol on YYOUTPUT.  |
2831 < `--------------------------------*/
3027 >      yyarg[0] = yytname[yytype];
3028 >      yyfmt = yystpcpy (yyformat, yyunexpected);
3029  
3030 < #if defined (__STDC__) || defined (__cplusplus)
3031 < static void
3032 < yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
3033 < #else
3034 < static void
3035 < yysymprint (yyoutput, yytype, yyvaluep)
3036 <    FILE *yyoutput;
3037 <    int yytype;
3038 <    YYSTYPE *yyvaluep;
3039 < #endif
3040 < {
3041 <  /* Pacify ``unused variable'' warnings.  */
3042 <  (void) yyvaluep;
3030 >      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
3031 >        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
3032 >          {
3033 >            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
3034 >              {
3035 >                yycount = 1;
3036 >                yysize = yysize0;
3037 >                yyformat[sizeof yyunexpected - 1] = '\0';
3038 >                break;
3039 >              }
3040 >            yyarg[yycount++] = yytname[yyx];
3041 >            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
3042 >            yysize_overflow |= (yysize1 < yysize);
3043 >            yysize = yysize1;
3044 >            yyfmt = yystpcpy (yyfmt, yyprefix);
3045 >            yyprefix = yyor;
3046 >          }
3047  
3048 <  if (yytype < YYNTOKENS)
3049 <    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
3050 <  else
3051 <    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
3048 >      yyf = YY_(yyformat);
3049 >      yysize1 = yysize + yystrlen (yyf);
3050 >      yysize_overflow |= (yysize1 < yysize);
3051 >      yysize = yysize1;
3052  
3053 +      if (yysize_overflow)
3054 +        return YYSIZE_MAXIMUM;
3055  
3056 < # ifdef YYPRINT
3057 <  if (yytype < YYNTOKENS)
3058 <    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
3059 < # endif
3060 <  switch (yytype)
3061 <    {
3062 <      default:
3063 <        break;
3056 >      if (yyresult)
3057 >        {
3058 >          /* Avoid sprintf, as that infringes on the user's name space.
3059 >             Don't have undefined behavior even if the translation
3060 >             produced a string with the wrong number of "%s"s.  */
3061 >          char *yyp = yyresult;
3062 >          int yyi = 0;
3063 >          while ((*yyp = *yyf) != '\0')
3064 >            {
3065 >              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
3066 >                {
3067 >                  yyp += yytnamerr (yyp, yyarg[yyi++]);
3068 >                  yyf += 2;
3069 >                }
3070 >              else
3071 >                {
3072 >                  yyp++;
3073 >                  yyf++;
3074 >                }
3075 >            }
3076 >        }
3077 >      return yysize;
3078      }
2862  YYFPRINTF (yyoutput, ")");
3079   }
3080 + #endif /* YYERROR_VERBOSE */
3081 +
3082  
2865 #endif /* ! YYDEBUG */
3083   /*-----------------------------------------------.
3084   | Release the memory associated to this symbol.  |
3085   `-----------------------------------------------*/
3086  
3087 < #if defined (__STDC__) || defined (__cplusplus)
3087 > /*ARGSUSED*/
3088 > #if (defined __STDC__ || defined __C99__FUNC__ \
3089 >     || defined __cplusplus || defined _MSC_VER)
3090   static void
3091   yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
3092   #else
# Line 2878 | Line 3097 | yydestruct (yymsg, yytype, yyvaluep)
3097      YYSTYPE *yyvaluep;
3098   #endif
3099   {
3100 <  /* Pacify ``unused variable'' warnings.  */
2882 <  (void) yyvaluep;
3100 >  YYUSE (yyvaluep);
3101  
3102    if (!yymsg)
3103      yymsg = "Deleting";
# Line 2889 | Line 3107 | yydestruct (yymsg, yytype, yyvaluep)
3107      {
3108  
3109        default:
3110 <        break;
3110 >        break;
3111      }
3112   }
3113  
# Line 2897 | Line 3115 | yydestruct (yymsg, yytype, yyvaluep)
3115   /* Prevent warnings from -Wmissing-prototypes.  */
3116  
3117   #ifdef YYPARSE_PARAM
3118 < # if defined (__STDC__) || defined (__cplusplus)
3118 > #if defined __STDC__ || defined __cplusplus
3119   int yyparse (void *YYPARSE_PARAM);
3120 < # else
3120 > #else
3121   int yyparse ();
3122 < # endif
3122 > #endif
3123   #else /* ! YYPARSE_PARAM */
3124 < #if defined (__STDC__) || defined (__cplusplus)
3124 > #if defined __STDC__ || defined __cplusplus
3125   int yyparse (void);
3126   #else
3127   int yyparse ();
# Line 2928 | Line 3146 | int yynerrs;
3146   `----------*/
3147  
3148   #ifdef YYPARSE_PARAM
3149 < # if defined (__STDC__) || defined (__cplusplus)
3150 < int yyparse (void *YYPARSE_PARAM)
3151 < # else
3152 < int yyparse (YYPARSE_PARAM)
3153 <  void *YYPARSE_PARAM;
3154 < # endif
3149 > #if (defined __STDC__ || defined __C99__FUNC__ \
3150 >     || defined __cplusplus || defined _MSC_VER)
3151 > int
3152 > yyparse (void *YYPARSE_PARAM)
3153 > #else
3154 > int
3155 > yyparse (YYPARSE_PARAM)
3156 >    void *YYPARSE_PARAM;
3157 > #endif
3158   #else /* ! YYPARSE_PARAM */
3159 < #if defined (__STDC__) || defined (__cplusplus)
3159 > #if (defined __STDC__ || defined __C99__FUNC__ \
3160 >     || defined __cplusplus || defined _MSC_VER)
3161   int
3162   yyparse (void)
3163   #else
3164   int
3165   yyparse ()
3166 <    ;
3166 >
3167   #endif
3168   #endif
3169   {
# Line 2953 | Line 3175 | yyparse ()
3175    int yyerrstatus;
3176    /* Look-ahead token as an internal (translated) token number.  */
3177    int yytoken = 0;
3178 + #if YYERROR_VERBOSE
3179 +  /* Buffer for error messages, and its allocated size.  */
3180 +  char yymsgbuf[128];
3181 +  char *yymsg = yymsgbuf;
3182 +  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
3183 + #endif
3184  
3185    /* Three stacks and their tools:
3186       `yyss': related to states,
# Line 2963 | Line 3191 | yyparse ()
3191       to reallocate them elsewhere.  */
3192  
3193    /* The state stack.  */
3194 <  short int yyssa[YYINITDEPTH];
3195 <  short int *yyss = yyssa;
3196 <  short int *yyssp;
3194 >  yytype_int16 yyssa[YYINITDEPTH];
3195 >  yytype_int16 *yyss = yyssa;
3196 >  yytype_int16 *yyssp;
3197  
3198    /* The semantic value stack.  */
3199    YYSTYPE yyvsa[YYINITDEPTH];
# Line 2974 | Line 3202 | yyparse ()
3202  
3203  
3204  
3205 < #define YYPOPSTACK   (yyvsp--, yyssp--)
3205 > #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
3206  
3207    YYSIZE_T yystacksize = YYINITDEPTH;
3208  
# Line 2983 | Line 3211 | yyparse ()
3211    YYSTYPE yyval;
3212  
3213  
3214 <  /* When reducing, the number of symbols on the RHS of the reduced
3215 <     rule.  */
3216 <  int yylen;
3214 >  /* The number of symbols on the RHS of the reduced rule.
3215 >     Keep to zero when no symbol should be popped.  */
3216 >  int yylen = 0;
3217  
3218    YYDPRINTF ((stderr, "Starting parse\n"));
3219  
# Line 3009 | Line 3237 | yyparse ()
3237   `------------------------------------------------------------*/
3238   yynewstate:
3239    /* In all cases, when you get here, the value and location stacks
3240 <     have just been pushed. so pushing a state here evens the stacks.
3013 <     */
3240 >     have just been pushed.  So pushing a state here evens the stacks.  */
3241    yyssp++;
3242  
3243   yysetstate:
# Line 3023 | Line 3250 | yyparse ()
3250  
3251   #ifdef yyoverflow
3252        {
3253 <        /* Give user a chance to reallocate the stack. Use copies of
3253 >        /* Give user a chance to reallocate the stack.  Use copies of
3254             these so that the &'s don't force the real ones into
3255             memory.  */
3256          YYSTYPE *yyvs1 = yyvs;
3257 <        short int *yyss1 = yyss;
3257 >        yytype_int16 *yyss1 = yyss;
3258  
3259  
3260          /* Each stack pointer address is followed by the size of the
# Line 3055 | Line 3282 | yyparse ()
3282          yystacksize = YYMAXDEPTH;
3283  
3284        {
3285 <        short int *yyss1 = yyss;
3285 >        yytype_int16 *yyss1 = yyss;
3286          union yyalloc *yyptr =
3287            (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
3288          if (! yyptr)
# Line 3090 | Line 3317 | yyparse ()
3317   `-----------*/
3318   yybackup:
3319  
3320 < /* Do appropriate processing given the current state.  */
3321 < /* Read a look-ahead token if we need one and don't already have one.  */
3095 < /* yyresume: */
3320 >  /* Do appropriate processing given the current state.  Read a
3321 >     look-ahead token if we need one and don't already have one.  */
3322  
3323    /* First try to decide what to do without reference to look-ahead token.  */
3098
3324    yyn = yypact[yystate];
3325    if (yyn == YYPACT_NINF)
3326      goto yydefault;
# Line 3137 | Line 3362 | yybackup:
3362    if (yyn == YYFINAL)
3363      YYACCEPT;
3364  
3365 +  /* Count tokens shifted since error; after three, turn off error
3366 +     status.  */
3367 +  if (yyerrstatus)
3368 +    yyerrstatus--;
3369 +
3370    /* Shift the look-ahead token.  */
3371    YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3372  
3373 <  /* Discard the token being shifted unless it is eof.  */
3373 >  /* Discard the shifted token unless it is eof.  */
3374    if (yychar != YYEOF)
3375      yychar = YYEMPTY;
3376  
3377 +  yystate = yyn;
3378    *++yyvsp = yylval;
3379  
3149
3150  /* Count tokens shifted since error; after three, turn off error
3151     status.  */
3152  if (yyerrstatus)
3153    yyerrstatus--;
3154
3155  yystate = yyn;
3380    goto yynewstate;
3381  
3382  
# Line 3195 | Line 3419 | yyreduce:
3419    case 28:
3420   #line 424 "ircd_parser.y"
3421      {
3422 <                        (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number);
3422 >                        (yyval.number) = (yyvsp[(1) - (2)].number) + (yyvsp[(2) - (2)].number);
3423                  }
3424      break;
3425  
3426    case 29:
3427   #line 428 "ircd_parser.y"
3428      {
3429 <                        (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number);
3429 >                        (yyval.number) = (yyvsp[(1) - (3)].number) + (yyvsp[(3) - (3)].number);
3430                  }
3431      break;
3432  
3433    case 30:
3434   #line 432 "ircd_parser.y"
3435      {
3436 <                        (yyval.number) = (yyvsp[-2].number) * 60 + (yyvsp[0].number);
3436 >                        (yyval.number) = (yyvsp[(1) - (3)].number) * 60 + (yyvsp[(3) - (3)].number);
3437                  }
3438      break;
3439  
3440    case 31:
3441   #line 436 "ircd_parser.y"
3442      {
3443 <                        (yyval.number) = (yyvsp[-2].number) * 60 * 60 + (yyvsp[0].number);
3443 >                        (yyval.number) = (yyvsp[(1) - (3)].number) * 60 * 60 + (yyvsp[(3) - (3)].number);
3444                  }
3445      break;
3446  
3447    case 32:
3448   #line 440 "ircd_parser.y"
3449      {
3450 <                        (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 + (yyvsp[0].number);
3450 >                        (yyval.number) = (yyvsp[(1) - (3)].number) * 60 * 60 * 24 + (yyvsp[(3) - (3)].number);
3451                  }
3452      break;
3453  
3454    case 33:
3455   #line 444 "ircd_parser.y"
3456      {
3457 <                        (yyval.number) = (yyvsp[-2].number) * 60 * 60 * 24 * 7 + (yyvsp[0].number);
3457 >                        (yyval.number) = (yyvsp[(1) - (3)].number) * 60 * 60 * 24 * 7 + (yyvsp[(3) - (3)].number);
3458                  }
3459      break;
3460  
# Line 3241 | Line 3465 | yyreduce:
3465  
3466    case 36:
3467   #line 450 "ircd_parser.y"
3468 <    { (yyval.number) = (yyvsp[-1].number) + (yyvsp[0].number); }
3468 >    { (yyval.number) = (yyvsp[(1) - (2)].number) + (yyvsp[(2) - (2)].number); }
3469      break;
3470  
3471    case 37:
3472   #line 451 "ircd_parser.y"
3473 <    { (yyval.number) = (yyvsp[-2].number) + (yyvsp[0].number); }
3473 >    { (yyval.number) = (yyvsp[(1) - (3)].number) + (yyvsp[(3) - (3)].number); }
3474      break;
3475  
3476    case 38:
3477   #line 452 "ircd_parser.y"
3478 <    { (yyval.number) = (yyvsp[-2].number) * 1024 + (yyvsp[0].number); }
3478 >    { (yyval.number) = (yyvsp[(1) - (3)].number) * 1024 + (yyvsp[(3) - (3)].number); }
3479      break;
3480  
3481    case 39:
3482   #line 453 "ircd_parser.y"
3483 <    { (yyval.number) = (yyvsp[-2].number) * 1024 * 1024 + (yyvsp[0].number); }
3483 >    { (yyval.number) = (yyvsp[(1) - (3)].number) * 1024 * 1024 + (yyvsp[(3) - (3)].number); }
3484      break;
3485  
3486    case 46:
# Line 3526 | Line 3750 | yyreduce:
3750    {
3751      recalc_fdlimit(NULL);
3752  
3753 <    if ((yyvsp[-1].number) < MAXCLIENTS_MIN)
3753 >    if ((yyvsp[(3) - (4)].number) < MAXCLIENTS_MIN)
3754      {
3755        char buf[IRCD_BUFSIZE];
3756        ircsprintf(buf, "MAXCLIENTS too low, setting to %d", MAXCLIENTS_MIN);
3757        yyerror(buf);
3758      }
3759 <    else if ((yyvsp[-1].number) > MAXCLIENTS_MAX)
3759 >    else if ((yyvsp[(3) - (4)].number) > MAXCLIENTS_MAX)
3760      {
3761        char buf[IRCD_BUFSIZE];
3762        ircsprintf(buf, "MAXCLIENTS too high, setting to %d", MAXCLIENTS_MAX);
3763        yyerror(buf);
3764      }
3765      else
3766 <      ServerInfo.max_clients = (yyvsp[-1].number);
3766 >      ServerInfo.max_clients = (yyvsp[(3) - (4)].number);
3767    }
3768   }
3769      break;
# Line 4620 | Line 4844 | yyreduce:
4844   #line 1623 "ircd_parser.y"
4845      {
4846    if (ypass == 1)
4847 <    PingFreq(yy_class) = (yyvsp[-1].number);
4847 >    PingFreq(yy_class) = (yyvsp[(3) - (4)].number);
4848   }
4849      break;
4850  
# Line 4628 | Line 4852 | yyreduce:
4852   #line 1629 "ircd_parser.y"
4853      {
4854    if (ypass == 1)
4855 <    PingWarning(yy_class) = (yyvsp[-1].number);
4855 >    PingWarning(yy_class) = (yyvsp[(3) - (4)].number);
4856   }
4857      break;
4858  
# Line 4636 | Line 4860 | yyreduce:
4860   #line 1635 "ircd_parser.y"
4861      {
4862    if (ypass == 1)
4863 <    MaxPerIp(yy_class) = (yyvsp[-1].number);
4863 >    MaxPerIp(yy_class) = (yyvsp[(3) - (4)].number);
4864   }
4865      break;
4866  
# Line 4644 | Line 4868 | yyreduce:
4868   #line 1641 "ircd_parser.y"
4869      {
4870    if (ypass == 1)
4871 <    ConFreq(yy_class) = (yyvsp[-1].number);
4871 >    ConFreq(yy_class) = (yyvsp[(3) - (4)].number);
4872   }
4873      break;
4874  
# Line 4652 | Line 4876 | yyreduce:
4876   #line 1647 "ircd_parser.y"
4877      {
4878    if (ypass == 1)
4879 <    MaxTotal(yy_class) = (yyvsp[-1].number);
4879 >    MaxTotal(yy_class) = (yyvsp[(3) - (4)].number);
4880   }
4881      break;
4882  
# Line 4660 | Line 4884 | yyreduce:
4884   #line 1653 "ircd_parser.y"
4885      {
4886    if (ypass == 1)
4887 <    MaxGlobal(yy_class) = (yyvsp[-1].number);
4887 >    MaxGlobal(yy_class) = (yyvsp[(3) - (4)].number);
4888   }
4889      break;
4890  
# Line 4668 | Line 4892 | yyreduce:
4892   #line 1659 "ircd_parser.y"
4893      {
4894    if (ypass == 1)
4895 <    MaxLocal(yy_class) = (yyvsp[-1].number);
4895 >    MaxLocal(yy_class) = (yyvsp[(3) - (4)].number);
4896   }
4897      break;
4898  
# Line 4676 | Line 4900 | yyreduce:
4900   #line 1665 "ircd_parser.y"
4901      {
4902    if (ypass == 1)
4903 <    MaxIdent(yy_class) = (yyvsp[-1].number);
4903 >    MaxIdent(yy_class) = (yyvsp[(3) - (4)].number);
4904   }
4905      break;
4906  
# Line 4684 | Line 4908 | yyreduce:
4908   #line 1671 "ircd_parser.y"
4909      {
4910    if (ypass == 1)
4911 <    MaxSendq(yy_class) = (yyvsp[-1].number);
4911 >    MaxSendq(yy_class) = (yyvsp[(3) - (4)].number);
4912   }
4913      break;
4914  
# Line 4692 | Line 4916 | yyreduce:
4916   #line 1677 "ircd_parser.y"
4917      {
4918    if (ypass == 1)
4919 <    CidrBitlenIPV4(yy_class) = (yyvsp[-1].number);
4919 >    CidrBitlenIPV4(yy_class) = (yyvsp[(3) - (4)].number);
4920   }
4921      break;
4922  
# Line 4700 | Line 4924 | yyreduce:
4924   #line 1683 "ircd_parser.y"
4925      {
4926    if (ypass == 1)
4927 <    CidrBitlenIPV6(yy_class) = (yyvsp[-1].number);
4927 >    CidrBitlenIPV6(yy_class) = (yyvsp[(3) - (4)].number);
4928   }
4929      break;
4930  
# Line 4708 | Line 4932 | yyreduce:
4932   #line 1689 "ircd_parser.y"
4933      {
4934    if (ypass == 1)
4935 <    NumberPerCidr(yy_class) = (yyvsp[-1].number);
4935 >    NumberPerCidr(yy_class) = (yyvsp[(3) - (4)].number);
4936   }
4937      break;
4938  
# Line 4775 | Line 4999 | yyreduce:
4999          yyerror("SSL not available - port closed");
5000          break;
5001        }
5002 <    add_listener((yyvsp[0].number), listener_address, listener_flags);
5002 >    add_listener((yyvsp[(1) - (1)].number), listener_address, listener_flags);
5003    }
5004   }
5005      break;
# Line 4796 | Line 5020 | yyreduce:
5020          break;
5021        }
5022  
5023 <    for (i = (yyvsp[-2].number); i <= (yyvsp[0].number); ++i)
5023 >    for (i = (yyvsp[(1) - (3)].number); i <= (yyvsp[(3) - (3)].number); ++i)
5024        add_listener(i, listener_address, listener_flags);
5025    }
5026   }
# Line 5232 | Line 5456 | yyreduce:
5456    if (ypass == 2)
5457    {
5458      yy_aconf->flags |= CONF_FLAGS_REDIR;
5459 <    yy_aconf->port = (yyvsp[-1].number);
5459 >    yy_aconf->port = (yyvsp[(3) - (4)].number);
5460    }
5461   }
5462      break;
# Line 5816 | Line 6040 | yyreduce:
6040      {
6041    if (ypass == 2)
6042    {
6043 <    if ((yyvsp[-1].string)[0] == ':')
6043 >    if ((yyvsp[(3) - (4)].string)[0] == ':')
6044        yyerror("Server passwords cannot begin with a colon");
6045 <    else if (strchr((yyvsp[-1].string), ' ') != NULL)
6045 >    else if (strchr((yyvsp[(3) - (4)].string), ' ') != NULL)
6046        yyerror("Server passwords cannot contain spaces");
6047      else {
6048        if (yy_aconf->spasswd != NULL)
# Line 5836 | Line 6060 | yyreduce:
6060      {
6061    if (ypass == 2)
6062    {
6063 <    if ((yyvsp[-1].string)[0] == ':')
6063 >    if ((yyvsp[(3) - (4)].string)[0] == ':')
6064        yyerror("Server passwords cannot begin with a colon");
6065 <    else if (strchr((yyvsp[-1].string), ' ') != NULL)
6065 >    else if (strchr((yyvsp[(3) - (4)].string), ' ') != NULL)
6066        yyerror("Server passwords cannot contain spaces");
6067      else {
6068        if (yy_aconf->passwd != NULL)
# Line 5855 | Line 6079 | yyreduce:
6079   #line 2647 "ircd_parser.y"
6080      {
6081    if (ypass == 2)
6082 <    yy_aconf->port = (yyvsp[-1].number);
6082 >    yy_aconf->port = (yyvsp[(3) - (4)].number);
6083   }
6084      break;
6085  
# Line 6425 | Line 6649 | yyreduce:
6649    case 548:
6650   #line 3186 "ircd_parser.y"
6651      {
6652 <  ConfigFileEntry.gline_min_cidr = (yyvsp[-1].number);
6652 >  ConfigFileEntry.gline_min_cidr = (yyvsp[(3) - (4)].number);
6653   }
6654      break;
6655  
6656    case 549:
6657   #line 3191 "ircd_parser.y"
6658      {
6659 <  ConfigFileEntry.gline_min_cidr6 = (yyvsp[-1].number);
6659 >  ConfigFileEntry.gline_min_cidr6 = (yyvsp[(3) - (4)].number);
6660   }
6661      break;
6662  
# Line 6467 | Line 6691 | yyreduce:
6691    case 554:
6692   #line 3216 "ircd_parser.y"
6693      {
6694 <  ConfigFileEntry.kill_chase_time_limit = (yyvsp[-1].number);
6694 >  ConfigFileEntry.kill_chase_time_limit = (yyvsp[(3) - (4)].number);
6695   }
6696      break;
6697  
# Line 6509 | Line 6733 | yyreduce:
6733    case 560:
6734   #line 3246 "ircd_parser.y"
6735      {
6736 <  ConfigFileEntry.max_nick_time = (yyvsp[-1].number);
6736 >  ConfigFileEntry.max_nick_time = (yyvsp[(3) - (4)].number);
6737   }
6738      break;
6739  
6740    case 561:
6741   #line 3251 "ircd_parser.y"
6742      {
6743 <  ConfigFileEntry.max_nick_changes = (yyvsp[-1].number);
6743 >  ConfigFileEntry.max_nick_changes = (yyvsp[(3) - (4)].number);
6744   }
6745      break;
6746  
6747    case 562:
6748   #line 3256 "ircd_parser.y"
6749      {
6750 <  ConfigFileEntry.max_accept = (yyvsp[-1].number);
6750 >  ConfigFileEntry.max_accept = (yyvsp[(3) - (4)].number);
6751   }
6752      break;
6753  
6754    case 563:
6755   #line 3261 "ircd_parser.y"
6756      {
6757 <  ConfigFileEntry.anti_spam_exit_message_time = (yyvsp[-1].number);
6757 >  ConfigFileEntry.anti_spam_exit_message_time = (yyvsp[(3) - (4)].number);
6758   }
6759      break;
6760  
6761    case 564:
6762   #line 3266 "ircd_parser.y"
6763      {
6764 <  ConfigFileEntry.ts_warn_delta = (yyvsp[-1].number);
6764 >  ConfigFileEntry.ts_warn_delta = (yyvsp[(3) - (4)].number);
6765   }
6766      break;
6767  
# Line 6545 | Line 6769 | yyreduce:
6769   #line 3271 "ircd_parser.y"
6770      {
6771    if (ypass == 2)
6772 <    ConfigFileEntry.ts_max_delta = (yyvsp[-1].number);
6772 >    ConfigFileEntry.ts_max_delta = (yyvsp[(3) - (4)].number);
6773   }
6774      break;
6775  
6776    case 566:
6777   #line 3277 "ircd_parser.y"
6778      {
6779 <  if (((yyvsp[-1].number) > 0) && ypass == 1)
6779 >  if (((yyvsp[(3) - (4)].number) > 0) && ypass == 1)
6780    {
6781      ilog(L_CRIT, "You haven't read your config file properly.");
6782      ilog(L_CRIT, "There is a line in the example conf that will kill your server if not removed.");
# Line 6646 | Line 6870 | yyreduce:
6870    case 578:
6871   #line 3343 "ircd_parser.y"
6872      {
6873 <  ConfigFileEntry.pace_wait = (yyvsp[-1].number);
6873 >  ConfigFileEntry.pace_wait = (yyvsp[(3) - (4)].number);
6874   }
6875      break;
6876  
6877    case 579:
6878   #line 3348 "ircd_parser.y"
6879      {
6880 <  ConfigFileEntry.caller_id_wait = (yyvsp[-1].number);
6880 >  ConfigFileEntry.caller_id_wait = (yyvsp[(3) - (4)].number);
6881   }
6882      break;
6883  
# Line 6667 | Line 6891 | yyreduce:
6891    case 581:
6892   #line 3358 "ircd_parser.y"
6893      {
6894 <  ConfigFileEntry.pace_wait_simple = (yyvsp[-1].number);
6894 >  ConfigFileEntry.pace_wait_simple = (yyvsp[(3) - (4)].number);
6895   }
6896      break;
6897  
# Line 6715 | Line 6939 | yyreduce:
6939    case 587:
6940   #line 3394 "ircd_parser.y"
6941      {
6942 <  ConfigFileEntry.idletime = (yyvsp[-1].number);
6942 >  ConfigFileEntry.idletime = (yyvsp[(3) - (4)].number);
6943   }
6944      break;
6945  
6946    case 588:
6947   #line 3399 "ircd_parser.y"
6948      {
6949 <  ConfigFileEntry.dots_in_ident = (yyvsp[-1].number);
6949 >  ConfigFileEntry.dots_in_ident = (yyvsp[(3) - (4)].number);
6950   }
6951      break;
6952  
6953    case 589:
6954   #line 3404 "ircd_parser.y"
6955      {
6956 <  ConfigFileEntry.max_targets = (yyvsp[-1].number);
6956 >  ConfigFileEntry.max_targets = (yyvsp[(3) - (4)].number);
6957   }
6958      break;
6959  
# Line 6783 | Line 7007 | yyreduce:
7007      {
7008    if (ypass == 2)
7009    {
7010 <    ConfigFileEntry.compression_level = (yyvsp[-1].number);
7010 >    ConfigFileEntry.compression_level = (yyvsp[(3) - (4)].number);
7011   #ifndef HAVE_LIBZ
7012      yyerror("Ignoring compression_level -- no zlib support");
7013   #else
# Line 7106 | Line 7330 | yyreduce:
7330    case 642:
7331   #line 3621 "ircd_parser.y"
7332      {
7333 <  ConfigFileEntry.min_nonwildcard = (yyvsp[-1].number);
7333 >  ConfigFileEntry.min_nonwildcard = (yyvsp[(3) - (4)].number);
7334   }
7335      break;
7336  
7337    case 643:
7338   #line 3626 "ircd_parser.y"
7339      {
7340 <  ConfigFileEntry.min_nonwildcard_simple = (yyvsp[-1].number);
7340 >  ConfigFileEntry.min_nonwildcard_simple = (yyvsp[(3) - (4)].number);
7341   }
7342      break;
7343  
7344    case 644:
7345   #line 3631 "ircd_parser.y"
7346      {
7347 <  ConfigFileEntry.default_floodcount = (yyvsp[-1].number);
7347 >  ConfigFileEntry.default_floodcount = (yyvsp[(3) - (4)].number);
7348   }
7349      break;
7350  
7351    case 645:
7352   #line 3636 "ircd_parser.y"
7353      {
7354 <  ConfigFileEntry.client_flood = (yyvsp[-1].number);
7354 >  ConfigFileEntry.client_flood = (yyvsp[(3) - (4)].number);
7355   }
7356      break;
7357  
# Line 7180 | Line 7404 | yyreduce:
7404   #line 3688 "ircd_parser.y"
7405      {
7406    if (ypass == 2)
7407 <    ConfigFileEntry.gline_time = (yyvsp[-1].number);
7407 >    ConfigFileEntry.gline_time = (yyvsp[(3) - (4)].number);
7408   }
7409      break;
7410  
# Line 7365 | Line 7589 | yyreduce:
7589    case 700:
7590   #line 3857 "ircd_parser.y"
7591      {
7592 <  ConfigChannel.knock_delay = (yyvsp[-1].number);
7592 >  ConfigChannel.knock_delay = (yyvsp[(3) - (4)].number);
7593   }
7594      break;
7595  
7596    case 701:
7597   #line 3862 "ircd_parser.y"
7598      {
7599 <  ConfigChannel.knock_delay_channel = (yyvsp[-1].number);
7599 >  ConfigChannel.knock_delay_channel = (yyvsp[(3) - (4)].number);
7600   }
7601      break;
7602  
7603    case 702:
7604   #line 3867 "ircd_parser.y"
7605      {
7606 <  ConfigChannel.max_chans_per_user = (yyvsp[-1].number);
7606 >  ConfigChannel.max_chans_per_user = (yyvsp[(3) - (4)].number);
7607   }
7608      break;
7609  
# Line 7393 | Line 7617 | yyreduce:
7617    case 704:
7618   #line 3877 "ircd_parser.y"
7619      {
7620 <  ConfigChannel.max_bans = (yyvsp[-1].number);
7620 >  ConfigChannel.max_bans = (yyvsp[(3) - (4)].number);
7621   }
7622      break;
7623  
7624    case 705:
7625   #line 3882 "ircd_parser.y"
7626      {
7627 <  ConfigChannel.default_split_user_count = (yyvsp[-1].number);
7627 >  ConfigChannel.default_split_user_count = (yyvsp[(3) - (4)].number);
7628   }
7629      break;
7630  
7631    case 706:
7632   #line 3887 "ircd_parser.y"
7633      {
7634 <  ConfigChannel.default_split_server_count = (yyvsp[-1].number);
7634 >  ConfigChannel.default_split_server_count = (yyvsp[(3) - (4)].number);
7635   }
7636      break;
7637  
# Line 7478 | Line 7702 | yyreduce:
7702      {
7703    if (ypass == 2)
7704    {
7705 <    if (((yyvsp[-1].number) > 0) && ConfigServerHide.links_disabled == 1)
7705 >    if (((yyvsp[(3) - (4)].number) > 0) && ConfigServerHide.links_disabled == 1)
7706      {
7707 <      eventAddIsh("write_links_file", write_links_file, NULL, (yyvsp[-1].number));
7707 >      eventAddIsh("write_links_file", write_links_file, NULL, (yyvsp[(3) - (4)].number));
7708        ConfigServerHide.links_disabled = 0;
7709      }
7710  
7711 <    ConfigServerHide.links_delay = (yyvsp[-1].number);
7711 >    ConfigServerHide.links_delay = (yyvsp[(3) - (4)].number);
7712    }
7713   }
7714      break;
# Line 7514 | Line 7738 | yyreduce:
7738      break;
7739  
7740  
7741 + /* Line 1267 of yacc.c.  */
7742 + #line 7743 "y.tab.c"
7743        default: break;
7744      }
7745 +  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
7746  
7747 < /* Line 1126 of yacc.c.  */
7748 < #line 7522 "y.tab.c"
7522 <
7523 <  yyvsp -= yylen;
7524 <  yyssp -= yylen;
7525 <
7526 <
7747 >  YYPOPSTACK (yylen);
7748 >  yylen = 0;
7749    YY_STACK_PRINT (yyss, yyssp);
7750  
7751    *++yyvsp = yyval;
# Line 7552 | Line 7774 | yyerrlab:
7774    if (!yyerrstatus)
7775      {
7776        ++yynerrs;
7777 < #if YYERROR_VERBOSE
7778 <      yyn = yypact[yystate];
7779 <
7780 <      if (YYPACT_NINF < yyn && yyn < YYLAST)
7781 <        {
7782 <          int yytype = YYTRANSLATE (yychar);
7783 <          YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
7784 <          YYSIZE_T yysize = yysize0;
7785 <          YYSIZE_T yysize1;
7786 <          int yysize_overflow = 0;
7787 <          char *yymsg = 0;
7788 < #         define YYERROR_VERBOSE_ARGS_MAXIMUM 5
7789 <          char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
7790 <          int yyx;
7791 <
7792 < #if 0
7571 <          /* This is so xgettext sees the translatable formats that are
7572 <             constructed on the fly.  */
7573 <          YY_("syntax error, unexpected %s");
7574 <          YY_("syntax error, unexpected %s, expecting %s");
7575 <          YY_("syntax error, unexpected %s, expecting %s or %s");
7576 <          YY_("syntax error, unexpected %s, expecting %s or %s or %s");
7577 <          YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
7578 < #endif
7579 <          char *yyfmt;
7580 <          char const *yyf;
7581 <          static char const yyunexpected[] = "syntax error, unexpected %s";
7582 <          static char const yyexpecting[] = ", expecting %s";
7583 <          static char const yyor[] = " or %s";
7584 <          char yyformat[sizeof yyunexpected
7585 <                        + sizeof yyexpecting - 1
7586 <                        + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
7587 <                           * (sizeof yyor - 1))];
7588 <          char const *yyprefix = yyexpecting;
7589 <
7590 <          /* Start YYX at -YYN if negative to avoid negative indexes in
7591 <             YYCHECK.  */
7592 <          int yyxbegin = yyn < 0 ? -yyn : 0;
7593 <
7594 <          /* Stay within bounds of both yycheck and yytname.  */
7595 <          int yychecklim = YYLAST - yyn;
7596 <          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
7597 <          int yycount = 1;
7598 <
7599 <          yyarg[0] = yytname[yytype];
7600 <          yyfmt = yystpcpy (yyformat, yyunexpected);
7601 <
7602 <          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
7603 <            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
7777 > #if ! YYERROR_VERBOSE
7778 >      yyerror (YY_("syntax error"));
7779 > #else
7780 >      {
7781 >        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
7782 >        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
7783 >          {
7784 >            YYSIZE_T yyalloc = 2 * yysize;
7785 >            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
7786 >              yyalloc = YYSTACK_ALLOC_MAXIMUM;
7787 >            if (yymsg != yymsgbuf)
7788 >              YYSTACK_FREE (yymsg);
7789 >            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
7790 >            if (yymsg)
7791 >              yymsg_alloc = yyalloc;
7792 >            else
7793                {
7794 <                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
7795 <                  {
7607 <                    yycount = 1;
7608 <                    yysize = yysize0;
7609 <                    yyformat[sizeof yyunexpected - 1] = '\0';
7610 <                    break;
7611 <                  }
7612 <                yyarg[yycount++] = yytname[yyx];
7613 <                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
7614 <                yysize_overflow |= yysize1 < yysize;
7615 <                yysize = yysize1;
7616 <                yyfmt = yystpcpy (yyfmt, yyprefix);
7617 <                yyprefix = yyor;
7794 >                yymsg = yymsgbuf;
7795 >                yymsg_alloc = sizeof yymsgbuf;
7796                }
7797 +          }
7798  
7799 <          yyf = YY_(yyformat);
7800 <          yysize1 = yysize + yystrlen (yyf);
7801 <          yysize_overflow |= yysize1 < yysize;
7802 <          yysize = yysize1;
7803 <
7804 <          if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
7805 <            yymsg = (char *) YYSTACK_ALLOC (yysize);
7806 <          if (yymsg)
7807 <            {
7629 <              /* Avoid sprintf, as that infringes on the user's name space.
7630 <                 Don't have undefined behavior even if the translation
7631 <                 produced a string with the wrong number of "%s"s.  */
7632 <              char *yyp = yymsg;
7633 <              int yyi = 0;
7634 <              while ((*yyp = *yyf))
7635 <                {
7636 <                  if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
7637 <                    {
7638 <                      yyp += yytnamerr (yyp, yyarg[yyi++]);
7639 <                      yyf += 2;
7640 <                    }
7641 <                  else
7642 <                    {
7643 <                      yyp++;
7644 <                      yyf++;
7645 <                    }
7646 <                }
7647 <              yyerror (yymsg);
7648 <              YYSTACK_FREE (yymsg);
7649 <            }
7650 <          else
7651 <            {
7652 <              yyerror (YY_("syntax error"));
7799 >        if (0 < yysize && yysize <= yymsg_alloc)
7800 >          {
7801 >            (void) yysyntax_error (yymsg, yystate, yychar);
7802 >            yyerror (yymsg);
7803 >          }
7804 >        else
7805 >          {
7806 >            yyerror (YY_("syntax error"));
7807 >            if (yysize != 0)
7808                goto yyexhaustedlab;
7809 <            }
7810 <        }
7811 <      else
7657 < #endif /* YYERROR_VERBOSE */
7658 <        yyerror (YY_("syntax error"));
7809 >          }
7810 >      }
7811 > #endif
7812      }
7813  
7814  
# Line 7666 | Line 7819 | yyerrlab:
7819           error, discard it.  */
7820  
7821        if (yychar <= YYEOF)
7822 <        {
7822 >        {
7823            /* Return failure if at end of input.  */
7824            if (yychar == YYEOF)
7825              YYABORT;
7826 <        }
7826 >        }
7827        else
7828          {
7829 <          yydestruct ("Error: discarding", yytoken, &yylval);
7829 >          yydestruct ("Error: discarding",
7830 >                      yytoken, &yylval);
7831            yychar = YYEMPTY;
7832          }
7833      }
# Line 7691 | Line 7845 | yyerrorlab:
7845    /* Pacify compilers like GCC when the user code never invokes
7846       YYERROR and the label yyerrorlab therefore never appears in user
7847       code.  */
7848 <  if (0)
7848 >  if (/*CONSTCOND*/ 0)
7849       goto yyerrorlab;
7850  
7851 < yyvsp -= yylen;
7852 <  yyssp -= yylen;
7851 >  /* Do not reclaim the symbols of the rule which action triggered
7852 >     this YYERROR.  */
7853 >  YYPOPSTACK (yylen);
7854 >  yylen = 0;
7855 >  YY_STACK_PRINT (yyss, yyssp);
7856    yystate = *yyssp;
7857    goto yyerrlab1;
7858  
# Line 7725 | Line 7882 | yyerrlab1:
7882          YYABORT;
7883  
7884  
7885 <      yydestruct ("Error: popping", yystos[yystate], yyvsp);
7886 <      YYPOPSTACK;
7885 >      yydestruct ("Error: popping",
7886 >                  yystos[yystate], yyvsp);
7887 >      YYPOPSTACK (1);
7888        yystate = *yyssp;
7889        YY_STACK_PRINT (yyss, yyssp);
7890      }
# Line 7737 | Line 7895 | yyerrlab1:
7895    *++yyvsp = yylval;
7896  
7897  
7898 <  /* Shift the error token. */
7898 >  /* Shift the error token.  */
7899    YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
7900  
7901    yystate = yyn;
# Line 7772 | Line 7930 | yyreturn:
7930    if (yychar != YYEOF && yychar != YYEMPTY)
7931       yydestruct ("Cleanup: discarding lookahead",
7932                   yytoken, &yylval);
7933 +  /* Do not reclaim the symbols of the rule which action triggered
7934 +     this YYABORT or YYACCEPT.  */
7935 +  YYPOPSTACK (yylen);
7936 +  YY_STACK_PRINT (yyss, yyssp);
7937    while (yyssp != yyss)
7938      {
7939        yydestruct ("Cleanup: popping",
7940                    yystos[*yyssp], yyvsp);
7941 <      YYPOPSTACK;
7941 >      YYPOPSTACK (1);
7942      }
7943   #ifndef yyoverflow
7944    if (yyss != yyssa)
7945      YYSTACK_FREE (yyss);
7946   #endif
7947 + #if YYERROR_VERBOSE
7948 +  if (yymsg != yymsgbuf)
7949 +    YYSTACK_FREE (yymsg);
7950 + #endif
7951    return yyresult;
7952   }
7953  

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines