dt_grammar.c

Last change on this file was 63135, checked in by vboxsync, 8 years ago
VBoxDTrace/generate: updated
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 109.1 KB

Line
1
2	/* A Bison parser, made by GNU Bison 2.4.1. */
3
4	/* Skeleton implementation for Bison's Yacc-like parsers in C
5
6	Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7	Free Software Foundation, Inc.
8
9	This program is free software: you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation, either version 3 of the License, or
12	(at your option) any later version.
13
14	This program is distributed in the hope that it will be useful,
15	but WITHOUT ANY WARRANTY; without even the implied warranty of
16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17	GNU General Public License for more details.
18
19	You should have received a copy of the GNU General Public License
20	along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22	/* As a special exception, you may create a larger work that contains
23	part or all of the Bison parser skeleton and distribute that work
24	under terms of your choice, so long as that work isn't itself a
25	parser generator using the skeleton or a modified version thereof
26	as a parser skeleton. Alternatively, if you modify or redistribute
27	the parser skeleton itself, you may (at your option) remove this
28	special exception, which will cause the skeleton and the resulting
29	Bison output files to be licensed under the GNU General Public
30	License without this special exception.
31
32	This special exception was added by the Free Software Foundation in
33	version 2.2 of Bison. */
34
35	/* C LALR(1) parser skeleton written by Richard Stallman, by
36	simplifying the original so-called "semantic" parser. */
37
38	/* All symbols defined below should begin with yy or YY, to avoid
39	infringing on user name space. This should be done even for local
40	variables, as they might otherwise be expanded by user macros.
41	There are some unavoidable exceptions within include files to
42	define necessary library symbols; they are noted "INFRINGES ON
43	USER NAME SPACE" below. */
44
45	/* Identify Bison output. */
46	#define YYBISON 1
47
48	/* Bison version. */
49	#define YYBISON_VERSION "2.4.1"
50
51	/* Skeleton name. */
52	#define YYSKELETON_NAME "yacc.c"
53
54	/* Pure parsers. */
55	#define YYPURE 0
56
57	/* Push parsers. */
58	#define YYPUSH 0
59
60	/* Pull parsers. */
61	#define YYPULL 1
62
63	/* Using locations. */
64	#define YYLSP_NEEDED 0
65
66
67
68	/* Copy the first part of user declarations. */
69
70	/* Line 189 of yacc.c */
71	#line 1 "dt_grammar.y"
72
73	/*
74	* CDDL HEADER START
75	*
76	* The contents of this file are subject to the terms of the
77	* Common Development and Distribution License, Version 1.0 only
78	* (the "License"). You may not use this file except in compliance
79	* with the License.
80	*
81	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
82	* or http://www.opensolaris.org/os/licensing.
83	* See the License for the specific language governing permissions
84	* and limitations under the License.
85	*
86	* When distributing Covered Code, include this CDDL HEADER in each
87	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
88	* If applicable, add the following below this CDDL HEADER, with the
89	* fields enclosed by brackets "[]" replaced with your own identifying
90	* information: Portions Copyright [yyyy] [name of copyright owner]
91	*
92	* CDDL HEADER END
93	*
94	* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
95	* Use is subject to license terms.
96	*/
97
98	#ifndef VBOX
99	#pragma ident "%Z%%M% %I% %E% SMI"
100	#else
101	# ifdef _MSC_VER
102	# pragma warning(disable:4255 4702)
103	# endif
104	#endif
105
106	#include <dt_impl.h>
107
108	#define OP1(op, c) dt_node_op1(op, c)
109	#define OP2(op, l, r) dt_node_op2(op, l, r)
110	#define OP3(x, y, z) dt_node_op3(x, y, z)
111	#define LINK(l, r) dt_node_link(l, r)
112	#define DUP(s) strdup(s)
113
114	#ifdef VBOX
115	# define YYMALLOC RTMemAlloc
116	# define YYFREE RTMemFree
117	#endif
118
119
120
121
122	/* Line 189 of yacc.c */
123	#line 124 "dt_grammar.c"
124
125	/* Enabling traces. */
126	#ifndef YYDEBUG
127	# define YYDEBUG 0
128	#endif
129
130	/* Enabling verbose error messages. */
131	#ifdef YYERROR_VERBOSE
132	# undef YYERROR_VERBOSE
133	# define YYERROR_VERBOSE 1
134	#else
135	# define YYERROR_VERBOSE 0
136	#endif
137
138	/* Enabling the token table. */
139	#ifndef YYTOKEN_TABLE
140	# define YYTOKEN_TABLE 0
141	#endif
142
143
144	/* Tokens. */
145	#ifndef YYTOKENTYPE
146	# define YYTOKENTYPE
147	/* Put the tokens into the symbol table, so that GDB and other debuggers
148	know about them. */
149	enum yytokentype {
150	DT_TOK_EOF = 0,
151	DT_TOK_COMMA = 258,
152	DT_TOK_ELLIPSIS = 259,
153	DT_TOK_ASGN = 260,
154	DT_TOK_ADD_EQ = 261,
155	DT_TOK_SUB_EQ = 262,
156	DT_TOK_MUL_EQ = 263,
157	DT_TOK_DIV_EQ = 264,
158	DT_TOK_MOD_EQ = 265,
159	DT_TOK_AND_EQ = 266,
160	DT_TOK_XOR_EQ = 267,
161	DT_TOK_OR_EQ = 268,
162	DT_TOK_LSH_EQ = 269,
163	DT_TOK_RSH_EQ = 270,
164	DT_TOK_QUESTION = 271,
165	DT_TOK_COLON = 272,
166	DT_TOK_LOR = 273,
167	DT_TOK_LXOR = 274,
168	DT_TOK_LAND = 275,
169	DT_TOK_BOR = 276,
170	DT_TOK_XOR = 277,
171	DT_TOK_BAND = 278,
172	DT_TOK_EQU = 279,
173	DT_TOK_NEQ = 280,
174	DT_TOK_LT = 281,
175	DT_TOK_LE = 282,
176	DT_TOK_GT = 283,
177	DT_TOK_GE = 284,
178	DT_TOK_LSH = 285,
179	DT_TOK_RSH = 286,
180	DT_TOK_ADD = 287,
181	DT_TOK_SUB = 288,
182	DT_TOK_MUL = 289,
183	DT_TOK_DIV = 290,
184	DT_TOK_MOD = 291,
185	DT_TOK_LNEG = 292,
186	DT_TOK_BNEG = 293,
187	DT_TOK_ADDADD = 294,
188	DT_TOK_SUBSUB = 295,
189	DT_TOK_PREINC = 296,
190	DT_TOK_POSTINC = 297,
191	DT_TOK_PREDEC = 298,
192	DT_TOK_POSTDEC = 299,
193	DT_TOK_IPOS = 300,
194	DT_TOK_INEG = 301,
195	DT_TOK_DEREF = 302,
196	DT_TOK_ADDROF = 303,
197	DT_TOK_OFFSETOF = 304,
198	DT_TOK_SIZEOF = 305,
199	DT_TOK_STRINGOF = 306,
200	DT_TOK_XLATE = 307,
201	DT_TOK_LPAR = 308,
202	DT_TOK_RPAR = 309,
203	DT_TOK_LBRAC = 310,
204	DT_TOK_RBRAC = 311,
205	DT_TOK_PTR = 312,
206	DT_TOK_DOT = 313,
207	DT_TOK_STRING = 314,
208	DT_TOK_IDENT = 315,
209	DT_TOK_PSPEC = 316,
210	DT_TOK_AGG = 317,
211	DT_TOK_TNAME = 318,
212	DT_TOK_INT = 319,
213	DT_KEY_AUTO = 320,
214	DT_KEY_BREAK = 321,
215	DT_KEY_CASE = 322,
216	DT_KEY_CHAR = 323,
217	DT_KEY_CONST = 324,
218	DT_KEY_CONTINUE = 325,
219	DT_KEY_COUNTER = 326,
220	DT_KEY_DEFAULT = 327,
221	DT_KEY_DO = 328,
222	DT_KEY_DOUBLE = 329,
223	DT_KEY_ELSE = 330,
224	DT_KEY_ENUM = 331,
225	DT_KEY_EXTERN = 332,
226	DT_KEY_FLOAT = 333,
227	DT_KEY_FOR = 334,
228	DT_KEY_GOTO = 335,
229	DT_KEY_IF = 336,
230	DT_KEY_IMPORT = 337,
231	DT_KEY_INLINE = 338,
232	DT_KEY_INT = 339,
233	DT_KEY_LONG = 340,
234	DT_KEY_PROBE = 341,
235	DT_KEY_PROVIDER = 342,
236	DT_KEY_REGISTER = 343,
237	DT_KEY_RESTRICT = 344,
238	DT_KEY_RETURN = 345,
239	DT_KEY_SELF = 346,
240	DT_KEY_SHORT = 347,
241	DT_KEY_SIGNED = 348,
242	DT_KEY_STATIC = 349,
243	DT_KEY_STRING = 350,
244	DT_KEY_STRUCT = 351,
245	DT_KEY_SWITCH = 352,
246	DT_KEY_THIS = 353,
247	DT_KEY_TYPEDEF = 354,
248	DT_KEY_UNION = 355,
249	DT_KEY_UNSIGNED = 356,
250	DT_KEY_VOID = 357,
251	DT_KEY_VOLATILE = 358,
252	DT_KEY_WHILE = 359,
253	DT_KEY_XLATOR = 360,
254	DT_TOK_EPRED = 361,
255	DT_CTX_DEXPR = 362,
256	DT_CTX_DPROG = 363,
257	DT_CTX_DTYPE = 364
258	};
259	#endif
260	/* Tokens. */
261	#define DT_TOK_EOF 0
262	#define DT_TOK_COMMA 258
263	#define DT_TOK_ELLIPSIS 259
264	#define DT_TOK_ASGN 260
265	#define DT_TOK_ADD_EQ 261
266	#define DT_TOK_SUB_EQ 262
267	#define DT_TOK_MUL_EQ 263
268	#define DT_TOK_DIV_EQ 264
269	#define DT_TOK_MOD_EQ 265
270	#define DT_TOK_AND_EQ 266
271	#define DT_TOK_XOR_EQ 267
272	#define DT_TOK_OR_EQ 268
273	#define DT_TOK_LSH_EQ 269
274	#define DT_TOK_RSH_EQ 270
275	#define DT_TOK_QUESTION 271
276	#define DT_TOK_COLON 272
277	#define DT_TOK_LOR 273
278	#define DT_TOK_LXOR 274
279	#define DT_TOK_LAND 275
280	#define DT_TOK_BOR 276
281	#define DT_TOK_XOR 277
282	#define DT_TOK_BAND 278
283	#define DT_TOK_EQU 279
284	#define DT_TOK_NEQ 280
285	#define DT_TOK_LT 281
286	#define DT_TOK_LE 282
287	#define DT_TOK_GT 283
288	#define DT_TOK_GE 284
289	#define DT_TOK_LSH 285
290	#define DT_TOK_RSH 286
291	#define DT_TOK_ADD 287
292	#define DT_TOK_SUB 288
293	#define DT_TOK_MUL 289
294	#define DT_TOK_DIV 290
295	#define DT_TOK_MOD 291
296	#define DT_TOK_LNEG 292
297	#define DT_TOK_BNEG 293
298	#define DT_TOK_ADDADD 294
299	#define DT_TOK_SUBSUB 295
300	#define DT_TOK_PREINC 296
301	#define DT_TOK_POSTINC 297
302	#define DT_TOK_PREDEC 298
303	#define DT_TOK_POSTDEC 299
304	#define DT_TOK_IPOS 300
305	#define DT_TOK_INEG 301
306	#define DT_TOK_DEREF 302
307	#define DT_TOK_ADDROF 303
308	#define DT_TOK_OFFSETOF 304
309	#define DT_TOK_SIZEOF 305
310	#define DT_TOK_STRINGOF 306
311	#define DT_TOK_XLATE 307
312	#define DT_TOK_LPAR 308
313	#define DT_TOK_RPAR 309
314	#define DT_TOK_LBRAC 310
315	#define DT_TOK_RBRAC 311
316	#define DT_TOK_PTR 312
317	#define DT_TOK_DOT 313
318	#define DT_TOK_STRING 314
319	#define DT_TOK_IDENT 315
320	#define DT_TOK_PSPEC 316
321	#define DT_TOK_AGG 317
322	#define DT_TOK_TNAME 318
323	#define DT_TOK_INT 319
324	#define DT_KEY_AUTO 320
325	#define DT_KEY_BREAK 321
326	#define DT_KEY_CASE 322
327	#define DT_KEY_CHAR 323
328	#define DT_KEY_CONST 324
329	#define DT_KEY_CONTINUE 325
330	#define DT_KEY_COUNTER 326
331	#define DT_KEY_DEFAULT 327
332	#define DT_KEY_DO 328
333	#define DT_KEY_DOUBLE 329
334	#define DT_KEY_ELSE 330
335	#define DT_KEY_ENUM 331
336	#define DT_KEY_EXTERN 332
337	#define DT_KEY_FLOAT 333
338	#define DT_KEY_FOR 334
339	#define DT_KEY_GOTO 335
340	#define DT_KEY_IF 336
341	#define DT_KEY_IMPORT 337
342	#define DT_KEY_INLINE 338
343	#define DT_KEY_INT 339
344	#define DT_KEY_LONG 340
345	#define DT_KEY_PROBE 341
346	#define DT_KEY_PROVIDER 342
347	#define DT_KEY_REGISTER 343
348	#define DT_KEY_RESTRICT 344
349	#define DT_KEY_RETURN 345
350	#define DT_KEY_SELF 346
351	#define DT_KEY_SHORT 347
352	#define DT_KEY_SIGNED 348
353	#define DT_KEY_STATIC 349
354	#define DT_KEY_STRING 350
355	#define DT_KEY_STRUCT 351
356	#define DT_KEY_SWITCH 352
357	#define DT_KEY_THIS 353
358	#define DT_KEY_TYPEDEF 354
359	#define DT_KEY_UNION 355
360	#define DT_KEY_UNSIGNED 356
361	#define DT_KEY_VOID 357
362	#define DT_KEY_VOLATILE 358
363	#define DT_KEY_WHILE 359
364	#define DT_KEY_XLATOR 360
365	#define DT_TOK_EPRED 361
366	#define DT_CTX_DEXPR 362
367	#define DT_CTX_DPROG 363
368	#define DT_CTX_DTYPE 364
369
370
371
372
373	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
374	typedef union YYSTYPE
375	{
376
377	/* Line 214 of yacc.c */
378	#line 51 "dt_grammar.y"
379
380	dt_node_t *l_node;
381	dt_decl_t *l_decl;
382	char *l_str;
383	uintmax_t l_int;
384	int l_tok;
385
386
387
388	/* Line 214 of yacc.c */
389	#line 390 "dt_grammar.c"
390	} YYSTYPE;
391	# define YYSTYPE_IS_TRIVIAL 1
392	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
393	# define YYSTYPE_IS_DECLARED 1
394	#endif
395
396
397	/* Copy the second part of user declarations. */
398
399
400	/* Line 264 of yacc.c */
401	#line 402 "dt_grammar.c"
402
403	#ifdef short
404	# undef short
405	#endif
406
407	#ifdef YYTYPE_UINT8
408	typedef YYTYPE_UINT8 yytype_uint8;
409	#else
410	typedef unsigned char yytype_uint8;
411	#endif
412
413	#ifdef YYTYPE_INT8
414	typedef YYTYPE_INT8 yytype_int8;
415	#elif (defined __STDC__ \|\| defined __C99__FUNC__ \
416	\|\| defined __cplusplus \|\| defined _MSC_VER)
417	typedef signed char yytype_int8;
418	#else
419	typedef short int yytype_int8;
420	#endif
421
422	#ifdef YYTYPE_UINT16
423	typedef YYTYPE_UINT16 yytype_uint16;
424	#else
425	typedef unsigned short int yytype_uint16;
426	#endif
427
428	#ifdef YYTYPE_INT16
429	typedef YYTYPE_INT16 yytype_int16;
430	#else
431	typedef short int yytype_int16;
432	#endif
433
434	#ifndef YYSIZE_T
435	# ifdef __SIZE_TYPE__
436	# define YYSIZE_T __SIZE_TYPE__
437	# elif defined size_t
438	# define YYSIZE_T size_t
439	# elif ! defined YYSIZE_T && (defined __STDC__ \|\| defined __C99__FUNC__ \
440	\|\| defined __cplusplus \|\| defined _MSC_VER)
441	# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
442	# define YYSIZE_T size_t
443	# else
444	# define YYSIZE_T unsigned int
445	# endif
446	#endif
447
448	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
449
450	#ifndef YY_
451	# if YYENABLE_NLS
452	# if ENABLE_NLS
453	# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
454	# define YY_(msgid) dgettext ("bison-runtime", msgid)
455	# endif
456	# endif
457	# ifndef YY_
458	# define YY_(msgid) msgid
459	# endif
460	#endif
461
462	/* Suppress unused-variable warnings by "using" E. */
463	#if ! defined lint \|\| defined __GNUC__
464	# define YYUSE(e) ((void) (e))
465	#else
466	# define YYUSE(e) /* empty */
467	#endif
468
469	/* Identity function, used to suppress warnings about constant conditions. */
470	#ifndef lint
471	# define YYID(n) (n)
472	#else
473	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
474	\|\| defined __cplusplus \|\| defined _MSC_VER)
475	static int
476	YYID (int yyi)
477	#else
478	static int
479	YYID (yyi)
480	int yyi;
481	#endif
482	{
483	return yyi;
484	}
485	#endif
486
487	#if ! defined yyoverflow \|\| YYERROR_VERBOSE
488
489	/* The parser invokes alloca or malloc; define the necessary symbols. */
490
491	# ifdef YYSTACK_USE_ALLOCA
492	# if YYSTACK_USE_ALLOCA
493	# ifdef __GNUC__
494	# define YYSTACK_ALLOC __builtin_alloca
495	# elif defined __BUILTIN_VA_ARG_INCR
496	# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
497	# elif defined _AIX
498	# define YYSTACK_ALLOC __alloca
499	# elif defined _MSC_VER
500	# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
501	# define alloca _alloca
502	# else
503	# define YYSTACK_ALLOC alloca
504	# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
505	\|\| defined __cplusplus \|\| defined _MSC_VER)
506	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
507	# ifndef _STDLIB_H
508	# define _STDLIB_H 1
509	# endif
510	# endif
511	# endif
512	# endif
513	# endif
514
515	# ifdef YYSTACK_ALLOC
516	/* Pacify GCC's `empty if-body' warning. */
517	# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
518	# ifndef YYSTACK_ALLOC_MAXIMUM
519	/* The OS might guarantee only one guard page at the bottom of the stack,
520	and a page size can be as small as 4096 bytes. So we cannot safely
521	invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
522	to allow for a few compiler-allocated temporary stack slots. */
523	# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
524	# endif
525	# else
526	# define YYSTACK_ALLOC YYMALLOC
527	# define YYSTACK_FREE YYFREE
528	# ifndef YYSTACK_ALLOC_MAXIMUM
529	# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
530	# endif
531	# if (defined __cplusplus && ! defined _STDLIB_H \
532	&& ! ((defined YYMALLOC \|\| defined malloc) \
533	&& (defined YYFREE \|\| defined free)))
534	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
535	# ifndef _STDLIB_H
536	# define _STDLIB_H 1
537	# endif
538	# endif
539	# ifndef YYMALLOC
540	# define YYMALLOC malloc
541	# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
542	\|\| defined __cplusplus \|\| defined _MSC_VER)
543	void malloc (YYSIZE_T); / INFRINGES ON USER NAME SPACE */
544	# endif
545	# endif
546	# ifndef YYFREE
547	# define YYFREE free
548	# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ \|\| defined __C99__FUNC__ \
549	\|\| defined __cplusplus \|\| defined _MSC_VER)
550	void free (void ); / INFRINGES ON USER NAME SPACE */
551	# endif
552	# endif
553	# endif
554	#endif /* ! defined yyoverflow \|\| YYERROR_VERBOSE */
555
556
557	#if (! defined yyoverflow \
558	&& (! defined __cplusplus \
559	\|\| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
560
561	/* A type that is properly aligned for any stack member. */
562	union yyalloc
563	{
564	yytype_int16 yyss_alloc;
565	YYSTYPE yyvs_alloc;
566	};
567
568	/* The size of the maximum gap between one aligned stack and the next. */
569	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
570
571	/* The size of an array large to enough to hold all stacks, each with
572	N elements. */
573	# define YYSTACK_BYTES(N) \
574	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
575	+ YYSTACK_GAP_MAXIMUM)
576
577	/* Copy COUNT objects from FROM to TO. The source and destination do
578	not overlap. */
579	# ifndef YYCOPY
580	# if defined __GNUC__ && 1 < __GNUC__
581	# define YYCOPY(To, From, Count) \
582	__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
583	# else
584	# define YYCOPY(To, From, Count) \
585	do \
586	{ \
587	YYSIZE_T yyi; \
588	for (yyi = 0; yyi < (Count); yyi++) \
589	(To)[yyi] = (From)[yyi]; \
590	} \
591	while (YYID (0))
592	# endif
593	# endif
594
595	/* Relocate STACK from its old location to the new one. The
596	local variables YYSIZE and YYSTACKSIZE give the old and new number of
597	elements in the stack, and YYPTR gives the new location of the
598	stack. Advance YYPTR to a properly aligned location for the next
599	stack. */
600	# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
601	do \
602	{ \
603	YYSIZE_T yynewbytes; \
604	YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
605	Stack = &yyptr->Stack_alloc; \
606	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
607	yyptr += yynewbytes / sizeof (*yyptr); \
608	} \
609	while (YYID (0))
610
611	#endif
612
613	/* YYFINAL -- State number of the termination state. */
614	#define YYFINAL 99
615	/* YYLAST -- Last index in YYTABLE. */
616	#define YYLAST 837
617
618	/* YYNTOKENS -- Number of terminals. */
619	#define YYNTOKENS 113
620	/* YYNNTS -- Number of nonterminals. */
621	#define YYNNTS 81
622	/* YYNRULES -- Number of rules. */
623	#define YYNRULES 239
624	/* YYNRULES -- Number of states. */
625	#define YYNSTATES 363
626
627	/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
628	#define YYUNDEFTOK 2
629	#define YYMAXUTOK 364
630
631	#define YYTRANSLATE(YYX) \
632	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
633
634	/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
635	static const yytype_uint8 yytranslate[] =
636	{
637	0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
638	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
639	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
640	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
641	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
642	2, 2, 2, 2, 2, 2, 2, 2, 2, 110,
643	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
644	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
645	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
646	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
647	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
648	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
649	2, 2, 2, 111, 2, 112, 2, 2, 2, 2,
650	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
651	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
652	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
653	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
654	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
655	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
656	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
657	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
658	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
659	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
660	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
661	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
662	2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
663	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
664	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
665	25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
666	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
667	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
668	55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
669	65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
670	75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
671	85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
672	95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
673	105, 106, 107, 108, 109
674	};
675
676	#if YYDEBUG
677	/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
678	YYRHS. */
679	static const yytype_uint16 yyprhs[] =
680	{
681	0, 0, 3, 6, 9, 12, 14, 17, 19, 22,
682	24, 27, 29, 32, 34, 36, 38, 40, 42, 43,
683	51, 62, 72, 74, 77, 82, 89, 95, 97, 100,
684	107, 112, 114, 119, 124, 132, 134, 136, 140, 142,
685	144, 146, 150, 151, 153, 155, 159, 161, 163, 165,
686	167, 169, 171, 175, 177, 182, 186, 191, 195, 199,
687	203, 207, 210, 213, 220, 227, 235, 237, 240, 243,
688	246, 249, 254, 257, 259, 261, 263, 265, 267, 269,
689	271, 276, 278, 282, 286, 290, 292, 296, 300, 302,
690	306, 310, 312, 316, 320, 324, 328, 330, 334, 338,
691	340, 344, 346, 350, 352, 356, 358, 362, 364, 368,
692	370, 374, 376, 378, 384, 386, 390, 392, 394, 396,
693	398, 400, 402, 404, 406, 408, 410, 412, 414, 418,
694	421, 425, 427, 430, 432, 435, 437, 440, 442, 445,
695	447, 450, 452, 455, 457, 459, 461, 463, 465, 467,
696	469, 471, 473, 475, 477, 479, 481, 483, 485, 487,
697	489, 491, 493, 495, 497, 499, 501, 503, 507, 510,
698	513, 516, 520, 524, 526, 528, 530, 533, 535, 539,
699	541, 545, 547, 550, 552, 555, 557, 561, 563, 566,
700	570, 574, 577, 580, 583, 587, 591, 593, 597, 599,
701	603, 605, 608, 610, 614, 617, 620, 622, 624, 627,
702	630, 634, 636, 639, 641, 643, 647, 649, 653, 655,
703	658, 661, 663, 666, 668, 670, 673, 677, 680, 682,
704	685, 687, 688, 693, 694, 696, 698, 699, 704, 705
705	};
706
707	/* YYRHS -- A `-1'-separated list of the rules' RHS. */
708	static const yytype_int16 yyrhs[] =
709	{
710	114, 0, -1, 115, 0, -1, 116, 0, -1, 117,
711	0, -1, 107, -1, 107, 155, -1, 108, -1, 108,
712	118, -1, 109, -1, 109, 185, -1, 119, -1, 118,
713	119, -1, 120, -1, 122, -1, 125, -1, 128, -1,
714	156, -1, -1, 83, 157, 177, 121, 5, 153, 110,
715	-1, 105, 185, 26, 185, 60, 28, 111, 123, 112,
716	110, -1, 105, 185, 26, 185, 60, 28, 111, 112,
717	110, -1, 124, -1, 123, 124, -1, 60, 5, 153,
718	110, -1, 87, 60, 111, 126, 112, 110, -1, 87,
719	60, 111, 112, 110, -1, 127, -1, 126, 127, -1,
720	86, 60, 191, 17, 191, 110, -1, 86, 60, 191,
721	110, -1, 129, -1, 129, 111, 132, 112, -1, 129,
722	35, 155, 106, -1, 129, 35, 155, 106, 111, 132,
723	112, -1, 130, -1, 131, -1, 130, 3, 131, -1,
724	61, -1, 64, -1, 133, -1, 132, 110, 133, -1,
725	-1, 155, -1, 153, -1, 134, 3, 153, -1, 60,
726	-1, 62, -1, 64, -1, 59, -1, 91, -1, 98,
727	-1, 53, 155, 54, -1, 135, -1, 136, 55, 134,
728	56, -1, 136, 53, 54, -1, 136, 53, 134, 54,
729	-1, 136, 58, 60, -1, 136, 58, 63, -1, 136,
730	57, 60, -1, 136, 57, 63, -1, 136, 39, -1,
731	136, 40, -1, 49, 53, 185, 3, 60, 54, -1,
732	49, 53, 185, 3, 63, 54, -1, 52, 26, 185,
733	28, 53, 155, 54, -1, 136, -1, 39, 137, -1,
734	40, 137, -1, 138, 139, -1, 50, 137, -1, 50,
735	53, 185, 54, -1, 51, 137, -1, 23, -1, 34,
736	-1, 32, -1, 33, -1, 38, -1, 37, -1, 137,
737	-1, 53, 185, 54, 139, -1, 139, -1, 140, 34,
738	139, -1, 140, 35, 139, -1, 140, 36, 139, -1,
739	140, -1, 141, 32, 140, -1, 141, 33, 140, -1,
740	141, -1, 142, 30, 141, -1, 142, 31, 141, -1,
741	142, -1, 143, 26, 142, -1, 143, 28, 142, -1,
742	143, 27, 142, -1, 143, 29, 142, -1, 143, -1,
743	144, 24, 143, -1, 144, 25, 143, -1, 144, -1,
744	145, 23, 144, -1, 145, -1, 146, 22, 145, -1,
745	146, -1, 147, 21, 146, -1, 147, -1, 148, 20,
746	147, -1, 148, -1, 149, 19, 148, -1, 149, -1,
747	150, 18, 149, -1, 152, -1, 150, -1, 150, 16,
748	155, 17, 152, -1, 152, -1, 137, 154, 153, -1,
749	5, -1, 8, -1, 9, -1, 10, -1, 6, -1,
750	7, -1, 14, -1, 15, -1, 11, -1, 12, -1,
751	13, -1, 153, -1, 155, 3, 153, -1, 157, 110,
752	-1, 157, 167, 110, -1, 160, -1, 160, 157, -1,
753	161, -1, 161, 157, -1, 162, -1, 162, 157, -1,
754	159, -1, 159, 157, -1, 161, -1, 161, 157, -1,
755	162, -1, 162, 157, -1, 65, -1, 88, -1, 94,
756	-1, 77, -1, 99, -1, 159, -1, 91, -1, 98,
757	-1, 102, -1, 68, -1, 92, -1, 84, -1, 85,
758	-1, 78, -1, 74, -1, 93, -1, 101, -1, 95,
759	-1, 63, -1, 163, -1, 173, -1, 69, -1, 89,
760	-1, 103, -1, 164, 166, 112, -1, 165, 60, -1,
761	165, 63, -1, 165, 111, -1, 165, 60, 111, -1,
762	165, 63, 111, -1, 96, -1, 100, -1, 169, -1,
763	166, 169, -1, 168, -1, 167, 3, 168, -1, 177,
764	-1, 170, 171, 110, -1, 161, -1, 161, 170, -1,
765	162, -1, 162, 170, -1, 172, -1, 171, 3, 172,
766	-1, 177, -1, 17, 151, -1, 177, 17, 151, -1,
767	174, 175, 112, -1, 76, 60, -1, 76, 63, -1,
768	76, 111, -1, 76, 60, 111, -1, 76, 63, 111,
769	-1, 176, -1, 175, 3, 176, -1, 60, -1, 60,
770	5, 155, -1, 178, -1, 180, 178, -1, 60, -1,
771	179, 177, 54, -1, 178, 188, -1, 178, 191, -1,
772	53, -1, 34, -1, 34, 181, -1, 34, 180, -1,
773	34, 181, 180, -1, 162, -1, 181, 162, -1, 183,
774	-1, 4, -1, 183, 3, 4, -1, 184, -1, 183,
775	3, 184, -1, 158, -1, 158, 177, -1, 158, 186,
776	-1, 170, -1, 170, 186, -1, 180, -1, 187, -1,
777	180, 187, -1, 179, 186, 54, -1, 187, 188, -1,
778	188, -1, 187, 191, -1, 191, -1, -1, 55, 189,
779	190, 56, -1, -1, 151, -1, 182, -1, -1, 53,
780	192, 193, 54, -1, -1, 182, -1
781	};
782
783	/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
784	static const yytype_uint16 yyrline[] =
785	{
786	0, 221, 221, 222, 223, 226, 227, 230, 231, 234,
787	235, 239, 240, 244, 245, 246, 247, 248, 253, 252,
788	268, 272, 279, 280, 284, 290, 293, 299, 300, 304,
789	307, 314, 330, 333, 337, 344, 348, 349, 355, 356,
790	359, 360, 363, 364, 368, 369, 375, 376, 377, 378,
791	379, 380, 381, 385, 386, 390, 393, 397, 400, 403,
792	406, 409, 412, 415, 419, 423, 430, 431, 432, 433,
793	434, 435, 438, 443, 444, 445, 446, 447, 448, 452,
794	453, 459, 460, 463, 466, 472, 473, 476, 482, 483,
795	486, 492, 493, 496, 499, 502, 508, 509, 512, 518,
796	519, 525, 526, 532, 533, 539, 540, 546, 547, 553,
797	554, 559, 563, 564, 569, 570, 576, 577, 578, 579,
798	580, 581, 582, 583, 584, 585, 586, 589, 590, 595,
799	600, 608, 609, 610, 611, 612, 613, 617, 618, 619,
800	620, 621, 622, 626, 627, 628, 629, 630, 634, 635,
801	636, 639, 640, 641, 642, 643, 644, 645, 646, 647,
802	648, 651, 652, 653, 656, 657, 658, 662, 665, 666,
803	670, 671, 672, 676, 677, 681, 682, 686, 687, 693,
804	700, 706, 707, 708, 709, 713, 714, 718, 719, 720,
805	726, 727, 728, 732, 733, 734, 738, 739, 742, 743,
806	748, 749, 753, 754, 755, 756, 759, 762, 763, 764,
807	765, 769, 770, 774, 775, 776, 781, 782, 788, 791,
808	794, 799, 802, 808, 809, 810, 814, 815, 816, 817,
809	818, 821, 821, 829, 830, 831, 834, 834, 842, 843
810	};
811	#endif
812
813	#if YYDEBUG \|\| YYERROR_VERBOSE \|\| YYTOKEN_TABLE
814	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
815	First, the terminals, then, starting at YYNTOKENS, nonterminals. */
816	static const char *const yytname[] =
817	{
818	"DT_TOK_EOF", "error", "$undefined", "DT_TOK_COMMA", "DT_TOK_ELLIPSIS",
819	"DT_TOK_ASGN", "DT_TOK_ADD_EQ", "DT_TOK_SUB_EQ", "DT_TOK_MUL_EQ",
820	"DT_TOK_DIV_EQ", "DT_TOK_MOD_EQ", "DT_TOK_AND_EQ", "DT_TOK_XOR_EQ",
821	"DT_TOK_OR_EQ", "DT_TOK_LSH_EQ", "DT_TOK_RSH_EQ", "DT_TOK_QUESTION",
822	"DT_TOK_COLON", "DT_TOK_LOR", "DT_TOK_LXOR", "DT_TOK_LAND", "DT_TOK_BOR",
823	"DT_TOK_XOR", "DT_TOK_BAND", "DT_TOK_EQU", "DT_TOK_NEQ", "DT_TOK_LT",
824	"DT_TOK_LE", "DT_TOK_GT", "DT_TOK_GE", "DT_TOK_LSH", "DT_TOK_RSH",
825	"DT_TOK_ADD", "DT_TOK_SUB", "DT_TOK_MUL", "DT_TOK_DIV", "DT_TOK_MOD",
826	"DT_TOK_LNEG", "DT_TOK_BNEG", "DT_TOK_ADDADD", "DT_TOK_SUBSUB",
827	"DT_TOK_PREINC", "DT_TOK_POSTINC", "DT_TOK_PREDEC", "DT_TOK_POSTDEC",
828	"DT_TOK_IPOS", "DT_TOK_INEG", "DT_TOK_DEREF", "DT_TOK_ADDROF",
829	"DT_TOK_OFFSETOF", "DT_TOK_SIZEOF", "DT_TOK_STRINGOF", "DT_TOK_XLATE",
830	"DT_TOK_LPAR", "DT_TOK_RPAR", "DT_TOK_LBRAC", "DT_TOK_RBRAC",
831	"DT_TOK_PTR", "DT_TOK_DOT", "DT_TOK_STRING", "DT_TOK_IDENT",
832	"DT_TOK_PSPEC", "DT_TOK_AGG", "DT_TOK_TNAME", "DT_TOK_INT",
833	"DT_KEY_AUTO", "DT_KEY_BREAK", "DT_KEY_CASE", "DT_KEY_CHAR",
834	"DT_KEY_CONST", "DT_KEY_CONTINUE", "DT_KEY_COUNTER", "DT_KEY_DEFAULT",
835	"DT_KEY_DO", "DT_KEY_DOUBLE", "DT_KEY_ELSE", "DT_KEY_ENUM",
836	"DT_KEY_EXTERN", "DT_KEY_FLOAT", "DT_KEY_FOR", "DT_KEY_GOTO",
837	"DT_KEY_IF", "DT_KEY_IMPORT", "DT_KEY_INLINE", "DT_KEY_INT",
838	"DT_KEY_LONG", "DT_KEY_PROBE", "DT_KEY_PROVIDER", "DT_KEY_REGISTER",
839	"DT_KEY_RESTRICT", "DT_KEY_RETURN", "DT_KEY_SELF", "DT_KEY_SHORT",
840	"DT_KEY_SIGNED", "DT_KEY_STATIC", "DT_KEY_STRING", "DT_KEY_STRUCT",
841	"DT_KEY_SWITCH", "DT_KEY_THIS", "DT_KEY_TYPEDEF", "DT_KEY_UNION",
842	"DT_KEY_UNSIGNED", "DT_KEY_VOID", "DT_KEY_VOLATILE", "DT_KEY_WHILE",
843	"DT_KEY_XLATOR", "DT_TOK_EPRED", "DT_CTX_DEXPR", "DT_CTX_DPROG",
844	"DT_CTX_DTYPE", "';'", "'{'", "'}'", "$accept", "dtrace_program",
845	"d_expression", "d_program", "d_type", "translation_unit",
846	"external_declaration", "inline_definition", "$@1",
847	"translator_definition", "translator_member_list", "translator_member",
848	"provider_definition", "provider_probe_list", "provider_probe",
849	"probe_definition", "probe_specifiers", "probe_specifier_list",
850	"probe_specifier", "statement_list", "statement",
851	"argument_expression_list", "primary_expression", "postfix_expression",
852	"unary_expression", "unary_operator", "cast_expression",
853	"multiplicative_expression", "additive_expression", "shift_expression",
854	"relational_expression", "equality_expression", "and_expression",
855	"exclusive_or_expression", "inclusive_or_expression",
856	"logical_and_expression", "logical_xor_expression",
857	"logical_or_expression", "constant_expression", "conditional_expression",
858	"assignment_expression", "assignment_operator", "expression",
859	"declaration", "declaration_specifiers",
860	"parameter_declaration_specifiers", "storage_class_specifier",
861	"d_storage_class_specifier", "type_specifier", "type_qualifier",
862	"struct_or_union_specifier", "struct_or_union_definition",
863	"struct_or_union", "struct_declaration_list", "init_declarator_list",
864	"init_declarator", "struct_declaration", "specifier_qualifier_list",
865	"struct_declarator_list", "struct_declarator", "enum_specifier",
866	"enum_definition", "enumerator_list", "enumerator", "declarator",
867	"direct_declarator", "lparen", "pointer", "type_qualifier_list",
868	"parameter_type_list", "parameter_list", "parameter_declaration",
869	"type_name", "abstract_declarator", "direct_abstract_declarator",
870	"array", "$@2", "array_parameters", "function", "$@3",
871	"function_parameters", 0
872	};
873	#endif
874
875	# ifdef YYPRINT
876	/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
877	token YYLEX-NUM. */
878	static const yytype_uint16 yytoknum[] =
879	{
880	0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
881	265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
882	275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
883	285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
884	295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
885	305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
886	315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
887	325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
888	335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
889	345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
890	355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
891	59, 123, 125
892	};
893	# endif
894
895	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
896	static const yytype_uint8 yyr1[] =
897	{
898	0, 113, 114, 114, 114, 115, 115, 116, 116, 117,
899	117, 118, 118, 119, 119, 119, 119, 119, 121, 120,
900	122, 122, 123, 123, 124, 125, 125, 126, 126, 127,
901	127, 128, 128, 128, 128, 129, 130, 130, 131, 131,
902	132, 132, 133, 133, 134, 134, 135, 135, 135, 135,
903	135, 135, 135, 136, 136, 136, 136, 136, 136, 136,
904	136, 136, 136, 136, 136, 136, 137, 137, 137, 137,
905	137, 137, 137, 138, 138, 138, 138, 138, 138, 139,
906	139, 140, 140, 140, 140, 141, 141, 141, 142, 142,
907	142, 143, 143, 143, 143, 143, 144, 144, 144, 145,
908	145, 146, 146, 147, 147, 148, 148, 149, 149, 150,
909	150, 151, 152, 152, 153, 153, 154, 154, 154, 154,
910	154, 154, 154, 154, 154, 154, 154, 155, 155, 156,
911	156, 157, 157, 157, 157, 157, 157, 158, 158, 158,
912	158, 158, 158, 159, 159, 159, 159, 159, 160, 160,
913	160, 161, 161, 161, 161, 161, 161, 161, 161, 161,
914	161, 161, 161, 161, 162, 162, 162, 163, 163, 163,
915	164, 164, 164, 165, 165, 166, 166, 167, 167, 168,
916	169, 170, 170, 170, 170, 171, 171, 172, 172, 172,
917	173, 173, 173, 174, 174, 174, 175, 175, 176, 176,
918	177, 177, 178, 178, 178, 178, 179, 180, 180, 180,
919	180, 181, 181, 182, 182, 182, 183, 183, 184, 184,
920	184, 185, 185, 186, 186, 186, 187, 187, 187, 187,
921	187, 189, 188, 190, 190, 190, 192, 191, 193, 193
922	};
923
924	/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
925	static const yytype_uint8 yyr2[] =
926	{
927	0, 2, 2, 2, 2, 1, 2, 1, 2, 1,
928	2, 1, 2, 1, 1, 1, 1, 1, 0, 7,
929	10, 9, 1, 2, 4, 6, 5, 1, 2, 6,
930	4, 1, 4, 4, 7, 1, 1, 3, 1, 1,
931	1, 3, 0, 1, 1, 3, 1, 1, 1, 1,
932	1, 1, 3, 1, 4, 3, 4, 3, 3, 3,
933	3, 2, 2, 6, 6, 7, 1, 2, 2, 2,
934	2, 4, 2, 1, 1, 1, 1, 1, 1, 1,
935	4, 1, 3, 3, 3, 1, 3, 3, 1, 3,
936	3, 1, 3, 3, 3, 3, 1, 3, 3, 1,
937	3, 1, 3, 1, 3, 1, 3, 1, 3, 1,
938	3, 1, 1, 5, 1, 3, 1, 1, 1, 1,
939	1, 1, 1, 1, 1, 1, 1, 1, 3, 2,
940	3, 1, 2, 1, 2, 1, 2, 1, 2, 1,
941	2, 1, 2, 1, 1, 1, 1, 1, 1, 1,
942	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
943	1, 1, 1, 1, 1, 1, 1, 3, 2, 2,
944	2, 3, 3, 1, 1, 1, 2, 1, 3, 1,
945	3, 1, 2, 1, 2, 1, 3, 1, 2, 3,
946	3, 2, 2, 2, 3, 3, 1, 3, 1, 3,
947	1, 2, 1, 3, 2, 2, 1, 1, 2, 2,
948	3, 1, 2, 1, 1, 3, 1, 3, 1, 2,
949	2, 1, 2, 1, 1, 2, 3, 2, 1, 2,
950	1, 0, 4, 0, 1, 1, 0, 4, 0, 1
951	};
952
953	/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
954	STATE-NUM when YYTABLE doesn't specify something else to do. Zero
955	means the default is an error. */
956	static const yytype_uint8 yydefact[] =
957	{
958	0, 5, 7, 9, 0, 0, 0, 0, 73, 75,
959	76, 74, 78, 77, 0, 0, 0, 0, 0, 0,
960	0, 49, 46, 47, 48, 50, 51, 53, 66, 79,
961	0, 81, 85, 88, 91, 96, 99, 101, 103, 105,
962	107, 109, 112, 114, 127, 6, 38, 161, 39, 143,
963	152, 164, 157, 0, 146, 156, 0, 154, 155, 0,
964	144, 165, 149, 153, 158, 145, 160, 173, 150, 147,
965	174, 159, 151, 166, 0, 8, 11, 13, 14, 15,
966	16, 31, 35, 36, 17, 0, 148, 131, 133, 135,
967	162, 0, 0, 163, 0, 181, 183, 221, 10, 1,
968	2, 3, 4, 0, 67, 68, 0, 0, 70, 72,
969	0, 0, 0, 61, 62, 0, 0, 0, 0, 116,
970	120, 121, 117, 118, 119, 124, 125, 126, 122, 123,
971	0, 79, 69, 0, 0, 0, 0, 0, 0, 0,
972	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
973	0, 0, 0, 0, 191, 192, 193, 0, 0, 0,
974	12, 0, 42, 0, 207, 206, 202, 129, 0, 177,
975	179, 200, 0, 0, 132, 134, 136, 0, 175, 0,
976	168, 169, 170, 198, 0, 196, 182, 184, 236, 231,
977	0, 223, 222, 224, 228, 230, 0, 0, 0, 52,
978	0, 55, 0, 44, 0, 59, 60, 57, 58, 115,
979	82, 83, 84, 86, 87, 89, 90, 92, 94, 93,
980	95, 97, 98, 100, 102, 104, 106, 108, 0, 110,
981	128, 194, 195, 18, 0, 0, 0, 0, 40, 43,
982	37, 211, 209, 208, 0, 130, 236, 204, 205, 0,
983	201, 167, 176, 0, 0, 185, 187, 171, 172, 0,
984	0, 190, 238, 233, 0, 225, 227, 229, 0, 71,
985	0, 80, 0, 56, 54, 0, 0, 0, 0, 0,
986	27, 0, 33, 42, 32, 212, 210, 178, 203, 188,
987	111, 0, 180, 0, 199, 197, 214, 218, 137, 139,
988	141, 239, 213, 216, 0, 234, 235, 0, 226, 0,
989	0, 0, 45, 113, 0, 0, 26, 0, 28, 0,
990	42, 41, 186, 189, 219, 0, 223, 220, 138, 140,
991	142, 0, 237, 232, 63, 64, 0, 0, 0, 25,
992	0, 0, 215, 217, 65, 19, 0, 30, 0, 34,
993	0, 0, 0, 0, 22, 29, 0, 21, 0, 23,
994	0, 20, 24
995	};
996
997	/* YYDEFGOTO[NTERM-NUM]. */
998	static const yytype_int16 yydefgoto[] =
999	{
1000	-1, 4, 5, 6, 7, 75, 76, 77, 276, 78,
1001	353, 354, 79, 279, 280, 80, 81, 82, 83, 237,
1002	238, 202, 27, 28, 131, 30, 31, 32, 33, 34,
1003	35, 36, 37, 38, 39, 40, 41, 42, 289, 43,
1004	44, 130, 111, 84, 85, 297, 86, 87, 95, 96,
1005	90, 91, 92, 177, 168, 169, 178, 97, 254, 255,
1006	93, 94, 184, 185, 170, 171, 172, 173, 243, 301,
1007	302, 303, 98, 264, 193, 194, 263, 307, 195, 262,
1008	304
1009	};
1010
1011	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1012	STATE-NUM. */
1013	#define YYPACT_NINF -224
1014	static const yytype_int16 yypact[] =
1015	{
1016	148, 553, 641, 723, 26, 49, 57, 76, -224, -224,
1017	-224, -224, -224, -224, 596, 596, 88, 629, 596, 72,
1018	446, -224, -224, -224, -224, -224, -224, -224, 179, 822,
1019	553, -224, 152, 37, 118, 109, 56, 132, 137, 154,
1020	149, 162, 175, -224, -224, 205, -224, -224, -224, -224,
1021	-224, -224, -224, 11, -224, -224, 682, -224, -224, 155,
1022	-224, -224, -224, -224, -224, -224, -224, -224, -224, -224,
1023	-224, -224, -224, -224, 723, 641, -224, -224, -224, -224,
1024	-224, 10, 217, -224, -224, 7, -224, 682, 682, 682,
1025	-224, 723, 22, -224, 167, 723, 723, 139, -224, -224,
1026	-224, -224, -224, 553, -224, -224, 723, 446, -224, -224,
1027	723, 58, 177, -224, -224, 520, 553, -5, 80, -224,
1028	-224, -224, -224, -224, -224, -224, -224, -224, -224, -224,
1029	553, -224, -224, 553, 553, 553, 553, 553, 553, 553,
1030	553, 553, 553, 553, 553, 553, 553, 553, 553, 553,
1031	553, 553, 553, 553, 127, 131, -224, 110, 133, 209,
1032	-224, 553, 553, 81, 4, -224, -224, -224, 17, -224,
1033	-224, 145, 110, 50, -224, -224, -224, 121, -224, 94,
1034	159, 161, -224, 243, 18, -224, -224, -224, 119, -224,
1035	139, 156, -224, 145, -224, -224, 247, 213, 231, -224,
1036	553, -224, 62, -224, 48, -224, -224, -224, -224, -224,
1037	-224, -224, -224, 152, 152, 37, 37, 118, 118, 118,
1038	118, 109, 109, 56, 132, 137, 154, 149, 45, 162,
1039	-224, -224, -224, -224, -49, 723, 19, 116, -224, 205,
1040	-224, -224, -224, 4, 110, -224, -224, -224, -224, 219,
1041	145, -224, -224, 553, 21, -224, 257, -224, -224, 553,
1042	167, -224, 331, 289, 221, 145, -224, -224, 117, -224,
1043	223, -224, 553, -224, -224, 553, 272, 218, 169, -44,
1044	-224, 220, 170, 553, -224, -224, -224, -224, -224, -224,
1045	-224, 94, -224, 553, -224, -224, -224, 123, 682, 682,
1046	682, -224, 280, -224, 230, -224, -224, 229, -224, 232,
1047	233, 553, -224, -224, 553, 236, -224, 180, -224, 263,
1048	553, -224, -224, -224, -224, 123, 79, -224, -224, -224,
1049	-224, 372, -224, -224, -224, -224, 69, 182, 16, -224,
1050	183, 129, -224, -224, -224, -224, 236, -224, -35, -224,
1051	185, 291, 187, -13, -224, -224, 553, -224, 194, -224,
1052	195, -224, -224
1053	};
1054
1055	/* YYPGOTO[NTERM-NUM]. */
1056	static const yytype_int16 yypgoto[] =
1057	{
1058	-224, -224, -224, -224, -224, -224, 234, -224, -224, -224,
1059	-224, -47, -224, -224, 28, -224, -224, -224, 151, -12,
1060	32, 201, -224, -224, -1, -224, -15, 66, 122, 111,
1061	124, 165, 171, 172, 181, 174, 184, -224, -210, -209,
1062	-107, -224, 5, -224, -53, -224, -223, -224, 3, 0,
1063	-224, -224, -224, -224, -224, 89, 160, -64, -224, 41,
1064	-224, -224, -224, 83, -129, -155, -96, -85, -224, 82,
1065	-224, 13, -10, -93, -180, -141, -224, -224, -164, -224,
1066	-224
1067	};
1068
1069	/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1070	positive, shift that token. If negative, reduce the rule which
1071	number is the opposite. If zero, do what YYDEFACT says.
1072	If YYTABLE_NINF, syntax error. */
1073	#define YYTABLE_NINF -207
1074	static const yytype_int16 yytable[] =
1075	{
1076	29, 190, 89, 157, 192, 88, 45, 248, 203, 203,
1077	112, 265, 191, 104, 105, 132, 108, 109, 250, 29,
1078	244, 260, 153, 209, 291, 351, 99, 179, 233, 267,
1079	247, 186, 187, 346, 174, 175, 176, 277, 164, 298,
1080	298, 164, 277, 249, 290, 161, 230, 351, 153, 100,
1081	256, 272, 266, 305, 290, 205, 89, 101, 206, 88,
1082	165, 153, 275, 278, 159, 272, 313, 166, 317, 136,
1083	137, 154, 153, 51, 155, 89, 102, 352, 88, 242,
1084	144, 145, 180, 323, 290, 181, 248, 89, 89, 89,
1085	88, 88, 88, 61, 190, 190, 196, 197, 110, 358,
1086	198, 267, 29, 165, 274, 191, 29, 73, 298, 247,
1087	166, 253, 199, 179, 29, 29, 273, 167, 210, 211,
1088	212, 162, 156, 344, 266, 282, 347, 245, 164, 29,
1089	261, 292, 188, 182, 189, 140, 141, 142, 143, 166,
1090	207, 106, 46, 208, 164, 48, 265, 165, 138, 139,
1091	29, 338, 29, -206, 166, 146, 228, 164, 286, 147,
1092	29, 29, 256, 165, 241, 312, 236, 239, 324, 149,
1093	166, 250, -206, 164, -206, 148, 188, 309, 189, -206,
1094	310, 150, 350, 166, 47, 271, 133, 134, 135, 50,
1095	51, 151, 188, 152, 189, 52, 249, 53, 246, 55,
1096	189, 325, 213, 214, 327, 57, 58, 337, 153, 188,
1097	61, 189, 326, 63, 64, 158, 66, 67, 113, 114,
1098	163, 70, 71, 72, 73, 281, 283, 183, 284, 325,
1099	325, 200, 115, 251, 116, 235, 117, 118, 231, 283,
1100	326, 349, 232, 285, 234, 328, 329, 330, 259, 360,
1101	268, 217, 218, 219, 220, 1, 2, 3, 29, 270,
1102	215, 216, 300, 300, 294, 299, 299, 269, 221, 222,
1103	257, 29, 258, 288, 293, 308, 311, 314, 315, 316,
1104	319, 320, 29, 331, 332, 333, 334, 335, 239, 246,
1105	339, 340, 345, 296, 348, 355, 356, 357, 89, 89,
1106	89, 88, 88, 88, 361, 362, 359, 318, 341, 160,
1107	29, 223, 8, 29, 240, 321, 336, 204, 224, 29,
1108	225, 9, 10, 11, 227, 239, 12, 13, 14, 15,
1109	226, 300, 322, 287, 299, 296, 229, 252, 16, 17,
1110	18, 19, 20, 295, 343, 306, 0, 0, 21, 22,
1111	0, 23, 47, 24, 49, 29, 0, 50, 51, 0,
1112	0, 0, 0, 52, 0, 53, 54, 55, 0, 0,
1113	0, 0, 0, 57, 58, 0, 342, 60, 61, 0,
1114	25, 63, 64, 65, 66, 67, 0, 26, 69, 70,
1115	71, 72, 73, 0, 47, 0, 49, 0, 0, 50,
1116	51, 0, 0, 0, 0, 52, 0, 53, 54, 55,
1117	0, 0, 0, 0, 0, 57, 58, 0, 0, 60,
1118	61, 0, 0, 63, 64, 65, 66, 67, 0, 0,
1119	69, 70, 71, 72, 73, 47, 0, 49, 0, 0,
1120	50, 51, 0, 0, 0, 0, 52, 0, 53, 54,
1121	55, 0, 0, 0, 0, 0, 57, 58, 0, 0,
1122	60, 61, 0, 0, 63, 64, 65, 66, 67, 8,
1123	0, 69, 70, 71, 72, 73, 0, 0, 9, 10,
1124	11, 0, 0, 12, 13, 14, 15, 0, 0, 0,
1125	0, 0, 0, 0, 0, 16, 17, 18, 19, 20,
1126	0, 0, 0, 0, 0, 21, 22, 0, 23, 47,
1127	24, 0, 0, 0, 50, 51, 0, 0, 0, 0,
1128	52, 0, 53, 0, 55, 0, 0, 0, 0, 0,
1129	57, 58, 0, 0, 0, 61, 0, 25, 63, 64,
1130	0, 66, 67, 8, 26, 0, 70, 71, 72, 73,
1131	0, 0, 9, 10, 11, 0, 0, 12, 13, 14,
1132	15, 0, 0, 0, 0, 0, 0, 0, 0, 16,
1133	17, 18, 19, 20, 201, 0, 8, 0, 0, 21,
1134	22, 0, 23, 0, 24, 9, 10, 11, 0, 0,
1135	12, 13, 14, 15, 0, 0, 0, 0, 0, 0,
1136	0, 0, 16, 17, 18, 19, 20, 0, 0, 0,
1137	0, 25, 21, 22, 0, 23, 0, 24, 26, 8,
1138	0, 0, 0, 0, 0, 0, 0, 0, 9, 10,
1139	11, 0, 0, 12, 13, 14, 15, 0, 0, 0,
1140	0, 0, 0, 0, 25, 16, 17, 18, 19, 103,
1141	0, 26, 8, 0, 0, 21, 22, 0, 23, 0,
1142	24, 9, 10, 11, 0, 0, 12, 13, 14, 15,
1143	0, 0, 0, 0, 0, 0, 0, 0, 16, 17,
1144	18, 19, 107, 0, 0, 0, 0, 25, 21, 22,
1145	0, 23, 0, 24, 26, 0, 0, 0, 0, 0,
1146	0, 0, 46, 0, 47, 48, 49, 0, 0, 50,
1147	51, 0, 0, 0, 0, 52, 0, 53, 54, 55,
1148	25, 0, 0, 0, 56, 57, 58, 26, 59, 60,
1149	61, 0, 62, 63, 64, 65, 66, 67, 0, 68,
1150	69, 70, 71, 72, 73, 47, 74, 49, 0, 0,
1151	50, 51, 0, 0, 0, 0, 52, 0, 53, 54,
1152	55, 0, 0, 0, 0, 0, 57, 58, 0, 0,
1153	60, 61, 0, 62, 63, 64, 65, 66, 67, 0,
1154	68, 69, 70, 71, 72, 73, 47, 0, 0, 0,
1155	0, 50, 51, 0, 0, 0, 0, 52, 0, 53,
1156	0, 55, 0, 0, 0, 0, 0, 57, 58, 0,
1157	0, 0, 61, 0, 0, 63, 64, 0, 66, 67,
1158	0, 0, 0, 70, 71, 72, 73, 119, 120, 121,
1159	122, 123, 124, 125, 126, 127, 128, 129
1160	};
1161
1162	static const yytype_int16 yycheck[] =
1163	{
1164	1, 97, 2, 56, 97, 2, 1, 171, 115, 116,
1165	20, 191, 97, 14, 15, 30, 17, 18, 173, 20,
1166	3, 3, 3, 130, 3, 60, 0, 91, 157, 193,
1167	171, 95, 96, 17, 87, 88, 89, 86, 34, 262,
1168	263, 34, 86, 172, 253, 35, 153, 60, 3, 0,
1169	179, 3, 193, 263, 263, 60, 56, 0, 63, 56,
1170	53, 3, 17, 112, 74, 3, 275, 60, 112, 32,
1171	33, 60, 3, 69, 63, 75, 0, 112, 75, 164,
1172	24, 25, 60, 293, 293, 63, 250, 87, 88, 89,
1173	87, 88, 89, 89, 190, 191, 106, 107, 26, 112,
1174	110, 265, 103, 53, 56, 190, 107, 103, 331, 250,
1175	60, 17, 54, 177, 115, 116, 54, 110, 133, 134,
1176	135, 111, 111, 54, 265, 106, 110, 110, 34, 130,
1177	112, 110, 53, 111, 55, 26, 27, 28, 29, 60,
1178	60, 53, 61, 63, 34, 64, 326, 53, 30, 31,
1179	151, 315, 153, 34, 60, 23, 151, 34, 243, 22,
1180	161, 162, 291, 53, 164, 272, 161, 162, 297, 20,
1181	60, 326, 53, 34, 55, 21, 53, 60, 55, 60,
1182	63, 19, 346, 60, 63, 200, 34, 35, 36, 68,
1183	69, 16, 53, 18, 55, 74, 325, 76, 53, 78,
1184	55, 297, 136, 137, 297, 84, 85, 314, 3, 53,
1185	89, 55, 297, 92, 93, 60, 95, 96, 39, 40,
1186	3, 100, 101, 102, 103, 235, 110, 60, 112, 325,
1187	326, 54, 53, 112, 55, 26, 57, 58, 111, 110,
1188	325, 112, 111, 243, 111, 298, 299, 300, 5, 356,
1189	3, 140, 141, 142, 143, 107, 108, 109, 259, 28,
1190	138, 139, 262, 263, 259, 262, 263, 54, 144, 145,
1191	111, 272, 111, 54, 17, 54, 53, 5, 60, 110,
1192	60, 111, 283, 3, 54, 56, 54, 54, 283, 53,
1193	110, 28, 110, 4, 111, 110, 5, 110, 298, 299,
1194	300, 298, 299, 300, 110, 110, 353, 279, 320, 75,
1195	311, 146, 23, 314, 163, 283, 311, 116, 147, 320,
1196	148, 32, 33, 34, 150, 320, 37, 38, 39, 40,
1197	149, 331, 291, 244, 331, 4, 152, 177, 49, 50,
1198	51, 52, 53, 260, 331, 263, -1, -1, 59, 60,
1199	-1, 62, 63, 64, 65, 356, -1, 68, 69, -1,
1200	-1, -1, -1, 74, -1, 76, 77, 78, -1, -1,
1201	-1, -1, -1, 84, 85, -1, 4, 88, 89, -1,
1202	91, 92, 93, 94, 95, 96, -1, 98, 99, 100,
1203	101, 102, 103, -1, 63, -1, 65, -1, -1, 68,
1204	69, -1, -1, -1, -1, 74, -1, 76, 77, 78,
1205	-1, -1, -1, -1, -1, 84, 85, -1, -1, 88,
1206	89, -1, -1, 92, 93, 94, 95, 96, -1, -1,
1207	99, 100, 101, 102, 103, 63, -1, 65, -1, -1,
1208	68, 69, -1, -1, -1, -1, 74, -1, 76, 77,
1209	78, -1, -1, -1, -1, -1, 84, 85, -1, -1,
1210	88, 89, -1, -1, 92, 93, 94, 95, 96, 23,
1211	-1, 99, 100, 101, 102, 103, -1, -1, 32, 33,
1212	34, -1, -1, 37, 38, 39, 40, -1, -1, -1,
1213	-1, -1, -1, -1, -1, 49, 50, 51, 52, 53,
1214	-1, -1, -1, -1, -1, 59, 60, -1, 62, 63,
1215	64, -1, -1, -1, 68, 69, -1, -1, -1, -1,
1216	74, -1, 76, -1, 78, -1, -1, -1, -1, -1,
1217	84, 85, -1, -1, -1, 89, -1, 91, 92, 93,
1218	-1, 95, 96, 23, 98, -1, 100, 101, 102, 103,
1219	-1, -1, 32, 33, 34, -1, -1, 37, 38, 39,
1220	40, -1, -1, -1, -1, -1, -1, -1, -1, 49,
1221	50, 51, 52, 53, 54, -1, 23, -1, -1, 59,
1222	60, -1, 62, -1, 64, 32, 33, 34, -1, -1,
1223	37, 38, 39, 40, -1, -1, -1, -1, -1, -1,
1224	-1, -1, 49, 50, 51, 52, 53, -1, -1, -1,
1225	-1, 91, 59, 60, -1, 62, -1, 64, 98, 23,
1226	-1, -1, -1, -1, -1, -1, -1, -1, 32, 33,
1227	34, -1, -1, 37, 38, 39, 40, -1, -1, -1,
1228	-1, -1, -1, -1, 91, 49, 50, 51, 52, 53,
1229	-1, 98, 23, -1, -1, 59, 60, -1, 62, -1,
1230	64, 32, 33, 34, -1, -1, 37, 38, 39, 40,
1231	-1, -1, -1, -1, -1, -1, -1, -1, 49, 50,
1232	51, 52, 53, -1, -1, -1, -1, 91, 59, 60,
1233	-1, 62, -1, 64, 98, -1, -1, -1, -1, -1,
1234	-1, -1, 61, -1, 63, 64, 65, -1, -1, 68,
1235	69, -1, -1, -1, -1, 74, -1, 76, 77, 78,
1236	91, -1, -1, -1, 83, 84, 85, 98, 87, 88,
1237	89, -1, 91, 92, 93, 94, 95, 96, -1, 98,
1238	99, 100, 101, 102, 103, 63, 105, 65, -1, -1,
1239	68, 69, -1, -1, -1, -1, 74, -1, 76, 77,
1240	78, -1, -1, -1, -1, -1, 84, 85, -1, -1,
1241	88, 89, -1, 91, 92, 93, 94, 95, 96, -1,
1242	98, 99, 100, 101, 102, 103, 63, -1, -1, -1,
1243	-1, 68, 69, -1, -1, -1, -1, 74, -1, 76,
1244	-1, 78, -1, -1, -1, -1, -1, 84, 85, -1,
1245	-1, -1, 89, -1, -1, 92, 93, -1, 95, 96,
1246	-1, -1, -1, 100, 101, 102, 103, 5, 6, 7,
1247	8, 9, 10, 11, 12, 13, 14, 15
1248	};
1249
1250	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1251	symbol of state STATE-NUM. */
1252	static const yytype_uint8 yystos[] =
1253	{
1254	0, 107, 108, 109, 114, 115, 116, 117, 23, 32,
1255	33, 34, 37, 38, 39, 40, 49, 50, 51, 52,
1256	53, 59, 60, 62, 64, 91, 98, 135, 136, 137,
1257	138, 139, 140, 141, 142, 143, 144, 145, 146, 147,
1258	148, 149, 150, 152, 153, 155, 61, 63, 64, 65,
1259	68, 69, 74, 76, 77, 78, 83, 84, 85, 87,
1260	88, 89, 91, 92, 93, 94, 95, 96, 98, 99,
1261	100, 101, 102, 103, 105, 118, 119, 120, 122, 125,
1262	128, 129, 130, 131, 156, 157, 159, 160, 161, 162,
1263	163, 164, 165, 173, 174, 161, 162, 170, 185, 0,
1264	0, 0, 0, 53, 137, 137, 53, 53, 137, 137,
1265	26, 155, 185, 39, 40, 53, 55, 57, 58, 5,
1266	6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1267	154, 137, 139, 34, 35, 36, 32, 33, 30, 31,
1268	26, 27, 28, 29, 24, 25, 23, 22, 21, 20,
1269	19, 16, 18, 3, 60, 63, 111, 157, 60, 185,
1270	119, 35, 111, 3, 34, 53, 60, 110, 167, 168,
1271	177, 178, 179, 180, 157, 157, 157, 166, 169, 170,
1272	60, 63, 111, 60, 175, 176, 170, 170, 53, 55,
1273	179, 180, 186, 187, 188, 191, 185, 185, 185, 54,
1274	54, 54, 134, 153, 134, 60, 63, 60, 63, 153,
1275	139, 139, 139, 140, 140, 141, 141, 142, 142, 142,
1276	142, 143, 143, 144, 145, 146, 147, 148, 155, 149,
1277	153, 111, 111, 177, 111, 26, 155, 132, 133, 155,
1278	131, 162, 180, 181, 3, 110, 53, 188, 191, 177,
1279	178, 112, 169, 17, 171, 172, 177, 111, 111, 5,
1280	3, 112, 192, 189, 186, 187, 188, 191, 3, 54,
1281	28, 139, 3, 54, 56, 17, 121, 86, 112, 126,
1282	127, 185, 106, 110, 112, 162, 180, 168, 54, 151,
1283	152, 3, 110, 17, 155, 176, 4, 158, 159, 161,
1284	162, 182, 183, 184, 193, 151, 182, 190, 54, 60,
1285	63, 53, 153, 152, 5, 60, 110, 112, 127, 60,
1286	111, 133, 172, 151, 177, 179, 180, 186, 157, 157,
1287	157, 3, 54, 56, 54, 54, 155, 153, 191, 110,
1288	28, 132, 4, 184, 54, 110, 17, 110, 111, 112,
1289	191, 60, 112, 123, 124, 110, 5, 110, 112, 124,
1290	153, 110, 110
1291	};
1292
1293	#define yyerrok (yyerrstatus = 0)
1294	#define yyclearin (yychar = YYEMPTY)
1295	#define YYEMPTY (-2)
1296	#define YYEOF 0
1297
1298	#define YYACCEPT goto yyacceptlab
1299	#define YYABORT goto yyabortlab
1300	#define YYERROR goto yyerrorlab
1301
1302
1303	/* Like YYERROR except do call yyerror. This remains here temporarily
1304	to ease the transition to the new meaning of YYERROR, for GCC.
1305	Once GCC version 2 has supplanted version 1, this can go. */
1306
1307	#define YYFAIL goto yyerrlab
1308
1309	#define YYRECOVERING() (!!yyerrstatus)
1310
1311	#define YYBACKUP(Token, Value) \
1312	do \
1313	if (yychar == YYEMPTY && yylen == 1) \
1314	{ \
1315	yychar = (Token); \
1316	yylval = (Value); \
1317	yytoken = YYTRANSLATE (yychar); \
1318	YYPOPSTACK (1); \
1319	goto yybackup; \
1320	} \
1321	else \
1322	{ \
1323	yyerror (YY_("syntax error: cannot back up")); \
1324	YYERROR; \
1325	} \
1326	while (YYID (0))
1327
1328
1329	#define YYTERROR 1
1330	#define YYERRCODE 256
1331
1332
1333	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1334	If N is 0, then set CURRENT to the empty location which ends
1335	the previous symbol: RHS[0] (always defined). */
1336
1337	#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1338	#ifndef YYLLOC_DEFAULT
1339	# define YYLLOC_DEFAULT(Current, Rhs, N) \
1340	do \
1341	if (YYID (N)) \
1342	{ \
1343	(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1344	(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1345	(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1346	(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1347	} \
1348	else \
1349	{ \
1350	(Current).first_line = (Current).last_line = \
1351	YYRHSLOC (Rhs, 0).last_line; \
1352	(Current).first_column = (Current).last_column = \
1353	YYRHSLOC (Rhs, 0).last_column; \
1354	} \
1355	while (YYID (0))
1356	#endif
1357
1358
1359	/* YY_LOCATION_PRINT -- Print the location on the stream.
1360	This macro was not mandated originally: define only if we know
1361	we won't break user code: when these are the locations we know. */
1362
1363	#ifndef YY_LOCATION_PRINT
1364	# if YYLTYPE_IS_TRIVIAL
1365	# define YY_LOCATION_PRINT(File, Loc) \
1366	fprintf (File, "%d.%d-%d.%d", \
1367	(Loc).first_line, (Loc).first_column, \
1368	(Loc).last_line, (Loc).last_column)
1369	# else
1370	# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1371	# endif
1372	#endif
1373
1374
1375	/* YYLEX -- calling `yylex' with the right arguments. */
1376
1377	#ifdef YYLEX_PARAM
1378	# define YYLEX yylex (YYLEX_PARAM)
1379	#else
1380	# define YYLEX yylex ()
1381	#endif
1382
1383	/* Enable debugging if requested. */
1384	#if YYDEBUG
1385
1386	# ifndef YYFPRINTF
1387	# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1388	# define YYFPRINTF fprintf
1389	# endif
1390
1391	# define YYDPRINTF(Args) \
1392	do { \
1393	if (yydebug) \
1394	YYFPRINTF Args; \
1395	} while (YYID (0))
1396
1397	# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1398	do { \
1399	if (yydebug) \
1400	{ \
1401	YYFPRINTF (stderr, "%s ", Title); \
1402	yy_symbol_print (stderr, \
1403	Type, Value); \
1404	YYFPRINTF (stderr, "\n"); \
1405	} \
1406	} while (YYID (0))
1407
1408
1409	/*--------------------------------.
1410	\| Print this symbol on YYOUTPUT. \|
1411	`--------------------------------*/
1412
1413	/ARGSUSED/
1414	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1415	\|\| defined __cplusplus \|\| defined _MSC_VER)
1416	static void
1417	yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1418	#else
1419	static void
1420	yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1421	FILE *yyoutput;
1422	int yytype;
1423	YYSTYPE const * const yyvaluep;
1424	#endif
1425	{
1426	if (!yyvaluep)
1427	return;
1428	# ifdef YYPRINT
1429	if (yytype < YYNTOKENS)
1430	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1431	# else
1432	YYUSE (yyoutput);
1433	# endif
1434	switch (yytype)
1435	{
1436	default:
1437	break;
1438	}
1439	}
1440
1441
1442	/*--------------------------------.
1443	\| Print this symbol on YYOUTPUT. \|
1444	`--------------------------------*/
1445
1446	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1447	\|\| defined __cplusplus \|\| defined _MSC_VER)
1448	static void
1449	yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1450	#else
1451	static void
1452	yy_symbol_print (yyoutput, yytype, yyvaluep)
1453	FILE *yyoutput;
1454	int yytype;
1455	YYSTYPE const * const yyvaluep;
1456	#endif
1457	{
1458	if (yytype < YYNTOKENS)
1459	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1460	else
1461	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1462
1463	yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1464	YYFPRINTF (yyoutput, ")");
1465	}
1466
1467	/*------------------------------------------------------------------.
1468	\| yy_stack_print -- Print the state stack from its BOTTOM up to its \|
1469	\| TOP (included). \|
1470	`------------------------------------------------------------------*/
1471
1472	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1473	\|\| defined __cplusplus \|\| defined _MSC_VER)
1474	static void
1475	yy_stack_print (yytype_int16 yybottom, yytype_int16 yytop)
1476	#else
1477	static void
1478	yy_stack_print (yybottom, yytop)
1479	yytype_int16 *yybottom;
1480	yytype_int16 *yytop;
1481	#endif
1482	{
1483	YYFPRINTF (stderr, "Stack now");
1484	for (; yybottom <= yytop; yybottom++)
1485	{
1486	int yybot = *yybottom;
1487	YYFPRINTF (stderr, " %d", yybot);
1488	}
1489	YYFPRINTF (stderr, "\n");
1490	}
1491
1492	# define YY_STACK_PRINT(Bottom, Top) \
1493	do { \
1494	if (yydebug) \
1495	yy_stack_print ((Bottom), (Top)); \
1496	} while (YYID (0))
1497
1498
1499	/*------------------------------------------------.
1500	\| Report that the YYRULE is going to be reduced. \|
1501	`------------------------------------------------*/
1502
1503	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1504	\|\| defined __cplusplus \|\| defined _MSC_VER)
1505	static void
1506	yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1507	#else
1508	static void
1509	yy_reduce_print (yyvsp, yyrule)
1510	YYSTYPE *yyvsp;
1511	int yyrule;
1512	#endif
1513	{
1514	int yynrhs = yyr2[yyrule];
1515	int yyi;
1516	unsigned long int yylno = yyrline[yyrule];
1517	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1518	yyrule - 1, yylno);
1519	/* The symbols being reduced. */
1520	for (yyi = 0; yyi < yynrhs; yyi++)
1521	{
1522	YYFPRINTF (stderr, " $%d = ", yyi + 1);
1523	yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1524	&(yyvsp[(yyi + 1) - (yynrhs)])
1525	);
1526	YYFPRINTF (stderr, "\n");
1527	}
1528	}
1529
1530	# define YY_REDUCE_PRINT(Rule) \
1531	do { \
1532	if (yydebug) \
1533	yy_reduce_print (yyvsp, Rule); \
1534	} while (YYID (0))
1535
1536	/* Nonzero means print parse trace. It is left uninitialized so that
1537	multiple parsers can coexist. */
1538	int yydebug;
1539	#else /* !YYDEBUG */
1540	# define YYDPRINTF(Args)
1541	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1542	# define YY_STACK_PRINT(Bottom, Top)
1543	# define YY_REDUCE_PRINT(Rule)
1544	#endif /* !YYDEBUG */
1545
1546
1547	/* YYINITDEPTH -- initial size of the parser's stacks. */
1548	#ifndef YYINITDEPTH
1549	# define YYINITDEPTH 200
1550	#endif
1551
1552	/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1553	if the built-in stack extension method is used).
1554
1555	Do not make this value too large; the results are undefined if
1556	YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1557	evaluated with infinite-precision integer arithmetic. */
1558
1559	#ifndef YYMAXDEPTH
1560	# define YYMAXDEPTH 10000
1561	#endif
1562
1563
1564
1565
1566	#if YYERROR_VERBOSE
1567
1568	# ifndef yystrlen
1569	# if defined __GLIBC__ && defined _STRING_H
1570	# define yystrlen strlen
1571	# else
1572	/* Return the length of YYSTR. */
1573	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1574	\|\| defined __cplusplus \|\| defined _MSC_VER)
1575	static YYSIZE_T
1576	yystrlen (const char *yystr)
1577	#else
1578	static YYSIZE_T
1579	yystrlen (yystr)
1580	const char *yystr;
1581	#endif
1582	{
1583	YYSIZE_T yylen;
1584	for (yylen = 0; yystr[yylen]; yylen++)
1585	continue;
1586	return yylen;
1587	}
1588	# endif
1589	# endif
1590
1591	# ifndef yystpcpy
1592	# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1593	# define yystpcpy stpcpy
1594	# else
1595	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1596	YYDEST. */
1597	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1598	\|\| defined __cplusplus \|\| defined _MSC_VER)
1599	static char *
1600	yystpcpy (char yydest, const char yysrc)
1601	#else
1602	static char *
1603	yystpcpy (yydest, yysrc)
1604	char *yydest;
1605	const char *yysrc;
1606	#endif
1607	{
1608	char *yyd = yydest;
1609	const char *yys = yysrc;
1610
1611	while ((yyd++ = yys++) != '\0')
1612	continue;
1613
1614	return yyd - 1;
1615	}
1616	# endif
1617	# endif
1618
1619	# ifndef yytnamerr
1620	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1621	quotes and backslashes, so that it's suitable for yyerror. The
1622	heuristic is that double-quoting is unnecessary unless the string
1623	contains an apostrophe, a comma, or backslash (other than
1624	backslash-backslash). YYSTR is taken from yytname. If YYRES is
1625	null, do not copy; instead, return the length of what the result
1626	would have been. */
1627	static YYSIZE_T
1628	yytnamerr (char yyres, const char yystr)
1629	{
1630	if (*yystr == '"')
1631	{
1632	YYSIZE_T yyn = 0;
1633	char const *yyp = yystr;
1634
1635	for (;;)
1636	switch (*++yyp)
1637	{
1638	case '\'':
1639	case ',':
1640	goto do_not_strip_quotes;
1641
1642	case '\\':
1643	if (*++yyp != '\\')
1644	goto do_not_strip_quotes;
1645	/* Fall through. */
1646	default:
1647	if (yyres)
1648	yyres[yyn] = *yyp;
1649	yyn++;
1650	break;
1651
1652	case '"':
1653	if (yyres)
1654	yyres[yyn] = '\0';
1655	return yyn;
1656	}
1657	do_not_strip_quotes: ;
1658	}
1659
1660	if (! yyres)
1661	return yystrlen (yystr);
1662
1663	return yystpcpy (yyres, yystr) - yyres;
1664	}
1665	# endif
1666
1667	/* Copy into YYRESULT an error message about the unexpected token
1668	YYCHAR while in state YYSTATE. Return the number of bytes copied,
1669	including the terminating null byte. If YYRESULT is null, do not
1670	copy anything; just return the number of bytes that would be
1671	copied. As a special case, return 0 if an ordinary "syntax error"
1672	message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1673	size calculation. */
1674	static YYSIZE_T
1675	yysyntax_error (char *yyresult, int yystate, int yychar)
1676	{
1677	int yyn = yypact[yystate];
1678
1679	if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1680	return 0;
1681	else
1682	{
1683	int yytype = YYTRANSLATE (yychar);
1684	YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1685	YYSIZE_T yysize = yysize0;
1686	YYSIZE_T yysize1;
1687	int yysize_overflow = 0;
1688	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1689	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1690	int yyx;
1691
1692	# if 0
1693	/* This is so xgettext sees the translatable formats that are
1694	constructed on the fly. */
1695	YY_("syntax error, unexpected %s");
1696	YY_("syntax error, unexpected %s, expecting %s");
1697	YY_("syntax error, unexpected %s, expecting %s or %s");
1698	YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1699	YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1700	# endif
1701	char *yyfmt;
1702	char const *yyf;
1703	static char const yyunexpected[] = "syntax error, unexpected %s";
1704	static char const yyexpecting[] = ", expecting %s";
1705	static char const yyor[] = " or %s";
1706	char yyformat[sizeof yyunexpected
1707	+ sizeof yyexpecting - 1
1708	+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1709	* (sizeof yyor - 1))];
1710	char const *yyprefix = yyexpecting;
1711
1712	/* Start YYX at -YYN if negative to avoid negative indexes in
1713	YYCHECK. */
1714	int yyxbegin = yyn < 0 ? -yyn : 0;
1715
1716	/* Stay within bounds of both yycheck and yytname. */
1717	int yychecklim = YYLAST - yyn + 1;
1718	int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1719	int yycount = 1;
1720
1721	yyarg[0] = yytname[yytype];
1722	yyfmt = yystpcpy (yyformat, yyunexpected);
1723
1724	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1725	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1726	{
1727	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1728	{
1729	yycount = 1;
1730	yysize = yysize0;
1731	yyformat[sizeof yyunexpected - 1] = '\0';
1732	break;
1733	}
1734	yyarg[yycount++] = yytname[yyx];
1735	yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1736	yysize_overflow \|= (yysize1 < yysize);
1737	yysize = yysize1;
1738	yyfmt = yystpcpy (yyfmt, yyprefix);
1739	yyprefix = yyor;
1740	}
1741
1742	yyf = YY_(yyformat);
1743	yysize1 = yysize + yystrlen (yyf);
1744	yysize_overflow \|= (yysize1 < yysize);
1745	yysize = yysize1;
1746
1747	if (yysize_overflow)
1748	return YYSIZE_MAXIMUM;
1749
1750	if (yyresult)
1751	{
1752	/* Avoid sprintf, as that infringes on the user's name space.
1753	Don't have undefined behavior even if the translation
1754	produced a string with the wrong number of "%s"s. */
1755	char *yyp = yyresult;
1756	int yyi = 0;
1757	while ((yyp = yyf) != '\0')
1758	{
1759	if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1760	{
1761	yyp += yytnamerr (yyp, yyarg[yyi++]);
1762	yyf += 2;
1763	}
1764	else
1765	{
1766	yyp++;
1767	yyf++;
1768	}
1769	}
1770	}
1771	return yysize;
1772	}
1773	}
1774	#endif /* YYERROR_VERBOSE */
1775
1776
1777
1778	/*-----------------------------------------------.
1779	\| Release the memory associated to this symbol. \|
1780	`-----------------------------------------------*/
1781
1782	/ARGSUSED/
1783	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1784	\|\| defined __cplusplus \|\| defined _MSC_VER)
1785	static void
1786	yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep)
1787	#else
1788	static void
1789	yydestruct (yymsg, yytype, yyvaluep)
1790	const char *yymsg;
1791	int yytype;
1792	YYSTYPE *yyvaluep;
1793	#endif
1794	{
1795	YYUSE (yyvaluep);
1796
1797	if (!yymsg)
1798	yymsg = "Deleting";
1799	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1800
1801	switch (yytype)
1802	{
1803
1804	default:
1805	break;
1806	}
1807	}
1808
1809	/* Prevent warnings from -Wmissing-prototypes. */
1810	#ifdef YYPARSE_PARAM
1811	#if defined __STDC__ \|\| defined __cplusplus
1812	int yyparse (void *YYPARSE_PARAM);
1813	#else
1814	int yyparse ();
1815	#endif
1816	#else /* ! YYPARSE_PARAM */
1817	#if defined __STDC__ \|\| defined __cplusplus
1818	int yyparse (void);
1819	#else
1820	int yyparse ();
1821	#endif
1822	#endif /* ! YYPARSE_PARAM */
1823
1824
1825	/* The lookahead symbol. */
1826	int yychar;
1827
1828	/* The semantic value of the lookahead symbol. */
1829	YYSTYPE yylval;
1830
1831	/* Number of syntax errors so far. */
1832	int yynerrs;
1833
1834
1835
1836	/*-------------------------.
1837	\| yyparse or yypush_parse. \|
1838	`-------------------------*/
1839
1840	#ifdef YYPARSE_PARAM
1841	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1842	\|\| defined __cplusplus \|\| defined _MSC_VER)
1843	int
1844	yyparse (void *YYPARSE_PARAM)
1845	#else
1846	int
1847	yyparse (YYPARSE_PARAM)
1848	void *YYPARSE_PARAM;
1849	#endif
1850	#else /* ! YYPARSE_PARAM */
1851	#if (defined __STDC__ \|\| defined __C99__FUNC__ \
1852	\|\| defined __cplusplus \|\| defined _MSC_VER)
1853	int
1854	yyparse (void)
1855	#else
1856	int
1857	yyparse ()
1858
1859	#endif
1860	#endif
1861	{
1862
1863
1864	int yystate;
1865	/* Number of tokens to shift before error messages enabled. */
1866	int yyerrstatus;
1867
1868	/* The stacks and their tools:
1869	`yyss': related to states.
1870	`yyvs': related to semantic values.
1871
1872	Refer to the stacks thru separate pointers, to allow yyoverflow
1873	to reallocate them elsewhere. */
1874
1875	/* The state stack. */
1876	yytype_int16 yyssa[YYINITDEPTH];
1877	yytype_int16 *yyss;
1878	yytype_int16 *yyssp;
1879
1880	/* The semantic value stack. */
1881	YYSTYPE yyvsa[YYINITDEPTH];
1882	YYSTYPE *yyvs;
1883	YYSTYPE *yyvsp;
1884
1885	YYSIZE_T yystacksize;
1886
1887	int yyn;
1888	int yyresult;
1889	/* Lookahead token as an internal (translated) token number. */
1890	int yytoken;
1891	/* The variables used to return semantic value and location from the
1892	action routines. */
1893	YYSTYPE yyval;
1894
1895	#if YYERROR_VERBOSE
1896	/* Buffer for error messages, and its allocated size. */
1897	char yymsgbuf[128];
1898	char *yymsg = yymsgbuf;
1899	YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1900	#endif
1901
1902	#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1903
1904	/* The number of symbols on the RHS of the reduced rule.
1905	Keep to zero when no symbol should be popped. */
1906	int yylen = 0;
1907
1908	yytoken = 0;
1909	yyss = yyssa;
1910	yyvs = yyvsa;
1911	yystacksize = YYINITDEPTH;
1912
1913	YYDPRINTF ((stderr, "Starting parse\n"));
1914
1915	yystate = 0;
1916	yyerrstatus = 0;
1917	yynerrs = 0;
1918	yychar = YYEMPTY; /* Cause a token to be read. */
1919
1920	/* Initialize stack pointers.
1921	Waste one element of value and location stack
1922	so that they stay on the same level as the state stack.
1923	The wasted elements are never initialized. */
1924	yyssp = yyss;
1925	yyvsp = yyvs;
1926
1927	goto yysetstate;
1928
1929	/*------------------------------------------------------------.
1930	\| yynewstate -- Push a new state, which is found in yystate. \|
1931	`------------------------------------------------------------*/
1932	yynewstate:
1933	/* In all cases, when you get here, the value and location stacks
1934	have just been pushed. So pushing a state here evens the stacks. */
1935	yyssp++;
1936
1937	yysetstate:
1938	*yyssp = yystate;
1939
1940	if (yyss + yystacksize - 1 <= yyssp)
1941	{
1942	/* Get the current used size of the three stacks, in elements. */
1943	YYSIZE_T yysize = yyssp - yyss + 1;
1944
1945	#ifdef yyoverflow
1946	{
1947	/* Give user a chance to reallocate the stack. Use copies of
1948	these so that the &'s don't force the real ones into
1949	memory. */
1950	YYSTYPE *yyvs1 = yyvs;
1951	yytype_int16 *yyss1 = yyss;
1952
1953	/* Each stack pointer address is followed by the size of the
1954	data in use in that stack, in bytes. This used to be a
1955	conditional around just the two extra args, but that might
1956	be undefined if yyoverflow is a macro. */
1957	yyoverflow (YY_("memory exhausted"),
1958	&yyss1, yysize * sizeof (*yyssp),
1959	&yyvs1, yysize * sizeof (*yyvsp),
1960	&yystacksize);
1961
1962	yyss = yyss1;
1963	yyvs = yyvs1;
1964	}
1965	#else /* no yyoverflow */
1966	# ifndef YYSTACK_RELOCATE
1967	goto yyexhaustedlab;
1968	# else
1969	/* Extend the stack our own way. */
1970	if (YYMAXDEPTH <= yystacksize)
1971	goto yyexhaustedlab;
1972	yystacksize *= 2;
1973	if (YYMAXDEPTH < yystacksize)
1974	yystacksize = YYMAXDEPTH;
1975
1976	{
1977	yytype_int16 *yyss1 = yyss;
1978	union yyalloc *yyptr =
1979	(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1980	if (! yyptr)
1981	goto yyexhaustedlab;
1982	YYSTACK_RELOCATE (yyss_alloc, yyss);
1983	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1984	# undef YYSTACK_RELOCATE
1985	if (yyss1 != yyssa)
1986	YYSTACK_FREE (yyss1);
1987	}
1988	# endif
1989	#endif /* no yyoverflow */
1990
1991	yyssp = yyss + yysize - 1;
1992	yyvsp = yyvs + yysize - 1;
1993
1994	YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1995	(unsigned long int) yystacksize));
1996
1997	if (yyss + yystacksize - 1 <= yyssp)
1998	YYABORT;
1999	}
2000
2001	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2002
2003	if (yystate == YYFINAL)
2004	YYACCEPT;
2005
2006	goto yybackup;
2007
2008	/*-----------.
2009	\| yybackup. \|
2010	`-----------*/
2011	yybackup:
2012
2013	/* Do appropriate processing given the current state. Read a
2014	lookahead token if we need one and don't already have one. */
2015
2016	/* First try to decide what to do without reference to lookahead token. */
2017	yyn = yypact[yystate];
2018	if (yyn == YYPACT_NINF)
2019	goto yydefault;
2020
2021	/* Not known => get a lookahead token if don't already have one. */
2022
2023	/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2024	if (yychar == YYEMPTY)
2025	{
2026	YYDPRINTF ((stderr, "Reading a token: "));
2027	yychar = YYLEX;
2028	}
2029
2030	if (yychar <= YYEOF)
2031	{
2032	yychar = yytoken = YYEOF;
2033	YYDPRINTF ((stderr, "Now at end of input.\n"));
2034	}
2035	else
2036	{
2037	yytoken = YYTRANSLATE (yychar);
2038	YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2039	}
2040
2041	/* If the proper action on seeing token YYTOKEN is to reduce or to
2042	detect an error, take that action. */
2043	yyn += yytoken;
2044	if (yyn < 0 \|\| YYLAST < yyn \|\| yycheck[yyn] != yytoken)
2045	goto yydefault;
2046	yyn = yytable[yyn];
2047	if (yyn <= 0)
2048	{
2049	if (yyn == 0 \|\| yyn == YYTABLE_NINF)
2050	goto yyerrlab;
2051	yyn = -yyn;
2052	goto yyreduce;
2053	}
2054
2055	/* Count tokens shifted since error; after three, turn off error
2056	status. */
2057	if (yyerrstatus)
2058	yyerrstatus--;
2059
2060	/* Shift the lookahead token. */
2061	YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2062
2063	/* Discard the shifted token. */
2064	yychar = YYEMPTY;
2065
2066	yystate = yyn;
2067	*++yyvsp = yylval;
2068
2069	goto yynewstate;
2070
2071
2072	/*-----------------------------------------------------------.
2073	\| yydefault -- do the default action for the current state. \|
2074	`-----------------------------------------------------------*/
2075	yydefault:
2076	yyn = yydefact[yystate];
2077	if (yyn == 0)
2078	goto yyerrlab;
2079	goto yyreduce;
2080
2081
2082	/*-----------------------------.
2083	\| yyreduce -- Do a reduction. \|
2084	`-----------------------------*/
2085	yyreduce:
2086	/* yyn is the number of a rule to reduce with. */
2087	yylen = yyr2[yyn];
2088
2089	/* If YYLEN is nonzero, implement the default value of the action:
2090	`$$ = $1'.
2091
2092	Otherwise, the following line sets YYVAL to garbage.
2093	This behavior is undocumented and Bison
2094	users should not rely upon it. Assigning to YYVAL
2095	unconditionally makes the parser a bit smaller, and it avoids a
2096	GCC warning that YYVAL may be used uninitialized. */
2097	yyval = yyvsp[1-yylen];
2098
2099
2100	YY_REDUCE_PRINT (yyn);
2101	switch (yyn)
2102	{
2103	case 2:
2104
2105	/* Line 1455 of yacc.c */
2106	#line 221 "dt_grammar.y"
2107	{ return (dt_node_root((yyvsp[(1) - (2)].l_node))); }
2108	break;
2109
2110	case 3:
2111
2112	/* Line 1455 of yacc.c */
2113	#line 222 "dt_grammar.y"
2114	{ return (dt_node_root((yyvsp[(1) - (2)].l_node))); }
2115	break;
2116
2117	case 4:
2118
2119	/* Line 1455 of yacc.c */
2120	#line 223 "dt_grammar.y"
2121	{ return (dt_node_root((yyvsp[(1) - (2)].l_node))); }
2122	break;
2123
2124	case 5:
2125
2126	/* Line 1455 of yacc.c */
2127	#line 226 "dt_grammar.y"
2128	{ (yyval.l_node) = NULL; }
2129	break;
2130
2131	case 6:
2132
2133	/* Line 1455 of yacc.c */
2134	#line 227 "dt_grammar.y"
2135	{ (yyval.l_node) = (yyvsp[(2) - (2)].l_node); }
2136	break;
2137
2138	case 7:
2139
2140	/* Line 1455 of yacc.c */
2141	#line 230 "dt_grammar.y"
2142	{ (yyval.l_node) = dt_node_program(NULL); }
2143	break;
2144
2145	case 8:
2146
2147	/* Line 1455 of yacc.c */
2148	#line 231 "dt_grammar.y"
2149	{ (yyval.l_node) = dt_node_program((yyvsp[(2) - (2)].l_node)); }
2150	break;
2151
2152	case 9:
2153
2154	/* Line 1455 of yacc.c */
2155	#line 234 "dt_grammar.y"
2156	{ (yyval.l_node) = NULL; }
2157	break;
2158
2159	case 10:
2160
2161	/* Line 1455 of yacc.c */
2162	#line 235 "dt_grammar.y"
2163	{ (yyval.l_node) = (dt_node_t *)(yyvsp[(2) - (2)].l_decl); }
2164	break;
2165
2166	case 12:
2167
2168	/* Line 1455 of yacc.c */
2169	#line 240 "dt_grammar.y"
2170	{ (yyval.l_node) = LINK((yyvsp[(1) - (2)].l_node), (yyvsp[(2) - (2)].l_node)); }
2171	break;
2172
2173	case 18:
2174
2175	/* Line 1455 of yacc.c */
2176	#line 253 "dt_grammar.y"
2177	{ dt_scope_push(NULL, CTF_ERR); }
2178	break;
2179
2180	case 19:
2181
2182	/* Line 1455 of yacc.c */
2183	#line 254 "dt_grammar.y"
2184	{
2185	/*
2186	* We push a new declaration scope before shifting the
2187	* assignment_expression in order to preserve ds_class
2188	* and ds_ident for use in dt_node_inline(). Once the
2189	* entire inline_definition rule is matched, pop the
2190	* scope and construct the inline using the saved decl.
2191	*/
2192	dt_scope_pop();
2193	(yyval.l_node) = dt_node_inline((yyvsp[(6) - (7)].l_node));
2194	}
2195	break;
2196
2197	case 20:
2198
2199	/* Line 1455 of yacc.c */
2200	#line 269 "dt_grammar.y"
2201	{
2202	(yyval.l_node) = dt_node_xlator((yyvsp[(2) - (10)].l_decl), (yyvsp[(4) - (10)].l_decl), (yyvsp[(5) - (10)].l_str), (yyvsp[(8) - (10)].l_node));
2203	}
2204	break;
2205
2206	case 21:
2207
2208	/* Line 1455 of yacc.c */
2209	#line 273 "dt_grammar.y"
2210	{
2211	(yyval.l_node) = dt_node_xlator((yyvsp[(2) - (9)].l_decl), (yyvsp[(4) - (9)].l_decl), (yyvsp[(5) - (9)].l_str), NULL);
2212	}
2213	break;
2214
2215	case 23:
2216
2217	/* Line 1455 of yacc.c */
2218	#line 280 "dt_grammar.y"
2219	{ (yyval.l_node) = LINK((yyvsp[(1) - (2)].l_node),(yyvsp[(2) - (2)].l_node)); }
2220	break;
2221
2222	case 24:
2223
2224	/* Line 1455 of yacc.c */
2225	#line 284 "dt_grammar.y"
2226	{
2227	(yyval.l_node) = dt_node_member(NULL, (yyvsp[(1) - (4)].l_str), (yyvsp[(3) - (4)].l_node));
2228	}
2229	break;
2230
2231	case 25:
2232
2233	/* Line 1455 of yacc.c */
2234	#line 290 "dt_grammar.y"
2235	{
2236	(yyval.l_node) = dt_node_provider((yyvsp[(2) - (6)].l_str), (yyvsp[(4) - (6)].l_node));
2237	}
2238	break;
2239
2240	case 26:
2241
2242	/* Line 1455 of yacc.c */
2243	#line 293 "dt_grammar.y"
2244	{
2245	(yyval.l_node) = dt_node_provider((yyvsp[(2) - (5)].l_str), NULL);
2246	}
2247	break;
2248
2249	case 28:
2250
2251	/* Line 1455 of yacc.c */
2252	#line 300 "dt_grammar.y"
2253	{ (yyval.l_node) = LINK((yyvsp[(1) - (2)].l_node), (yyvsp[(2) - (2)].l_node)); }
2254	break;
2255
2256	case 29:
2257
2258	/* Line 1455 of yacc.c */
2259	#line 304 "dt_grammar.y"
2260	{
2261	(yyval.l_node) = dt_node_probe((yyvsp[(2) - (6)].l_str), 2, (yyvsp[(3) - (6)].l_node), (yyvsp[(5) - (6)].l_node));
2262	}
2263	break;
2264
2265	case 30:
2266
2267	/* Line 1455 of yacc.c */
2268	#line 307 "dt_grammar.y"
2269	{
2270	(yyval.l_node) = dt_node_probe((yyvsp[(2) - (4)].l_str), 1, (yyvsp[(3) - (4)].l_node), NULL);
2271	}
2272	break;
2273
2274	case 31:
2275
2276	/* Line 1455 of yacc.c */
2277	#line 314 "dt_grammar.y"
2278	{
2279	/*
2280	* If the input stream is a file, do not permit a probe
2281	* specification without / <pred> / or { <act> } after
2282	* it. This can only occur if the next token is EOF or
2283	* an ambiguous predicate was slurped up as a comment.
2284	* We cannot perform this check if input() is a string
2285	* because dtrace(1M) [-fmnP] also use the compiler and
2286	* things like dtrace -n BEGIN have to be accepted.
2287	*/
2288	if (yypcb->pcb_fileptr != NULL) {
2289	dnerror((yyvsp[(1) - (1)].l_node), D_SYNTAX, "expected predicate and/"
2290	"or actions following probe description\n");
2291	}
2292	(yyval.l_node) = dt_node_clause((yyvsp[(1) - (1)].l_node), NULL, NULL);
2293	}
2294	break;
2295
2296	case 32:
2297
2298	/* Line 1455 of yacc.c */
2299	#line 330 "dt_grammar.y"
2300	{
2301	(yyval.l_node) = dt_node_clause((yyvsp[(1) - (4)].l_node), NULL, (yyvsp[(3) - (4)].l_node));
2302	}
2303	break;
2304
2305	case 33:
2306
2307	/* Line 1455 of yacc.c */
2308	#line 333 "dt_grammar.y"
2309	{
2310	dnerror((yyvsp[(3) - (4)].l_node), D_SYNTAX, "expected actions { } following "
2311	"probe description and predicate\n");
2312	}
2313	break;
2314
2315	case 34:
2316
2317	/* Line 1455 of yacc.c */
2318	#line 338 "dt_grammar.y"
2319	{
2320	(yyval.l_node) = dt_node_clause((yyvsp[(1) - (7)].l_node), (yyvsp[(3) - (7)].l_node), (yyvsp[(6) - (7)].l_node));
2321	}
2322	break;
2323
2324	case 35:
2325
2326	/* Line 1455 of yacc.c */
2327	#line 344 "dt_grammar.y"
2328	{ yybegin(YYS_EXPR); (yyval.l_node) = (yyvsp[(1) - (1)].l_node); }
2329	break;
2330
2331	case 37:
2332
2333	/* Line 1455 of yacc.c */
2334	#line 349 "dt_grammar.y"
2335	{
2336	(yyval.l_node) = LINK((yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2337	}
2338	break;
2339
2340	case 38:
2341
2342	/* Line 1455 of yacc.c */
2343	#line 355 "dt_grammar.y"
2344	{ (yyval.l_node) = dt_node_pdesc_by_name((yyvsp[(1) - (1)].l_str)); }
2345	break;
2346
2347	case 39:
2348
2349	/* Line 1455 of yacc.c */
2350	#line 356 "dt_grammar.y"
2351	{ (yyval.l_node) = dt_node_pdesc_by_id((yyvsp[(1) - (1)].l_int)); }
2352	break;
2353
2354	case 40:
2355
2356	/* Line 1455 of yacc.c */
2357	#line 359 "dt_grammar.y"
2358	{ (yyval.l_node) = (yyvsp[(1) - (1)].l_node); }
2359	break;
2360
2361	case 41:
2362
2363	/* Line 1455 of yacc.c */
2364	#line 360 "dt_grammar.y"
2365	{ (yyval.l_node) = LINK((yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node)); }
2366	break;
2367
2368	case 42:
2369
2370	/* Line 1455 of yacc.c */
2371	#line 363 "dt_grammar.y"
2372	{ (yyval.l_node) = NULL; }
2373	break;
2374
2375	case 43:
2376
2377	/* Line 1455 of yacc.c */
2378	#line 364 "dt_grammar.y"
2379	{ (yyval.l_node) = dt_node_statement((yyvsp[(1) - (1)].l_node)); }
2380	break;
2381
2382	case 45:
2383
2384	/* Line 1455 of yacc.c */
2385	#line 369 "dt_grammar.y"
2386	{
2387	(yyval.l_node) = LINK((yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2388	}
2389	break;
2390
2391	case 46:
2392
2393	/* Line 1455 of yacc.c */
2394	#line 375 "dt_grammar.y"
2395	{ (yyval.l_node) = dt_node_ident((yyvsp[(1) - (1)].l_str)); }
2396	break;
2397
2398	case 47:
2399
2400	/* Line 1455 of yacc.c */
2401	#line 376 "dt_grammar.y"
2402	{ (yyval.l_node) = dt_node_ident((yyvsp[(1) - (1)].l_str)); }
2403	break;
2404
2405	case 48:
2406
2407	/* Line 1455 of yacc.c */
2408	#line 377 "dt_grammar.y"
2409	{ (yyval.l_node) = dt_node_int((yyvsp[(1) - (1)].l_int)); }
2410	break;
2411
2412	case 49:
2413
2414	/* Line 1455 of yacc.c */
2415	#line 378 "dt_grammar.y"
2416	{ (yyval.l_node) = dt_node_string((yyvsp[(1) - (1)].l_str)); }
2417	break;
2418
2419	case 50:
2420
2421	/* Line 1455 of yacc.c */
2422	#line 379 "dt_grammar.y"
2423	{ (yyval.l_node) = dt_node_ident(DUP("self")); }
2424	break;
2425
2426	case 51:
2427
2428	/* Line 1455 of yacc.c */
2429	#line 380 "dt_grammar.y"
2430	{ (yyval.l_node) = dt_node_ident(DUP("this")); }
2431	break;
2432
2433	case 52:
2434
2435	/* Line 1455 of yacc.c */
2436	#line 381 "dt_grammar.y"
2437	{ (yyval.l_node) = (yyvsp[(2) - (3)].l_node); }
2438	break;
2439
2440	case 54:
2441
2442	/* Line 1455 of yacc.c */
2443	#line 387 "dt_grammar.y"
2444	{
2445	(yyval.l_node) = OP2(DT_TOK_LBRAC, (yyvsp[(1) - (4)].l_node), (yyvsp[(3) - (4)].l_node));
2446	}
2447	break;
2448
2449	case 55:
2450
2451	/* Line 1455 of yacc.c */
2452	#line 390 "dt_grammar.y"
2453	{
2454	(yyval.l_node) = dt_node_func((yyvsp[(1) - (3)].l_node), NULL);
2455	}
2456	break;
2457
2458	case 56:
2459
2460	/* Line 1455 of yacc.c */
2461	#line 394 "dt_grammar.y"
2462	{
2463	(yyval.l_node) = dt_node_func((yyvsp[(1) - (4)].l_node), (yyvsp[(3) - (4)].l_node));
2464	}
2465	break;
2466
2467	case 57:
2468
2469	/* Line 1455 of yacc.c */
2470	#line 397 "dt_grammar.y"
2471	{
2472	(yyval.l_node) = OP2(DT_TOK_DOT, (yyvsp[(1) - (3)].l_node), dt_node_ident((yyvsp[(3) - (3)].l_str)));
2473	}
2474	break;
2475
2476	case 58:
2477
2478	/* Line 1455 of yacc.c */
2479	#line 400 "dt_grammar.y"
2480	{
2481	(yyval.l_node) = OP2(DT_TOK_DOT, (yyvsp[(1) - (3)].l_node), dt_node_ident((yyvsp[(3) - (3)].l_str)));
2482	}
2483	break;
2484
2485	case 59:
2486
2487	/* Line 1455 of yacc.c */
2488	#line 403 "dt_grammar.y"
2489	{
2490	(yyval.l_node) = OP2(DT_TOK_PTR, (yyvsp[(1) - (3)].l_node), dt_node_ident((yyvsp[(3) - (3)].l_str)));
2491	}
2492	break;
2493
2494	case 60:
2495
2496	/* Line 1455 of yacc.c */
2497	#line 406 "dt_grammar.y"
2498	{
2499	(yyval.l_node) = OP2(DT_TOK_PTR, (yyvsp[(1) - (3)].l_node), dt_node_ident((yyvsp[(3) - (3)].l_str)));
2500	}
2501	break;
2502
2503	case 61:
2504
2505	/* Line 1455 of yacc.c */
2506	#line 409 "dt_grammar.y"
2507	{
2508	(yyval.l_node) = OP1(DT_TOK_POSTINC, (yyvsp[(1) - (2)].l_node));
2509	}
2510	break;
2511
2512	case 62:
2513
2514	/* Line 1455 of yacc.c */
2515	#line 412 "dt_grammar.y"
2516	{
2517	(yyval.l_node) = OP1(DT_TOK_POSTDEC, (yyvsp[(1) - (2)].l_node));
2518	}
2519	break;
2520
2521	case 63:
2522
2523	/* Line 1455 of yacc.c */
2524	#line 416 "dt_grammar.y"
2525	{
2526	(yyval.l_node) = dt_node_offsetof((yyvsp[(3) - (6)].l_decl), (yyvsp[(5) - (6)].l_str));
2527	}
2528	break;
2529
2530	case 64:
2531
2532	/* Line 1455 of yacc.c */
2533	#line 420 "dt_grammar.y"
2534	{
2535	(yyval.l_node) = dt_node_offsetof((yyvsp[(3) - (6)].l_decl), (yyvsp[(5) - (6)].l_str));
2536	}
2537	break;
2538
2539	case 65:
2540
2541	/* Line 1455 of yacc.c */
2542	#line 424 "dt_grammar.y"
2543	{
2544	(yyval.l_node) = OP2(DT_TOK_XLATE, dt_node_type((yyvsp[(3) - (7)].l_decl)), (yyvsp[(6) - (7)].l_node));
2545	}
2546	break;
2547
2548	case 67:
2549
2550	/* Line 1455 of yacc.c */
2551	#line 431 "dt_grammar.y"
2552	{ (yyval.l_node) = OP1(DT_TOK_PREINC, (yyvsp[(2) - (2)].l_node)); }
2553	break;
2554
2555	case 68:
2556
2557	/* Line 1455 of yacc.c */
2558	#line 432 "dt_grammar.y"
2559	{ (yyval.l_node) = OP1(DT_TOK_PREDEC, (yyvsp[(2) - (2)].l_node)); }
2560	break;
2561
2562	case 69:
2563
2564	/* Line 1455 of yacc.c */
2565	#line 433 "dt_grammar.y"
2566	{ (yyval.l_node) = OP1((yyvsp[(1) - (2)].l_tok), (yyvsp[(2) - (2)].l_node)); }
2567	break;
2568
2569	case 70:
2570
2571	/* Line 1455 of yacc.c */
2572	#line 434 "dt_grammar.y"
2573	{ (yyval.l_node) = OP1(DT_TOK_SIZEOF, (yyvsp[(2) - (2)].l_node)); }
2574	break;
2575
2576	case 71:
2577
2578	/* Line 1455 of yacc.c */
2579	#line 435 "dt_grammar.y"
2580	{
2581	(yyval.l_node) = OP1(DT_TOK_SIZEOF, dt_node_type((yyvsp[(3) - (4)].l_decl)));
2582	}
2583	break;
2584
2585	case 72:
2586
2587	/* Line 1455 of yacc.c */
2588	#line 438 "dt_grammar.y"
2589	{
2590	(yyval.l_node) = OP1(DT_TOK_STRINGOF, (yyvsp[(2) - (2)].l_node));
2591	}
2592	break;
2593
2594	case 73:
2595
2596	/* Line 1455 of yacc.c */
2597	#line 443 "dt_grammar.y"
2598	{ (yyval.l_tok) = DT_TOK_ADDROF; }
2599	break;
2600
2601	case 74:
2602
2603	/* Line 1455 of yacc.c */
2604	#line 444 "dt_grammar.y"
2605	{ (yyval.l_tok) = DT_TOK_DEREF; }
2606	break;
2607
2608	case 75:
2609
2610	/* Line 1455 of yacc.c */
2611	#line 445 "dt_grammar.y"
2612	{ (yyval.l_tok) = DT_TOK_IPOS; }
2613	break;
2614
2615	case 76:
2616
2617	/* Line 1455 of yacc.c */
2618	#line 446 "dt_grammar.y"
2619	{ (yyval.l_tok) = DT_TOK_INEG; }
2620	break;
2621
2622	case 77:
2623
2624	/* Line 1455 of yacc.c */
2625	#line 447 "dt_grammar.y"
2626	{ (yyval.l_tok) = DT_TOK_BNEG; }
2627	break;
2628
2629	case 78:
2630
2631	/* Line 1455 of yacc.c */
2632	#line 448 "dt_grammar.y"
2633	{ (yyval.l_tok) = DT_TOK_LNEG; }
2634	break;
2635
2636	case 80:
2637
2638	/* Line 1455 of yacc.c */
2639	#line 453 "dt_grammar.y"
2640	{
2641	(yyval.l_node) = OP2(DT_TOK_LPAR, dt_node_type((yyvsp[(2) - (4)].l_decl)), (yyvsp[(4) - (4)].l_node));
2642	}
2643	break;
2644
2645	case 82:
2646
2647	/* Line 1455 of yacc.c */
2648	#line 460 "dt_grammar.y"
2649	{
2650	(yyval.l_node) = OP2(DT_TOK_MUL, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2651	}
2652	break;
2653
2654	case 83:
2655
2656	/* Line 1455 of yacc.c */
2657	#line 463 "dt_grammar.y"
2658	{
2659	(yyval.l_node) = OP2(DT_TOK_DIV, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2660	}
2661	break;
2662
2663	case 84:
2664
2665	/* Line 1455 of yacc.c */
2666	#line 466 "dt_grammar.y"
2667	{
2668	(yyval.l_node) = OP2(DT_TOK_MOD, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2669	}
2670	break;
2671
2672	case 86:
2673
2674	/* Line 1455 of yacc.c */
2675	#line 473 "dt_grammar.y"
2676	{
2677	(yyval.l_node) = OP2(DT_TOK_ADD, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2678	}
2679	break;
2680
2681	case 87:
2682
2683	/* Line 1455 of yacc.c */
2684	#line 476 "dt_grammar.y"
2685	{
2686	(yyval.l_node) = OP2(DT_TOK_SUB, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2687	}
2688	break;
2689
2690	case 89:
2691
2692	/* Line 1455 of yacc.c */
2693	#line 483 "dt_grammar.y"
2694	{
2695	(yyval.l_node) = OP2(DT_TOK_LSH, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2696	}
2697	break;
2698
2699	case 90:
2700
2701	/* Line 1455 of yacc.c */
2702	#line 486 "dt_grammar.y"
2703	{
2704	(yyval.l_node) = OP2(DT_TOK_RSH, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2705	}
2706	break;
2707
2708	case 92:
2709
2710	/* Line 1455 of yacc.c */
2711	#line 493 "dt_grammar.y"
2712	{
2713	(yyval.l_node) = OP2(DT_TOK_LT, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2714	}
2715	break;
2716
2717	case 93:
2718
2719	/* Line 1455 of yacc.c */
2720	#line 496 "dt_grammar.y"
2721	{
2722	(yyval.l_node) = OP2(DT_TOK_GT, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2723	}
2724	break;
2725
2726	case 94:
2727
2728	/* Line 1455 of yacc.c */
2729	#line 499 "dt_grammar.y"
2730	{
2731	(yyval.l_node) = OP2(DT_TOK_LE, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2732	}
2733	break;
2734
2735	case 95:
2736
2737	/* Line 1455 of yacc.c */
2738	#line 502 "dt_grammar.y"
2739	{
2740	(yyval.l_node) = OP2(DT_TOK_GE, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2741	}
2742	break;
2743
2744	case 97:
2745
2746	/* Line 1455 of yacc.c */
2747	#line 509 "dt_grammar.y"
2748	{
2749	(yyval.l_node) = OP2(DT_TOK_EQU, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2750	}
2751	break;
2752
2753	case 98:
2754
2755	/* Line 1455 of yacc.c */
2756	#line 512 "dt_grammar.y"
2757	{
2758	(yyval.l_node) = OP2(DT_TOK_NEQ, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2759	}
2760	break;
2761
2762	case 100:
2763
2764	/* Line 1455 of yacc.c */
2765	#line 519 "dt_grammar.y"
2766	{
2767	(yyval.l_node) = OP2(DT_TOK_BAND, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2768	}
2769	break;
2770
2771	case 102:
2772
2773	/* Line 1455 of yacc.c */
2774	#line 526 "dt_grammar.y"
2775	{
2776	(yyval.l_node) = OP2(DT_TOK_XOR, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2777	}
2778	break;
2779
2780	case 104:
2781
2782	/* Line 1455 of yacc.c */
2783	#line 533 "dt_grammar.y"
2784	{
2785	(yyval.l_node) = OP2(DT_TOK_BOR, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2786	}
2787	break;
2788
2789	case 106:
2790
2791	/* Line 1455 of yacc.c */
2792	#line 540 "dt_grammar.y"
2793	{
2794	(yyval.l_node) = OP2(DT_TOK_LAND, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2795	}
2796	break;
2797
2798	case 108:
2799
2800	/* Line 1455 of yacc.c */
2801	#line 547 "dt_grammar.y"
2802	{
2803	(yyval.l_node) = OP2(DT_TOK_LXOR, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2804	}
2805	break;
2806
2807	case 110:
2808
2809	/* Line 1455 of yacc.c */
2810	#line 554 "dt_grammar.y"
2811	{
2812	(yyval.l_node) = OP2(DT_TOK_LOR, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2813	}
2814	break;
2815
2816	case 113:
2817
2818	/* Line 1455 of yacc.c */
2819	#line 565 "dt_grammar.y"
2820	{ (yyval.l_node) = OP3((yyvsp[(1) - (5)].l_node), (yyvsp[(3) - (5)].l_node), (yyvsp[(5) - (5)].l_node)); }
2821	break;
2822
2823	case 115:
2824
2825	/* Line 1455 of yacc.c */
2826	#line 570 "dt_grammar.y"
2827	{
2828	(yyval.l_node) = OP2((yyvsp[(2) - (3)].l_tok), (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2829	}
2830	break;
2831
2832	case 116:
2833
2834	/* Line 1455 of yacc.c */
2835	#line 576 "dt_grammar.y"
2836	{ (yyval.l_tok) = DT_TOK_ASGN; }
2837	break;
2838
2839	case 117:
2840
2841	/* Line 1455 of yacc.c */
2842	#line 577 "dt_grammar.y"
2843	{ (yyval.l_tok) = DT_TOK_MUL_EQ; }
2844	break;
2845
2846	case 118:
2847
2848	/* Line 1455 of yacc.c */
2849	#line 578 "dt_grammar.y"
2850	{ (yyval.l_tok) = DT_TOK_DIV_EQ; }
2851	break;
2852
2853	case 119:
2854
2855	/* Line 1455 of yacc.c */
2856	#line 579 "dt_grammar.y"
2857	{ (yyval.l_tok) = DT_TOK_MOD_EQ; }
2858	break;
2859
2860	case 120:
2861
2862	/* Line 1455 of yacc.c */
2863	#line 580 "dt_grammar.y"
2864	{ (yyval.l_tok) = DT_TOK_ADD_EQ; }
2865	break;
2866
2867	case 121:
2868
2869	/* Line 1455 of yacc.c */
2870	#line 581 "dt_grammar.y"
2871	{ (yyval.l_tok) = DT_TOK_SUB_EQ; }
2872	break;
2873
2874	case 122:
2875
2876	/* Line 1455 of yacc.c */
2877	#line 582 "dt_grammar.y"
2878	{ (yyval.l_tok) = DT_TOK_LSH_EQ; }
2879	break;
2880
2881	case 123:
2882
2883	/* Line 1455 of yacc.c */
2884	#line 583 "dt_grammar.y"
2885	{ (yyval.l_tok) = DT_TOK_RSH_EQ; }
2886	break;
2887
2888	case 124:
2889
2890	/* Line 1455 of yacc.c */
2891	#line 584 "dt_grammar.y"
2892	{ (yyval.l_tok) = DT_TOK_AND_EQ; }
2893	break;
2894
2895	case 125:
2896
2897	/* Line 1455 of yacc.c */
2898	#line 585 "dt_grammar.y"
2899	{ (yyval.l_tok) = DT_TOK_XOR_EQ; }
2900	break;
2901
2902	case 126:
2903
2904	/* Line 1455 of yacc.c */
2905	#line 586 "dt_grammar.y"
2906	{ (yyval.l_tok) = DT_TOK_OR_EQ; }
2907	break;
2908
2909	case 128:
2910
2911	/* Line 1455 of yacc.c */
2912	#line 590 "dt_grammar.y"
2913	{
2914	(yyval.l_node) = OP2(DT_TOK_COMMA, (yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
2915	}
2916	break;
2917
2918	case 129:
2919
2920	/* Line 1455 of yacc.c */
2921	#line 595 "dt_grammar.y"
2922	{
2923	(yyval.l_node) = dt_node_decl();
2924	dt_decl_free(dt_decl_pop());
2925	yybegin(YYS_CLAUSE);
2926	}
2927	break;
2928
2929	case 130:
2930
2931	/* Line 1455 of yacc.c */
2932	#line 600 "dt_grammar.y"
2933	{
2934	(yyval.l_node) = (yyvsp[(2) - (3)].l_node);
2935	dt_decl_free(dt_decl_pop());
2936	yybegin(YYS_CLAUSE);
2937	}
2938	break;
2939
2940	case 143:
2941
2942	/* Line 1455 of yacc.c */
2943	#line 626 "dt_grammar.y"
2944	{ dt_decl_class(DT_DC_AUTO); }
2945	break;
2946
2947	case 144:
2948
2949	/* Line 1455 of yacc.c */
2950	#line 627 "dt_grammar.y"
2951	{ dt_decl_class(DT_DC_REGISTER); }
2952	break;
2953
2954	case 145:
2955
2956	/* Line 1455 of yacc.c */
2957	#line 628 "dt_grammar.y"
2958	{ dt_decl_class(DT_DC_STATIC); }
2959	break;
2960
2961	case 146:
2962
2963	/* Line 1455 of yacc.c */
2964	#line 629 "dt_grammar.y"
2965	{ dt_decl_class(DT_DC_EXTERN); }
2966	break;
2967
2968	case 147:
2969
2970	/* Line 1455 of yacc.c */
2971	#line 630 "dt_grammar.y"
2972	{ dt_decl_class(DT_DC_TYPEDEF); }
2973	break;
2974
2975	case 149:
2976
2977	/* Line 1455 of yacc.c */
2978	#line 635 "dt_grammar.y"
2979	{ dt_decl_class(DT_DC_SELF); }
2980	break;
2981
2982	case 150:
2983
2984	/* Line 1455 of yacc.c */
2985	#line 636 "dt_grammar.y"
2986	{ dt_decl_class(DT_DC_THIS); }
2987	break;
2988
2989	case 151:
2990
2991	/* Line 1455 of yacc.c */
2992	#line 639 "dt_grammar.y"
2993	{ (yyval.l_decl) = dt_decl_spec(CTF_K_INTEGER, DUP("void")); }
2994	break;
2995
2996	case 152:
2997
2998	/* Line 1455 of yacc.c */
2999	#line 640 "dt_grammar.y"
3000	{ (yyval.l_decl) = dt_decl_spec(CTF_K_INTEGER, DUP("char")); }
3001	break;
3002
3003	case 153:
3004
3005	/* Line 1455 of yacc.c */
3006	#line 641 "dt_grammar.y"
3007	{ (yyval.l_decl) = dt_decl_attr(DT_DA_SHORT); }
3008	break;
3009
3010	case 154:
3011
3012	/* Line 1455 of yacc.c */
3013	#line 642 "dt_grammar.y"
3014	{ (yyval.l_decl) = dt_decl_spec(CTF_K_INTEGER, DUP("int")); }
3015	break;
3016
3017	case 155:
3018
3019	/* Line 1455 of yacc.c */
3020	#line 643 "dt_grammar.y"
3021	{ (yyval.l_decl) = dt_decl_attr(DT_DA_LONG); }
3022	break;
3023
3024	case 156:
3025
3026	/* Line 1455 of yacc.c */
3027	#line 644 "dt_grammar.y"
3028	{ (yyval.l_decl) = dt_decl_spec(CTF_K_FLOAT, DUP("float")); }
3029	break;
3030
3031	case 157:
3032
3033	/* Line 1455 of yacc.c */
3034	#line 645 "dt_grammar.y"
3035	{ (yyval.l_decl) = dt_decl_spec(CTF_K_FLOAT, DUP("double")); }
3036	break;
3037
3038	case 158:
3039
3040	/* Line 1455 of yacc.c */
3041	#line 646 "dt_grammar.y"
3042	{ (yyval.l_decl) = dt_decl_attr(DT_DA_SIGNED); }
3043	break;
3044
3045	case 159:
3046
3047	/* Line 1455 of yacc.c */
3048	#line 647 "dt_grammar.y"
3049	{ (yyval.l_decl) = dt_decl_attr(DT_DA_UNSIGNED); }
3050	break;
3051
3052	case 160:
3053
3054	/* Line 1455 of yacc.c */
3055	#line 648 "dt_grammar.y"
3056	{
3057	(yyval.l_decl) = dt_decl_spec(CTF_K_TYPEDEF, DUP("string"));
3058	}
3059	break;
3060
3061	case 161:
3062
3063	/* Line 1455 of yacc.c */
3064	#line 651 "dt_grammar.y"
3065	{ (yyval.l_decl) = dt_decl_spec(CTF_K_TYPEDEF, (yyvsp[(1) - (1)].l_str)); }
3066	break;
3067
3068	case 164:
3069
3070	/* Line 1455 of yacc.c */
3071	#line 656 "dt_grammar.y"
3072	{ (yyval.l_decl) = dt_decl_attr(DT_DA_CONST); }
3073	break;
3074
3075	case 165:
3076
3077	/* Line 1455 of yacc.c */
3078	#line 657 "dt_grammar.y"
3079	{ (yyval.l_decl) = dt_decl_attr(DT_DA_RESTRICT); }
3080	break;
3081
3082	case 166:
3083
3084	/* Line 1455 of yacc.c */
3085	#line 658 "dt_grammar.y"
3086	{ (yyval.l_decl) = dt_decl_attr(DT_DA_VOLATILE); }
3087	break;
3088
3089	case 167:
3090
3091	/* Line 1455 of yacc.c */
3092	#line 662 "dt_grammar.y"
3093	{
3094	(yyval.l_decl) = dt_scope_pop();
3095	}
3096	break;
3097
3098	case 168:
3099
3100	/* Line 1455 of yacc.c */
3101	#line 665 "dt_grammar.y"
3102	{ (yyval.l_decl) = dt_decl_spec((yyvsp[(1) - (2)].l_tok), (yyvsp[(2) - (2)].l_str)); }
3103	break;
3104
3105	case 169:
3106
3107	/* Line 1455 of yacc.c */
3108	#line 666 "dt_grammar.y"
3109	{ (yyval.l_decl) = dt_decl_spec((yyvsp[(1) - (2)].l_tok), (yyvsp[(2) - (2)].l_str)); }
3110	break;
3111
3112	case 170:
3113
3114	/* Line 1455 of yacc.c */
3115	#line 670 "dt_grammar.y"
3116	{ dt_decl_sou((yyvsp[(1) - (2)].l_tok), NULL); }
3117	break;
3118
3119	case 171:
3120
3121	/* Line 1455 of yacc.c */
3122	#line 671 "dt_grammar.y"
3123	{ dt_decl_sou((yyvsp[(1) - (3)].l_tok), (yyvsp[(2) - (3)].l_str)); }
3124	break;
3125
3126	case 172:
3127
3128	/* Line 1455 of yacc.c */
3129	#line 672 "dt_grammar.y"
3130	{ dt_decl_sou((yyvsp[(1) - (3)].l_tok), (yyvsp[(2) - (3)].l_str)); }
3131	break;
3132
3133	case 173:
3134
3135	/* Line 1455 of yacc.c */
3136	#line 676 "dt_grammar.y"
3137	{ (yyval.l_tok) = CTF_K_STRUCT; }
3138	break;
3139
3140	case 174:
3141
3142	/* Line 1455 of yacc.c */
3143	#line 677 "dt_grammar.y"
3144	{ (yyval.l_tok) = CTF_K_UNION; }
3145	break;
3146
3147	case 178:
3148
3149	/* Line 1455 of yacc.c */
3150	#line 687 "dt_grammar.y"
3151	{
3152	(yyval.l_node) = LINK((yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
3153	}
3154	break;
3155
3156	case 179:
3157
3158	/* Line 1455 of yacc.c */
3159	#line 693 "dt_grammar.y"
3160	{
3161	(yyval.l_node) = dt_node_decl();
3162	dt_decl_reset();
3163	}
3164	break;
3165
3166	case 180:
3167
3168	/* Line 1455 of yacc.c */
3169	#line 700 "dt_grammar.y"
3170	{
3171	dt_decl_free(dt_decl_pop());
3172	}
3173	break;
3174
3175	case 182:
3176
3177	/* Line 1455 of yacc.c */
3178	#line 707 "dt_grammar.y"
3179	{ (yyval.l_decl) = (yyvsp[(2) - (2)].l_decl); }
3180	break;
3181
3182	case 184:
3183
3184	/* Line 1455 of yacc.c */
3185	#line 709 "dt_grammar.y"
3186	{ (yyval.l_decl) = (yyvsp[(2) - (2)].l_decl); }
3187	break;
3188
3189	case 187:
3190
3191	/* Line 1455 of yacc.c */
3192	#line 718 "dt_grammar.y"
3193	{ dt_decl_member(NULL); }
3194	break;
3195
3196	case 188:
3197
3198	/* Line 1455 of yacc.c */
3199	#line 719 "dt_grammar.y"
3200	{ dt_decl_member((yyvsp[(2) - (2)].l_node)); }
3201	break;
3202
3203	case 189:
3204
3205	/* Line 1455 of yacc.c */
3206	#line 720 "dt_grammar.y"
3207	{
3208	dt_decl_member((yyvsp[(3) - (3)].l_node));
3209	}
3210	break;
3211
3212	case 190:
3213
3214	/* Line 1455 of yacc.c */
3215	#line 726 "dt_grammar.y"
3216	{ (yyval.l_decl) = dt_scope_pop(); }
3217	break;
3218
3219	case 191:
3220
3221	/* Line 1455 of yacc.c */
3222	#line 727 "dt_grammar.y"
3223	{ (yyval.l_decl) = dt_decl_spec(CTF_K_ENUM, (yyvsp[(2) - (2)].l_str)); }
3224	break;
3225
3226	case 192:
3227
3228	/* Line 1455 of yacc.c */
3229	#line 728 "dt_grammar.y"
3230	{ (yyval.l_decl) = dt_decl_spec(CTF_K_ENUM, (yyvsp[(2) - (2)].l_str)); }
3231	break;
3232
3233	case 193:
3234
3235	/* Line 1455 of yacc.c */
3236	#line 732 "dt_grammar.y"
3237	{ dt_decl_enum(NULL); }
3238	break;
3239
3240	case 194:
3241
3242	/* Line 1455 of yacc.c */
3243	#line 733 "dt_grammar.y"
3244	{ dt_decl_enum((yyvsp[(2) - (3)].l_str)); }
3245	break;
3246
3247	case 195:
3248
3249	/* Line 1455 of yacc.c */
3250	#line 734 "dt_grammar.y"
3251	{ dt_decl_enum((yyvsp[(2) - (3)].l_str)); }
3252	break;
3253
3254	case 198:
3255
3256	/* Line 1455 of yacc.c */
3257	#line 742 "dt_grammar.y"
3258	{ dt_decl_enumerator((yyvsp[(1) - (1)].l_str), NULL); }
3259	break;
3260
3261	case 199:
3262
3263	/* Line 1455 of yacc.c */
3264	#line 743 "dt_grammar.y"
3265	{
3266	dt_decl_enumerator((yyvsp[(1) - (3)].l_str), (yyvsp[(3) - (3)].l_node));
3267	}
3268	break;
3269
3270	case 202:
3271
3272	/* Line 1455 of yacc.c */
3273	#line 753 "dt_grammar.y"
3274	{ (yyval.l_decl) = dt_decl_ident((yyvsp[(1) - (1)].l_str)); }
3275	break;
3276
3277	case 203:
3278
3279	/* Line 1455 of yacc.c */
3280	#line 754 "dt_grammar.y"
3281	{ (yyval.l_decl) = (yyvsp[(2) - (3)].l_decl); }
3282	break;
3283
3284	case 204:
3285
3286	/* Line 1455 of yacc.c */
3287	#line 755 "dt_grammar.y"
3288	{ dt_decl_array((yyvsp[(2) - (2)].l_node)); }
3289	break;
3290
3291	case 205:
3292
3293	/* Line 1455 of yacc.c */
3294	#line 756 "dt_grammar.y"
3295	{ dt_decl_func((yyvsp[(1) - (2)].l_decl), (yyvsp[(2) - (2)].l_node)); }
3296	break;
3297
3298	case 206:
3299
3300	/* Line 1455 of yacc.c */
3301	#line 759 "dt_grammar.y"
3302	{ dt_decl_top()->dd_attr \|= DT_DA_PAREN; }
3303	break;
3304
3305	case 207:
3306
3307	/* Line 1455 of yacc.c */
3308	#line 762 "dt_grammar.y"
3309	{ (yyval.l_decl) = dt_decl_ptr(); }
3310	break;
3311
3312	case 208:
3313
3314	/* Line 1455 of yacc.c */
3315	#line 763 "dt_grammar.y"
3316	{ (yyval.l_decl) = dt_decl_ptr(); }
3317	break;
3318
3319	case 209:
3320
3321	/* Line 1455 of yacc.c */
3322	#line 764 "dt_grammar.y"
3323	{ (yyval.l_decl) = dt_decl_ptr(); }
3324	break;
3325
3326	case 210:
3327
3328	/* Line 1455 of yacc.c */
3329	#line 765 "dt_grammar.y"
3330	{ (yyval.l_decl) = dt_decl_ptr(); }
3331	break;
3332
3333	case 212:
3334
3335	/* Line 1455 of yacc.c */
3336	#line 770 "dt_grammar.y"
3337	{ (yyval.l_decl) = (yyvsp[(2) - (2)].l_decl); }
3338	break;
3339
3340	case 214:
3341
3342	/* Line 1455 of yacc.c */
3343	#line 775 "dt_grammar.y"
3344	{ (yyval.l_node) = dt_node_vatype(); }
3345	break;
3346
3347	case 215:
3348
3349	/* Line 1455 of yacc.c */
3350	#line 776 "dt_grammar.y"
3351	{
3352	(yyval.l_node) = LINK((yyvsp[(1) - (3)].l_node), dt_node_vatype());
3353	}
3354	break;
3355
3356	case 217:
3357
3358	/* Line 1455 of yacc.c */
3359	#line 782 "dt_grammar.y"
3360	{
3361	(yyval.l_node) = LINK((yyvsp[(1) - (3)].l_node), (yyvsp[(3) - (3)].l_node));
3362	}
3363	break;
3364
3365	case 218:
3366
3367	/* Line 1455 of yacc.c */
3368	#line 788 "dt_grammar.y"
3369	{
3370	(yyval.l_node) = dt_node_type(NULL);
3371	}
3372	break;
3373
3374	case 219:
3375
3376	/* Line 1455 of yacc.c */
3377	#line 791 "dt_grammar.y"
3378	{
3379	(yyval.l_node) = dt_node_type(NULL);
3380	}
3381	break;
3382
3383	case 220:
3384
3385	/* Line 1455 of yacc.c */
3386	#line 794 "dt_grammar.y"
3387	{
3388	(yyval.l_node) = dt_node_type(NULL);
3389	}
3390	break;
3391
3392	case 221:
3393
3394	/* Line 1455 of yacc.c */
3395	#line 799 "dt_grammar.y"
3396	{
3397	(yyval.l_decl) = dt_decl_pop();
3398	}
3399	break;
3400
3401	case 222:
3402
3403	/* Line 1455 of yacc.c */
3404	#line 802 "dt_grammar.y"
3405	{
3406	(yyval.l_decl) = dt_decl_pop();
3407	}
3408	break;
3409
3410	case 226:
3411
3412	/* Line 1455 of yacc.c */
3413	#line 814 "dt_grammar.y"
3414	{ (yyval.l_decl) = (yyvsp[(2) - (3)].l_decl); }
3415	break;
3416
3417	case 227:
3418
3419	/* Line 1455 of yacc.c */
3420	#line 815 "dt_grammar.y"
3421	{ dt_decl_array((yyvsp[(2) - (2)].l_node)); }
3422	break;
3423
3424	case 228:
3425
3426	/* Line 1455 of yacc.c */
3427	#line 816 "dt_grammar.y"
3428	{ dt_decl_array((yyvsp[(1) - (1)].l_node)); (yyval.l_decl) = NULL; }
3429	break;
3430
3431	case 229:
3432
3433	/* Line 1455 of yacc.c */
3434	#line 817 "dt_grammar.y"
3435	{ dt_decl_func((yyvsp[(1) - (2)].l_decl), (yyvsp[(2) - (2)].l_node)); }
3436	break;
3437
3438	case 230:
3439
3440	/* Line 1455 of yacc.c */
3441	#line 818 "dt_grammar.y"
3442	{ dt_decl_func(NULL, (yyvsp[(1) - (1)].l_node)); }
3443	break;
3444
3445	case 231:
3446
3447	/* Line 1455 of yacc.c */
3448	#line 821 "dt_grammar.y"
3449	{ dt_scope_push(NULL, CTF_ERR); }
3450	break;
3451
3452	case 232:
3453
3454	/* Line 1455 of yacc.c */
3455	#line 822 "dt_grammar.y"
3456	{
3457	dt_scope_pop();
3458	(yyval.l_node) = (yyvsp[(3) - (4)].l_node);
3459	}
3460	break;
3461
3462	case 233:
3463
3464	/* Line 1455 of yacc.c */
3465	#line 829 "dt_grammar.y"
3466	{ (yyval.l_node) = NULL; }
3467	break;
3468
3469	case 234:
3470
3471	/* Line 1455 of yacc.c */
3472	#line 830 "dt_grammar.y"
3473	{ (yyval.l_node) = (yyvsp[(1) - (1)].l_node); }
3474	break;
3475
3476	case 235:
3477
3478	/* Line 1455 of yacc.c */
3479	#line 831 "dt_grammar.y"
3480	{ (yyval.l_node) = (yyvsp[(1) - (1)].l_node); }
3481	break;
3482
3483	case 236:
3484
3485	/* Line 1455 of yacc.c */
3486	#line 834 "dt_grammar.y"
3487	{ dt_scope_push(NULL, CTF_ERR); }
3488	break;
3489
3490	case 237:
3491
3492	/* Line 1455 of yacc.c */
3493	#line 835 "dt_grammar.y"
3494	{
3495	dt_scope_pop();
3496	(yyval.l_node) = (yyvsp[(3) - (4)].l_node);
3497	}
3498	break;
3499
3500	case 238:
3501
3502	/* Line 1455 of yacc.c */
3503	#line 842 "dt_grammar.y"
3504	{ (yyval.l_node) = NULL; }
3505	break;
3506
3507	case 239:
3508
3509	/* Line 1455 of yacc.c */
3510	#line 843 "dt_grammar.y"
3511	{ (yyval.l_node) = (yyvsp[(1) - (1)].l_node); }
3512	break;
3513
3514
3515
3516	/* Line 1455 of yacc.c */
3517	#line 3516 "dt_grammar.c"
3518	default: break;
3519	}
3520	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3521
3522	YYPOPSTACK (yylen);
3523	yylen = 0;
3524	YY_STACK_PRINT (yyss, yyssp);
3525
3526	*++yyvsp = yyval;
3527
3528	/* Now `shift' the result of the reduction. Determine what state
3529	that goes to, based on the state we popped back to and the rule
3530	number reduced by. */
3531
3532	yyn = yyr1[yyn];
3533
3534	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3535	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3536	yystate = yytable[yystate];
3537	else
3538	yystate = yydefgoto[yyn - YYNTOKENS];
3539
3540	goto yynewstate;
3541
3542
3543	/*------------------------------------.
3544	\| yyerrlab -- here on detecting error \|
3545	`------------------------------------*/
3546	yyerrlab:
3547	/* If not already recovering from an error, report this error. */
3548	if (!yyerrstatus)
3549	{
3550	++yynerrs;
3551	#if ! YYERROR_VERBOSE
3552	yyerror (YY_("syntax error"));
3553	#else
3554	{
3555	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3556	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3557	{
3558	YYSIZE_T yyalloc = 2 * yysize;
3559	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3560	yyalloc = YYSTACK_ALLOC_MAXIMUM;
3561	if (yymsg != yymsgbuf)
3562	YYSTACK_FREE (yymsg);
3563	yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3564	if (yymsg)
3565	yymsg_alloc = yyalloc;
3566	else
3567	{
3568	yymsg = yymsgbuf;
3569	yymsg_alloc = sizeof yymsgbuf;
3570	}
3571	}
3572
3573	if (0 < yysize && yysize <= yymsg_alloc)
3574	{
3575	(void) yysyntax_error (yymsg, yystate, yychar);
3576	yyerror (yymsg);
3577	}
3578	else
3579	{
3580	yyerror (YY_("syntax error"));
3581	if (yysize != 0)
3582	goto yyexhaustedlab;
3583	}
3584	}
3585	#endif
3586	}
3587
3588
3589
3590	if (yyerrstatus == 3)
3591	{
3592	/* If just tried and failed to reuse lookahead token after an
3593	error, discard it. */
3594
3595	if (yychar <= YYEOF)
3596	{
3597	/* Return failure if at end of input. */
3598	if (yychar == YYEOF)
3599	YYABORT;
3600	}
3601	else
3602	{
3603	yydestruct ("Error: discarding",
3604	yytoken, &yylval);
3605	yychar = YYEMPTY;
3606	}
3607	}
3608
3609	/* Else will try to reuse lookahead token after shifting the error
3610	token. */
3611	goto yyerrlab1;
3612
3613
3614	/*---------------------------------------------------.
3615	\| yyerrorlab -- error raised explicitly by YYERROR. \|
3616	`---------------------------------------------------*/
3617	yyerrorlab:
3618
3619	/* Pacify compilers like GCC when the user code never invokes
3620	YYERROR and the label yyerrorlab therefore never appears in user
3621	code. */
3622	if (/CONSTCOND/ 0)
3623	goto yyerrorlab;
3624
3625	/* Do not reclaim the symbols of the rule which action triggered
3626	this YYERROR. */
3627	YYPOPSTACK (yylen);
3628	yylen = 0;
3629	YY_STACK_PRINT (yyss, yyssp);
3630	yystate = *yyssp;
3631	goto yyerrlab1;
3632
3633
3634	/*-------------------------------------------------------------.
3635	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
3636	`-------------------------------------------------------------*/
3637	yyerrlab1:
3638	yyerrstatus = 3; /* Each real token shifted decrements this. */
3639
3640	for (;;)
3641	{
3642	yyn = yypact[yystate];
3643	if (yyn != YYPACT_NINF)
3644	{
3645	yyn += YYTERROR;
3646	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3647	{
3648	yyn = yytable[yyn];
3649	if (0 < yyn)
3650	break;
3651	}
3652	}
3653
3654	/* Pop the current state because it cannot handle the error token. */
3655	if (yyssp == yyss)
3656	YYABORT;
3657
3658
3659	yydestruct ("Error: popping",
3660	yystos[yystate], yyvsp);
3661	YYPOPSTACK (1);
3662	yystate = *yyssp;
3663	YY_STACK_PRINT (yyss, yyssp);
3664	}
3665
3666	*++yyvsp = yylval;
3667
3668
3669	/* Shift the error token. */
3670	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3671
3672	yystate = yyn;
3673	goto yynewstate;
3674
3675
3676	/*-------------------------------------.
3677	\| yyacceptlab -- YYACCEPT comes here. \|
3678	`-------------------------------------*/
3679	yyacceptlab:
3680	yyresult = 0;
3681	goto yyreturn;
3682
3683	/*-----------------------------------.
3684	\| yyabortlab -- YYABORT comes here. \|
3685	`-----------------------------------*/
3686	yyabortlab:
3687	yyresult = 1;
3688	goto yyreturn;
3689
3690	#if !defined(yyoverflow) \|\| YYERROR_VERBOSE
3691	/*-------------------------------------------------.
3692	\| yyexhaustedlab -- memory exhaustion comes here. \|
3693	`-------------------------------------------------*/
3694	yyexhaustedlab:
3695	yyerror (YY_("memory exhausted"));
3696	yyresult = 2;
3697	/* Fall through. */
3698	#endif
3699
3700	yyreturn:
3701	if (yychar != YYEMPTY)
3702	yydestruct ("Cleanup: discarding lookahead",
3703	yytoken, &yylval);
3704	/* Do not reclaim the symbols of the rule which action triggered
3705	this YYABORT or YYACCEPT. */
3706	YYPOPSTACK (yylen);
3707	YY_STACK_PRINT (yyss, yyssp);
3708	while (yyssp != yyss)
3709	{
3710	yydestruct ("Cleanup: popping",
3711	yystos[*yyssp], yyvsp);
3712	YYPOPSTACK (1);
3713	}
3714	#ifndef yyoverflow
3715	if (yyss != yyssa)
3716	YYSTACK_FREE (yyss);
3717	#endif
3718	#if YYERROR_VERBOSE
3719	if (yymsg != yymsgbuf)
3720	YYSTACK_FREE (yymsg);
3721	#endif
3722	/* Make sure YYID is used. */
3723	return YYID (yyresult);
3724	}
3725
3726
3727
3728	/* Line 1675 of yacc.c */
3729	#line 846 "dt_grammar.y"
3730
3731

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/ExtPacks/VBoxDTrace/generated/dt_grammar.c

Download in other formats: