Navigation

← Previous Change
Next Change →

OSGScanParseSkelParser.cpp

Timestamp:

12/29/06 10:28:00 (2 years ago)

Author:

cneumann

Message:

- regenerated all base files to include the full set

of access functions for non-ptr mfields.

Files:

trunk/Source/System/FileIO/ScanParseSkel/OSGScanParseSkelParser.cpp (modified) (118 diffs)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/Source/System/FileIO/ScanParseSkel/OSGScanParseSkelParser.cpp

r264	r459
1		/* A Bison parser, made by GNU Bison 2.0. */
2
3		/* Skeleton parser for Yacc-like parsing with Bison,
4		Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
	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.
5	7
6	8	This program is free software; you can redistribute it and/or modify
…	…
16	18	You should have received a copy of the GNU General Public License
17	19	along with this program; if not, write to the Free Software
18		Foundation, Inc., 59 Temple Place - Suite 330,
19		Boston, MA 02111-1307, USA. */
20
21		/* As a special exception, when this file is copied by Bison into a
22		Bison output file, you may use that output file without restriction.
23		This special exception was added by the Free Software Foundation
24		in version 1.24 of Bison. */
25
26		/* Written by Richard Stallman by simplifying the original so called
27		``semantic'' parser. */
	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. */
28	38
29	39	/* All symbols defined below should begin with yy or YY, to avoid
…	…
36	46	/* Identify Bison output. */
37	47	#define YYBISON 1
	48
	49	/* Bison version. */
	50	#define YYBISON_VERSION "2.3"
38	51
39	52	/* Skeleton name. */
…	…
144	157	};
145	158	#endif
	159	/* Tokens. */
146	160	#define TOK_HEADER 258
147	161	#define TOK_PROFILE 259
…	…
244	258	#endif
245	259
246		#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
	260	/* Enabling the token table. */
	261	#ifndef YYTOKEN_TABLE
	262	# define YYTOKEN_TABLE 0
	263	#endif
	264
	265	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
	266	typedef union YYSTYPE
247	267	#line 41 "Source/System/FileIO/ScanParseSkel/OSGScanParseSkelParser.yy"
248		~~typedef union YYSTYPE~~ {
	268	{
249	269	long intVal;
250	270	double doubleVal;
…	…
252	272	const char *stringVal;
253	273	bool boolVal;
254		} YYSTYPE;
255		/* Line 190 of yacc.c. */
256		#line 257 "Source/System/FileIO/ScanParseSkel/OSGScanParseSkelParser.cpp"
	274	}
	275	/* Line 193 of yacc.c. */
	276	#line 277 "Source/System/FileIO/ScanParseSkel/OSGScanParseSkelParser.cpp"
	277	YYSTYPE;
257	278	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
258	279	# define YYSTYPE_IS_DECLARED 1
…	…
294	315
295	316
296		/* Line 213 of yacc.c. */
297		#line 298 "Source/System/FileIO/ScanParseSkel/OSGScanParseSkelParser.cpp"
298
299		#if ! defined (yyoverflow) \|\| YYERROR_VERBOSE
300
301		# ifndef YYFREE
302		# define YYFREE free
	317	/* Line 216 of yacc.c. */
	318	#line 319 "Source/System/FileIO/ScanParseSkel/OSGScanParseSkelParser.cpp"
	319
	320	#ifdef short
	321	# undef short
	322	#endif
	323
	324	#ifdef YYTYPE_UINT8
	325	typedef YYTYPE_UINT8 yytype_uint8;
	326	#else
	327	typedef unsigned char yytype_uint8;
	328	#endif
	329
	330	#ifdef YYTYPE_INT8
	331	typedef YYTYPE_INT8 yytype_int8;
	332	#elif (defined __STDC__ \|\| defined __C99__FUNC__ \
	333	\|\| defined __cplusplus \|\| defined _MSC_VER)
	334	typedef signed char yytype_int8;
	335	#else
	336	typedef short int yytype_int8;
	337	#endif
	338
	339	#ifdef YYTYPE_UINT16
	340	typedef YYTYPE_UINT16 yytype_uint16;
	341	#else
	342	typedef unsigned short int yytype_uint16;
	343	#endif
	344
	345	#ifdef YYTYPE_INT16
	346	typedef YYTYPE_INT16 yytype_int16;
	347	#else
	348	typedef short int yytype_int16;
	349	#endif
	350
	351	#ifndef YYSIZE_T
	352	# ifdef __SIZE_TYPE__
	353	# define YYSIZE_T __SIZE_TYPE__
	354	# elif defined size_t
	355	# define YYSIZE_T size_t
	356	# elif ! defined YYSIZE_T && (defined __STDC__ \|\| defined __C99__FUNC__ \
	357	\|\| defined __cplusplus \|\| defined _MSC_VER)
	358	# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
	359	# define YYSIZE_T size_t
	360	# else
	361	# define YYSIZE_T unsigned int
