dt_grammar.c@ 61468

最後變更在這個檔案從61468是 53983,由 vboxsync 提交於 10 年前
Checked in bison and flex output for VBoxDTrace so we can build on systems that doesn't have these tools..
屬性 svn:eol-style 設為 `native` 屬性 svn:keywords 設為 `Author Date Id Revision`
檔案大小: 103.9 KB

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

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

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

以其他格式下載: