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 |
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 |
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" |
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 |
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 |
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 |
|
|
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 |
|
|
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 |
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 |
|
|
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. */ |
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, |
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, |
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, |
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, |
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", |
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, |
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, |
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, |
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, |
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, |
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, |
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, |
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, |
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, |
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, |
2622 |
|
yychar = (Token); \ |
2623 |
|
yylval = (Value); \ |
2624 |
|
yytoken = YYTRANSLATE (yychar); \ |
2625 |
< |
YYPOPSTACK; \ |
2625 |
> |
YYPOPSTACK (1); \ |
2626 |
|
goto yybackup; \ |
2627 |
|
} \ |
2628 |
|
else \ |
2630 |
|
yyerror (YY_("syntax error: cannot back up")); \ |
2631 |
|
YYERROR; \ |
2632 |
|
} \ |
2633 |
< |
while (0) |
2633 |
> |
while (YYID (0)) |
2634 |
|
|
2635 |
|
|
2636 |
|
#define YYTERROR 1 |
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; \ |
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 |
|
|
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 |
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 |
|
} |
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. */ |
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; |
2935 |
|
{ |
2936 |
|
if (*yystr == '"') |
2937 |
|
{ |
2938 |
< |
size_t yyn = 0; |
2938 |
> |
YYSIZE_T yyn = 0; |
2939 |
|
char const *yyp = yystr; |
2940 |
|
|
2941 |
|
for (;;) |
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 |
3097 |
|
YYSTYPE *yyvaluep; |
3098 |
|
#endif |
3099 |
|
{ |
3100 |
< |
/* Pacify ``unused variable'' warnings. */ |
2882 |
< |
(void) yyvaluep; |
3100 |
> |
YYUSE (yyvaluep); |
3101 |
|
|
3102 |
|
if (!yymsg) |
3103 |
|
yymsg = "Deleting"; |
3107 |
|
{ |
3108 |
|
|
3109 |
|
default: |
3110 |
< |
break; |
3110 |
> |
break; |
3111 |
|
} |
3112 |
|
} |
3113 |
|
|
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 (); |
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 |
|
{ |
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, |
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]; |
3202 |
|
|
3203 |
|
|
3204 |
|
|
3205 |
< |
#define YYPOPSTACK (yyvsp--, yyssp--) |
3205 |
> |
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) |
3206 |
|
|
3207 |
|
YYSIZE_T yystacksize = YYINITDEPTH; |
3208 |
|
|
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 |
|
|
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: |
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 |
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) |
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; |
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 |
|
|
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 |
|
|
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: |
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; |
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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; |
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 |
|
} |
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; |
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) |
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) |
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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."); |
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 |
|
|
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 |
|
|
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 |
|
|
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 |
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 |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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; |
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; |
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 |
|
|
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 |
|
} |
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 |
|
|
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 |
|
} |
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; |
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 |
|
|