303	362	# endif
304		# ifndef YYMALLOC
305		# define YYMALLOC malloc
	363	#endif
	364
	365	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
	366
	367	#ifndef YY_
	368	# if YYENABLE_NLS
	369	# if ENABLE_NLS
	370	# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
	371	# define YY_(msgid) dgettext ("bison-runtime", msgid)
	372	# endif
306	373	# endif
	374	# ifndef YY_
	375	# define YY_(msgid) msgid
	376	# endif
	377	#endif
	378
	379	/* Suppress unused-variable warnings by "using" E. */
	380	#if ! defined lint \|\| defined __GNUC__
	381	# define YYUSE(e) ((void) (e))
	382	#else
	383	# define YYUSE(e) /* empty */
	384	#endif
	385
	386	/* Identity function, used to suppress warnings about constant conditions. */
	387	#ifndef lint
	388	# define YYID(n) (n)
	389	#else
	390	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	391	\|\| defined __cplusplus \|\| defined _MSC_VER)
	392	static int
	393	YYID (int i)
	394	#else
	395	static int
	396	YYID (i)
	397	int i;
	398	#endif
	399	{
	400	return i;
	401	}
	402	#endif
	403
	404	#if ! defined yyoverflow \|\| YYERROR_VERBOSE
307	405
308	406	/* The parser invokes alloca or malloc; define the necessary symbols. */
…	…
312	410	# ifdef __GNUC__
313	411	# define YYSTACK_ALLOC __builtin_alloca
	412	# elif defined __BUILTIN_VA_ARG_INCR
	413	# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
	414	# elif defined _AIX
	415	# define YYSTACK_ALLOC __alloca
	416	# elif defined _MSC_VER
	417	# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
	418	# define alloca _alloca
314	419	# else
315	420	# define YYSTACK_ALLOC alloca
	421	# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
	422	\|\| defined __cplusplus \|\| defined _MSC_VER)
	423	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
	424	# ifndef _STDLIB_H
	425	# define _STDLIB_H 1
	426	# endif
	427	# endif
316	428	# endif
317	429	# endif
…	…
319	431
320	432	# ifdef YYSTACK_ALLOC
321		/* Pacify GCC's `empty if-body' warning. */
322		# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
	433	/* Pacify GCC's `empty if-body' warning. */
	434	# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
	435	# ifndef YYSTACK_ALLOC_MAXIMUM
	436	/* The OS might guarantee only one guard page at the bottom of the stack,
	437	and a page size can be as small as 4096 bytes. So we cannot safely
	438	invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
	439	to allow for a few compiler-allocated temporary stack slots. */
	440	# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
	441	# endif
323	442	# else
324		~~# if defined (__STDC__) \|\| defined (__cplusplus)~~
325		~~# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */~~
326		~~# define YYSIZE_T size_t~~
327		~~# endif~~
328	443	# define YYSTACK_ALLOC YYMALLOC
329	444	# define YYSTACK_FREE YYFREE
	445	# ifndef YYSTACK_ALLOC_MAXIMUM
	446	# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
	447	# endif
	448	# if (defined __cplusplus && ! defined _STDLIB_H \
	449	&& ! ((defined YYMALLOC \|\| defined malloc) \
	450	&& (defined YYFREE \|\| defined free)))
	451	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
	452	# ifndef _STDLIB_H
	453	# define _STDLIB_H 1
	454	# endif
	455	# endif
	456	# ifndef YYMALLOC
	457	# define YYMALLOC malloc
	458	# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
	459	\|\| defined __cplusplus \|\| defined _MSC_VER)
	460	void malloc (YYSIZE_T); / INFRINGES ON USER NAME SPACE */
	461	# endif
	462	# endif
	463	# ifndef YYFREE
	464	# define YYFREE free
	465	# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
	466	\|\| defined __cplusplus \|\| defined _MSC_VER)
	467	void free (void ); / INFRINGES ON USER NAME SPACE */
	468	# endif
	469	# endif
