diff options
author | Sergey Poznyakoff <gray@gnu.org.ua> | 2007-11-05 09:18:38 +0000 |
---|---|---|
committer | Sergey Poznyakoff <gray@gnu.org.ua> | 2007-11-05 09:18:38 +0000 |
commit | ce9e898286c31564511c893480c66b25266f01f0 (patch) | |
tree | 168908da3af701ed16c689a188f6373222187a8f | |
parent | 54a7ce71b297f9ba5eea27f52b604031b86e0c88 (diff) | |
download | mailutils-ce9e898286c31564511c893480c66b25266f01f0.tar.gz mailutils-ce9e898286c31564511c893480c66b25266f01f0.tar.bz2 |
Remove generated file, add source instead
-rw-r--r-- | mailbox/cfg_parser.c | 2563 | ||||
-rw-r--r-- | mailbox/cfg_parser.y | 1035 |
2 files changed, 1035 insertions, 2563 deletions
diff --git a/mailbox/cfg_parser.c b/mailbox/cfg_parser.c deleted file mode 100644 index 444bee416..000000000 --- a/mailbox/cfg_parser.c +++ /dev/null @@ -1,2563 +0,0 @@ -/* A Bison parser, made by GNU Bison 2.3. */ - -/* Skeleton implementation for Bison's Yacc-like parsers in C - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* C LALR(1) parser skeleton written by Richard Stallman, by - simplifying the original so-called "semantic" parser. */ - -/* All symbols defined below should begin with mu_cfg_yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Bison version. */ -#define YYBISON_VERSION "2.3" - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Using locations. */ -#define YYLSP_NEEDED 0 - - - -/* Tokens. */ -#ifndef YYTOKENTYPE -# define YYTOKENTYPE - /* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ - enum mu_cfg_yytokentype { - MU_CFG_EOL_TOKEN = 258, - MU_CFG_START_TOKEN = 259, - MU_CFG_END_TOKEN = 260, - MU_CFG_STRING_TOKEN = 261 - }; -#endif -/* Tokens. */ -#define MU_CFG_EOL_TOKEN 258 -#define MU_CFG_START_TOKEN 259 -#define MU_CFG_END_TOKEN 260 -#define MU_CFG_STRING_TOKEN 261 - - - - -/* Copy the first part of user declarations. */ -#line 1 "cfg_parser.y" - -/* cfg_parser.y -- general-purpose configuration file parser - Copyright (C) 2007 Free Software Foundation, Inc. - - GNU Mailutils is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License as - published by the Free Software Foundation; either version 3, or (at - your option) any later version. - - This program is distributed in the hope that it will be useful, but - WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see <http://www.gnu.org/licenses/>. -*/ - -#include <stdio.h> -#include <stdlib.h> -#include <stdarg.h> -#include <string.h> -#include <netdb.h> -#include "intprops.h" -#include <mailutils/nls.h> -#include <mailutils/cfg.h> -#include <mailutils/errno.h> -#include <mailutils/error.h> - -static mu_cfg_node_t *parse_tree; -mu_cfg_locus_t mu_cfg_locus; -int mu_cfg_tie_in; - -static int _mu_cfg_errcnt; -static mu_cfg_lexer_t _mu_cfg_lexer; -mu_cfg_perror_t mu_cfg_perror; -static void *_mu_cfg_lexer_data; -mu_cfg_alloc_t _mu_cfg_alloc; -mu_cfg_free_t _mu_cfg_free; - -static int -mu_cfg_yyerror (char *s) -{ - mu_cfg_perror (_mu_cfg_lexer_data, &mu_cfg_locus, "%s", s); - return 0; -} - -static int -mu_cfg_yylex () -{ - return _mu_cfg_lexer (_mu_cfg_lexer_data); -} - -static mu_cfg_node_t * -mu_cfg_alloc_node (enum mu_cfg_node_type type, mu_cfg_locus_t *loc, - char *tag, char *label, mu_cfg_node_t *node) -{ - char *p; - mu_cfg_node_t *np; - size_t size = sizeof *np + strlen (tag) + 1 - + (label ? (strlen (label) + 1) : 0); - np = _mu_cfg_alloc (size); - if (!np) - { - mu_cfg_perror (_mu_cfg_lexer_data, &mu_cfg_locus, - _("Not enough memory")); - abort(); - } - np->type = type; - np->locus = *loc; - p = (char*) (np + 1); - np->tag_name = p; - strcpy (p, tag); - p += strlen (p) + 1; - if (label) - { - np->tag_label = p; - strcpy (p, label); - } - else - np->tag_label = label; - np->node = node; - np->next = NULL; - return np; -} - -static void -_mu_cfg_default_perror (void *ptr, const mu_cfg_locus_t *loc, - const char *fmt, ...) -{ - va_list ap; - - fprintf (stderr, "%s:", loc->file ? loc->file : _("unknown file")); - if (loc->line > 0) - fprintf (stderr, "%lu", (unsigned long) loc->line); - else - fprintf (stderr, "%s", _("unknown line")); - fprintf (stderr, ": "); - va_start (ap, fmt); - vfprintf (stderr, fmt, ap); - va_end (ap); - fprintf (stderr, "\n"); -} - - - -/* Enabling traces. */ -#ifndef YYDEBUG -# define YYDEBUG 1 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -# undef YYERROR_VERBOSE -# define YYERROR_VERBOSE 1 -#else -# define YYERROR_VERBOSE 0 -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -# define YYTOKEN_TABLE 0 -#endif - -#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -#line 115 "cfg_parser.y" -{ - mu_cfg_node_t node; - mu_cfg_node_t *pnode; - struct - { - mu_cfg_node_t *head, *tail; - } nodelist; - char *string; -} -/* Line 187 of yacc.c. */ -#line 224 "cfg_parser.c" - YYSTYPE; -# define mu_cfg_yystype YYSTYPE /* obsolescent; will be withdrawn */ -# define YYSTYPE_IS_DECLARED 1 -# define YYSTYPE_IS_TRIVIAL 1 -#endif - - - -/* Copy the second part of user declarations. */ - - -/* Line 216 of yacc.c. */ -#line 237 "cfg_parser.c" - -#ifdef short -# undef short -#endif - -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 mu_cfg_yytype_uint8; -#else -typedef unsigned char mu_cfg_yytype_uint8; -#endif - -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 mu_cfg_yytype_int8; -#elif (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -typedef signed char mu_cfg_yytype_int8; -#else -typedef short int mu_cfg_yytype_int8; -#endif - -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 mu_cfg_yytype_uint16; -#else -typedef unsigned short int mu_cfg_yytype_uint16; -#endif - -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 mu_cfg_yytype_int16; -#else -typedef short int mu_cfg_yytype_int16; -#endif - -#ifndef YYSIZE_T -# ifdef __SIZE_TYPE__ -# define YYSIZE_T __SIZE_TYPE__ -# elif defined size_t -# define YYSIZE_T size_t -# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ -# define YYSIZE_T size_t -# else -# define YYSIZE_T unsigned int -# endif -#endif - -#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) - -#ifndef YY_ -# if YYENABLE_NLS -# if ENABLE_NLS -# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ -# define YY_(msgid) dgettext ("bison-runtime", msgid) -# endif -# endif -# ifndef YY_ -# define YY_(msgid) msgid -# endif -#endif - -/* Suppress unused-variable warnings by "using" E. */ -#if ! defined lint || defined __GNUC__ -# define YYUSE(e) ((void) (e)) -#else -# define YYUSE(e) /* empty */ -#endif - -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -# define YYID(n) (n) -#else -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static int -YYID (int i) -#else -static int -YYID (i) - int i; -#endif -{ - return i; -} -#endif - -#if ! defined mu_cfg_yyoverflow || YYERROR_VERBOSE - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -# ifdef YYSTACK_USE_ALLOCA -# if YYSTACK_USE_ALLOCA -# ifdef __GNUC__ -# define YYSTACK_ALLOC __builtin_alloca -# elif defined __BUILTIN_VA_ARG_INCR -# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ -# elif defined _AIX -# define YYSTACK_ALLOC __alloca -# elif defined _MSC_VER -# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ -# define alloca _alloca -# else -# define YYSTACK_ALLOC alloca -# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# endif -# endif -# endif - -# ifdef YYSTACK_ALLOC - /* Pacify GCC's `empty if-body' warning. */ -# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) -# ifndef YYSTACK_ALLOC_MAXIMUM - /* The OS might guarantee only one guard page at the bottom of the stack, - and a page size can be as small as 4096 bytes. So we cannot safely - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number - to allow for a few compiler-allocated temporary stack slots. */ -# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ -# endif -# else -# define YYSTACK_ALLOC YYMALLOC -# define YYSTACK_FREE YYFREE -# ifndef YYSTACK_ALLOC_MAXIMUM -# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM -# endif -# if (defined __cplusplus && ! defined _STDLIB_H \ - && ! ((defined YYMALLOC || defined malloc) \ - && (defined YYFREE || defined free))) -# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ -# ifndef _STDLIB_H -# define _STDLIB_H 1 -# endif -# endif -# ifndef YYMALLOC -# define YYMALLOC malloc -# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# ifndef YYFREE -# define YYFREE free -# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -void free (void *); /* INFRINGES ON USER NAME SPACE */ -# endif -# endif -# endif -#endif /* ! defined mu_cfg_yyoverflow || YYERROR_VERBOSE */ - - -#if (! defined mu_cfg_yyoverflow \ - && (! defined __cplusplus \ - || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union mu_cfg_yyalloc -{ - mu_cfg_yytype_int16 mu_cfg_yyss; - YYSTYPE mu_cfg_yyvs; - }; - -/* The size of the maximum gap between one aligned stack and the next. */ -# define YYSTACK_GAP_MAXIMUM (sizeof (union mu_cfg_yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -# define YYSTACK_BYTES(N) \ - ((N) * (sizeof (mu_cfg_yytype_int16) + sizeof (YYSTYPE)) \ - + YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -# ifndef YYCOPY -# if defined __GNUC__ && 1 < __GNUC__ -# define YYCOPY(To, From, Count) \ - __builtin_memcpy (To, From, (Count) * sizeof (*(From))) -# else -# define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T mu_cfg_yyi; \ - for (mu_cfg_yyi = 0; mu_cfg_yyi < (Count); mu_cfg_yyi++) \ - (To)[mu_cfg_yyi] = (From)[mu_cfg_yyi]; \ - } \ - while (YYID (0)) -# endif -# endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -# define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T mu_cfg_yynewbytes; \ - YYCOPY (&mu_cfg_yyptr->Stack, Stack, mu_cfg_yysize); \ - Stack = &mu_cfg_yyptr->Stack; \ - mu_cfg_yynewbytes = mu_cfg_yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ - mu_cfg_yyptr += mu_cfg_yynewbytes / sizeof (*mu_cfg_yyptr); \ - } \ - while (YYID (0)) - -#endif - -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 10 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 17 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 7 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 8 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 12 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 19 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 261 - -#define YYTRANSLATE(YYX) \ - ((unsigned int) (YYX) <= YYMAXUTOK ? mu_cfg_yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const mu_cfg_yytype_uint8 mu_cfg_yytranslate[] = -{ - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, - 5, 6 -}; - -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const mu_cfg_yytype_uint8 mu_cfg_yyprhs[] = -{ - 0, 0, 3, 5, 7, 10, 11, 13, 15, 18, - 24, 25, 26 -}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const mu_cfg_yytype_int8 mu_cfg_yyrhs[] = -{ - 8, 0, -1, 9, -1, 12, -1, 9, 12, -1, - -1, 11, -1, 3, -1, 11, 3, -1, 4, 10, - 9, 5, 3, -1, -1, -1, 6, 13, 6, 14, - 3, -1 -}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const mu_cfg_yytype_uint8 mu_cfg_yyrline[] = -{ - 0, 127, 127, 133, 137, 145, 146, 149, 150, 153, - 170, 171, 170 -}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const mu_cfg_yytname[] = -{ - "$end", "error", "$undefined", "MU_CFG_EOL_TOKEN", "MU_CFG_START_TOKEN", - "MU_CFG_END_TOKEN", "MU_CFG_STRING_TOKEN", "$accept", "input", "taglist", - "opt_eol", "eol", "tag", "@1", "@2", 0 -}; -#endif - -# ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const mu_cfg_yytype_uint16 mu_cfg_yytoknum[] = -{ - 0, 256, 257, 258, 259, 260, 261 -}; -# endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const mu_cfg_yytype_uint8 mu_cfg_yyr1[] = -{ - 0, 7, 8, 9, 9, 10, 10, 11, 11, 12, - 13, 14, 12 -}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const mu_cfg_yytype_uint8 mu_cfg_yyr2[] = -{ - 0, 2, 1, 1, 2, 0, 1, 1, 2, 5, - 0, 0, 5 -}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const mu_cfg_yytype_uint8 mu_cfg_yydefact[] = -{ - 0, 5, 10, 0, 2, 3, 7, 0, 6, 0, - 1, 4, 0, 8, 11, 0, 0, 9, 12 -}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const mu_cfg_yytype_int8 mu_cfg_yydefgoto[] = -{ - -1, 3, 4, 7, 8, 5, 9, 16 -}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -5 -static const mu_cfg_yytype_int8 mu_cfg_yypact[] = -{ - 0, 2, -5, 7, 0, -5, -5, 0, 6, 4, - -5, -5, -3, -5, -5, 8, 9, -5, -5 -}; - -/* YYPGOTO[NTERM-NUM]. */ -static const mu_cfg_yytype_int8 mu_cfg_yypgoto[] = -{ - -5, -5, 10, -5, -5, -4, -5, -5 -}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -1 -static const mu_cfg_yytype_uint8 mu_cfg_yytable[] = -{ - 11, 1, 15, 2, 1, 6, 2, 10, 11, 13, - 14, 17, 18, 0, 0, 0, 0, 12 -}; - -static const mu_cfg_yytype_int8 mu_cfg_yycheck[] = -{ - 4, 4, 5, 6, 4, 3, 6, 0, 12, 3, - 6, 3, 3, -1, -1, -1, -1, 7 -}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const mu_cfg_yytype_uint8 mu_cfg_yystos[] = -{ - 0, 4, 6, 8, 9, 12, 3, 10, 11, 13, - 0, 12, 9, 3, 6, 5, 14, 3, 3 -}; - -#define mu_cfg_yyerrok (mu_cfg_yyerrstatus = 0) -#define mu_cfg_yyclearin (mu_cfg_yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 - -#define YYACCEPT goto mu_cfg_yyacceptlab -#define YYABORT goto mu_cfg_yyabortlab -#define YYERROR goto mu_cfg_yyerrorlab - - -/* Like YYERROR except do call mu_cfg_yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ - -#define YYFAIL goto mu_cfg_yyerrlab - -#define YYRECOVERING() (!!mu_cfg_yyerrstatus) - -#define YYBACKUP(Token, Value) \ -do \ - if (mu_cfg_yychar == YYEMPTY && mu_cfg_yylen == 1) \ - { \ - mu_cfg_yychar = (Token); \ - mu_cfg_yylval = (Value); \ - mu_cfg_yytoken = YYTRANSLATE (mu_cfg_yychar); \ - YYPOPSTACK (1); \ - goto mu_cfg_yybackup; \ - } \ - else \ - { \ - mu_cfg_yyerror (YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ -while (YYID (0)) - - -#define YYTERROR 1 -#define YYERRCODE 256 - - -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID (N)) \ - { \ - (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = \ - YYRHSLOC (Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = \ - YYRHSLOC (Rhs, 0).last_column; \ - } \ - while (YYID (0)) -#endif - - -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -#ifndef YY_LOCATION_PRINT -# if YYLTYPE_IS_TRIVIAL -# define YY_LOCATION_PRINT(File, Loc) \ - fprintf (File, "%d.%d-%d.%d", \ - (Loc).first_line, (Loc).first_column, \ - (Loc).last_line, (Loc).last_column) -# else -# define YY_LOCATION_PRINT(File, Loc) ((void) 0) -# endif -#endif - - -/* YYLEX -- calling `mu_cfg_yylex' with the right arguments. */ - -#ifdef YYLEX_PARAM -# define YYLEX mu_cfg_yylex (YYLEX_PARAM) -#else -# define YYLEX mu_cfg_yylex () -#endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -# ifndef YYFPRINTF -# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ -# define YYFPRINTF fprintf -# endif - -# define YYDPRINTF(Args) \ -do { \ - if (mu_cfg_yydebug) \ - YYFPRINTF Args; \ -} while (YYID (0)) - -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ -do { \ - if (mu_cfg_yydebug) \ - { \ - YYFPRINTF (stderr, "%s ", Title); \ - mu_cfg_yy_symbol_print (stderr, \ - Type, Value); \ - YYFPRINTF (stderr, "\n"); \ - } \ -} while (YYID (0)) - - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -mu_cfg_yy_symbol_value_print (FILE *mu_cfg_yyoutput, int mu_cfg_yytype, YYSTYPE const * const mu_cfg_yyvaluep) -#else -static void -mu_cfg_yy_symbol_value_print (mu_cfg_yyoutput, mu_cfg_yytype, mu_cfg_yyvaluep) - FILE *mu_cfg_yyoutput; - int mu_cfg_yytype; - YYSTYPE const * const mu_cfg_yyvaluep; -#endif -{ - if (!mu_cfg_yyvaluep) - return; -# ifdef YYPRINT - if (mu_cfg_yytype < YYNTOKENS) - YYPRINT (mu_cfg_yyoutput, mu_cfg_yytoknum[mu_cfg_yytype], *mu_cfg_yyvaluep); -# else - YYUSE (mu_cfg_yyoutput); -# endif - switch (mu_cfg_yytype) - { - default: - break; - } -} - - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -mu_cfg_yy_symbol_print (FILE *mu_cfg_yyoutput, int mu_cfg_yytype, YYSTYPE const * const mu_cfg_yyvaluep) -#else -static void -mu_cfg_yy_symbol_print (mu_cfg_yyoutput, mu_cfg_yytype, mu_cfg_yyvaluep) - FILE *mu_cfg_yyoutput; - int mu_cfg_yytype; - YYSTYPE const * const mu_cfg_yyvaluep; -#endif -{ - if (mu_cfg_yytype < YYNTOKENS) - YYFPRINTF (mu_cfg_yyoutput, "token %s (", mu_cfg_yytname[mu_cfg_yytype]); - else - YYFPRINTF (mu_cfg_yyoutput, "nterm %s (", mu_cfg_yytname[mu_cfg_yytype]); - - mu_cfg_yy_symbol_value_print (mu_cfg_yyoutput, mu_cfg_yytype, mu_cfg_yyvaluep); - YYFPRINTF (mu_cfg_yyoutput, ")"); -} - -/*------------------------------------------------------------------. -| mu_cfg_yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -mu_cfg_yy_stack_print (mu_cfg_yytype_int16 *bottom, mu_cfg_yytype_int16 *top) -#else -static void -mu_cfg_yy_stack_print (bottom, top) - mu_cfg_yytype_int16 *bottom; - mu_cfg_yytype_int16 *top; -#endif -{ - YYFPRINTF (stderr, "Stack now"); - for (; bottom <= top; ++bottom) - YYFPRINTF (stderr, " %d", *bottom); - YYFPRINTF (stderr, "\n"); -} - -# define YY_STACK_PRINT(Bottom, Top) \ -do { \ - if (mu_cfg_yydebug) \ - mu_cfg_yy_stack_print ((Bottom), (Top)); \ -} while (YYID (0)) - - -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static void -mu_cfg_yy_reduce_print (YYSTYPE *mu_cfg_yyvsp, int mu_cfg_yyrule) -#else -static void -mu_cfg_yy_reduce_print (mu_cfg_yyvsp, mu_cfg_yyrule) - YYSTYPE *mu_cfg_yyvsp; - int mu_cfg_yyrule; -#endif -{ - int mu_cfg_yynrhs = mu_cfg_yyr2[mu_cfg_yyrule]; - int mu_cfg_yyi; - unsigned long int mu_cfg_yylno = mu_cfg_yyrline[mu_cfg_yyrule]; - YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", - mu_cfg_yyrule - 1, mu_cfg_yylno); - /* The symbols being reduced. */ - for (mu_cfg_yyi = 0; mu_cfg_yyi < mu_cfg_yynrhs; mu_cfg_yyi++) - { - fprintf (stderr, " $%d = ", mu_cfg_yyi + 1); - mu_cfg_yy_symbol_print (stderr, mu_cfg_yyrhs[mu_cfg_yyprhs[mu_cfg_yyrule] + mu_cfg_yyi], - &(mu_cfg_yyvsp[(mu_cfg_yyi + 1) - (mu_cfg_yynrhs)]) - ); - fprintf (stderr, "\n"); - } -} - -# define YY_REDUCE_PRINT(Rule) \ -do { \ - if (mu_cfg_yydebug) \ - mu_cfg_yy_reduce_print (mu_cfg_yyvsp, Rule); \ -} while (YYID (0)) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int mu_cfg_yydebug; -#else /* !YYDEBUG */ -# define YYDPRINTF(Args) -# define YY_SYMBOL_PRINT(Title, Type, Value, Location) -# define YY_STACK_PRINT(Bottom, Top) -# define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ - - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -# define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#ifndef YYMAXDEPTH -# define YYMAXDEPTH 10000 -#endif - - - -#if YYERROR_VERBOSE - -# ifndef mu_cfg_yystrlen -# if defined __GLIBC__ && defined _STRING_H -# define mu_cfg_yystrlen strlen -# else -/* Return the length of YYSTR. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static YYSIZE_T -mu_cfg_yystrlen (const char *mu_cfg_yystr) -#else -static YYSIZE_T -mu_cfg_yystrlen (mu_cfg_yystr) - const char *mu_cfg_yystr; -#endif -{ - YYSIZE_T mu_cfg_yylen; - for (mu_cfg_yylen = 0; mu_cfg_yystr[mu_cfg_yylen]; mu_cfg_yylen++) - continue; - return mu_cfg_yylen; -} -# endif -# endif - -# ifndef mu_cfg_yystpcpy -# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE -# define mu_cfg_yystpcpy stpcpy -# else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -#if (defined __STDC__ || defined __C99__FUNC__ \ - || defined __cplusplus || defined _MSC_VER) -static char * -mu_cfg_yystpcpy (char *mu_cfg_yydest, const char *mu_cfg_yysrc) -#else -static char * -mu_cfg_yystpcpy (mu_cfg_yydest, mu_cfg_yysrc) - char *mu_cfg_yydest; - const char *mu_cfg_yysrc; -#endif -{ - char *mu_cfg_yyd = mu_cfg_yydest; - const char *mu_cfg_yys = mu_cfg_yysrc; - - while ((*mu_cfg_yyd++ = *mu_cfg_yys++) != '\0') - continue; - - return mu_cfg_yyd - 1; -} -# endif -# endif - -# ifndef mu_cfg_yytnamerr -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary - quotes and backslashes, so that it's suitable for mu_cfg_yyerror. The - heuristic is that double-quoting is unnecessary unless the string - contains an apostrophe, a comma, or backslash (other than - backslash-backslash). YYSTR is taken from mu_cfg_yytname. If YYRES is - null, do not copy; instead, return the length of what the result - would have been. */ -static YYSIZE_T -mu_cfg_yytnamerr (char *mu_cfg_yyres, const char *mu_cfg_yystr) -{ - if (*mu_cfg_yystr == '"') - { - YYSIZE_T mu_cfg_yyn = 0; - char const *mu_cfg_yyp = mu_cfg_yystr; - - for (;;) - switch (*++mu_cfg_yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++mu_cfg_yyp != '\\') - goto do_not_strip_quotes; - /* Fall through. */ - default: - if (mu_cfg_yyres) - mu_cfg_yyres[mu_cfg_yyn] = *mu_cfg_yyp; - mu_cfg_yyn++; - break; - - case '"': - if (mu_cfg_yyres) - mu_cfg_yyres[mu_cfg_yyn] = '\0'; - return mu_cfg_yyn; - } - do_not_strip_quotes: ; - } - - if (! mu_cfg_yyres) - return mu_cfg_yystrlen (mu_cfg_yystr); - - return mu_cfg_yystpcpy (mu_cfg_yyres, mu_cfg_yystr) - mu_cfg_yyres; -} -# endif - -/* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T -mu_cfg_yysyntax_error (char *mu_cfg_yyresult, int mu_cfg_yystate, int mu_cfg_yychar) -{ - int mu_cfg_yyn = mu_cfg_yypact[mu_cfg_yystate]; - - if (! (YYPACT_NINF < mu_cfg_yyn && mu_cfg_yyn <= YYLAST)) - return 0; - else - { - int mu_cfg_yytype = YYTRANSLATE (mu_cfg_yychar); - YYSIZE_T mu_cfg_yysize0 = mu_cfg_yytnamerr (0, mu_cfg_yytname[mu_cfg_yytype]); - YYSIZE_T mu_cfg_yysize = mu_cfg_yysize0; - YYSIZE_T mu_cfg_yysize1; - int mu_cfg_yysize_overflow = 0; - enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; - char const *mu_cfg_yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int mu_cfg_yyx; - -# if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -# endif - char *mu_cfg_yyfmt; - char const *mu_cfg_yyf; - static char const mu_cfg_yyunexpected[] = "syntax error, unexpected %s"; - static char const mu_cfg_yyexpecting[] = ", expecting %s"; - static char const mu_cfg_yyor[] = " or %s"; - char mu_cfg_yyformat[sizeof mu_cfg_yyunexpected - + sizeof mu_cfg_yyexpecting - 1 - + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) - * (sizeof mu_cfg_yyor - 1))]; - char const *mu_cfg_yyprefix = mu_cfg_yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int mu_cfg_yyxbegin = mu_cfg_yyn < 0 ? -mu_cfg_yyn : 0; - - /* Stay within bounds of both mu_cfg_yycheck and mu_cfg_yytname. */ - int mu_cfg_yychecklim = YYLAST - mu_cfg_yyn + 1; - int mu_cfg_yyxend = mu_cfg_yychecklim < YYNTOKENS ? mu_cfg_yychecklim : YYNTOKENS; - int mu_cfg_yycount = 1; - - mu_cfg_yyarg[0] = mu_cfg_yytname[mu_cfg_yytype]; - mu_cfg_yyfmt = mu_cfg_yystpcpy (mu_cfg_yyformat, mu_cfg_yyunexpected); - - for (mu_cfg_yyx = mu_cfg_yyxbegin; mu_cfg_yyx < mu_cfg_yyxend; ++mu_cfg_yyx) - if (mu_cfg_yycheck[mu_cfg_yyx + mu_cfg_yyn] == mu_cfg_yyx && mu_cfg_yyx != YYTERROR) - { - if (mu_cfg_yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - mu_cfg_yycount = 1; - mu_cfg_yysize = mu_cfg_yysize0; - mu_cfg_yyformat[sizeof mu_cfg_yyunexpected - 1] = '\0'; - break; - } - mu_cfg_yyarg[mu_cfg_yycount++] = mu_cfg_yytname[mu_cfg_yyx]; - mu_cfg_yysize1 = mu_cfg_yysize + mu_cfg_yytnamerr (0, mu_cfg_yytname[mu_cfg_yyx]); - mu_cfg_yysize_overflow |= (mu_cfg_yysize1 < mu_cfg_yysize); - mu_cfg_yysize = mu_cfg_yysize1; - mu_cfg_yyfmt = mu_cfg_yystpcpy (mu_cfg_yyfmt, mu_cfg_yyprefix); - mu_cfg_yyprefix = mu_cfg_yyor; - } - - mu_cfg_yyf = YY_(mu_cfg_yyformat); - mu_cfg_yysize1 = mu_cfg_yysize + mu_cfg_yystrlen (mu_cfg_yyf); - mu_cfg_yysize_overflow |= (mu_cfg_yysize1 < mu_cfg_yysize); - mu_cfg_yysize = mu_cfg_yysize1; - - if (mu_cfg_yysize_overflow) - retur |