VirtualBox

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

Last change on this file was 63135, checked in by vboxsync, 8 years ago

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

© 2023 Oracle
Contact – Privacy policy – Terms of Use