330	470	# endif
331		#endif /* ! defined ~~(yyoverflow)~~ \|\| YYERROR_VERBOSE */
332
333
334		#if (! defined ~~(yyoverflow)~~ \
335		&& (! defined ~~(__cplusplus)~~ \
336		\|\| (defined ~~(YYSTYPE_IS_TRIVIAL)~~ && YYSTYPE_IS_TRIVIAL)))
	471	#endif /* ! defined yyoverflow \|\| YYERROR_VERBOSE */
	472
	473
	474	#if (! defined yyoverflow \
	475	&& (! defined __cplusplus \
	476	\|\| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
337	477
338	478	/* A type that is properly aligned for any stack member. */
339	479	union yyalloc
340	480	{
341		~~short int~~ yyss;
	481	yytype_int16 yyss;
342	482	YYSTYPE yyvs;
343	483	};
…	…
349	489	N elements. */
350	490	# define YYSTACK_BYTES(N) \
351		((N) * (sizeof (~~short int) + sizeof (YYSTYPE))~~ \
	491	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
352	492	+ YYSTACK_GAP_MAXIMUM)
353	493
…	…
355	495	not overlap. */
356	496	# ifndef YYCOPY
357		# if defined ~~(__GNUC__)~~ && 1 < __GNUC__
	497	# if defined __GNUC__ && 1 < __GNUC__
358	498	# define YYCOPY(To, From, Count) \
359	499	__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
…	…
362	502	do \
363	503	{ \
364		~~register YYSIZE_T yyi;~~ \
	504	YYSIZE_T yyi; \
365	505	for (yyi = 0; yyi < (Count); yyi++) \
366	506	(To)[yyi] = (From)[yyi]; \
367	507	} \
368		while (0)
	508	while (YYID (0))
369	509	# endif
370	510	# endif
…	…
384	524	yyptr += yynewbytes / sizeof (*yyptr); \
385	525	} \
386		while (0)
387
388		#endif
389
390		#if defined (__STDC__) \|\| defined (__cplusplus)
391		typedef signed char yysigned_char;
392		#else
393		typedef short int yysigned_char;
394		#endif
395
396		/* YYFINAL -- State number of the termination state. */
	526	while (YYID (0))
	527
	528	#endif
	529
	530	/* YYFINAL -- State number of the termination state. */
397	531	#define YYFINAL 4
398	532	/* YYLAST -- Last index in YYTABLE. */
399	533	#define YYLAST 967
400	534
401		/* YYNTOKENS -- Number of terminals. */
	535	/* YYNTOKENS -- Number of terminals. */
402	536	#define YYNTOKENS 88
403		/* YYNNTS -- Number of nonterminals. */
	537	/* YYNNTS -- Number of nonterminals. */
404	538	#define YYNNTS 257
405		/* YYNRULES -- Number of rules. */
	539	/* YYNRULES -- Number of rules. */
406	540	#define YYNRULES 458
407		/* YYNRULES -- Number of states. */
	541	/* YYNRULES -- Number of states. */
408	542	#define YYNSTATES 749
409	543
…	…
412	546	#define YYMAXUTOK 337
413	547
414		#define YYTRANSLATE(YYX) \
	548	#define YYTRANSLATE(YYX) \
415	549	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
416	550
417	551	/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
418		static const ~~unsigned char~~ yytranslate[] =
	552	static const yytype_uint8 yytranslate[] =
