WebSVN – Kolibri OS – Blame – /contrib/toolchain/binutils/binutils/arparse.c

Rev	Author	Line No.	Line
5219	serge	1	/* A Bison parser, made by GNU Bison 2.3. */
		2
		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
		10	the Free Software Foundation; either version 2, or (at your option)
		11	any later version.
		12
		13	This program is distributed in the hope that it will be useful,
		14	but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		16	GNU General Public License for more details.
		17
		18	You should have received a copy of the GNU General Public License
		19	along with this program; if not, write to the Free Software
		20	Foundation, Inc., 51 Franklin Street, Fifth Floor,
		21	Boston, MA 02110-1301, USA. */
		22
		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	/* 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
		41	variables, as they might otherwise be expanded by user macros.
		42	There are some unavoidable exceptions within include files to
		43	define necessary library symbols; they are noted "INFRINGES ON
		44	USER NAME SPACE" below. */
		45
		46	/* Identify Bison output. */
		47	#define YYBISON 1
		48
		49	/* Bison version. */
		50	#define YYBISON_VERSION "2.3"
		51
		52	/* Skeleton name. */
		53	#define YYSKELETON_NAME "yacc.c"
		54
		55	/* Pure parsers. */
		56	#define YYPURE 0
		57
		58	/* Using locations. */
		59	#define YYLSP_NEEDED 0
		60
		61
		62
		63	/* Tokens. */
		64	#ifndef YYTOKENTYPE
		65	# define YYTOKENTYPE
		66	/* Put the tokens into the symbol table, so that GDB and other debuggers
		67	know about them. */
		68	enum yytokentype {
		69	NEWLINE = 258,
		70	VERBOSE = 259,
		71	FILENAME = 260,
		72	ADDLIB = 261,
		73	LIST = 262,
		74	ADDMOD = 263,
		75	CLEAR = 264,
		76	CREATE = 265,
		77	DELETE = 266,
		78	DIRECTORY = 267,
		79	END = 268,
		80	EXTRACT = 269,
		81	FULLDIR = 270,
		82	HELP = 271,
		83	QUIT = 272,
		84	REPLACE = 273,
		85	SAVE = 274,
		86	OPEN = 275
		87	};
		88	#endif
		89	/* Tokens. */
		90	#define NEWLINE 258
		91	#define VERBOSE 259
		92	#define FILENAME 260
		93	#define ADDLIB 261
		94	#define LIST 262
		95	#define ADDMOD 263
		96	#define CLEAR 264
		97	#define CREATE 265
		98	#define DELETE 266
		99	#define DIRECTORY 267
		100	#define END 268
		101	#define EXTRACT 269
		102	#define FULLDIR 270
		103	#define HELP 271
		104	#define QUIT 272
		105	#define REPLACE 273
		106	#define SAVE 274
		107	#define OPEN 275
		108
		109
		110
		111
		112	/* Copy the first part of user declarations. */
		113	#line 1 "arparse.y"
		114
		115	/* arparse.y - Stange script language parser */
		116
		117	/* Copyright 1992, 1993, 1995, 1997, 1999, 2002, 2003, 2005, 2007
		118	Free Software Foundation, Inc.
		119
		120	This file is part of GNU Binutils.
		121
		122	This program is free software; you can redistribute it and/or modify
		123	it under the terms of the GNU General Public License as published by
		124	the Free Software Foundation; either version 3 of the License, or
		125	(at your option) any later version.
		126
		127	This program is distributed in the hope that it will be useful,
		128	but WITHOUT ANY WARRANTY; without even the implied warranty of
		129	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		130	GNU General Public License for more details.
		131
		132	You should have received a copy of the GNU General Public License
		133	along with this program; if not, write to the Free Software
		134	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
		135	MA 02110-1301, USA. */
		136
		137
		138	/* Contributed by Steve Chamberlain
		139	sac@cygnus.com
		140
		141	*/
		142	#define DONTDECLARE_MALLOC
		143	#include "sysdep.h"
		144	#include "bfd.h"
		145	#include "arsup.h"
		146	extern int verbose;
		147	extern int yylex (void);
		148	static int yyerror (const char *);
		149
		150
		151	/* Enabling traces. */
		152	#ifndef YYDEBUG
		153	# define YYDEBUG 0
		154	#endif
		155
		156	/* Enabling verbose error messages. */
		157	#ifdef YYERROR_VERBOSE
		158	# undef YYERROR_VERBOSE
		159	# define YYERROR_VERBOSE 1
		160	#else
		161	# define YYERROR_VERBOSE 0
		162	#endif
		163
		164	/* Enabling the token table. */
		165	#ifndef YYTOKEN_TABLE
		166	# define YYTOKEN_TABLE 0
		167	#endif
		168
		169	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
		170	typedef union YYSTYPE
		171	#line 38 "arparse.y"
		172	{
		173	char *name;
		174	struct list *list ;
		175
		176	}
		177	/* Line 193 of yacc.c. */
		178	#line 179 "arparse.c"
		179	YYSTYPE;
		180	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
		181	# define YYSTYPE_IS_DECLARED 1
		182	# define YYSTYPE_IS_TRIVIAL 1
		183	#endif
		184
		185
		186
		187	/* Copy the second part of user declarations. */
		188
		189
		190	/* Line 216 of yacc.c. */
		191	#line 192 "arparse.c"
		192
		193	#ifdef short
		194	# undef short
		195	#endif
		196
		197	#ifdef YYTYPE_UINT8
		198	typedef YYTYPE_UINT8 yytype_uint8;
		199	#else
		200	typedef unsigned char yytype_uint8;
		201	#endif
		202
		203	#ifdef YYTYPE_INT8
		204	typedef YYTYPE_INT8 yytype_int8;
		205	#elif (defined __STDC__ \|\| defined __C99__FUNC__ \
		206	\|\| defined __cplusplus \|\| defined _MSC_VER)
		207	typedef signed char yytype_int8;
		208	#else
		209	typedef short int yytype_int8;
		210	#endif
		211
		212	#ifdef YYTYPE_UINT16
		213	typedef YYTYPE_UINT16 yytype_uint16;
		214	#else
		215	typedef unsigned short int yytype_uint16;
		216	#endif
		217
		218	#ifdef YYTYPE_INT16
		219	typedef YYTYPE_INT16 yytype_int16;
		220	#else
		221	typedef short int yytype_int16;
		222	#endif
		223
		224	#ifndef YYSIZE_T
		225	# ifdef __SIZE_TYPE__
		226	# define YYSIZE_T __SIZE_TYPE__
		227	# elif defined size_t
		228	# define YYSIZE_T size_t
		229	# elif ! defined YYSIZE_T && (defined __STDC__ \|\| defined __C99__FUNC__ \
		230	\|\| defined __cplusplus \|\| defined _MSC_VER)
		231	# include /* INFRINGES ON USER NAME SPACE */
		232	# define YYSIZE_T size_t
		233	# else
		234	# define YYSIZE_T unsigned int
		235	# endif
		236	#endif
		237
		238	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
		239
		240	#ifndef YY_
		241	# if defined YYENABLE_NLS && YYENABLE_NLS
		242	# if ENABLE_NLS
		243	# include /* INFRINGES ON USER NAME SPACE */
		244	# define YY_(msgid) dgettext ("bison-runtime", msgid)
		245	# endif
		246	# endif
		247	# ifndef YY_
		248	# define YY_(msgid) msgid
		249	# endif
		250	#endif
		251
		252	/* Suppress unused-variable warnings by "using" E. */
		253	#if ! defined lint \|\| defined __GNUC__
		254	# define YYUSE(e) ((void) (e))
		255	#else
		256	# define YYUSE(e) /* empty */
		257	#endif
		258
		259	/* Identity function, used to suppress warnings about constant conditions. */
		260	#ifndef lint
		261	# define YYID(n) (n)
		262	#else
		263	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		264	\|\| defined __cplusplus \|\| defined _MSC_VER)
		265	static int
		266	YYID (int i)
		267	#else
		268	static int
		269	YYID (i)
		270	int i;
		271	#endif
		272	{
		273	return i;
		274	}
		275	#endif
		276
		277	#if ! defined yyoverflow \|\| YYERROR_VERBOSE
		278
		279	/* The parser invokes alloca or malloc; define the necessary symbols. */
		280
		281	# ifdef YYSTACK_USE_ALLOCA
		282	# if YYSTACK_USE_ALLOCA
		283	# ifdef __GNUC__
		284	# define YYSTACK_ALLOC __builtin_alloca
		285	# elif defined __BUILTIN_VA_ARG_INCR
		286	# include /* INFRINGES ON USER NAME SPACE */
		287	# elif defined _AIX
		288	# define YYSTACK_ALLOC __alloca
		289	# elif defined _MSC_VER
		290	# include /* INFRINGES ON USER NAME SPACE */
		291	# define alloca _alloca
		292	# else
		293	# define YYSTACK_ALLOC alloca
		294	# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
		295	\|\| defined __cplusplus \|\| defined _MSC_VER)
		296	# include /* INFRINGES ON USER NAME SPACE */
		297	# ifndef _STDLIB_H
		298	# define _STDLIB_H 1
		299	# endif
		300	# endif
		301	# endif
		302	# endif
		303	# endif
		304
		305	# ifdef YYSTACK_ALLOC
		306	/* Pacify GCC's `empty if-body' warning. */
		307	# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
		308	# ifndef YYSTACK_ALLOC_MAXIMUM
		309	/* The OS might guarantee only one guard page at the bottom of the stack,
		310	and a page size can be as small as 4096 bytes. So we cannot safely
		311	invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
		312	to allow for a few compiler-allocated temporary stack slots. */
		313	# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
		314	# endif
		315	# else
		316	# define YYSTACK_ALLOC YYMALLOC
		317	# define YYSTACK_FREE YYFREE
		318	# ifndef YYSTACK_ALLOC_MAXIMUM
		319	# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
		320	# endif
		321	# if (defined __cplusplus && ! defined _STDLIB_H \
		322	&& ! ((defined YYMALLOC \|\| defined malloc) \
		323	&& (defined YYFREE \|\| defined free)))
		324	# include /* INFRINGES ON USER NAME SPACE */
		325	# ifndef _STDLIB_H
		326	# define _STDLIB_H 1
		327	# endif
		328	# endif
		329	# ifndef YYMALLOC
		330	# define YYMALLOC malloc
		331	# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
		332	\|\| defined __cplusplus \|\| defined _MSC_VER)
		333	void malloc (YYSIZE_T); / INFRINGES ON USER NAME SPACE */
		334	# endif
		335	# endif
		336	# ifndef YYFREE
		337	# define YYFREE free
		338	# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
		339	\|\| defined __cplusplus \|\| defined _MSC_VER)
		340	void free (void ); / INFRINGES ON USER NAME SPACE */
		341	# endif
		342	# endif
		343	# endif
		344	#endif /* ! defined yyoverflow \|\| YYERROR_VERBOSE */
		345
		346
		347	#if (! defined yyoverflow \
		348	&& (! defined __cplusplus \
		349	\|\| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
		350
		351	/* A type that is properly aligned for any stack member. */
		352	union yyalloc
		353	{
		354	yytype_int16 yyss;
		355	YYSTYPE yyvs;
		356	};
		357
		358	/* The size of the maximum gap between one aligned stack and the next. */
		359	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
		360
		361	/* The size of an array large to enough to hold all stacks, each with
		362	N elements. */
		363	# define YYSTACK_BYTES(N) \
		364	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
		365	+ YYSTACK_GAP_MAXIMUM)
		366
		367	/* Copy COUNT objects from FROM to TO. The source and destination do
		368	not overlap. */
		369	# ifndef YYCOPY
		370	# if defined __GNUC__ && 1 < __GNUC__
		371	# define YYCOPY(To, From, Count) \
		372	__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
		373	# else
		374	# define YYCOPY(To, From, Count) \
		375	do \
		376	{ \
		377	YYSIZE_T yyi; \
		378	for (yyi = 0; yyi < (Count); yyi++) \
		379	(To)[yyi] = (From)[yyi]; \
		380	} \
		381	while (YYID (0))
		382	# endif
		383	# endif
		384
		385	/* Relocate STACK from its old location to the new one. The
		386	local variables YYSIZE and YYSTACKSIZE give the old and new number of
		387	elements in the stack, and YYPTR gives the new location of the
		388	stack. Advance YYPTR to a properly aligned location for the next
		389	stack. */
		390	# define YYSTACK_RELOCATE(Stack) \
		391	do \
		392	{ \
		393	YYSIZE_T yynewbytes; \
		394	YYCOPY (&yyptr->Stack, Stack, yysize); \
		395	Stack = &yyptr->Stack; \
		396	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
		397	yyptr += yynewbytes / sizeof (*yyptr); \
		398	} \
		399	while (YYID (0))
		400
		401	#endif
		402
		403	/* YYFINAL -- State number of the termination state. */
		404	#define YYFINAL 3
		405	/* YYLAST -- Last index in YYTABLE. */
		406	#define YYLAST 34
		407
		408	/* YYNTOKENS -- Number of terminals. */
		409	#define YYNTOKENS 24
		410	/* YYNNTS -- Number of nonterminals. */
		411	#define YYNNTS 22
		412	/* YYNRULES -- Number of rules. */
		413	#define YYNRULES 42
		414	/* YYNRULES -- Number of states. */
		415	#define YYNSTATES 53
		416
		417	/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
		418	#define YYUNDEFTOK 2
		419	#define YYMAXUTOK 275
		420
		421	#define YYTRANSLATE(YYX) \
		422	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
		423
		424	/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
		425	static const yytype_uint8 yytranslate[] =
		426	{
		427	0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		428	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		429	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		430	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		431	21, 22, 2, 2, 23, 2, 2, 2, 2, 2,
		432	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		433	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		434	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		435	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		436	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		437	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		438	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		439	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		440	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		441	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		442	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		443	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		444	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		445	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		446	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		447	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		448	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		449	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		450	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		451	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
		452	2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
		453	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
		454	15, 16, 17, 18, 19, 20
		455	};
		456
		457	#if YYDEBUG
		458	/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
		459	YYRHS. */
		460	static const yytype_uint8 yyprhs[] =
		461	{
		462	0, 0, 3, 4, 7, 10, 11, 14, 16, 18,
		463	20, 22, 24, 26, 28, 30, 32, 34, 36, 38,
		464	40, 42, 44, 45, 48, 51, 53, 56, 59, 61,
		465	63, 66, 69, 73, 78, 80, 81, 85, 86, 90,
		466	91, 93, 94
		467	};
		468
		469	/* YYRHS -- A `-1'-separated list of the rules' RHS. */
		470	static const yytype_int8 yyrhs[] =
		471	{
		472	25, 0, -1, -1, 26, 27, -1, 27, 28, -1,
		473	-1, 29, 3, -1, 37, -1, 38, -1, 45, -1,
		474	40, -1, 39, -1, 32, -1, 34, -1, 36, -1,
		475	30, -1, 31, -1, 33, -1, 35, -1, 13, -1,
		476	1, -1, 5, -1, -1, 14, 43, -1, 18, 43,
		477	-1, 9, -1, 11, 43, -1, 8, 43, -1, 7,
		478	-1, 19, -1, 20, 5, -1, 10, 5, -1, 6,
		479	5, 42, -1, 12, 5, 42, 41, -1, 5, -1,
		480	-1, 21, 43, 22, -1, -1, 43, 44, 5, -1,
		481	-1, 23, -1, -1, 4, -1
		482	};
		483
		484	/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
		485	static const yytype_uint8 yyrline[] =
		486	{
		487	0, 69, 69, 69, 73, 74, 78, 82, 83, 84,
		488	85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
		489	95, 96, 97, 102, 107, 112, 117, 121, 126, 131,
		490	138, 143, 149, 153, 160, 162, 166, 169, 173, 179,
		491	184, 185, 190
		492	};
		493	#endif
		494
		495	#if YYDEBUG \|\| YYERROR_VERBOSE \|\| YYTOKEN_TABLE
		496	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
		497	First, the terminals, then, starting at YYNTOKENS, nonterminals. */
		498	static const char *const yytname[] =
		499	{
		500	"$end", "error", "$undefined", "NEWLINE", "VERBOSE", "FILENAME",
		501	"ADDLIB", "LIST", "ADDMOD", "CLEAR", "CREATE", "DELETE", "DIRECTORY",
		502	"END", "EXTRACT", "FULLDIR", "HELP", "QUIT", "REPLACE", "SAVE", "OPEN",
		503	"'('", "')'", "','", "$accept", "start", "@1", "session", "command_line",
		504	"command", "extract_command", "replace_command", "clear_command",
		505	"delete_command", "addmod_command", "list_command", "save_command",
		506	"open_command", "create_command", "addlib_command", "directory_command",
		507	"optional_filename", "modulelist", "modulename", "optcomma",
		508	"verbose_command", 0
		509	};
		510	#endif
		511
		512	# ifdef YYPRINT
		513	/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
		514	token YYLEX-NUM. */
		515	static const yytype_uint16 yytoknum[] =
		516	{
		517	0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
		518	265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
		519	275, 40, 41, 44
		520	};
		521	# endif
		522
		523	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
		524	static const yytype_uint8 yyr1[] =
		525	{
		526	0, 24, 26, 25, 27, 27, 28, 29, 29, 29,
		527	29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
		528	29, 29, 29, 30, 31, 32, 33, 34, 35, 36,
		529	37, 38, 39, 40, 41, 41, 42, 42, 43, 43,
		530	44, 44, 45
		531	};
		532
		533	/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
		534	static const yytype_uint8 yyr2[] =
		535	{
		536	0, 2, 0, 2, 2, 0, 2, 1, 1, 1,
		537	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
		538	1, 1, 0, 2, 2, 1, 2, 2, 1, 1,
		539	2, 2, 3, 4, 1, 0, 3, 0, 3, 0,
		540	1, 0, 1
		541	};
		542
		543	/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
		544	STATE-NUM when YYTABLE doesn't specify something else to do. Zero
		545	means the default is an error. */
		546	static const yytype_uint8 yydefact[] =
		547	{
		548	2, 0, 5, 1, 0, 20, 42, 21, 0, 28,
		549	39, 25, 0, 39, 0, 19, 39, 39, 29, 0,
		550	4, 0, 15, 16, 12, 17, 13, 18, 14, 7,
		551	8, 11, 10, 9, 37, 27, 31, 26, 37, 23,
		552	24, 30, 6, 39, 32, 40, 0, 35, 41, 38,
		553	34, 33, 36
		554	};
		555
		556	/* YYDEFGOTO[NTERM-NUM]. */
		557	static const yytype_int8 yydefgoto[] =
		558	{
		559	-1, 1, 2, 4, 20, 21, 22, 23, 24, 25,
		560	26, 27, 28, 29, 30, 31, 32, 51, 44, 35,
		561	46, 33
		562	};
		563
		564	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
		565	STATE-NUM. */
		566	#define YYPACT_NINF -14
		567	static const yytype_int8 yypact[] =
		568	{
		569	-14, 1, -14, -14, 5, -14, -14, -14, 2, -14,
		570	-14, -14, 21, -14, 22, -14, -14, -14, -14, 23,
		571	-14, 26, -14, -14, -14, -14, -14, -14, -14, -14,
		572	-14, -14, -14, -14, 10, -3, -14, -3, 10, -3,
		573	-3, -14, -14, -14, -14, -14, 27, 28, -1, -14,
		574	-14, -14, -14
		575	};
		576
		577	/* YYPGOTO[NTERM-NUM]. */
		578	static const yytype_int8 yypgoto[] =
		579	{
		580	-14, -14, -14, -14, -14, -14, -14, -14, -14, -14,
		581	-14, -14, -14, -14, -14, -14, -14, -14, -4, -13,
		582	-14, -14
		583	};
		584
		585	/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
		586	positive, shift that token. If negative, reduce the rule which
		587	number is the opposite. If zero, do what YYDEFACT says.
		588	If YYTABLE_NINF, syntax error. */
		589	#define YYTABLE_NINF -42
		590	static const yytype_int8 yytable[] =
		591	{
		592	37, 3, -41, 39, 40, -3, 5, 34, -22, 6,
		593	7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
		594	45, 52, 45, 17, 18, 19, 36, 38, 41, 42,
		595	48, 43, 49, 50, 47
		596	};
		597
		598	static const yytype_uint8 yycheck[] =
		599	{
		600	13, 0, 5, 16, 17, 0, 1, 5, 3, 4,
		601	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
		602	23, 22, 23, 18, 19, 20, 5, 5, 5, 3,
		603	43, 21, 5, 5, 38
		604	};
		605
		606	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
		607	symbol of state STATE-NUM. */
		608	static const yytype_uint8 yystos[] =
		609	{
		610	0, 25, 26, 0, 27, 1, 4, 5, 6, 7,
		611	8, 9, 10, 11, 12, 13, 14, 18, 19, 20,
		612	28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
		613	38, 39, 40, 45, 5, 43, 5, 43, 5, 43,
		614	43, 5, 3, 21, 42, 23, 44, 42, 43, 5,
		615	5, 41, 22
		616	};
		617
		618	#define yyerrok (yyerrstatus = 0)
		619	#define yyclearin (yychar = YYEMPTY)
		620	#define YYEMPTY (-2)
		621	#define YYEOF 0
		622
		623	#define YYACCEPT goto yyacceptlab
		624	#define YYABORT goto yyabortlab
		625	#define YYERROR goto yyerrorlab
		626
		627
		628	/* Like YYERROR except do call yyerror. This remains here temporarily
		629	to ease the transition to the new meaning of YYERROR, for GCC.
		630	Once GCC version 2 has supplanted version 1, this can go. */
		631
		632	#define YYFAIL goto yyerrlab
		633
		634	#define YYRECOVERING() (!!yyerrstatus)
		635
		636	#define YYBACKUP(Token, Value) \
		637	do \
		638	if (yychar == YYEMPTY && yylen == 1) \
		639	{ \
		640	yychar = (Token); \
		641	yylval = (Value); \
		642	yytoken = YYTRANSLATE (yychar); \
		643	YYPOPSTACK (1); \
		644	goto yybackup; \
		645	} \
		646	else \
		647	{ \
		648	yyerror (YY_("syntax error: cannot back up")); \
		649	YYERROR; \
		650	} \
		651	while (YYID (0))
		652
		653
		654	#define YYTERROR 1
		655	#define YYERRCODE 256
		656
		657
		658	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
		659	If N is 0, then set CURRENT to the empty location which ends
		660	the previous symbol: RHS[0] (always defined). */
		661
		662	#define YYRHSLOC(Rhs, K) ((Rhs)[K])
		663	#ifndef YYLLOC_DEFAULT
		664	# define YYLLOC_DEFAULT(Current, Rhs, N) \
		665	do \
		666	if (YYID (N)) \
		667	{ \
		668	(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
		669	(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
		670	(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
		671	(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
		672	} \
		673	else \
		674	{ \
		675	(Current).first_line = (Current).last_line = \
		676	YYRHSLOC (Rhs, 0).last_line; \
		677	(Current).first_column = (Current).last_column = \
		678	YYRHSLOC (Rhs, 0).last_column; \
		679	} \
		680	while (YYID (0))
		681	#endif
		682
		683
		684	/* YY_LOCATION_PRINT -- Print the location on the stream.
		685	This macro was not mandated originally: define only if we know
		686	we won't break user code: when these are the locations we know. */
		687
		688	#ifndef YY_LOCATION_PRINT
		689	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
		690	# define YY_LOCATION_PRINT(File, Loc) \
		691	fprintf (File, "%d.%d-%d.%d", \
		692	(Loc).first_line, (Loc).first_column, \
		693	(Loc).last_line, (Loc).last_column)
		694	# else
		695	# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
		696	# endif
		697	#endif
		698
		699
		700	/* YYLEX -- calling `yylex' with the right arguments. */
		701
		702	#ifdef YYLEX_PARAM
		703	# define YYLEX yylex (YYLEX_PARAM)
		704	#else
		705	# define YYLEX yylex ()
		706	#endif
		707
		708	/* Enable debugging if requested. */
		709	#if YYDEBUG
		710
		711	# ifndef YYFPRINTF
		712	# include /* INFRINGES ON USER NAME SPACE */
		713	# define YYFPRINTF fprintf
		714	# endif
		715
		716	# define YYDPRINTF(Args) \
		717	do { \
		718	if (yydebug) \
		719	YYFPRINTF Args; \
		720	} while (YYID (0))
		721
		722	# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
		723	do { \
		724	if (yydebug) \
		725	{ \
		726	YYFPRINTF (stderr, "%s ", Title); \
		727	yy_symbol_print (stderr, \
		728	Type, Value); \
		729	YYFPRINTF (stderr, "\n"); \
		730	} \
		731	} while (YYID (0))
		732
		733
		734	/*--------------------------------.
		735	\| Print this symbol on YYOUTPUT. \|
		736	`--------------------------------*/
		737
		738	/ARGSUSED/
		739	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		740	\|\| defined __cplusplus \|\| defined _MSC_VER)
		741	static void
		742	yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
		743	#else
		744	static void
		745	yy_symbol_value_print (yyoutput, yytype, yyvaluep)
		746	FILE *yyoutput;
		747	int yytype;
		748	YYSTYPE const * const yyvaluep;
		749	#endif
		750	{
		751	if (!yyvaluep)
		752	return;
		753	# ifdef YYPRINT
		754	if (yytype < YYNTOKENS)
		755	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
		756	# else
		757	YYUSE (yyoutput);
		758	# endif
		759	switch (yytype)
		760	{
		761	default:
		762	break;
		763	}
		764	}
		765
		766
		767	/*--------------------------------.
		768	\| Print this symbol on YYOUTPUT. \|
		769	`--------------------------------*/
		770
		771	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		772	\|\| defined __cplusplus \|\| defined _MSC_VER)
		773	static void
		774	yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
		775	#else
		776	static void
		777	yy_symbol_print (yyoutput, yytype, yyvaluep)
		778	FILE *yyoutput;
		779	int yytype;
		780	YYSTYPE const * const yyvaluep;
		781	#endif
		782	{
		783	if (yytype < YYNTOKENS)
		784	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
		785	else
		786	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
		787
		788	yy_symbol_value_print (yyoutput, yytype, yyvaluep);
		789	YYFPRINTF (yyoutput, ")");
		790	}
		791
		792	/*------------------------------------------------------------------.
		793	\| yy_stack_print -- Print the state stack from its BOTTOM up to its \|
		794	\| TOP (included). \|
		795	`------------------------------------------------------------------*/
		796
		797	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		798	\|\| defined __cplusplus \|\| defined _MSC_VER)
		799	static void
		800	yy_stack_print (yytype_int16 bottom, yytype_int16 top)
		801	#else
		802	static void
		803	yy_stack_print (bottom, top)
		804	yytype_int16 *bottom;
		805	yytype_int16 *top;
		806	#endif
		807	{
		808	YYFPRINTF (stderr, "Stack now");
		809	for (; bottom <= top; ++bottom)
		810	YYFPRINTF (stderr, " %d", *bottom);
		811	YYFPRINTF (stderr, "\n");
		812	}
		813
		814	# define YY_STACK_PRINT(Bottom, Top) \
		815	do { \
		816	if (yydebug) \
		817	yy_stack_print ((Bottom), (Top)); \
		818	} while (YYID (0))
		819
		820
		821	/*------------------------------------------------.
		822	\| Report that the YYRULE is going to be reduced. \|
		823	`------------------------------------------------*/
		824
		825	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		826	\|\| defined __cplusplus \|\| defined _MSC_VER)
		827	static void
		828	yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
		829	#else
		830	static void
		831	yy_reduce_print (yyvsp, yyrule)
		832	YYSTYPE *yyvsp;
		833	int yyrule;
		834	#endif
		835	{
		836	int yynrhs = yyr2[yyrule];
		837	int yyi;
		838	unsigned long int yylno = yyrline[yyrule];
		839	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
		840	yyrule - 1, yylno);
		841	/* The symbols being reduced. */
		842	for (yyi = 0; yyi < yynrhs; yyi++)
		843	{
		844	fprintf (stderr, " $%d = ", yyi + 1);
		845	yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
		846	&(yyvsp[(yyi + 1) - (yynrhs)])
		847	);
		848	fprintf (stderr, "\n");
		849	}
		850	}
		851
		852	# define YY_REDUCE_PRINT(Rule) \
		853	do { \
		854	if (yydebug) \
		855	yy_reduce_print (yyvsp, Rule); \
		856	} while (YYID (0))
		857
		858	/* Nonzero means print parse trace. It is left uninitialized so that
		859	multiple parsers can coexist. */
		860	int yydebug;
		861	#else /* !YYDEBUG */
		862	# define YYDPRINTF(Args)
		863	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
		864	# define YY_STACK_PRINT(Bottom, Top)
		865	# define YY_REDUCE_PRINT(Rule)
		866	#endif /* !YYDEBUG */
		867
		868
		869	/* YYINITDEPTH -- initial size of the parser's stacks. */
		870	#ifndef YYINITDEPTH
		871	# define YYINITDEPTH 200
		872	#endif
		873
		874	/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
		875	if the built-in stack extension method is used).
		876
		877	Do not make this value too large; the results are undefined if
		878	YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
		879	evaluated with infinite-precision integer arithmetic. */
		880
		881	#ifndef YYMAXDEPTH
		882	# define YYMAXDEPTH 10000
		883	#endif
		884
		885
		886
		887	#if YYERROR_VERBOSE
		888
		889	# ifndef yystrlen
		890	# if defined __GLIBC__ && defined _STRING_H
		891	# define yystrlen strlen
		892	# else
		893	/* Return the length of YYSTR. */
		894	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		895	\|\| defined __cplusplus \|\| defined _MSC_VER)
		896	static YYSIZE_T
		897	yystrlen (const char *yystr)
		898	#else
		899	static YYSIZE_T
		900	yystrlen (yystr)
		901	const char *yystr;
		902	#endif
		903	{
		904	YYSIZE_T yylen;
		905	for (yylen = 0; yystr[yylen]; yylen++)
		906	continue;
		907	return yylen;
		908	}
		909	# endif
		910	# endif
		911
		912	# ifndef yystpcpy
		913	# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
		914	# define yystpcpy stpcpy
		915	# else
		916	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
		917	YYDEST. */
		918	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		919	\|\| defined __cplusplus \|\| defined _MSC_VER)
		920	static char *
		921	yystpcpy (char yydest, const char yysrc)
		922	#else
		923	static char *
		924	yystpcpy (yydest, yysrc)
		925	char *yydest;
		926	const char *yysrc;
		927	#endif
		928	{
		929	char *yyd = yydest;
		930	const char *yys = yysrc;
		931
		932	while ((yyd++ = yys++) != '\0')
		933	continue;
		934
		935	return yyd - 1;
		936	}
		937	# endif
		938	# endif
		939
		940	# ifndef yytnamerr
		941	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
		942	quotes and backslashes, so that it's suitable for yyerror. The
		943	heuristic is that double-quoting is unnecessary unless the string
		944	contains an apostrophe, a comma, or backslash (other than
		945	backslash-backslash). YYSTR is taken from yytname. If YYRES is
		946	null, do not copy; instead, return the length of what the result
		947	would have been. */
		948	static YYSIZE_T
		949	yytnamerr (char yyres, const char yystr)
		950	{
		951	if (*yystr == '"')
		952	{
		953	YYSIZE_T yyn = 0;
		954	char const *yyp = yystr;
		955
		956	for (;;)
		957	switch (*++yyp)
		958	{
		959	case '\'':
		960	case ',':
		961	goto do_not_strip_quotes;
		962
		963	case '\\':
		964	if (*++yyp != '\\')
		965	goto do_not_strip_quotes;
		966	/* Fall through. */
		967	default:
		968	if (yyres)
		969	yyres[yyn] = *yyp;
		970	yyn++;
		971	break;
		972
		973	case '"':
		974	if (yyres)
		975	yyres[yyn] = '\0';
		976	return yyn;
		977	}
		978	do_not_strip_quotes: ;
		979	}
		980
		981	if (! yyres)
		982	return yystrlen (yystr);
		983
		984	return yystpcpy (yyres, yystr) - yyres;
		985	}
		986	# endif
		987
		988	/* Copy into YYRESULT an error message about the unexpected token
		989	YYCHAR while in state YYSTATE. Return the number of bytes copied,
		990	including the terminating null byte. If YYRESULT is null, do not
		991	copy anything; just return the number of bytes that would be
		992	copied. As a special case, return 0 if an ordinary "syntax error"
		993	message will do. Return YYSIZE_MAXIMUM if overflow occurs during
		994	size calculation. */
		995	static YYSIZE_T
		996	yysyntax_error (char *yyresult, int yystate, int yychar)
		997	{
		998	int yyn = yypact[yystate];
		999
		1000	if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
		1001	return 0;
		1002	else
		1003	{
		1004	int yytype = YYTRANSLATE (yychar);
		1005	YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
		1006	YYSIZE_T yysize = yysize0;
		1007	YYSIZE_T yysize1;
		1008	int yysize_overflow = 0;
		1009	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
		1010	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
		1011	int yyx;
		1012
		1013	# if 0
		1014	/* This is so xgettext sees the translatable formats that are
		1015	constructed on the fly. */
		1016	YY_("syntax error, unexpected %s");
		1017	YY_("syntax error, unexpected %s, expecting %s");
		1018	YY_("syntax error, unexpected %s, expecting %s or %s");
		1019	YY_("syntax error, unexpected %s, expecting %s or %s or %s");
		1020	YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
		1021	# endif
		1022	char *yyfmt;
		1023	char const *yyf;
		1024	static char const yyunexpected[] = "syntax error, unexpected %s";
		1025	static char const yyexpecting[] = ", expecting %s";
		1026	static char const yyor[] = " or %s";
		1027	char yyformat[sizeof yyunexpected
		1028	+ sizeof yyexpecting - 1
		1029	+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
		1030	* (sizeof yyor - 1))];
		1031	char const *yyprefix = yyexpecting;
		1032
		1033	/* Start YYX at -YYN if negative to avoid negative indexes in
		1034	YYCHECK. */
		1035	int yyxbegin = yyn < 0 ? -yyn : 0;
		1036
		1037	/* Stay within bounds of both yycheck and yytname. */
		1038	int yychecklim = YYLAST - yyn + 1;
		1039	int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
		1040	int yycount = 1;
		1041
		1042	yyarg[0] = yytname[yytype];
		1043	yyfmt = yystpcpy (yyformat, yyunexpected);
		1044
		1045	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
		1046	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
		1047	{
		1048	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
		1049	{
		1050	yycount = 1;
		1051	yysize = yysize0;
		1052	yyformat[sizeof yyunexpected - 1] = '\0';
		1053	break;
		1054	}
		1055	yyarg[yycount++] = yytname[yyx];
		1056	yysize1 = yysize + yytnamerr (0, yytname[yyx]);
		1057	yysize_overflow \|= (yysize1 < yysize);
		1058	yysize = yysize1;
		1059	yyfmt = yystpcpy (yyfmt, yyprefix);
		1060	yyprefix = yyor;
		1061	}
		1062
		1063	yyf = YY_(yyformat);
		1064	yysize1 = yysize + yystrlen (yyf);
		1065	yysize_overflow \|= (yysize1 < yysize);
		1066	yysize = yysize1;
		1067
		1068	if (yysize_overflow)
		1069	return YYSIZE_MAXIMUM;
		1070
		1071	if (yyresult)
		1072	{
		1073	/* Avoid sprintf, as that infringes on the user's name space.
		1074	Don't have undefined behavior even if the translation
		1075	produced a string with the wrong number of "%s"s. */
		1076	char *yyp = yyresult;
		1077	int yyi = 0;
		1078	while ((yyp = yyf) != '\0')
		1079	{
		1080	if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
		1081	{
		1082	yyp += yytnamerr (yyp, yyarg[yyi++]);
		1083	yyf += 2;
		1084	}
		1085	else
		1086	{
		1087	yyp++;
		1088	yyf++;
		1089	}
		1090	}
		1091	}
		1092	return yysize;
		1093	}
		1094	}
		1095	#endif /* YYERROR_VERBOSE */
		1096
		1097
		1098	/*-----------------------------------------------.
		1099	\| Release the memory associated to this symbol. \|
		1100	`-----------------------------------------------*/
		1101
		1102	/ARGSUSED/
		1103	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		1104	\|\| defined __cplusplus \|\| defined _MSC_VER)
		1105	static void
		1106	yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep)
		1107	#else
		1108	static void
		1109	yydestruct (yymsg, yytype, yyvaluep)
		1110	const char *yymsg;
		1111	int yytype;
		1112	YYSTYPE *yyvaluep;
		1113	#endif
		1114	{
		1115	YYUSE (yyvaluep);
		1116
		1117	if (!yymsg)
		1118	yymsg = "Deleting";
		1119	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
		1120
		1121	switch (yytype)
		1122	{
		1123
		1124	default:
		1125	break;
		1126	}
		1127	}
		1128
		1129
		1130	/* Prevent warnings from -Wmissing-prototypes. */
		1131
		1132	#ifdef YYPARSE_PARAM
		1133	#if defined __STDC__ \|\| defined __cplusplus
		1134	int yyparse (void *YYPARSE_PARAM);
		1135	#else
		1136	int yyparse ();
		1137	#endif
		1138	#else /* ! YYPARSE_PARAM */
		1139	#if defined __STDC__ \|\| defined __cplusplus
		1140	int yyparse (void);
		1141	#else
		1142	int yyparse ();
		1143	#endif
		1144	#endif /* ! YYPARSE_PARAM */
		1145
		1146
		1147
		1148	/* The look-ahead symbol. */
		1149	int yychar;
		1150
		1151	/* The semantic value of the look-ahead symbol. */
		1152	YYSTYPE yylval;
		1153
		1154	/* Number of syntax errors so far. */
		1155	int yynerrs;
		1156
		1157
		1158
		1159	/*----------.
		1160	\| yyparse. \|
		1161	`----------*/
		1162
		1163	#ifdef YYPARSE_PARAM
		1164	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		1165	\|\| defined __cplusplus \|\| defined _MSC_VER)
		1166	int
		1167	yyparse (void *YYPARSE_PARAM)
		1168	#else
		1169	int
		1170	yyparse (YYPARSE_PARAM)
		1171	void *YYPARSE_PARAM;
		1172	#endif
		1173	#else /* ! YYPARSE_PARAM */
		1174	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
		1175	\|\| defined __cplusplus \|\| defined _MSC_VER)
		1176	int
		1177	yyparse (void)
		1178	#else
		1179	int
		1180	yyparse ()
		1181
		1182	#endif
		1183	#endif
		1184	{
		1185
		1186	int yystate;
		1187	int yyn;
		1188	int yyresult;
		1189	/* Number of tokens to shift before error messages enabled. */
		1190	int yyerrstatus;
		1191	/* Look-ahead token as an internal (translated) token number. */
		1192	int yytoken = 0;
		1193	#if YYERROR_VERBOSE
		1194	/* Buffer for error messages, and its allocated size. */
		1195	char yymsgbuf[128];
		1196	char *yymsg = yymsgbuf;
		1197	YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
		1198	#endif
		1199
		1200	/* Three stacks and their tools:
		1201	`yyss': related to states,
		1202	`yyvs': related to semantic values,
		1203	`yyls': related to locations.
		1204
		1205	Refer to the stacks thru separate pointers, to allow yyoverflow
		1206	to reallocate them elsewhere. */
		1207
		1208	/* The state stack. */
		1209	yytype_int16 yyssa[YYINITDEPTH];
		1210	yytype_int16 *yyss = yyssa;
		1211	yytype_int16 *yyssp;
		1212
		1213	/* The semantic value stack. */
		1214	YYSTYPE yyvsa[YYINITDEPTH];
		1215	YYSTYPE *yyvs = yyvsa;
		1216	YYSTYPE *yyvsp;
		1217
		1218
		1219
		1220	#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
		1221
		1222	YYSIZE_T yystacksize = YYINITDEPTH;
		1223
		1224	/* The variables used to return semantic value and location from the
		1225	action routines. */
		1226	YYSTYPE yyval;
		1227
		1228
		1229	/* The number of symbols on the RHS of the reduced rule.
		1230	Keep to zero when no symbol should be popped. */
		1231	int yylen = 0;
		1232
		1233	YYDPRINTF ((stderr, "Starting parse\n"));
		1234
		1235	yystate = 0;
		1236	yyerrstatus = 0;
		1237	yynerrs = 0;
		1238	yychar = YYEMPTY; /* Cause a token to be read. */
		1239
		1240	/* Initialize stack pointers.
		1241	Waste one element of value and location stack
		1242	so that they stay on the same level as the state stack.
		1243	The wasted elements are never initialized. */
		1244
		1245	yyssp = yyss;
		1246	yyvsp = yyvs;
		1247
		1248	goto yysetstate;
		1249
		1250	/*------------------------------------------------------------.
		1251	\| yynewstate -- Push a new state, which is found in yystate. \|
		1252	`------------------------------------------------------------*/
		1253	yynewstate:
		1254	/* In all cases, when you get here, the value and location stacks
		1255	have just been pushed. So pushing a state here evens the stacks. */
		1256	yyssp++;
		1257
		1258	yysetstate:
		1259	*yyssp = yystate;
		1260
		1261	if (yyss + yystacksize - 1 <= yyssp)
		1262	{
		1263	/* Get the current used size of the three stacks, in elements. */
		1264	YYSIZE_T yysize = yyssp - yyss + 1;
		1265
		1266	#ifdef yyoverflow
		1267	{
		1268	/* Give user a chance to reallocate the stack. Use copies of
		1269	these so that the &'s don't force the real ones into
		1270	memory. */
		1271	YYSTYPE *yyvs1 = yyvs;
		1272	yytype_int16 *yyss1 = yyss;
		1273
		1274
		1275	/* Each stack pointer address is followed by the size of the
		1276	data in use in that stack, in bytes. This used to be a
		1277	conditional around just the two extra args, but that might
		1278	be undefined if yyoverflow is a macro. */
		1279	yyoverflow (YY_("memory exhausted"),
		1280	&yyss1, yysize * sizeof (*yyssp),
		1281	&yyvs1, yysize * sizeof (*yyvsp),
		1282
		1283	&yystacksize);
		1284
		1285	yyss = yyss1;
		1286	yyvs = yyvs1;
		1287	}
		1288	#else /* no yyoverflow */
		1289	# ifndef YYSTACK_RELOCATE
		1290	goto yyexhaustedlab;
		1291	# else
		1292	/* Extend the stack our own way. */
		1293	if (YYMAXDEPTH <= yystacksize)
		1294	goto yyexhaustedlab;
		1295	yystacksize *= 2;
		1296	if (YYMAXDEPTH < yystacksize)
		1297	yystacksize = YYMAXDEPTH;
		1298
		1299	{
		1300	yytype_int16 *yyss1 = yyss;
		1301	union yyalloc *yyptr =
		1302	(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
		1303	if (! yyptr)
		1304	goto yyexhaustedlab;
		1305	YYSTACK_RELOCATE (yyss);
		1306	YYSTACK_RELOCATE (yyvs);
		1307
		1308	# undef YYSTACK_RELOCATE
		1309	if (yyss1 != yyssa)
		1310	YYSTACK_FREE (yyss1);
		1311	}
		1312	# endif
		1313	#endif /* no yyoverflow */
		1314
		1315	yyssp = yyss + yysize - 1;
		1316	yyvsp = yyvs + yysize - 1;
		1317
		1318
		1319	YYDPRINTF ((stderr, "Stack size increased to %lu\n",
		1320	(unsigned long int) yystacksize));
		1321
		1322	if (yyss + yystacksize - 1 <= yyssp)
		1323	YYABORT;
		1324	}
		1325
		1326	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
		1327
		1328	goto yybackup;
		1329
		1330	/*-----------.
		1331	\| yybackup. \|
		1332	`-----------*/
		1333	yybackup:
		1334
		1335	/* Do appropriate processing given the current state. Read a
		1336	look-ahead token if we need one and don't already have one. */
		1337
		1338	/* First try to decide what to do without reference to look-ahead token. */
		1339	yyn = yypact[yystate];
		1340	if (yyn == YYPACT_NINF)
		1341	goto yydefault;
		1342
		1343	/* Not known => get a look-ahead token if don't already have one. */
		1344
		1345	/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
		1346	if (yychar == YYEMPTY)
		1347	{
		1348	YYDPRINTF ((stderr, "Reading a token: "));
		1349	yychar = YYLEX;
		1350	}
		1351
		1352	if (yychar <= YYEOF)
		1353	{
		1354	yychar = yytoken = YYEOF;
		1355	YYDPRINTF ((stderr, "Now at end of input.\n"));
		1356	}
		1357	else
		1358	{
		1359	yytoken = YYTRANSLATE (yychar);
		1360	YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
		1361	}
		1362
		1363	/* If the proper action on seeing token YYTOKEN is to reduce or to
		1364	detect an error, take that action. */
		1365	yyn += yytoken;
		1366	if (yyn < 0 \|\| YYLAST < yyn \|\| yycheck[yyn] != yytoken)
		1367	goto yydefault;
		1368	yyn = yytable[yyn];
		1369	if (yyn <= 0)
		1370	{
		1371	if (yyn == 0 \|\| yyn == YYTABLE_NINF)
		1372	goto yyerrlab;
		1373	yyn = -yyn;
		1374	goto yyreduce;
		1375	}
		1376
		1377	if (yyn == YYFINAL)
		1378	YYACCEPT;
		1379
		1380	/* Count tokens shifted since error; after three, turn off error
		1381	status. */
		1382	if (yyerrstatus)
		1383	yyerrstatus--;
		1384
		1385	/* Shift the look-ahead token. */
		1386	YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
		1387
		1388	/* Discard the shifted token unless it is eof. */
		1389	if (yychar != YYEOF)
		1390	yychar = YYEMPTY;
		1391
		1392	yystate = yyn;
		1393	*++yyvsp = yylval;
		1394
		1395	goto yynewstate;
		1396
		1397
		1398	/*-----------------------------------------------------------.
		1399	\| yydefault -- do the default action for the current state. \|
		1400	`-----------------------------------------------------------*/
		1401	yydefault:
		1402	yyn = yydefact[yystate];
		1403	if (yyn == 0)
		1404	goto yyerrlab;
		1405	goto yyreduce;
		1406
		1407
		1408	/*-----------------------------.
		1409	\| yyreduce -- Do a reduction. \|
		1410	`-----------------------------*/
		1411	yyreduce:
		1412	/* yyn is the number of a rule to reduce with. */
		1413	yylen = yyr2[yyn];
		1414
		1415	/* If YYLEN is nonzero, implement the default value of the action:
		1416	`$$ = $1'.
		1417
		1418	Otherwise, the following line sets YYVAL to garbage.
		1419	This behavior is undocumented and Bison
		1420	users should not rely upon it. Assigning to YYVAL
		1421	unconditionally makes the parser a bit smaller, and it avoids a
		1422	GCC warning that YYVAL may be used uninitialized. */
		1423	yyval = yyvsp[1-yylen];
		1424
		1425
		1426	YY_REDUCE_PRINT (yyn);
		1427	switch (yyn)
		1428	{
		1429	case 2:
		1430	#line 69 "arparse.y"
		1431	{ prompt(); }
		1432	break;
		1433
		1434	case 6:
		1435	#line 78 "arparse.y"
		1436	{ prompt(); }
		1437	break;
		1438
		1439	case 19:
		1440	#line 94 "arparse.y"
		1441	{ ar_end(); return 0; }
		1442	break;
		1443
		1444	case 21:
		1445	#line 96 "arparse.y"
		1446	{ yyerror("foo"); }
		1447	break;
		1448
		1449	case 23:
		1450	#line 103 "arparse.y"
		1451	{ ar_extract((yyvsp[(2) - (2)].list)); }
		1452	break;
		1453
		1454	case 24:
		1455	#line 108 "arparse.y"
		1456	{ ar_replace((yyvsp[(2) - (2)].list)); }
		1457	break;
		1458
		1459	case 25:
		1460	#line 113 "arparse.y"
		1461	{ ar_clear(); }
		1462	break;
		1463
		1464	case 26:
		1465	#line 118 "arparse.y"
		1466	{ ar_delete((yyvsp[(2) - (2)].list)); }
		1467	break;
		1468
		1469	case 27:
		1470	#line 122 "arparse.y"
		1471	{ ar_addmod((yyvsp[(2) - (2)].list)); }
		1472	break;
		1473
		1474	case 28:
		1475	#line 127 "arparse.y"
		1476	{ ar_list(); }
		1477	break;
		1478
		1479	case 29:
		1480	#line 132 "arparse.y"
		1481	{ ar_save(); }
		1482	break;
		1483
		1484	case 30:
		1485	#line 139 "arparse.y"
		1486	{ ar_open((yyvsp[(2) - (2)].name),0); }
		1487	break;
		1488
		1489	case 31:
		1490	#line 144 "arparse.y"
		1491	{ ar_open((yyvsp[(2) - (2)].name),1); }
		1492	break;
		1493
		1494	case 32:
		1495	#line 150 "arparse.y"
		1496	{ ar_addlib((yyvsp[(2) - (3)].name),(yyvsp[(3) - (3)].list)); }
		1497	break;
		1498
		1499	case 33:
		1500	#line 154 "arparse.y"
		1501	{ ar_directory((yyvsp[(2) - (4)].name), (yyvsp[(3) - (4)].list), (yyvsp[(4) - (4)].name)); }
		1502	break;
		1503
		1504	case 34:
		1505	#line 161 "arparse.y"
		1506	{ (yyval.name) = (yyvsp[(1) - (1)].name); }
		1507	break;
		1508
		1509	case 35:
		1510	#line 162 "arparse.y"
		1511	{ (yyval.name) = 0; }
		1512	break;
		1513
		1514	case 36:
		1515	#line 167 "arparse.y"
		1516	{ (yyval.list) = (yyvsp[(2) - (3)].list); }
		1517	break;
		1518
		1519	case 37:
		1520	#line 169 "arparse.y"
		1521	{ (yyval.list) = 0; }
		1522	break;
		1523
		1524	case 38:
		1525	#line 174 "arparse.y"
		1526	{ struct list n = (struct list ) malloc(sizeof(struct list));
		1527	n->next = (yyvsp[(1) - (3)].list);
		1528	n->name = (yyvsp[(3) - (3)].name);
		1529	(yyval.list) = n;
		1530	}
		1531	break;
		1532
		1533	case 39:
		1534	#line 179 "arparse.y"
		1535	{ (yyval.list) = 0; }
		1536	break;
		1537
		1538	case 42:
		1539	#line 191 "arparse.y"
		1540	{ verbose = !verbose; }
		1541	break;
		1542
		1543
		1544	/* Line 1267 of yacc.c. */
		1545	#line 1546 "arparse.c"
		1546	default: break;
		1547	}
		1548	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
		1549
		1550	YYPOPSTACK (yylen);
		1551	yylen = 0;
		1552	YY_STACK_PRINT (yyss, yyssp);
		1553
		1554	*++yyvsp = yyval;
		1555
		1556
		1557	/* Now `shift' the result of the reduction. Determine what state
		1558	that goes to, based on the state we popped back to and the rule
		1559	number reduced by. */
		1560
		1561	yyn = yyr1[yyn];
		1562
		1563	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
		1564	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
		1565	yystate = yytable[yystate];
		1566	else
		1567	yystate = yydefgoto[yyn - YYNTOKENS];
		1568
		1569	goto yynewstate;
		1570
		1571
		1572	/*------------------------------------.
		1573	\| yyerrlab -- here on detecting error \|
		1574	`------------------------------------*/
		1575	yyerrlab:
		1576	/* If not already recovering from an error, report this error. */
		1577	if (!yyerrstatus)
		1578	{
		1579	++yynerrs;
		1580	#if ! YYERROR_VERBOSE
		1581	yyerror (YY_("syntax error"));
		1582	#else
		1583	{
		1584	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
		1585	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
		1586	{
		1587	YYSIZE_T yyalloc = 2 * yysize;
		1588	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
		1589	yyalloc = YYSTACK_ALLOC_MAXIMUM;
		1590	if (yymsg != yymsgbuf)
		1591	YYSTACK_FREE (yymsg);
		1592	yymsg = (char *) YYSTACK_ALLOC (yyalloc);
		1593	if (yymsg)
		1594	yymsg_alloc = yyalloc;
		1595	else
		1596	{
		1597	yymsg = yymsgbuf;
		1598	yymsg_alloc = sizeof yymsgbuf;
		1599	}
		1600	}
		1601
		1602	if (0 < yysize && yysize <= yymsg_alloc)
		1603	{
		1604	(void) yysyntax_error (yymsg, yystate, yychar);
		1605	yyerror (yymsg);
		1606	}
		1607	else
		1608	{
		1609	yyerror (YY_("syntax error"));
		1610	if (yysize != 0)
		1611	goto yyexhaustedlab;
		1612	}
		1613	}
		1614	#endif
		1615	}
		1616
		1617
		1618
		1619	if (yyerrstatus == 3)
		1620	{
		1621	/* If just tried and failed to reuse look-ahead token after an
		1622	error, discard it. */
		1623
		1624	if (yychar <= YYEOF)
		1625	{
		1626	/* Return failure if at end of input. */
		1627	if (yychar == YYEOF)
		1628	YYABORT;
		1629	}
		1630	else
		1631	{
		1632	yydestruct ("Error: discarding",
		1633	yytoken, &yylval);
		1634	yychar = YYEMPTY;
		1635	}
		1636	}
		1637
		1638	/* Else will try to reuse look-ahead token after shifting the error
		1639	token. */
		1640	goto yyerrlab1;
		1641
		1642
		1643	/*---------------------------------------------------.
		1644	\| yyerrorlab -- error raised explicitly by YYERROR. \|
		1645	`---------------------------------------------------*/
		1646	yyerrorlab:
		1647
		1648	/* Pacify compilers like GCC when the user code never invokes
		1649	YYERROR and the label yyerrorlab therefore never appears in user
		1650	code. */
		1651	if (/CONSTCOND/ 0)
		1652	goto yyerrorlab;
		1653
		1654	/* Do not reclaim the symbols of the rule which action triggered
		1655	this YYERROR. */
		1656	YYPOPSTACK (yylen);
		1657	yylen = 0;
		1658	YY_STACK_PRINT (yyss, yyssp);
		1659	yystate = *yyssp;
		1660	goto yyerrlab1;
		1661
		1662
		1663	/*-------------------------------------------------------------.
		1664	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
		1665	`-------------------------------------------------------------*/
		1666	yyerrlab1:
		1667	yyerrstatus = 3; /* Each real token shifted decrements this. */
		1668
		1669	for (;;)
		1670	{
		1671	yyn = yypact[yystate];
		1672	if (yyn != YYPACT_NINF)
		1673	{
		1674	yyn += YYTERROR;
		1675	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
		1676	{
		1677	yyn = yytable[yyn];
		1678	if (0 < yyn)
		1679	break;
		1680	}
		1681	}
		1682
		1683	/* Pop the current state because it cannot handle the error token. */
		1684	if (yyssp == yyss)
		1685	YYABORT;
		1686
		1687
		1688	yydestruct ("Error: popping",
		1689	yystos[yystate], yyvsp);
		1690	YYPOPSTACK (1);
		1691	yystate = *yyssp;
		1692	YY_STACK_PRINT (yyss, yyssp);
		1693	}
		1694
		1695	if (yyn == YYFINAL)
		1696	YYACCEPT;
		1697
		1698	*++yyvsp = yylval;
		1699
		1700
		1701	/* Shift the error token. */
		1702	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
		1703
		1704	yystate = yyn;
		1705	goto yynewstate;
		1706
		1707
		1708	/*-------------------------------------.
		1709	\| yyacceptlab -- YYACCEPT comes here. \|
		1710	`-------------------------------------*/
		1711	yyacceptlab:
		1712	yyresult = 0;
		1713	goto yyreturn;
		1714
		1715	/*-----------------------------------.
		1716	\| yyabortlab -- YYABORT comes here. \|
		1717	`-----------------------------------*/
		1718	yyabortlab:
		1719	yyresult = 1;
		1720	goto yyreturn;
		1721
		1722	#ifndef yyoverflow
		1723	/*-------------------------------------------------.
		1724	\| yyexhaustedlab -- memory exhaustion comes here. \|
		1725	`-------------------------------------------------*/
		1726	yyexhaustedlab:
		1727	yyerror (YY_("memory exhausted"));
		1728	yyresult = 2;
		1729	/* Fall through. */
		1730	#endif
		1731
		1732	yyreturn:
		1733	if (yychar != YYEOF && yychar != YYEMPTY)
		1734	yydestruct ("Cleanup: discarding lookahead",
		1735	yytoken, &yylval);
		1736	/* Do not reclaim the symbols of the rule which action triggered
		1737	this YYABORT or YYACCEPT. */
		1738	YYPOPSTACK (yylen);
		1739	YY_STACK_PRINT (yyss, yyssp);
		1740	while (yyssp != yyss)
		1741	{
		1742	yydestruct ("Cleanup: popping",
		1743	yystos[*yyssp], yyvsp);
		1744	YYPOPSTACK (1);
		1745	}
		1746	#ifndef yyoverflow
		1747	if (yyss != yyssa)
		1748	YYSTACK_FREE (yyss);
		1749	#endif
		1750	#if YYERROR_VERBOSE
		1751	if (yymsg != yymsgbuf)
		1752	YYSTACK_FREE (yymsg);
		1753	#endif
		1754	/* Make sure YYID is used. */
		1755	return YYID (yyresult);
		1756	}
		1757
		1758
		1759	#line 195 "arparse.y"
		1760
		1761
		1762	static int
		1763	yyerror (const char *x ATTRIBUTE_UNUSED)
		1764	{
		1765	extern int linenumber;
		1766
		1767	printf (_("Syntax error in archive script, line %d\n"), linenumber + 1);
		1768	return 0;
		1769	}
		1770

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/binutils/arparse.c – Rev 5219