419	553	{
420	554	0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
…	…
457	591	/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
458	592	YYRHS. */
459		static const ~~unsigned short int~~ yyprhs[] =
	593	static const yytype_uint16 yyprhs[] =
460	594	{
461	595	0, 0, 3, 9, 11, 12, 15, 16, 18, 21,
…	…
507	641	};
508	642
509		/* YYRHS -- A `-1'-separated list of the rules' RHS. */
510		static const ~~short int~~ yyrhs[] =
	643	/* YYRHS -- A `-1'-separated list of the rules' RHS. */
	644	static const yytype_int16 yyrhs[] =
511	645	{
512	646	89, 0, -1, 90, 91, 93, 96, 101, -1, 3,
…	…
632	766
633	767	/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
634		static const ~~unsigned short int~~ yyrline[] =
	768	static const yytype_uint16 yyrline[] =
635	769	{
636	770	0, 196, 196, 203, 204, 207, 208, 211, 214, 215,
…	…
683	817	#endif
684	818
685		#if YYDEBUG \|\| YYERROR_VERBOSE
686		/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
687		First, the terminals, then, starting at YYNTOKENS, nonterminals. */
	819	#if YYDEBUG \|\| YYERROR_VERBOSE \|\| YYTOKEN_TABLE
	820	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
	821	First, the terminals, then, starting at YYNTOKENS, nonterminals. */
688	822	static const char *const yytname[] =
689	823	{
…	…
761	895	/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
762	896	token YYLEX-NUM. */
763		static const ~~unsigned short int~~ yytoknum[] =
	897	static const yytype_uint16 yytoknum[] =
764	898	{
765	899	0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
…	…
776	910
777	911	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
778		static const ~~unsigned short int~~ yyr1[] =
	912	static const yytype_uint16 yyr1[] =
779	913	{
780	914	0, 88, 89, 90, 90, 91, 91, 92, 93, 93,
…	…
827	961
828	962	/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
829		static const ~~unsigned char~~ yyr2[] =
	963	static const yytype_uint8 yyr2[] =
830	964	{
831	965	0, 2, 5, 1, 0, 2, 0, 1, 2, 0,
…	…
880	1014	STATE-NUM when YYTABLE doesn't specify something else to do. Zero
881	1015	means the default is an error. */
882		static const ~~unsigned short int~~ yydefact[] =
	1016	static const yytype_uint16 yydefact[] =
883	1017	{
884	1018	4, 3, 0, 6, 1, 0, 9, 7, 5, 14,
…	…
959	1093	};
960	1094
961		/* YYDEFGOTO[NTERM-NUM]. */
962		static const ~~short int~~ yydefgoto[] =
	1095	/* YYDEFGOTO[NTERM-NUM]. */
	1096	static const yytype_int16 yydefgoto[] =
963	1097	{
964	1098	-1, 2, 3, 6, 8, 9, 11, 15, 12, 17,
…	…
993	1127	STATE-NUM. */
994	1128	#define YYPACT_NINF -204
995		static const ~~short int~~ yypact[] =
	1129	static const yytype_int16 yypact[] =
996	1130	{
997	1131	32, -204, 87, 122, -204, -41, -204, -204, -204, 60,
…	…
1073	1207
1074	1208	/* YYPGOTO[NTERM-NUM]. */
1075		static const ~~short int~~ yypgoto[] =
	1209	static const yytype_int16 yypgoto[] =
1076	1210	{
1077	1211	-204, -204, -204, -204, -204, -204, -204, -204, -204, -204,
…	…
1108	1242	If YYTABLE_NINF, syntax error. */
1109	1243	#define YYTABLE_NINF -1
1110		static const ~~unsigned short int~~ yytable[] =
	1244	static const yytype_uint16 yytable[] =
1111	1245	{
1112	1246	39, 40, 103, 270, 30, 280, 347, 350, 348, 298,
…	…
1209	1343	};
1210	1344
1211		static const ~~short int~~ yycheck[] =
	1345	static const yytype_int16 yycheck[] =
1212	1346	{
1213	1347	21, 22, 68, 182, 18, 184, 201, 204, 202, 188,
…	…
1312	1446	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1313	1447	symbol of state STATE-NUM. */
1314		static const ~~unsigned short int~~ yystos[] =
	1448	static const yytype_uint16 yystos[] =
1315	1449	{
1316	1450	0, 3, 89, 90, 0, 4, 91, 80, 92, 93,
…	…
1391	1525	};
1392	1526
1393		~~#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)~~
1394		~~# define YYSIZE_T __SIZE_TYPE__~~
1395		~~#endif~~
1396		~~#if ! defined (YYSIZE_T) && defined (size_t)~~
1397		~~# define YYSIZE_T size_t~~
1398		~~#endif~~
1399		~~#if ! defined (YYSIZE_T)~~
1400		~~# if defined (__STDC__) \|\| defined (__cplusplus)~~
1401		~~# include <stddef.h> /* INFRINGES ON USER NAME SPACE */~~
1402		~~# define YYSIZE_T size_t~~
1403		~~# endif~~
1404		~~#endif~~
1405		~~#if ! defined (YYSIZE_T)~~
1406		~~# define YYSIZE_T unsigned int~~
1407		~~#endif~~
1408
1409	1527	#define yyerrok (yyerrstatus = 0)
1410	1528	#define yyclearin (yychar = YYEMPTY)
…	…
1432	1550	yylval = (Value); \
1433	1551	yytoken = YYTRANSLATE (yychar); \
1434		YYPOPSTACK; \
	1552	YYPOPSTACK (1); \
1435	1553	goto yybackup; \
1436	1554	} \
1437	1555	else \
1438		{ \
1439		yyerror (~~"syntax error: cannot back up");~~\
	1556	{ \
	1557	yyerror (YY_("syntax error: cannot back up")); \
1440	1558	YYERROR; \
1441	1559	} \
1442		while (0)
	1560	while (YYID (0))
1443	1561
1444	1562
…	…
1455	1573	# define YYLLOC_DEFAULT(Current, Rhs, N) \
1456	1574	do \
1457		if (N) \
	1575	if (YYID (N)) \
1458	1576	{ \
1459	1577	(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
…	…
1469	1587	YYRHSLOC (Rhs, 0).last_column; \
1470	1588	} \
1471		while (0)
	1589	while (YYID (0))
1472	1590	#endif
1473	1591
…	…
1481	1599	# define YY_LOCATION_PRINT(File, Loc) \
1482	1600	fprintf (File, "%d.%d-%d.%d", \
1483		(Loc).first_line, (Loc).first_column, \
1484		(Loc).last_line, (Loc).last_column)
	1601	(Loc).first_line, (Loc).first_column, \
	1602	(Loc).last_line, (Loc).last_column)
1485	1603	# else
1486	1604	# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
…	…
1509	1627	if (yydebug) \
1510	1628	YYFPRINTF Args; \
1511		} while (0)
1512
1513		# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1514		do { \
1515		if (yydebug) \
1516		{ \
1517		YYFPRINTF (stderr, "%s ", Title); \
1518		yysymprint (stderr, \
1519		Type, Value); \
1520		YYFPRINTF (stderr, "\n"); \
1521		} \
1522		} while (0)
	1629	} while (YYID (0))
	1630
	1631	# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
	1632	do { \
	1633	if (yydebug) \
	1634	{ \
	1635	YYFPRINTF (stderr, "%s ", Title); \
	1636	yy_symbol_print (stderr, \
	1637	Type, Value); \
	1638	YYFPRINTF (stderr, "\n"); \
	1639	} \
	1640	} while (YYID (0))
	1641
	1642
	1643	/*--------------------------------.
	1644	\| Print this symbol on YYOUTPUT. \|
	1645	`--------------------------------*/
	1646
	1647	/ARGSUSED/
	1648	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	1649	\|\| defined __cplusplus \|\| defined _MSC_VER)
	1650	static void
	1651	yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
	1652	#else
	1653	static void
	1654	yy_symbol_value_print (yyoutput, yytype, yyvaluep)
	1655	FILE *yyoutput;
	1656	int yytype;
	1657	YYSTYPE const * const yyvaluep;
	1658	#endif
	1659	{
	1660	if (!yyvaluep)
	1661	return;
	1662	# ifdef YYPRINT
	1663	if (yytype < YYNTOKENS)
	1664	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
	1665	# else
	1666	YYUSE (yyoutput);
	1667	# endif
	1668	switch (yytype)
	1669	{
	1670	default:
	1671	break;
	1672	}
	1673	}
	1674
	1675
	1676	/*--------------------------------.
	1677	\| Print this symbol on YYOUTPUT. \|
	1678	`--------------------------------*/
	1679
	1680	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	1681	\|\| defined __cplusplus \|\| defined _MSC_VER)
	1682	static void
	1683	yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
	1684	#else
	1685	static void
	1686	yy_symbol_print (yyoutput, yytype, yyvaluep)
	1687	FILE *yyoutput;
	1688	int yytype;
	1689	YYSTYPE const * const yyvaluep;
	1690	#endif
	1691	{
	1692	if (yytype < YYNTOKENS)
	1693	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
	1694	else
	1695	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
	1696
	1697	yy_symbol_value_print (yyoutput, yytype, yyvaluep);
	1698	YYFPRINTF (yyoutput, ")");
	1699	}
1523	1700
1524	1701	/*------------------------------------------------------------------.
…	…
1527	1704	`------------------------------------------------------------------*/
1528	1705
1529		#if defined (__STDC__) \|\| defined (__cplusplus)
	1706	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	1707	\|\| defined __cplusplus \|\| defined _MSC_VER)
1530	1708	static void
1531		yy_stack_print (~~short int bottom, short int~~ top)
	1709	yy_stack_print (yytype_int16 bottom, yytype_int16 top)
1532	1710	#else
1533	1711	static void
1534	1712	yy_stack_print (bottom, top)
1535		~~short int~~ *bottom;
1536		~~short int~~ *top;
	1713	yytype_int16 *bottom;
	1714	yytype_int16 *top;
1537	1715	#endif
1538	1716	{
1539	1717	YYFPRINTF (stderr, "Stack now");
1540		for (~~/* Nothing. */~~; bottom <= top; ++bottom)
	1718	for (; bottom <= top; ++bottom)
1541	1719	YYFPRINTF (stderr, " %d", *bottom);
1542	1720	YYFPRINTF (stderr, "\n");
…	…
1547	1725	if (yydebug) \
1548	1726	yy_stack_print ((Bottom), (Top)); \
1549		} while (0)
	1727	} while (YYID (0))
1550	1728
1551	1729
…	…
1554	1732	`------------------------------------------------*/
1555	1733
1556		#if defined (__STDC__) \|\| defined (__cplusplus)
	1734	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	1735	\|\| defined __cplusplus \|\| defined _MSC_VER)
1557	1736	static void
1558		yy_reduce_print (int yyrule)
	1737	yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1559	1738	#else
1560	1739	static void
1561		yy_reduce_print (yyrule)
	1740	yy_reduce_print (yyvsp, yyrule)
	1741	YYSTYPE *yyvsp;
1562	1742	int yyrule;
1563	1743	#endif
1564	1744	{
	1745	int yynrhs = yyr2[yyrule];
1565	1746	int yyi;
1566		unsigned int yylno = yyrline[yyrule];
1567		YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
1568		yyrule - 1, yylno);
1569		/* Print the symbols being reduced, and their result. */
1570		for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1571		YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
1572		YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
	1747	unsigned long int yylno = yyrline[yyrule];
	1748	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
	1749	yyrule - 1, yylno);
	1750	/* The symbols being reduced. */
	1751	for (yyi = 0; yyi < yynrhs; yyi++)
	1752	{
	1753	fprintf (stderr, " $%d = ", yyi + 1);
	1754	yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
	1755	&(yyvsp[(yyi + 1) - (yynrhs)])
	1756	);
	1757	fprintf (stderr, "\n");
	1758	}
1573	1759	}
1574	1760
…	…
1576	1762	do { \
1577	1763	if (yydebug) \
1578		yy_reduce_print (~~Rule);~~ \
1579		} while (0)
	1764	yy_reduce_print (yyvsp, Rule); \
	1765	} while (YYID (0))
1580	1766
1581	1767	/* Nonzero means print parse trace. It is left uninitialized so that
…	…
1599	1785
1600	1786	Do not make this value too large; the results are undefined if
1601		~~SIZE_MAX~~ < YYSTACK_BYTES (YYMAXDEPTH)
	1787	YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1602	1788	evaluated with infinite-precision integer arithmetic. */
1603	1789
…	…
1611	1797
1612	1798	# ifndef yystrlen
1613		# if defined ~~(__GLIBC__) && defined (_STRING_H)~~
	1799	# if defined __GLIBC__ && defined _STRING_H
1614	1800	# define yystrlen strlen
1615	1801	# else
1616	1802	/* Return the length of YYSTR. */
	1803	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	1804	\|\| defined __cplusplus \|\| defined _MSC_VER)
1617	1805	static YYSIZE_T
1618		~~# if defined (__STDC__) \|\| defined (__cplusplus)~~
1619	1806	yystrlen (const char *yystr)
1620		# else
	1807	#else
	1808	static YYSIZE_T
1621	1809	yystrlen (yystr)
1622		const char *yystr;
1623		# endif
	1810	const char *yystr;
	1811	#endif
1624	1812	{
1625		register const char *yys = yystr;
1626
1627		while (*yys++ != '\0')
	1813	YYSIZE_T yylen;
	1814	for (yylen = 0; yystr[yylen]; yylen++)
1628	1815	continue;
1629
1630		return yys - yystr - 1;
	1816	return yylen;
1631	1817	}
1632	1818	# endif
…	…
1634	1820
1635	1821	# ifndef yystpcpy
1636		# if defined ~~(__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)~~
	1822	# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1637	1823	# define yystpcpy stpcpy
1638	1824	# else
1639	1825	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1640	1826	YYDEST. */
	1827	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	1828	\|\| defined __cplusplus \|\| defined _MSC_VER)
1641	1829	static char *
1642		~~# if defined (__STDC__) \|\| defined (__cplusplus)~~
1643	1830	yystpcpy (char yydest, const char yysrc)
1644		# else
	1831	#else
	1832	static char *
1645	1833	yystpcpy (yydest, yysrc)
1646		char *yydest;
1647		const char *yysrc;
1648		# endif
	1834	char *yydest;
	1835	const char *yysrc;
	1836	#endif
1649	1837	{
1650		~~register~~ char *yyd = yydest;
1651		~~register~~ const char *yys = yysrc;
	1838	char *yyd = yydest;
	1839	const char *yys = yysrc;
1652	1840
1653	1841	while ((yyd++ = yys++) != '\0')
…	…
1659	1847	# endif
1660	1848
1661		#endif /* !YYERROR_VERBOSE */
1662
	1849	# ifndef yytnamerr
	1850	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
	1851	quotes and backslashes, so that it's suitable for yyerror. The
	1852	heuristic is that double-quoting is unnecessary unless the string
	1853	contains an apostrophe, a comma, or backslash (other than
	1854	backslash-backslash). YYSTR is taken from yytname. If YYRES is
	1855	null, do not copy; instead, return the length of what the result
	1856	would have been. */
	1857	static YYSIZE_T
	1858	yytnamerr (char yyres, const char yystr)
	1859	{
	1860	if (*yystr == '"')
	1861	{
	1862	YYSIZE_T yyn = 0;
	1863	char const *yyp = yystr;
	1864
	1865	for (;;)
	1866	switch (*++yyp)
	1867	{
	1868	case '\'':
	1869	case ',':
	1870	goto do_not_strip_quotes;
	1871
	1872	case '\\':
	1873	if (*++yyp != '\\')
	1874	goto do_not_strip_quotes;
	1875	/* Fall through. */
	1876	default:
	1877	if (yyres)
	1878	yyres[yyn] = *yyp;
	1879	yyn++;
	1880	break;
	1881
	1882	case '"':
	1883	if (yyres)
	1884	yyres[yyn] = '\0';
	1885	return yyn;
	1886	}
	1887	do_not_strip_quotes: ;
	1888	}
	1889
	1890	if (! yyres)
	1891	return yystrlen (yystr);
	1892
	1893	return yystpcpy (yyres, yystr) - yyres;
	1894	}
	1895	# endif
	1896
	1897	/* Copy into YYRESULT an error message about the unexpected token
	1898	YYCHAR while in state YYSTATE. Return the number of bytes copied,
	1899	including the terminating null byte. If YYRESULT is null, do not
	1900	copy anything; just return the number of bytes that would be
	1901	copied. As a special case, return 0 if an ordinary "syntax error"
	1902	message will do. Return YYSIZE_MAXIMUM if overflow occurs during
	1903	size calculation. */
	1904	static YYSIZE_T
	1905	yysyntax_error (char *yyresult, int yystate, int yychar)
	1906	{
	1907	int yyn = yypact[yystate];
	1908
	1909	if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
	1910	return 0;
	1911	else
	1912	{
	1913	int yytype = YYTRANSLATE (yychar);
	1914	YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
	1915	YYSIZE_T yysize = yysize0;
	1916	YYSIZE_T yysize1;
	1917	int yysize_overflow = 0;
	1918	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
	1919	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
	1920	int yyx;
	1921
	1922	# if 0
	1923	/* This is so xgettext sees the translatable formats that are
	1924	constructed on the fly. */
	1925	YY_("syntax error, unexpected %s");
	1926	YY_("syntax error, unexpected %s, expecting %s");
	1927	YY_("syntax error, unexpected %s, expecting %s or %s");
	1928	YY_("syntax error, unexpected %s, expecting %s or %s or %s");
	1929	YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
	1930	# endif
	1931	char *yyfmt;
	1932	char const *yyf;
	1933	static char const yyunexpected[] = "syntax error, unexpected %s";
	1934	static char const yyexpecting[] = ", expecting %s";
	1935	static char const yyor[] = " or %s";
	1936	char yyformat[sizeof yyunexpected
	1937	+ sizeof yyexpecting - 1
	1938	+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
	1939	* (sizeof yyor - 1))];
	1940	char const *yyprefix = yyexpecting;
	1941
	1942	/* Start YYX at -YYN if negative to avoid negative indexes in
	1943	YYCHECK. */
	1944	int yyxbegin = yyn < 0 ? -yyn : 0;
	1945
	1946	/* Stay within bounds of both yycheck and yytname. */
	1947	int yychecklim = YYLAST - yyn + 1;
	1948	int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
	1949	int yycount = 1;
	1950
	1951	yyarg[0] = yytname[yytype];
	1952	yyfmt = yystpcpy (yyformat, yyunexpected);
	1953
	1954	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
	1955	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
	1956	{
	1957	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
	1958	{
	1959	yycount = 1;
	1960	yysize = yysize0;
	1961	yyformat[sizeof yyunexpected - 1] = '\0';
	1962	break;
	1963	}
	1964	yyarg[yycount++] = yytname[yyx];
	1965	yysize1 = yysize + yytnamerr (0, yytname[yyx]);
	1966	yysize_overflow \|= (yysize1 < yysize);
	1967	yysize = yysize1;
	1968	yyfmt = yystpcpy (yyfmt, yyprefix);
	1969	yyprefix = yyor;
	1970	}
	1971
	1972	yyf = YY_(yyformat);
	1973	yysize1 = yysize + yystrlen (yyf);
	1974	yysize_overflow \|= (yysize1 < yysize);
	1975	yysize = yysize1;
	1976
	1977	if (yysize_overflow)
	1978	return YYSIZE_MAXIMUM;
	1979
	1980	if (yyresult)
	1981	{
	1982	/* Avoid sprintf, as that infringes on the user's name space.
	1983	Don't have undefined behavior even if the translation
	1984	produced a string with the wrong number of "%s"s. */
	1985	char *yyp = yyresult;
	1986	int yyi = 0;
	1987	while ((yyp = yyf) != '\0')
	1988	{
	1989	if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
	1990	{
	1991	yyp += yytnamerr (yyp, yyarg[yyi++]);
	1992	yyf += 2;
	1993	}
	1994	else
	1995	{
	1996	yyp++;
	1997	yyf++;
	1998	}
	1999	}
	2000	}
	2001	return yysize;
	2002	}
	2003	}
	2004	#endif /* YYERROR_VERBOSE */
1663	2005
1664	2006
1665		~~#if YYDEBUG~~
1666		~~/*--------------------------------.~~
1667		~~\| Print this symbol on YYOUTPUT. \|~~
1668		~~`--------------------------------*/~~
1669
1670		~~#if defined (__STDC__) \|\| defined (__cplusplus)~~
1671		~~static void~~
1672		~~yysymprint (FILE yyoutput, int yytype, YYSTYPE yyvaluep)~~
1673		~~#else~~
1674		~~static void~~
1675		~~yysymprint (yyoutput, yytype, yyvaluep)~~
1676		~~FILE *yyoutput;~~
1677		~~int yytype;~~
1678		~~YYSTYPE *yyvaluep;~~
1679		~~#endif~~
1680		{
1681		~~/* Pacify ``unused variable'' warnings. */~~
1682		~~(void) yyvaluep;~~
1683
1684		~~if (yytype < YYNTOKENS)~~
1685		~~YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);~~
1686		~~else~~
1687		~~YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);~~
1688
1689
1690		~~# ifdef YYPRINT~~
1691		~~if (yytype < YYNTOKENS)~~
1692		~~YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);~~
1693		~~# endif~~
1694		~~switch (yytype)~~
1695		{
1696		~~default:~~
1697		~~break;~~
1698		}
1699		~~YYFPRINTF (yyoutput, ")");~~
1700		}
1701
1702		~~#endif /* ! YYDEBUG */~~
1703	2007	/*-----------------------------------------------.
1704	2008	\| Release the memory associated to this symbol. \|
1705	2009	`-----------------------------------------------*/
1706	2010
1707		#if defined (__STDC__) \|\| defined (__cplusplus)
	2011	/ARGSUSED/
	2012	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	2013	\|\| defined __cplusplus \|\| defined _MSC_VER)
1708	2014	static void
1709	2015	yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep)
…	…
1716	2022	#endif
1717	2023	{
1718		/* Pacify ``unused variable'' warnings. */
1719		(void) yyvaluep;
	2024	YYUSE (yyvaluep);
1720	2025
1721	2026	if (!yymsg)
…	…
1727	2032
1728	2033	default:
1729		break;
	2034	break;
1730	2035	}
1731	2036	}
…	…
1735	2040
1736	2041	#ifdef YYPARSE_PARAM
1737		# ~~if defined (__STDC__) \|\| defined (__cplusplus)~~
	2042	#if defined __STDC__ \|\| defined __cplusplus
1738	2043	int yyparse (void *YYPARSE_PARAM);
1739		# else
	2044	#else
1740	2045	int yyparse ();
1741		# endif
	2046	#endif
1742	2047	#else /* ! YYPARSE_PARAM */
1743		#if defined ~~(__STDC__) \|\| defined (__cplusplus)~~
	2048	#if defined __STDC__ \|\| defined __cplusplus
1744	2049	int yyparse (void);
1745	2050	#else
…	…
1758	2063
1759	2064	#ifdef YYPARSE_PARAM
1760		# if defined (__STDC__) \|\| defined (__cplusplus)
1761		int yyparse (void *YYPARSE_PARAM)
1762		# else
1763		int yyparse (YYPARSE_PARAM)
1764		void *YYPARSE_PARAM;
1765		# endif
	2065	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	2066	\|\| defined __cplusplus \|\| defined _MSC_VER)
	2067	int
	2068	yyparse (void *YYPARSE_PARAM)
	2069	#else
	2070	int
	2071	yyparse (YYPARSE_PARAM)
	2072	void *YYPARSE_PARAM;
	2073	#endif
1766	2074	#else /* ! YYPARSE_PARAM */
1767		#if defined (__STDC__) \|\| defined (__cplusplus)
	2075	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
	2076	\|\| defined __cplusplus \|\| defined _MSC_VER)
1768	2077	int
1769	2078