1 | /* A Bison parser, made by GNU Bison 3.7.4. */
2 |
3 | /* Bison implementation for Yacc-like parsers in C
4 |
5 | Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
6 | Inc.
7 |
8 | This program is free software: you can redistribute it and/or modify
9 | it under the terms of the GNU General Public License as published by
10 | the Free Software Foundation, either version 3 of the License, or
11 | (at your option) any later version.
12 |
13 | This program is distributed in the hope that it will be useful,
14 | but WITHOUT ANY WARRANTY; without even the implied warranty of
15 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 | GNU General Public License for more details.
17 |
18 | You should have received a copy of the GNU General Public License
19 | along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 |
21 | /* As a special exception, you may create a larger work that contains
22 | part or all of the Bison parser skeleton and distribute that work
23 | under terms of your choice, so long as that work isn't itself a
24 | parser generator using the skeleton or a modified version thereof
25 | as a parser skeleton. Alternatively, if you modify or redistribute
26 | the parser skeleton itself, you may (at your option) remove this
27 | special exception, which will cause the skeleton and the resulting
28 | Bison output files to be licensed under the GNU General Public
29 | License without this special exception.
30 |
31 | This special exception was added by the Free Software Foundation in
32 | version 2.2 of Bison. */
33 |
34 | /* C LALR(1) parser skeleton written by Richard Stallman, by
35 | simplifying the original so-called "semantic" parser. */
36 |
37 | /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38 | especially those whose name start with YY_ or yy_. They are
39 | private implementation details that can be changed or removed. */
40 |
41 | /* All symbols defined below should begin with yy or YY, to avoid
42 | infringing on user name space. This should be done even for local
43 | variables, as they might otherwise be expanded by user macros.
44 | There are some unavoidable exceptions within include files to
45 | define necessary library symbols; they are noted "INFRINGES ON
46 | USER NAME SPACE" below. */
47 |
48 | /* Identify Bison output, and Bison version. */
49 | #define YYBISON 30704
50 |
51 | /* Bison version string. */
52 | #define YYBISON_VERSION "3.7.4"
53 |
54 | /* Skeleton name. */
55 | #define YYSKELETON_NAME "yacc.c"
56 |
57 | /* Pure parsers. */
58 | #define YYPURE 0
59 |
60 | /* Push parsers. */
61 | #define YYPUSH 0
62 |
63 | /* Pull parsers. */
64 | #define YYPULL 1
65 |
66 |
67 |
68 |
69 | /* First part of user prologue. */
70 | #line 1 "./parse.y"
71 |
72 | /***************************************
73 | C Cross Referencing & Documentation tool. Version 1.6e.
74 |
75 | C parser.
76 | ******************/ /******************
77 | Written by Andrew M. Bishop
78 |
79 | This file Copyright 1995-2013 Andrew M. Bishop
80 | It may be distributed under the GNU Public License, version 2, or
81 | any higher version. See section COPYING of the GNU Public license
82 | for conditions under which this file may be redistributed.
83 | ***************************************/
84 |
85 | #include <string.h>
86 | #include "parse-yy.h"
87 | #include "cxref.h"
88 | #include "memory.h"
89 |
90 | /*+ A structure to hold the information about an object. +*/
91 | typedef struct _stack
92 | {
93 | char *name; /*+ The name of the object. +*/
94 | char *type; /*+ The type of the object. +*/
95 | char *qual; /*+ The type qualifier of the object. +*/
96 | }
97 | stack;
98 |
99 | #define yylex cxref_yylex
100 |
101 | static int cxref_yylex(void);
102 |
103 | static void yyerror(const char *s);
104 |
105 | /*+ When in a header file, some stuff can be skipped over quickly. +*/
106 | extern int in_header;
107 |
108 | /*+ A flag that is set to true when typedef is seen in a statement. +*/
109 | int in_typedef=0;
110 |
111 | /*+ The scope of the function / variable that is being examined. +*/
112 | static int scope;
113 |
114 | /*+ The variable must be LOCAL or EXTERNAL or GLOBAL, so this checks and sets that. +*/
115 | #define SCOPE ( scope&(LOCAL|EXTERNAL|EXTERN_H|EXTERN_F) ? scope : scope|GLOBAL )
116 |
117 | /*+ When in a function or a function definition, the behaviour is different. +*/
118 | static int in_function=0,in_funcdef=0,in_funcbody=0;
119 |
120 | /*+ The parsing stack +*/
121 | static stack first={NULL,NULL,NULL}, /*+ first value. +*/
122 | *list=NULL, /*+ list of all values. +*/
123 | *current=&first; /*+ current values. +*/
124 |
125 | /*+ The depth of the stack +*/
126 | static int depth=0, /*+ currently in use. +*/
127 | maxdepth=0; /*+ total malloced. +*/
128 |
129 | /*+ Declarations that are in the same statement share this comment. +*/
130 | static char* common_comment=NULL;
131 |
132 | /*+ When inside a struct / union / enum definition, this is the depth. +*/
133 | static int in_structunion=0;
134 |
135 | /*+ When inside a struct / union definition, this is the component type. +*/
136 | static char *comp_type=NULL;
137 |
138 | /*+ To solve the problem where a type name is used as an identifier. +*/
139 | static int in_type_spec=0;
140 |
141 |
142 | /*++++++++++++++++++++++++++++++++++++++
143 | Reset the current level on the stack.
144 | ++++++++++++++++++++++++++++++++++++++*/
145 |
146 | static void reset(void)
147 | {
148 | current->name=NULL;
149 | current->type=NULL;
150 | current->qual=NULL;
151 | }
152 |
153 |
154 | /*++++++++++++++++++++++++++++++++++++++
155 | Push a level onto the stack.
156 | ++++++++++++++++++++++++++++++++++++++*/
157 |
158 | static void push(void)
159 | {
160 | if(list==NULL)
161 | {
162 | list=(stack*)Malloc(8*sizeof(struct _stack));
163 | list[0]=first;
164 | maxdepth=8;
165 | }
166 | else if(depth==(maxdepth-1))
167 | {
168 | list=Realloc(list,(maxdepth+8)*sizeof(struct _stack));
169 | maxdepth+=8;
170 | }
171 |
172 | depth++;
173 | current=&list[depth];
174 |
175 | reset();
176 | }
177 |
178 |
179 | /*++++++++++++++++++++++++++++++++++++++
180 | Pop a level from the stack.
181 | ++++++++++++++++++++++++++++++++++++++*/
182 |
183 | static void pop(void)
184 | {
185 | reset();
186 |
187 | depth--;
188 | current=&list[depth];
189 | }
190 |
191 |
192 | /*++++++++++++++++++++++++++++++++++++++
193 | Reset the Parser, ready for the next file.
194 | ++++++++++++++++++++++++++++++++++++++*/
195 |
196 | void ResetParser(void)
197 | {
198 | in_typedef=0;
199 | scope=0;
200 | in_function=0;
201 | in_funcdef=0;
202 | in_funcbody=0;
203 | depth=0;
204 | maxdepth=0;
205 | if(list) Free(list);
206 | list=NULL;
207 | current=&first;
208 | reset();
209 | common_comment=NULL;
210 | in_structunion=0;
211 | comp_type=NULL;
212 | in_type_spec=0;
213 | }
214 |
215 |
216 | #line 217 "y.tab.c"
217 |
218 | # ifndef YY_CAST
219 | # ifdef __cplusplus
220 | # define YY_CAST(Type, Val) static_cast<Type> (Val)
221 | # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
222 | # else
223 | # define YY_CAST(Type, Val) ((Type) (Val))
224 | # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
225 | # endif
226 | # endif
227 | # ifndef YY_NULLPTR
228 | # if defined __cplusplus
229 | # if 201103L <= __cplusplus
230 | # define YY_NULLPTR nullptr
231 | # else
232 | # define YY_NULLPTR 0
233 | # endif
234 | # else
235 | # define YY_NULLPTR ((void*)0)
236 | # endif
237 | # endif
238 |
239 | /* Use api.header.include to #include this header
240 | instead of duplicating it here. */
241 | #ifndef YY_YY_Y_TAB_H_INCLUDED
242 | # define YY_YY_Y_TAB_H_INCLUDED
243 | /* Debug traces. */
244 | #ifndef YYDEBUG
245 | # define YYDEBUG 0
246 | #endif
247 | #if YYDEBUG
248 | extern int yydebug;
249 | #endif
250 |
251 | /* Token kinds. */
252 | #ifndef YYTOKENTYPE
253 | # define YYTOKENTYPE
254 | enum yytokentype
255 | {
256 | YYEMPTY = -2,
257 | YYEOF = 0, /* "end of file" */
258 | YYerror = 256, /* error */
259 | YYUNDEF = 257, /* "invalid token" */
260 | IDENTIFIER = 258, /* IDENTIFIER */
261 | TYPE_NAME = 259, /* TYPE_NAME */
262 | LITERAL = 260, /* LITERAL */
263 | STRING_LITERAL = 261, /* STRING_LITERAL */
264 | ELLIPSES = 262, /* ELLIPSES */
265 | MUL_ASSIGN = 263, /* MUL_ASSIGN */
266 | DIV_ASSIGN = 264, /* DIV_ASSIGN */
267 | MOD_ASSIGN = 265, /* MOD_ASSIGN */
268 | ADD_ASSIGN = 266, /* ADD_ASSIGN */
269 | SUB_ASSIGN = 267, /* SUB_ASSIGN */
270 | LEFT_ASSIGN = 268, /* LEFT_ASSIGN */
271 | RIGHT_ASSIGN = 269, /* RIGHT_ASSIGN */
272 | AND_ASSIGN = 270, /* AND_ASSIGN */
273 | XOR_ASSIGN = 271, /* XOR_ASSIGN */
274 | OR_ASSIGN = 272, /* OR_ASSIGN */
275 | EQ_OP = 273, /* EQ_OP */
276 | NE_OP = 274, /* NE_OP */
277 | PTR_OP = 275, /* PTR_OP */
278 | AND_OP = 276, /* AND_OP */
279 | OR_OP = 277, /* OR_OP */
280 | DEC_OP = 278, /* DEC_OP */
281 | INC_OP = 279, /* INC_OP */
282 | LE_OP = 280, /* LE_OP */
283 | GE_OP = 281, /* GE_OP */
284 | LEFT_SHIFT = 282, /* LEFT_SHIFT */
285 | RIGHT_SHIFT = 283, /* RIGHT_SHIFT */
286 | SIZEOF = 284, /* SIZEOF */
287 | TYPEDEF = 285, /* TYPEDEF */
288 | EXTERN = 286, /* EXTERN */
289 | STATIC = 287, /* STATIC */
290 | AUTO = 288, /* AUTO */
291 | REGISTER = 289, /* REGISTER */
292 | CONST = 290, /* CONST */
293 | VOLATILE = 291, /* VOLATILE */
294 | VOID = 292, /* VOID */
295 | INLINE = 293, /* INLINE */
296 | CHAR = 294, /* CHAR */
297 | SHORT = 295, /* SHORT */
298 | INT = 296, /* INT */
299 | LONG = 297, /* LONG */
300 | SIGNED = 298, /* SIGNED */
301 | UNSIGNED = 299, /* UNSIGNED */
302 | FLOAT = 300, /* FLOAT */
303 | DOUBLE = 301, /* DOUBLE */
304 | BOOL = 302, /* BOOL */
305 | STRUCT = 303, /* STRUCT */
306 | UNION = 304, /* UNION */
307 | ENUM = 305, /* ENUM */
308 | CASE = 306, /* CASE */
309 | DEFAULT = 307, /* DEFAULT */
310 | IF = 308, /* IF */
311 | ELSE = 309, /* ELSE */
312 | SWITCH = 310, /* SWITCH */
313 | WHILE = 311, /* WHILE */
314 | DO = 312, /* DO */
315 | FOR = 313, /* FOR */
316 | GOTO = 314, /* GOTO */
317 | CONTINUE = 315, /* CONTINUE */
318 | BREAK = 316, /* BREAK */
319 | RETURN = 317, /* RETURN */
320 | ASM = 318 /* ASM */
321 | };
322 | typedef enum yytokentype yytoken_kind_t;
323 | #endif
324 | /* Token kinds. */
325 | #define YYEMPTY -2
326 | #define YYEOF 0
327 | #define YYerror 256
328 | #define YYUNDEF 257
329 | #define IDENTIFIER 258
330 | #define TYPE_NAME 259
331 | #define LITERAL 260
332 | #define STRING_LITERAL 261
333 | #define ELLIPSES 262
334 | #define MUL_ASSIGN 263
335 | #define DIV_ASSIGN 264
336 | #define MOD_ASSIGN 265
337 | #define ADD_ASSIGN 266
338 | #define SUB_ASSIGN 267
339 | #define LEFT_ASSIGN 268
340 | #define RIGHT_ASSIGN 269
341 | #define AND_ASSIGN 270
342 | #define XOR_ASSIGN 271
343 | #define OR_ASSIGN 272
344 | #define EQ_OP 273
345 | #define NE_OP 274
346 | #define PTR_OP 275
347 | #define AND_OP 276
348 | #define OR_OP 277
349 | #define DEC_OP 278
350 | #define INC_OP 279
351 | #define LE_OP 280
352 | #define GE_OP 281
353 | #define LEFT_SHIFT 282
354 | #define RIGHT_SHIFT 283
355 | #define SIZEOF 284
356 | #define TYPEDEF 285
357 | #define EXTERN 286
358 | #define STATIC 287
359 | #define AUTO 288
360 | #define REGISTER 289
361 | #define CONST 290
362 | #define VOLATILE 291
363 | #define VOID 292
364 | #define INLINE 293
365 | #define CHAR 294
366 | #define SHORT 295
367 | #define INT 296
368 | #define LONG 297
369 | #define SIGNED 298
370 | #define UNSIGNED 299
371 | #define FLOAT 300
372 | #define DOUBLE 301
373 | #define BOOL 302
374 | #define STRUCT 303
375 | #define UNION 304
376 | #define ENUM 305
377 | #define CASE 306
378 | #define DEFAULT 307
379 | #define IF 308
380 | #define ELSE 309
381 | #define SWITCH 310
382 | #define WHILE 311
383 | #define DO 312
384 | #define FOR 313
385 | #define GOTO 314
386 | #define CONTINUE 315
387 | #define BREAK 316
388 | #define RETURN 317
389 | #define ASM 318
390 |
391 | /* Value type. */
392 | #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
393 | typedef int YYSTYPE;
394 | # define YYSTYPE_IS_TRIVIAL 1
395 | # define YYSTYPE_IS_DECLARED 1
396 | #endif
397 |
398 |
399 | extern YYSTYPE yylval;
400 |
401 | int yyparse (void);
402 |
403 | #endif /* !YY_YY_Y_TAB_H_INCLUDED */
404 | /* Symbol kind. */
405 | enum yysymbol_kind_t
406 | {
407 | YYSYMBOL_YYEMPTY = -2,
408 | YYSYMBOL_YYEOF = 0, /* "end of file" */
409 | YYSYMBOL_YYerror = 1, /* error */
410 | YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
411 | YYSYMBOL_IDENTIFIER = 3, /* IDENTIFIER */
412 | YYSYMBOL_TYPE_NAME = 4, /* TYPE_NAME */
413 | YYSYMBOL_LITERAL = 5, /* LITERAL */
414 | YYSYMBOL_STRING_LITERAL = 6, /* STRING_LITERAL */
415 | YYSYMBOL_ELLIPSES = 7, /* ELLIPSES */
416 | YYSYMBOL_MUL_ASSIGN = 8, /* MUL_ASSIGN */
417 | YYSYMBOL_DIV_ASSIGN = 9, /* DIV_ASSIGN */
418 | YYSYMBOL_MOD_ASSIGN = 10, /* MOD_ASSIGN */
419 | YYSYMBOL_ADD_ASSIGN = 11, /* ADD_ASSIGN */
420 | YYSYMBOL_SUB_ASSIGN = 12, /* SUB_ASSIGN */
421 | YYSYMBOL_LEFT_ASSIGN = 13, /* LEFT_ASSIGN */
422 | YYSYMBOL_RIGHT_ASSIGN = 14, /* RIGHT_ASSIGN */
423 | YYSYMBOL_AND_ASSIGN = 15, /* AND_ASSIGN */
424 | YYSYMBOL_XOR_ASSIGN = 16, /* XOR_ASSIGN */
425 | YYSYMBOL_OR_ASSIGN = 17, /* OR_ASSIGN */
426 | YYSYMBOL_EQ_OP = 18, /* EQ_OP */
427 | YYSYMBOL_NE_OP = 19, /* NE_OP */
428 | YYSYMBOL_PTR_OP = 20, /* PTR_OP */
429 | YYSYMBOL_AND_OP = 21, /* AND_OP */
430 | YYSYMBOL_OR_OP = 22, /* OR_OP */
431 | YYSYMBOL_DEC_OP = 23, /* DEC_OP */
432 | YYSYMBOL_INC_OP = 24, /* INC_OP */
433 | YYSYMBOL_LE_OP = 25, /* LE_OP */
434 | YYSYMBOL_GE_OP = 26, /* GE_OP */
435 | YYSYMBOL_LEFT_SHIFT = 27, /* LEFT_SHIFT */
436 | YYSYMBOL_RIGHT_SHIFT = 28, /* RIGHT_SHIFT */
437 | YYSYMBOL_SIZEOF = 29, /* SIZEOF */
438 | YYSYMBOL_TYPEDEF = 30, /* TYPEDEF */
439 | YYSYMBOL_EXTERN = 31, /* EXTERN */
440 | YYSYMBOL_STATIC = 32, /* STATIC */
441 | YYSYMBOL_AUTO = 33, /* AUTO */
442 | YYSYMBOL_REGISTER = 34, /* REGISTER */
443 | YYSYMBOL_CONST = 35, /* CONST */
444 | YYSYMBOL_VOLATILE = 36, /* VOLATILE */
445 | YYSYMBOL_VOID = 37, /* VOID */
446 | YYSYMBOL_INLINE = 38, /* INLINE */
447 | YYSYMBOL_CHAR = 39, /* CHAR */
448 | YYSYMBOL_SHORT = 40, /* SHORT */
449 | YYSYMBOL_INT = 41, /* INT */
450 | YYSYMBOL_LONG = 42, /* LONG */
451 | YYSYMBOL_SIGNED = 43, /* SIGNED */
452 | YYSYMBOL_UNSIGNED = 44, /* UNSIGNED */
453 | YYSYMBOL_FLOAT = 45, /* FLOAT */
454 | YYSYMBOL_DOUBLE = 46, /* DOUBLE */
455 | YYSYMBOL_BOOL = 47, /* BOOL */
456 | YYSYMBOL_STRUCT = 48, /* STRUCT */
457 | YYSYMBOL_UNION = 49, /* UNION */
458 | YYSYMBOL_ENUM = 50, /* ENUM */
459 | YYSYMBOL_CASE = 51, /* CASE */
460 | YYSYMBOL_DEFAULT = 52, /* DEFAULT */
461 | YYSYMBOL_IF = 53, /* IF */
462 | YYSYMBOL_ELSE = 54, /* ELSE */
463 | YYSYMBOL_SWITCH = 55, /* SWITCH */
464 | YYSYMBOL_WHILE = 56, /* WHILE */
465 | YYSYMBOL_DO = 57, /* DO */
466 | YYSYMBOL_FOR = 58, /* FOR */
467 | YYSYMBOL_GOTO = 59, /* GOTO */
468 | YYSYMBOL_CONTINUE = 60, /* CONTINUE */
469 | YYSYMBOL_BREAK = 61, /* BREAK */
470 | YYSYMBOL_RETURN = 62, /* RETURN */
471 | YYSYMBOL_ASM = 63, /* ASM */
472 | YYSYMBOL_64_ = 64, /* ';' */
473 | YYSYMBOL_65_ = 65, /* ',' */
474 | YYSYMBOL_66_ = 66, /* '=' */
475 | YYSYMBOL_67_ = 67, /* '{' */
476 | YYSYMBOL_68_ = 68, /* '}' */
477 | YYSYMBOL_69_ = 69, /* ':' */
478 | YYSYMBOL_70_ = 70, /* '.' */
479 | YYSYMBOL_71_ = 71, /* '[' */
480 | YYSYMBOL_72_ = 72, /* ']' */
481 | YYSYMBOL_73_ = 73, /* '(' */
482 | YYSYMBOL_74_ = 74, /* ')' */
483 | YYSYMBOL_75_ = 75, /* '*' */
484 | YYSYMBOL_76_ = 76, /* '?' */
485 | YYSYMBOL_77_ = 77, /* '|' */
486 | YYSYMBOL_78_ = 78, /* '^' */
487 | YYSYMBOL_79_ = 79, /* '&' */
488 | YYSYMBOL_80_ = 80, /* '<' */
489 | YYSYMBOL_81_ = 81, /* '>' */
490 | YYSYMBOL_82_ = 82, /* '+' */
491 | YYSYMBOL_83_ = 83, /* '-' */
492 | YYSYMBOL_84_ = 84, /* '/' */
493 | YYSYMBOL_85_ = 85, /* '%' */
494 | YYSYMBOL_86_ = 86, /* '~' */
495 | YYSYMBOL_87_ = 87, /* '!' */
496 | YYSYMBOL_YYACCEPT = 88, /* $accept */
497 | YYSYMBOL_file = 89, /* file */
498 | YYSYMBOL_program = 90, /* program */
499 | YYSYMBOL_top_level_declaration = 91, /* top_level_declaration */
500 | YYSYMBOL_declaration_list = 92, /* declaration_list */
501 | YYSYMBOL_declaration = 93, /* declaration */
502 | YYSYMBOL_declaration_specifiers = 94, /* declaration_specifiers */
503 | YYSYMBOL_declaration_specifiers1 = 95, /* declaration_specifiers1 */
504 | YYSYMBOL_initialized_declarator_list = 96, /* initialized_declarator_list */
505 | YYSYMBOL_97_1 = 97, /* $@1 */
506 | YYSYMBOL_initialized_declarator = 98, /* initialized_declarator */
507 | YYSYMBOL_initialized_declarator1 = 99, /* initialized_declarator1 */
508 | YYSYMBOL_initializer_part = 100, /* initializer_part */
509 | YYSYMBOL_initializer = 101, /* initializer */
510 | YYSYMBOL_struct_initializer_list = 102, /* struct_initializer_list */
511 | YYSYMBOL_named_initializer = 103, /* named_initializer */
512 | YYSYMBOL_designator = 104, /* designator */
513 | YYSYMBOL_designator_list = 105, /* designator_list */
514 | YYSYMBOL_named_initializer_index = 106, /* named_initializer_index */
515 | YYSYMBOL_abstract_declarator = 107, /* abstract_declarator */
516 | YYSYMBOL_direct_abstract_declarator = 108, /* direct_abstract_declarator */
517 | YYSYMBOL_declarator = 109, /* declarator */
518 | YYSYMBOL_pointer = 110, /* pointer */
519 | YYSYMBOL_direct_declarator = 111, /* direct_declarator */
520 | YYSYMBOL_simple_declarator = 112, /* simple_declarator */
521 | YYSYMBOL_array_declarator = 113, /* array_declarator */
522 | YYSYMBOL_114_2 = 114, /* $@2 */
523 | YYSYMBOL_115_3 = 115, /* $@3 */
524 | YYSYMBOL_name = 116, /* name */
525 | YYSYMBOL_storage_class_specifier = 117, /* storage_class_specifier */
526 | YYSYMBOL_type_qualifier_list = 118, /* type_qualifier_list */
527 | YYSYMBOL_type_qualifier = 119, /* type_qualifier */
528 | YYSYMBOL_type_specifier = 120, /* type_specifier */
529 | YYSYMBOL_type_specifier1 = 121, /* type_specifier1 */
530 | YYSYMBOL_floating_type_specifier = 122, /* floating_type_specifier */
531 | YYSYMBOL_integer_type_specifier = 123, /* integer_type_specifier */
532 | YYSYMBOL_integer_type_specifier_part = 124, /* integer_type_specifier_part */
533 | YYSYMBOL_boolean_type_specifier = 125, /* boolean_type_specifier */
534 | YYSYMBOL_typedef_name = 126, /* typedef_name */
535 | YYSYMBOL_void_type_specifier = 127, /* void_type_specifier */
536 | YYSYMBOL_type_name = 128, /* type_name */
537 | YYSYMBOL_enumeration_type_specifier = 129, /* enumeration_type_specifier */
538 | YYSYMBOL_enumeration_type_definition = 130, /* enumeration_type_definition */
539 | YYSYMBOL_131_4 = 131, /* $@4 */
540 | YYSYMBOL_132_5 = 132, /* $@5 */
541 | YYSYMBOL_enumeration_definition_list = 133, /* enumeration_definition_list */
542 | YYSYMBOL_enumeration_definition_list1 = 134, /* enumeration_definition_list1 */
543 | YYSYMBOL_enumeration_constant_definition = 135, /* enumeration_constant_definition */
544 | YYSYMBOL_enumeration_constant = 136, /* enumeration_constant */
545 | YYSYMBOL_enumeration_type_reference = 137, /* enumeration_type_reference */
546 | YYSYMBOL_enumeration_tag = 138, /* enumeration_tag */
547 | YYSYMBOL_structure_type_specifier = 139, /* structure_type_specifier */
548 | YYSYMBOL_structure_type_definition = 140, /* structure_type_definition */
549 | YYSYMBOL_141_6 = 141, /* $@6 */
550 | YYSYMBOL_142_7 = 142, /* $@7 */
551 | YYSYMBOL_structure_type_reference = 143, /* structure_type_reference */
552 | YYSYMBOL_structure_tag = 144, /* structure_tag */
553 | YYSYMBOL_union_type_specifier = 145, /* union_type_specifier */
554 | YYSYMBOL_union_type_definition = 146, /* union_type_definition */
555 | YYSYMBOL_147_8 = 147, /* $@8 */
556 | YYSYMBOL_148_9 = 148, /* $@9 */
557 | YYSYMBOL_union_type_reference = 149, /* union_type_reference */
558 | YYSYMBOL_union_tag = 150, /* union_tag */
559 | YYSYMBOL_field_list = 151, /* field_list */
560 | YYSYMBOL_field_list1 = 152, /* field_list1 */
561 | YYSYMBOL_field_list2 = 153, /* field_list2 */
562 | YYSYMBOL_component_declaration = 154, /* component_declaration */
563 | YYSYMBOL_155_10 = 155, /* $@10 */
564 | YYSYMBOL_156_11 = 156, /* $@11 */
565 | YYSYMBOL_157_12 = 157, /* $@12 */
566 | YYSYMBOL_component_declarator_list = 158, /* component_declarator_list */
567 | YYSYMBOL_component_declarator = 159, /* component_declarator */
568 | YYSYMBOL_simple_component = 160, /* simple_component */
569 | YYSYMBOL_bit_field = 161, /* bit_field */
570 | YYSYMBOL_width = 162, /* width */
571 | YYSYMBOL_component_name = 163, /* component_name */
572 | YYSYMBOL_function_definition = 164, /* function_definition */
573 | YYSYMBOL_165_13 = 165, /* $@13 */
574 | YYSYMBOL_function_specifier = 166, /* function_specifier */
575 | YYSYMBOL_function_specifier1 = 167, /* function_specifier1 */
576 | YYSYMBOL_function_declarator = 168, /* function_declarator */
577 | YYSYMBOL_function_declarator0 = 169, /* function_declarator0 */
578 | YYSYMBOL_function_direct_declarator = 170, /* function_direct_declarator */
579 | YYSYMBOL_171_14 = 171, /* $@14 */
580 | YYSYMBOL_function_declarator1 = 172, /* function_declarator1 */
581 | YYSYMBOL_function_declarator2 = 173, /* function_declarator2 */
582 | YYSYMBOL_identifier_list = 174, /* identifier_list */
583 | YYSYMBOL_parameter_type_list = 175, /* parameter_type_list */
584 | YYSYMBOL_parameter_list = 176, /* parameter_list */
585 | YYSYMBOL_parameter_declaration = 177, /* parameter_declaration */
586 | YYSYMBOL_statement = 178, /* statement */
587 | YYSYMBOL_compound_statement = 179, /* compound_statement */
588 | YYSYMBOL_180_15 = 180, /* $@15 */
589 | YYSYMBOL_181_16 = 181, /* $@16 */
590 | YYSYMBOL_compound_statement_body = 182, /* compound_statement_body */
591 | YYSYMBOL_block_item_list = 183, /* block_item_list */
592 | YYSYMBOL_block_item = 184, /* block_item */
593 | YYSYMBOL_conditional_statement = 185, /* conditional_statement */
594 | YYSYMBOL_if_else_statement = 186, /* if_else_statement */
595 | YYSYMBOL_if_statement = 187, /* if_statement */
596 | YYSYMBOL_iterative_statement = 188, /* iterative_statement */
597 | YYSYMBOL_do_statement = 189, /* do_statement */
598 | YYSYMBOL_for_statement = 190, /* for_statement */
599 | YYSYMBOL_191_17 = 191, /* $@17 */
600 | YYSYMBOL_for_expressions = 192, /* for_expressions */
601 | YYSYMBOL_for_expression_or_declaration = 193, /* for_expression_or_declaration */
602 | YYSYMBOL_while_statement = 194, /* while_statement */
603 | YYSYMBOL_labeled_statement = 195, /* labeled_statement */
604 | YYSYMBOL_case_label = 196, /* case_label */
605 | YYSYMBOL_default_label = 197, /* default_label */
606 | YYSYMBOL_named_label = 198, /* named_label */
607 | YYSYMBOL_switch_statement = 199, /* switch_statement */
608 | YYSYMBOL_break_statement = 200, /* break_statement */
609 | YYSYMBOL_continue_statement = 201, /* continue_statement */
610 | YYSYMBOL_expression_statement = 202, /* expression_statement */
611 | YYSYMBOL_goto_statement = 203, /* goto_statement */
612 | YYSYMBOL_null_statement = 204, /* null_statement */
613 | YYSYMBOL_return_statement = 205, /* return_statement */
614 | YYSYMBOL_expression = 206, /* expression */
615 | YYSYMBOL_comma_expression = 207, /* comma_expression */
616 | YYSYMBOL_assignment_expression = 208, /* assignment_expression */
617 | YYSYMBOL_assignment_op = 209, /* assignment_op */
618 | YYSYMBOL_conditional_expression = 210, /* conditional_expression */
619 | YYSYMBOL_logical_or_expression = 211, /* logical_or_expression */
620 | YYSYMBOL_logical_and_expression = 212, /* logical_and_expression */
621 | YYSYMBOL_bitwise_or_expression = 213, /* bitwise_or_expression */
622 | YYSYMBOL_bitwise_xor_expression = 214, /* bitwise_xor_expression */
623 | YYSYMBOL_bitwise_and_expression = 215, /* bitwise_and_expression */
624 | YYSYMBOL_equality_expression = 216, /* equality_expression */
625 | YYSYMBOL_equality_op = 217, /* equality_op */
626 | YYSYMBOL_relational_expression = 218, /* relational_expression */
627 | YYSYMBOL_relational_op = 219, /* relational_op */
628 | YYSYMBOL_shift_expression = 220, /* shift_expression */
629 | YYSYMBOL_shift_op = 221, /* shift_op */
630 | YYSYMBOL_additive_expression = 222, /* additive_expression */
631 | YYSYMBOL_add_op = 223, /* add_op */
632 | YYSYMBOL_multiplicative_expression = 224, /* multiplicative_expression */
633 | YYSYMBOL_mult_op = 225, /* mult_op */
634 | YYSYMBOL_unary_expression = 226, /* unary_expression */
635 | YYSYMBOL_address_expression = 227, /* address_expression */
636 | YYSYMBOL_bitwise_negation_expression = 228, /* bitwise_negation_expression */
637 | YYSYMBOL_cast_expression = 229, /* cast_expression */
638 | YYSYMBOL_indirection_expression = 230, /* indirection_expression */
639 | YYSYMBOL_logical_negation_expression = 231, /* logical_negation_expression */
640 | YYSYMBOL_predecrement_expression = 232, /* predecrement_expression */
641 | YYSYMBOL_preincrement_expression = 233, /* preincrement_expression */
642 | YYSYMBOL_sizeof_expression = 234, /* sizeof_expression */
643 | YYSYMBOL_unary_minus_expression = 235, /* unary_minus_expression */
644 | YYSYMBOL_unary_plus_expression = 236, /* unary_plus_expression */
645 | YYSYMBOL_postfix_expression = 237, /* postfix_expression */
646 | YYSYMBOL_component_selection_expression = 238, /* component_selection_expression */
647 | YYSYMBOL_direct_component_selection = 239, /* direct_component_selection */
648 | YYSYMBOL_indirect_component_selection = 240, /* indirect_component_selection */
649 | YYSYMBOL_function_call = 241, /* function_call */
650 | YYSYMBOL_function_call_direct = 242, /* function_call_direct */
651 | YYSYMBOL_postdecrement_expression = 243, /* postdecrement_expression */
652 | YYSYMBOL_postincrement_expression = 244, /* postincrement_expression */
653 | YYSYMBOL_subscript_expression = 245, /* subscript_expression */
654 | YYSYMBOL_primary_expression = 246, /* primary_expression */
655 | YYSYMBOL_string_literal = 247, /* string_literal */
656 | YYSYMBOL_parenthesized_expression = 248, /* parenthesized_expression */
657 | YYSYMBOL_249_18 = 249, /* $@18 */
658 | YYSYMBOL_250_19 = 250, /* $@19 */
659 | YYSYMBOL_constant_expression = 251, /* constant_expression */
660 | YYSYMBOL_expression_list = 252, /* expression_list */
661 | YYSYMBOL_asm_statement = 253, /* asm_statement */
662 | YYSYMBOL_asm_type = 254, /* asm_type */
663 | YYSYMBOL_asm_inout_list = 255, /* asm_inout_list */
664 | YYSYMBOL_asm_inout = 256, /* asm_inout */
665 | YYSYMBOL_asm_clobber_list = 257, /* asm_clobber_list */
666 | YYSYMBOL_asm_label = 258, /* asm_label */
667 | YYSYMBOL_named_label_address = 259 /* named_label_address */
668 | };
669 | typedef enum yysymbol_kind_t yysymbol_kind_t;
670 |
671 |
672 |
673 |
674 | #ifdef short
675 | # undef short
676 | #endif
677 |
678 | /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
679 | <limits.h> and (if available) <stdint.h> are included
680 | so that the code can choose integer types of a good width. */
681 |
682 | #ifndef __PTRDIFF_MAX__
683 | # include <limits.h> /* INFRINGES ON USER NAME SPACE */
684 | # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
685 | # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
686 | # define YY_STDINT_H
687 | # endif
688 | #endif
689 |
690 | /* Narrow types that promote to a signed type and that can represent a
691 | signed or unsigned integer of at least N bits. In tables they can
692 | save space and decrease cache pressure. Promoting to a signed type
693 | helps avoid bugs in integer arithmetic. */
694 |
695 | #ifdef __INT_LEAST8_MAX__
696 | typedef __INT_LEAST8_TYPE__ yytype_int8;
697 | #elif defined YY_STDINT_H
698 | typedef int_least8_t yytype_int8;
699 | #else
700 | typedef signed char yytype_int8;
701 | #endif
702 |
703 | #ifdef __INT_LEAST16_MAX__
704 | typedef __INT_LEAST16_TYPE__ yytype_int16;
705 | #elif defined YY_STDINT_H
706 | typedef int_least16_t yytype_int16;
707 | #else
708 | typedef short yytype_int16;
709 | #endif
710 |
711 | #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
712 | typedef __UINT_LEAST8_TYPE__ yytype_uint8;
713 | #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
714 | && UINT_LEAST8_MAX <= INT_MAX)
715 | typedef uint_least8_t yytype_uint8;
716 | #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
717 | typedef unsigned char yytype_uint8;
718 | #else
719 | typedef short yytype_uint8;
720 | #endif
721 |
722 | #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
723 | typedef __UINT_LEAST16_TYPE__ yytype_uint16;
724 | #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
725 | && UINT_LEAST16_MAX <= INT_MAX)
726 | typedef uint_least16_t yytype_uint16;
727 | #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
728 | typedef unsigned short yytype_uint16;
729 | #else
730 | typedef int yytype_uint16;
731 | #endif
732 |
733 | #ifndef YYPTRDIFF_T
734 | # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
735 | # define YYPTRDIFF_T __PTRDIFF_TYPE__
736 | # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
737 | # elif defined PTRDIFF_MAX
738 | # ifndef ptrdiff_t
739 | # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
740 | # endif
741 | # define YYPTRDIFF_T ptrdiff_t
742 | # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
743 | # else
744 | # define YYPTRDIFF_T long
745 | # define YYPTRDIFF_MAXIMUM LONG_MAX
746 | # endif
747 | #endif
748 |
749 | #ifndef YYSIZE_T
750 | # ifdef __SIZE_TYPE__
751 | # define YYSIZE_T __SIZE_TYPE__
752 | # elif defined size_t
753 | # define YYSIZE_T size_t
754 | # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
755 | # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
756 | # define YYSIZE_T size_t
757 | # else
758 | # define YYSIZE_T unsigned
759 | # endif
760 | #endif
761 |
762 | #define YYSIZE_MAXIMUM \
763 | YY_CAST (YYPTRDIFF_T, \
764 | (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
765 | ? YYPTRDIFF_MAXIMUM \
766 | : YY_CAST (YYSIZE_T, -1)))
767 |
768 | #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
769 |
770 |
771 | /* Stored state numbers (used for stacks). */
772 | typedef yytype_int16 yy_state_t;
773 |
774 | /* State numbers in computations. */
775 | typedef int yy_state_fast_t;
776 |
777 | #ifndef YY_
778 | # if defined YYENABLE_NLS && YYENABLE_NLS
779 | # if ENABLE_NLS
780 | # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
781 | # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
782 | # endif
783 | # endif
784 | # ifndef YY_
785 | # define YY_(Msgid) Msgid
786 | # endif
787 | #endif
788 |
789 |
790 | #ifndef YY_ATTRIBUTE_PURE
791 | # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
792 | # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
793 | # else
794 | # define YY_ATTRIBUTE_PURE
795 | # endif
796 | #endif
797 |
798 | #ifndef YY_ATTRIBUTE_UNUSED
799 | # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
800 | # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
801 | # else
802 | # define YY_ATTRIBUTE_UNUSED
803 | # endif
804 | #endif
805 |
806 | /* Suppress unused-variable warnings by "using" E. */
807 | #if ! defined lint || defined __GNUC__
808 | # define YYUSE(E) ((void) (E))
809 | #else
810 | # define YYUSE(E) /* empty */
811 | #endif
812 |
813 | #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
814 | /* Suppress an incorrect diagnostic about yylval being uninitialized. */
815 | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
816 | _Pragma ("GCC diagnostic push") \
817 | _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
818 | _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
819 | # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
820 | _Pragma ("GCC diagnostic pop")
821 | #else
822 | # define YY_INITIAL_VALUE(Value) Value
823 | #endif
824 | #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
825 | # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
826 | # define YY_IGNORE_MAYBE_UNINITIALIZED_END
827 | #endif
828 | #ifndef YY_INITIAL_VALUE
829 | # define YY_INITIAL_VALUE(Value) /* Nothing. */
830 | #endif
831 |
832 | #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
833 | # define YY_IGNORE_USELESS_CAST_BEGIN \
834 | _Pragma ("GCC diagnostic push") \
835 | _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
836 | # define YY_IGNORE_USELESS_CAST_END \
837 | _Pragma ("GCC diagnostic pop")
838 | #endif
839 | #ifndef YY_IGNORE_USELESS_CAST_BEGIN
840 | # define YY_IGNORE_USELESS_CAST_BEGIN
841 | # define YY_IGNORE_USELESS_CAST_END
842 | #endif
843 |
844 |
845 | #define YY_ASSERT(E) ((void) (0 && (E)))
846 |
847 | #if !defined yyoverflow
848 |
849 | /* The parser invokes alloca or malloc; define the necessary symbols. */
850 |
851 | # ifdef YYSTACK_USE_ALLOCA
852 | # if YYSTACK_USE_ALLOCA
853 | # ifdef __GNUC__
854 | # define YYSTACK_ALLOC __builtin_alloca
855 | # elif defined __BUILTIN_VA_ARG_INCR
856 | # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
857 | # elif defined _AIX
858 | # define YYSTACK_ALLOC __alloca
859 | # elif defined _MSC_VER
860 | # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
861 | # define alloca _alloca
862 | # else
863 | # define YYSTACK_ALLOC alloca
864 | # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
865 | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
866 | /* Use EXIT_SUCCESS as a witness for stdlib.h. */
867 | # ifndef EXIT_SUCCESS
868 | # define EXIT_SUCCESS 0
869 | # endif
870 | # endif
871 | # endif
872 | # endif
873 | # endif
874 |
875 | # ifdef YYSTACK_ALLOC
876 | /* Pacify GCC's 'empty if-body' warning. */
877 | # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
878 | # ifndef YYSTACK_ALLOC_MAXIMUM
879 | /* The OS might guarantee only one guard page at the bottom of the stack,
880 | and a page size can be as small as 4096 bytes. So we cannot safely
881 | invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
882 | to allow for a few compiler-allocated temporary stack slots. */
883 | # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
884 | # endif
885 | # else
886 | # define YYSTACK_ALLOC YYMALLOC
887 | # define YYSTACK_FREE YYFREE
888 | # ifndef YYSTACK_ALLOC_MAXIMUM
889 | # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
890 | # endif
891 | # if (defined __cplusplus && ! defined EXIT_SUCCESS \
892 | && ! ((defined YYMALLOC || defined malloc) \
893 | && (defined YYFREE || defined free)))
894 | # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
895 | # ifndef EXIT_SUCCESS
896 | # define EXIT_SUCCESS 0
897 | # endif
898 | # endif
899 | # ifndef YYMALLOC
900 | # define YYMALLOC malloc
901 | # if ! defined malloc && ! defined EXIT_SUCCESS
902 | void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
903 | # endif
904 | # endif
905 | # ifndef YYFREE
906 | # define YYFREE free
907 | # if ! defined free && ! defined EXIT_SUCCESS
908 | void free (void *); /* INFRINGES ON USER NAME SPACE */
909 | # endif
910 | # endif
911 | # endif
912 | #endif /* !defined yyoverflow */
913 |
914 | #if (! defined yyoverflow \
915 | && (! defined __cplusplus \
916 | || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
917 |
918 | /* A type that is properly aligned for any stack member. */
919 | union yyalloc
920 | {
921 | yy_state_t yyss_alloc;
922 | YYSTYPE yyvs_alloc;
923 | };
924 |
925 | /* The size of the maximum gap between one aligned stack and the next. */
926 | # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
927 |
928 | /* The size of an array large to enough to hold all stacks, each with
929 | N elements. */
930 | # define YYSTACK_BYTES(N) \
931 | ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
932 | + YYSTACK_GAP_MAXIMUM)
933 |
934 | # define YYCOPY_NEEDED 1
935 |
936 | /* Relocate STACK from its old location to the new one. The
937 | local variables YYSIZE and YYSTACKSIZE give the old and new number of
938 | elements in the stack, and YYPTR gives the new location of the
939 | stack. Advance YYPTR to a properly aligned location for the next
940 | stack. */
941 | # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
942 | do \
943 | { \
944 | YYPTRDIFF_T yynewbytes; \
945 | YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
946 | Stack = &yyptr->Stack_alloc; \
947 | yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
948 | yyptr += yynewbytes / YYSIZEOF (*yyptr); \
949 | } \
950 | while (0)
951 |
952 | #endif
953 |
954 | #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
955 | /* Copy COUNT objects from SRC to DST. The source and destination do
956 | not overlap. */
957 | # ifndef YYCOPY
958 | # if defined __GNUC__ && 1 < __GNUC__
959 | # define YYCOPY(Dst, Src, Count) \
960 | __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
961 | # else
962 | # define YYCOPY(Dst, Src, Count) \
963 | do \
964 | { \
965 | YYPTRDIFF_T yyi; \
966 | for (yyi = 0; yyi < (Count); yyi++) \
967 | (Dst)[yyi] = (Src)[yyi]; \
968 | } \
969 | while (0)
970 | # endif
971 | # endif
972 | #endif /* !YYCOPY_NEEDED */
973 |
974 | /* YYFINAL -- State number of the termination state. */
975 | #define YYFINAL 92
976 | /* YYLAST -- Last index in YYTABLE. */
977 | #define YYLAST 1500
978 |
979 | /* YYNTOKENS -- Number of terminals. */
980 | #define YYNTOKENS 88
981 | /* YYNNTS -- Number of nonterminals. */
982 | #define YYNNTS 172
983 | /* YYNRULES -- Number of rules. */
984 | #define YYNRULES 379
985 | /* YYNSTATES -- Number of states. */
986 | #define YYNSTATES 572
987 |
988 | /* YYMAXUTOK -- Last valid token kind. */
989 | #define YYMAXUTOK 318
990 |
991 |
992 | /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
993 | as returned by yylex, with out-of-bounds checking. */
994 | #define YYTRANSLATE(YYX) \
995 | (0 <= (YYX) && (YYX) <= YYMAXUTOK \
996 | ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
997 | : YYSYMBOL_YYUNDEF)
998 |
999 | /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
1000 | as returned by yylex. */
1001 | static const yytype_int8 yytranslate[] =
1002 | {
1003 | 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1004 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1005 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1006 | 2, 2, 2, 87, 2, 2, 2, 85, 79, 2,
1007 | 73, 74, 75, 82, 65, 83, 70, 84, 2, 2,
1008 | 2, 2, 2, 2, 2, 2, 2, 2, 69, 64,
1009 | 80, 66, 81, 76, 2, 2, 2, 2, 2, 2,
1010 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1011 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1012 | 2, 71, 2, 72, 78, 2, 2, 2, 2, 2,
1013 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1014 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1015 | 2, 2, 2, 67, 77, 68, 86, 2, 2, 2,
1016 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1017 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1018 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1019 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1020 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1021 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1022 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1023 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1024 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1025 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1026 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1027 | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1028 | 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1029 | 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1030 | 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1031 | 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1032 | 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1033 | 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1034 | 55, 56, 57, 58, 59, 60, 61, 62, 63
1035 | };
1036 |
1037 | #if YYDEBUG
1038 | /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1039 | static const yytype_int16 yyrline[] =
1040 | {
1041 | 0, 167, 167, 168, 172, 173, 177, 179, 181, 182,
1042 | 188, 190, 196, 198, 203, 209, 210, 212, 214, 217,
1043 | 218, 225, 226, 226, 230, 274, 275, 276, 277, 281,
1044 | 285, 286, 290, 291, 292, 293, 297, 298, 299, 303,
1045 | 304, 308, 309, 313, 314, 320, 321, 323, 327, 330,
1046 | 332, 334, 336, 338, 340, 342, 344, 351, 353, 358,
1047 | 359, 361, 363, 368, 369, 373, 374, 378, 385, 387,
1048 | 387, 387, 394, 398, 400, 405, 407, 409, 413, 418,
1049 | 419, 424, 426, 433, 438, 439, 440, 441, 442, 443,
1050 | 444, 445, 449, 450, 451, 453, 458, 459, 461, 466,
1051 | 467, 468, 469, 470, 471, 475, 479, 483, 487, 489,
1052 | 496, 497, 502, 501, 515, 514, 530, 531, 535, 536,
1053 | 541, 543, 548, 552, 557, 558, 564, 565, 570, 569,
1054 | 583, 582, 598, 603, 604, 610, 611, 616, 615, 629,
1055 | 628, 644, 649, 650, 656, 657, 661, 662, 667, 668,
1056 | 671, 674, 679, 678, 683, 682, 687, 686, 693, 695,
1057 | 701, 702, 706, 711, 713, 718, 722, 723, 732, 731,
1058 | 738, 761, 762, 764, 765, 772, 777, 778, 779, 781,
1059 | 787, 786, 797, 806, 808, 809, 813, 815, 821, 822,
1060 | 828, 831, 837, 839, 841, 848, 849, 850, 851, 852,
1061 | 853, 854, 855, 856, 857, 858, 859, 866, 868, 865,
1062 | 873, 874, 878, 879, 883, 884, 891, 892, 896, 900,
1063 | 906, 907, 908, 912, 917, 916, 923, 924, 925, 926,
1064 | 927, 928, 929, 930, 934, 935, 937, 942, 948, 949,
1065 | 950, 954, 955, 959, 963, 964, 970, 976, 980, 984,
1066 | 988, 992, 996, 997, 1003, 1009, 1010, 1017, 1018, 1019,
1067 | 1020, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032,
1068 | 1033, 1034, 1040, 1041, 1043, 1050, 1051, 1058, 1059, 1066,
1069 | 1067, 1074, 1075, 1082, 1083, 1090, 1091, 1096, 1097, 1103,
1070 | 1104, 1109, 1110, 1111, 1112, 1118, 1119, 1124, 1125, 1131,
1071 | 1132, 1137, 1138, 1144, 1145, 1150, 1151, 1152, 1158, 1159,
1072 | 1160, 1161, 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1172,
1073 | 1176, 1181, 1183, 1187, 1191, 1196, 1200, 1204, 1206, 1211,
1074 | 1216, 1223, 1224, 1225, 1227, 1228, 1229, 1230, 1234, 1235,
1075 | 1239, 1243, 1247, 1248, 1252, 1253, 1257, 1261, 1265, 1269,
1076 | 1271, 1272, 1273, 1277, 1278, 1282, 1284, 1284, 1284, 1290,
1077 | 1294, 1295, 1303, 1304, 1305, 1306, 1310, 1311, 1312, 1316,
1078 | 1317, 1318, 1322, 1323, 1324, 1328, 1329, 1330, 1334, 1340
1079 | };
1080 | #endif
1081 |
1082 | /** Accessing symbol of state STATE. */
1083 | #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
1084 |
1085 | #if YYDEBUG || 0
1086 | /* The user-facing name of the symbol whose (internal) number is
1087 | YYSYMBOL. No bounds checking. */
1088 | static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
1089 |
1090 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1091 | First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1092 | static const char *const yytname[] =
1093 | {
1094 | "\"end of file\"", "error", "\"invalid token\"", "IDENTIFIER",
1095 | "TYPE_NAME", "LITERAL", "STRING_LITERAL", "ELLIPSES", "MUL_ASSIGN",
1096 | "DIV_ASSIGN", "MOD_ASSIGN", "ADD_ASSIGN", "SUB_ASSIGN", "LEFT_ASSIGN",
1097 | "RIGHT_ASSIGN", "AND_ASSIGN", "XOR_ASSIGN", "OR_ASSIGN", "EQ_OP",
1098 | "NE_OP", "PTR_OP", "AND_OP", "OR_OP", "DEC_OP", "INC_OP", "LE_OP",
1099 | "GE_OP", "LEFT_SHIFT", "RIGHT_SHIFT", "SIZEOF", "TYPEDEF", "EXTERN",
1100 | "STATIC", "AUTO", "REGISTER", "CONST", "VOLATILE", "VOID", "INLINE",
1101 | "CHAR", "SHORT", "INT", "LONG", "SIGNED", "UNSIGNED", "FLOAT", "DOUBLE",
1102 | "BOOL", "STRUCT", "UNION", "ENUM", "CASE", "DEFAULT", "IF", "ELSE",
1103 | "SWITCH", "WHILE", "DO", "FOR", "GOTO", "CONTINUE", "BREAK", "RETURN",
1104 | "ASM", "';'", "','", "'='", "'{'", "'}'", "':'", "'.'", "'['", "']'",
1105 | "'('", "')'", "'*'", "'?'", "'|'", "'^'", "'&'", "'<'", "'>'", "'+'",
1106 | "'-'", "'/'", "'%'", "'~'", "'!'", "$accept", "file", "program",
1107 | "top_level_declaration", "declaration_list", "declaration",
1108 | "declaration_specifiers", "declaration_specifiers1",
1109 | "initialized_declarator_list", "$@1", "initialized_declarator",
1110 | "initialized_declarator1", "initializer_part", "initializer",
1111 | "struct_initializer_list", "named_initializer", "designator",
1112 | "designator_list", "named_initializer_index", "abstract_declarator",
1113 | "direct_abstract_declarator", "declarator", "pointer",
1114 | "direct_declarator", "simple_declarator", "array_declarator", "$@2",
1115 | "$@3", "name", "storage_class_specifier", "type_qualifier_list",
1116 | "type_qualifier", "type_specifier", "type_specifier1",
1117 | "floating_type_specifier", "integer_type_specifier",
1118 | "integer_type_specifier_part", "boolean_type_specifier", "typedef_name",
1119 | "void_type_specifier", "type_name", "enumeration_type_specifier",
1120 | "enumeration_type_definition", "$@4", "$@5",
1121 | "enumeration_definition_list", "enumeration_definition_list1",
1122 | "enumeration_constant_definition", "enumeration_constant",
1123 | "enumeration_type_reference", "enumeration_tag",
1124 | "structure_type_specifier", "structure_type_definition", "$@6", "$@7",
1125 | "structure_type_reference", "structure_tag", "union_type_specifier",
1126 | "union_type_definition", "$@8", "$@9", "union_type_reference",
1127 | "union_tag", "field_list", "field_list1", "field_list2",
1128 | "component_declaration", "$@10", "$@11", "$@12",
1129 | "component_declarator_list", "component_declarator", "simple_component",
1130 | "bit_field", "width", "component_name", "function_definition", "$@13",
1131 | "function_specifier", "function_specifier1", "function_declarator",
1132 | "function_declarator0", "function_direct_declarator", "$@14",
1133 | "function_declarator1", "function_declarator2", "identifier_list",
1134 | "parameter_type_list", "parameter_list", "parameter_declaration",
1135 | "statement", "compound_statement", "$@15", "$@16",
1136 | "compound_statement_body", "block_item_list", "block_item",
1137 | "conditional_statement", "if_else_statement", "if_statement",
1138 | "iterative_statement", "do_statement", "for_statement", "$@17",
1139 | "for_expressions", "for_expression_or_declaration", "while_statement",
1140 | "labeled_statement", "case_label", "default_label", "named_label",
1141 | "switch_statement", "break_statement", "continue_statement",
1142 | "expression_statement", "goto_statement", "null_statement",
1143 | "return_statement", "expression", "comma_expression",
1144 | "assignment_expression", "assignment_op", "conditional_expression",
1145 | "logical_or_expression", "logical_and_expression",
1146 | "bitwise_or_expression", "bitwise_xor_expression",
1147 | "bitwise_and_expression", "equality_expression", "equality_op",
1148 | "relational_expression", "relational_op", "shift_expression", "shift_op",
1149 | "additive_expression", "add_op", "multiplicative_expression", "mult_op",
1150 | "unary_expression", "address_expression", "bitwise_negation_expression",
1151 | "cast_expression", "indirection_expression",
1152 | "logical_negation_expression", "predecrement_expression",
1153 | "preincrement_expression", "sizeof_expression", "unary_minus_expression",
1154 | "unary_plus_expression", "postfix_expression",
1155 | "component_selection_expression", "direct_component_selection",
1156 | "indirect_component_selection", "function_call", "function_call_direct",
1157 | "postdecrement_expression", "postincrement_expression",
1158 | "subscript_expression", "primary_expression", "string_literal",
1159 | "parenthesized_expression", "$@18", "$@19", "constant_expression",
1160 | "expression_list", "asm_statement", "asm_type", "asm_inout_list",
1161 | "asm_inout", "asm_clobber_list", "asm_label", "named_label_address", YY_NULLPTR
1162 | };
1163 |
1164 | static const char *
1165 | yysymbol_name (yysymbol_kind_t yysymbol)
1166 | {
1167 | return yytname[yysymbol];
1168 | }
1169 | #endif
1170 |
1171 | #ifdef YYPRINT
1172 | /* YYTOKNUM[NUM] -- (External) token number corresponding to the
1173 | (internal) symbol number NUM (which must be that of a token). */
1174 | static const yytype_int16 yytoknum[] =
1175 | {
1176 | 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1177 | 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1178 | 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1179 | 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1180 | 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1181 | 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1182 | 315, 316, 317, 318, 59, 44, 61, 123, 125, 58,
1183 | 46, 91, 93, 40, 41, 42, 63, 124, 94, 38,
1184 | 60, 62, 43, 45, 47, 37, 126, 33
1185 | };
1186 | #endif
1187 |
1188 | #define YYPACT_NINF (-406)
1189 |
1190 | #define yypact_value_is_default(Yyn) \
1191 | ((Yyn) == YYPACT_NINF)
1192 |
1193 | #define YYTABLE_NINF (-246)
1194 |
1195 | #define yytable_value_is_error(Yyn) \
1196 | 0
1197 |
1198 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1199 | STATE-NUM. */
1200 | static const yytype_int16 yypact[] =
1201 | {
1202 | 1192, -406, -406, -406, -406, -406, -406, -406, -406, -1,
1203 | -406, -406, -406, -406, -406, 21, -406, -406, -406, 36,
1204 | -406, 53, 57, 61, 62, -406, 43, 120, 151, 1192,
1205 | -406, -406, 19, -406, 14, 104, -406, -406, 1450, 1450,
1206 | 1450, -406, -406, 386, 126, -406, -406, -406, -406, -406,
1207 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -406,
1208 | 1450, -406, 332, 106, -406, -406, 117, -406, -406, -406,
1209 | -406, -406, -406, 129, -406, -406, -406, 165, -406, -406,
1210 | -406, 188, -406, 43, 130, 39, -3, 144, -406, -406,
1211 | 120, -406, -406, -406, -406, 223, -406, -406, 78, 14,
1212 | 1450, 43, 332, 152, -406, -406, -406, -406, -406, -406,
1213 | 200, 1450, -406, 38, -406, 235, 417, -406, 417, -406,
1214 | 248, -406, -406, -406, -3, -406, -406, -406, -406, -406,
1215 | 187, 301, -406, 209, 1450, 205, -406, 1042, -406, -406,
1216 | -406, 1382, -406, 30, -406, 1257, 126, 218, 220, 237,
1217 | 417, -406, -406, 417, 251, 417, -406, 253, 264, -406,
1218 | 273, 248, 43, 235, -406, -406, 287, 1107, 1107, 1132,
1219 | 210, 636, 1107, 1107, 1107, 1107, 1107, 1107, -406, 281,
1220 | -406, -406, 1, 325, 279, 284, 278, 276, 140, 275,
1221 | 244, 103, 300, -406, -406, -406, -406, -406, -406, -406,
1222 | -406, -406, -406, 174, -406, -406, -406, -406, -406, -406,
1223 | -406, -406, -406, 353, -406, -406, -406, -406, -406, 306,
1224 | -406, -406, 466, -406, 137, 299, 313, -406, 314, -406,
1225 | -406, 68, 317, -406, 126, 11, -406, -406, -406, -406,
1226 | 318, -406, 326, -406, 248, 1042, 338, -406, 41, -406,
1227 | -406, -406, -406, -406, 636, -406, 316, -406, 328, 1042,
1228 | -406, 32, -406, -406, 192, 324, 193, 308, 333, 200,
1229 | -406, -406, -406, -406, -406, -406, 85, 1107, 755, 1107,
1230 | 1107, 1107, 1107, -406, -406, 1107, -406, -406, -406, -406,
1231 | 1107, -406, -406, 1107, -406, -406, 1107, -406, -406, -406,
1232 | 1107, -406, -406, -406, -406, -406, -406, -406, -406, -406,
1233 | -406, -406, 777, 328, -406, -406, 328, 1042, 802, 1042,
1234 | 336, 341, 342, 1042, -406, 339, 343, 344, 684, -406,
1235 | 415, 355, 359, 877, -406, -406, -406, -406, 466, -406,
1236 | -406, -406, -406, -406, -406, -406, -406, -406, 362, 363,
1237 | 364, -406, -406, -406, -406, -406, -406, -406, 371, -406,
1238 | 899, 1240, -406, 169, -406, 52, -406, 433, 1403, 330,
1239 | 28, 161, -406, -406, 11, 11, 1042, 368, 272, -406,
1240 | -406, -406, -406, -406, -406, -406, -406, -406, 365, -406,
1241 | -406, 369, 435, 210, -406, 301, -406, 301, 1287, -406,
1242 | 199, 1085, -406, -406, -406, -406, 89, 325, -406, 1107,
1243 | 374, 279, 284, 278, 276, 140, 275, 244, 103, -406,
1244 | 210, -406, -406, -406, 372, -406, 109, -406, -406, 438,
1245 | 1042, 1042, 1042, -1, 384, 375, 383, -406, -406, -406,
1246 | 385, 382, -406, -406, -406, -406, -406, -406, 379, -406,
1247 | 394, 399, 924, 1334, 169, -406, -406, -406, 402, 403,
1248 | 1042, 68, 68, 412, 280, 286, -406, -406, 1042, -406,
1249 | 11, 1085, -406, 1042, -406, -406, -406, 210, -406, 404,
1250 | 1042, -406, -406, 1107, 157, -406, -406, 1042, 405, 406,
1251 | 408, 410, 551, -406, -406, -406, -406, -406, -406, -406,
1252 | 413, -406, 414, 235, 235, 418, -406, 185, -406, -406,
1253 | -406, -406, -406, -406, 184, -406, -406, -406, -406, -406,
1254 | 684, 684, 684, 1042, 995, 43, 446, 420, -406, -406,
1255 | -406, 34, 46, -406, 235, 422, -406, 423, -406, -406,
1256 | 457, 1042, 427, 467, 684, 1020, 1042, 1042, 353, 115,
1257 | -406, 684, 470, -406, 1042, -406, 1042, 471, 462, 463,
1258 | 235, 474, -406, -406, -406, -406, 1042, -406, -406, 353,
1259 | -406, -406
1260 | };
1261 |
1262 | /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1263 | Performed when YYTABLE does not specify something else to do. Zero
1264 | means the default is an error. */
1265 | static const yytype_int16 yydefact[] =
1266 | {
1267 | 2, 67, 106, 77, 74, 76, 73, 75, 81, 82,
1268 | 107, 78, 101, 102, 103, 104, 99, 100, 92, 93,
1269 | 105, 0, 0, 0, 366, 251, 0, 59, 0, 3,
1270 | 4, 6, 0, 14, 0, 182, 63, 65, 15, 19,
1271 | 17, 83, 85, 86, 96, 87, 89, 91, 84, 110,
1272 | 111, 88, 126, 127, 90, 135, 136, 7, 168, 170,
1273 | 171, 175, 176, 0, 9, 8, 0, 368, 95, 94,
1274 | 133, 134, 128, 132, 142, 143, 137, 141, 124, 125,
1275 | 112, 123, 367, 0, 0, 0, 57, 66, 82, 61,
1276 | 60, 79, 1, 5, 13, 0, 21, 24, 25, 0,
1277 | 172, 0, 178, 69, 16, 20, 18, 104, 98, 97,
1278 | 0, 173, 10, 0, 180, 0, 144, 130, 144, 139,
1279 | 0, 114, 66, 64, 58, 177, 62, 80, 12, 22,
1280 | 0, 0, 27, 26, 174, 66, 68, 0, 207, 169,
1281 | 11, 183, 353, 0, 148, 0, 152, 126, 135, 0,
1282 | 145, 146, 151, 144, 0, 144, 122, 0, 116, 118,
1283 | 120, 0, 0, 0, 72, 350, 0, 0, 0, 0,
1284 | 32, 356, 0, 0, 0, 0, 0, 0, 29, 349,
1285 | 30, 257, 272, 275, 277, 279, 281, 283, 285, 289,
1286 | 295, 299, 303, 308, 309, 310, 311, 312, 313, 314,
1287 | 315, 316, 317, 318, 331, 338, 339, 332, 333, 334,
1288 | 335, 336, 337, 351, 352, 258, 28, 179, 359, 254,
1289 | 255, 70, 210, 186, 193, 0, 185, 184, 188, 190,
1290 | 354, 369, 0, 154, 156, 0, 149, 150, 129, 147,
1291 | 0, 138, 0, 113, 117, 0, 0, 23, 0, 244,
1292 | 245, 379, 325, 326, 356, 328, 72, 167, 0, 0,
1293 | 36, 0, 33, 41, 0, 0, 108, 0, 0, 0,
1294 | 323, 319, 330, 329, 320, 324, 0, 0, 0, 0,
1295 | 0, 0, 0, 287, 288, 0, 292, 294, 291, 293,
1296 | 0, 297, 298, 0, 301, 302, 0, 305, 306, 307,
1297 | 0, 262, 263, 264, 265, 266, 267, 268, 269, 270,
1298 | 271, 261, 0, 0, 346, 347, 0, 0, 0, 0,
1299 | 0, 72, 106, 0, 243, 0, 0, 0, 0, 224,
1300 | 0, 0, 0, 0, 215, 214, 196, 208, 211, 212,
1301 | 197, 217, 216, 198, 220, 221, 222, 199, 0, 0,
1302 | 0, 200, 201, 202, 203, 204, 205, 206, 0, 195,
1303 | 0, 0, 194, 47, 192, 45, 181, 0, 0, 0,
1304 | 0, 0, 370, 362, 0, 0, 0, 162, 0, 158,
1305 | 160, 161, 131, 140, 119, 121, 115, 378, 0, 166,
1306 | 39, 0, 43, 35, 31, 0, 42, 0, 0, 109,
1307 | 45, 0, 355, 357, 344, 360, 0, 276, 303, 0,
1308 | 0, 278, 280, 282, 284, 286, 290, 296, 300, 304,
1309 | 32, 259, 341, 340, 0, 342, 0, 256, 71, 241,
1310 | 0, 0, 0, 0, 0, 0, 0, 248, 247, 252,
1311 | 0, 0, 213, 238, 240, 239, 249, 49, 0, 53,
1312 | 0, 0, 0, 0, 46, 187, 189, 191, 0, 0,
1313 | 0, 0, 369, 0, 0, 0, 163, 165, 0, 153,
1314 | 0, 327, 40, 0, 34, 38, 37, 32, 321, 0,
1315 | 0, 345, 274, 0, 0, 348, 343, 0, 0, 0,
1316 | 0, 0, 0, 250, 253, 209, 51, 48, 55, 50,
1317 | 0, 54, 0, 0, 0, 0, 371, 0, 363, 155,
1318 | 157, 164, 159, 44, 0, 358, 361, 273, 260, 242,
1319 | 0, 0, 0, 0, 0, 236, 0, 0, 234, 52,
1320 | 56, 0, 0, 374, 375, 0, 322, 219, 246, 237,
1321 | 0, 226, 0, 235, 0, 0, 0, 0, 376, 0,
1322 | 364, 0, 0, 229, 228, 225, 227, 0, 0, 0,
1323 | 0, 0, 218, 223, 230, 231, 232, 372, 373, 377,
1324 | 365, 233
1325 | };
1326 |
1327 | /* YYPGOTO[NTERM-NUM]. */
1328 | static const yytype_int16 yypgoto[] =
1329 | {
1330 | -406, -406, -406, 511, 442, -52, 2, 5, 18, -406,
1331 | 388, -406, 411, -124, -405, 153, 283, -406, -406, -170,
1332 | -347, -32, 3, 4, -406, -406, -406, -406, -406, -406,
1333 | -11, 31, 93, -406, -406, -406, 508, -406, -406, -406,
1334 | 304, -406, -406, -406, -406, 398, -406, 319, -406, -406,
1335 | -406, -406, 222, -406, -406, -406, -406, -406, 249, -406,
1336 | -406, -406, -406, 64, -406, 416, -406, -406, -406, -406,
1337 | -22, 90, -406, -406, 94, -163, -406, -406, -406, -406,
1338 | 529, -406, 37, -406, -406, -406, -406, -135, -406, 196,
1339 | -315, -100, -406, -406, -406, -406, 227, -406, -406, -406,
1340 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -406,
1341 | 401, -406, -406, -406, -406, -406, 50, -406, -132, -406,
1342 | -119, -406, -398, -406, 291, 290, 293, 289, 294, -406,
1343 | 292, -406, 288, -406, 309, -406, 307, -406, -148, -406,
1344 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -406,
1345 | -406, -406, -406, -406, -406, -406, -406, -406, -406, -114,
1346 | -406, -406, -406, -250, 261, 76, -406, 142, 110, -406,
1347 | -406, -406
1348 | };
1349 |
1350 | /* YYDEFGOTO[NTERM-NUM]. */
1351 | static const yytype_int16 yydefgoto[] =
1352 | {
1353 | -1, 28, 29, 30, 111, 31, 113, 33, 95, 162,
1354 | 96, 97, 132, 260, 261, 262, 263, 264, 391, 450,
1355 | 363, 84, 85, 86, 36, 37, 137, 320, 179, 38,
1356 | 145, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1357 | 267, 48, 49, 120, 161, 157, 158, 159, 160, 50,
1358 | 81, 51, 52, 116, 153, 53, 73, 54, 55, 118,
1359 | 155, 56, 77, 149, 150, 151, 152, 235, 374, 375,
1360 | 378, 379, 380, 381, 466, 265, 57, 110, 58, 59,
1361 | 60, 61, 122, 141, 63, 225, 226, 451, 228, 229,
1362 | 335, 336, 222, 441, 337, 338, 339, 340, 341, 342,
1363 | 343, 344, 345, 435, 526, 527, 346, 347, 348, 349,
1364 | 350, 351, 352, 353, 354, 355, 356, 357, 358, 219,
1365 | 220, 312, 181, 182, 183, 184, 185, 186, 187, 285,
1366 | 188, 290, 189, 293, 190, 296, 191, 300, 192, 193,
1367 | 194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
1368 | 204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
1369 | 214, 269, 479, 221, 406, 359, 66, 371, 372, 549,
1370 | 133, 215
1371 | };
1372 |
1373 | /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1374 | positive, shift that token. If negative, reduce the rule whose
1375 | number is the opposite. If YYTABLE_NINF, syntax error. */
1376 | static const yytype_int16 yytable[] =
1377 | {
1378 | 98, 143, 32, 34, 35, 218, 227, 178, 112, 392,
1379 | 139, 482, 180, 434, 1, 484, 90, 1, 454, 252,
1380 | 253, 255, 1, 277, 270, 271, 272, 273, 274, 275,
1381 | 89, 32, 34, 35, 230, 99, 230, 62, 35, 268,
1382 | 230, 1, 1, 104, 105, 106, 1, 230, 112, 248,
1383 | 64, 180, 230, 454, 362, 1, 70, 71, 91, 140,
1384 | 74, 75, 67, 87, 78, 79, 62, 68, 103, 62,
1385 | -182, 102, 514, 429, 142, 109, 65, 278, 69, 64,
1386 | 376, 98, 140, 94, 83, 517, 27, 101, 164, 124,
1387 | 165, 142, 26, 126, 27, 390, 399, 393, 82, 231,
1388 | 394, 460, 94, 124, 232, 65, 166, 546, 167, 168,
1389 | 448, 83, 83, 27, 169, 387, 83, 370, 27, 547,
1390 | 72, 127, 268, 360, 76, 361, 385, 218, 80, 408,
1391 | 98, 408, 408, 408, 408, 234, 102, 408, 135, 369,
1392 | 1, 130, 408, 224, 131, 408, 410, 91, 408, 91,
1393 | 422, 92, 419, 423, 480, 8, 88, 405, 171, 404,
1394 | 172, 8, 88, 481, 173, 286, 287, 174, 175, 403,
1395 | 334, 176, 177, 266, 480, 103, 127, 91, 297, 114,
1396 | 560, 91, 154, 486, 91, 424, 91, 298, 299, 561,
1397 | 115, 218, 364, 421, 313, 27, 117, 314, 315, 405,
1398 | 427, 440, 500, 377, 123, 537, 538, 539, 360, 146,
1399 | 361, 146, 27, 256, 257, 165, 142, 240, 125, 242,
1400 | 288, 289, 393, 513, 136, 518, 461, 365, 218, 555,
1401 | 462, 166, 119, 167, 168, 463, 562, 519, 233, 169,
1402 | 452, 142, 453, 146, 316, 317, 146, 318, 146, 393,
1403 | 461, 156, 536, 478, 534, 121, 266, 467, 395, 535,
1404 | 163, 408, 258, 259, 360, 127, 398, 138, 27, 400,
1405 | 360, 475, 398, 476, 180, 131, 180, 170, 180, 217,
1406 | 258, 259, 236, 171, 237, 172, 334, 128, 129, 173,
1407 | 249, 250, 174, 175, 283, 284, 176, 177, 488, 489,
1408 | 490, 180, 291, 292, 164, 238, 165, 142, 301, 302,
1409 | 303, 304, 305, 306, 307, 308, 309, 310, 502, 241,
1410 | 218, 243, 166, 478, 167, 168, 294, 295, 505, 244,
1411 | 169, 389, 257, 458, 459, 408, 469, 470, 147, 245,
1412 | 147, 218, 377, 377, 509, 470, 279, 370, 370, 467,
1413 | 510, 470, 464, 465, 276, 218, 280, 282, 180, 230,
1414 | 528, 516, 281, 224, 365, 148, 311, 148, 170, 124,
1415 | 224, 319, 147, 366, 171, 147, 172, 147, 367, 368,
1416 | 173, 373, 401, 174, 175, -166, 382, 176, 177, 531,
1417 | 532, 540, 542, 397, 383, -66, -66, -66, -66, 148,
1418 | 224, 400, 148, -66, 148, -66, 386, 402, 428, 553,
1419 | -244, -245, 430, 557, 558, 559, 431, 432, 436, 437,
1420 | 548, 2, 564, 438, 565, 12, 13, 14, 107, 16,
1421 | 17, 443, 444, 445, 571, 446, 455, 468, 377, 471,
1422 | 491, 472, 473, 483, 485, 487, 569, 493, 492, 494,
1423 | 495, 496, 8, 88, 10, 224, 12, 13, 14, 15,
1424 | 16, 17, 18, 19, 20, 21, 22, 23, 497, 321,
1425 | 322, 165, 142, 498, 503, 504, 508, 551, 515, 520,
1426 | 521, 144, 522, 523, 545, 529, 550, 166, 530, 167,
1427 | 168, 554, 533, 98, 525, 169, 3, 4, 5, 6,
1428 | 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1429 | 17, 18, 19, 20, 21, 22, 23, 323, 324, 325,
1430 | 544, 326, 327, 328, 329, 330, 331, 332, 333, 24,
1431 | 25, 552, 129, 138, 563, 566, 567, 568, 570, 171,
1432 | 93, 172, 134, 543, 216, 173, 474, 396, 174, 175,
1433 | 247, 108, 176, 177, 164, 2, 165, 142, 388, 246,
1434 | 512, 100, 511, 384, 457, 442, 239, 251, 407, 411,
1435 | 413, 506, 166, 412, 167, 168, 414, 415, 416, 426,
1436 | 169, 3, 4, 5, 6, 7, 8, 88, 10, 11,
1437 | 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1438 | 22, 23, 417, 418, 507, 0, 0, 0, 0, 0,
1439 | 0, 0, 0, 0, 0, 524, 0, 0, 0, 0,
1440 | 0, 0, 0, 0, 171, 0, 172, 0, 0, 0,
1441 | 173, 0, 0, 174, 175, 0, 0, 176, 177, 164,
1442 | 2, 165, 142, 0, 0, 0, 0, 0, 0, 0,
1443 | 0, 0, 0, 0, 0, 0, 0, 166, 0, 167,
1444 | 168, 0, 0, 0, 0, 169, 3, 4, 5, 6,
1445 | 7, 8, 88, 10, 11, 12, 13, 14, 15, 16,
1446 | 17, 18, 19, 20, 21, 22, 23, 321, 250, 165,
1447 | 142, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1448 | 0, 0, 0, 0, 0, 166, 0, 167, 168, 171,
1449 | 0, 172, 0, 169, 0, 173, 0, 0, 174, 175,
1450 | 433, 0, 176, 177, 0, 0, 0, 0, 0, 0,
1451 | 0, 0, 0, 0, 0, 323, 324, 325, 0, 326,
1452 | 327, 328, 329, 330, 331, 332, 333, 24, 25, 0,
1453 | 0, 138, 0, 0, 0, 0, 0, 171, 164, 172,
1454 | 165, 142, 0, 173, 0, 0, 174, 175, 0, 0,
1455 | 176, 177, 0, 0, 0, 0, 166, 0, 167, 168,
1456 | 164, 0, 165, 142, 169, 0, 0, 0, 0, 0,
1457 | 0, 0, 0, 0, 0, 0, 0, 0, 166, 0,
1458 | 167, 168, 0, 0, 0, 164, 169, 165, 142, 0,
1459 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1460 | 0, 0, 0, 166, 409, 167, 168, 0, 171, 0,
1461 | 172, 169, 0, 0, 173, 0, 0, 174, 175, 0,
1462 | 0, 176, 177, 0, 420, 0, 0, 0, 0, 0,
1463 | 171, 0, 172, 0, 0, 0, 173, 0, 0, 174,
1464 | 175, 0, 0, 176, 177, 0, 0, 0, 0, 0,
1465 | 0, 0, 0, 0, 0, 171, 425, 172, 0, 0,
1466 | 164, 173, 165, 142, 174, 175, 0, 0, 176, 177,
1467 | 0, 0, 0, 0, 0, 0, 0, 0, 166, 0,
1468 | 167, 168, 164, 0, 165, 142, 169, 0, 0, 0,
1469 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1470 | 166, 0, 167, 168, 0, 0, 0, 164, 169, 165,
1471 | 142, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1472 | 0, 439, 0, 0, 0, 166, 0, 167, 168, 0,
1473 | 171, 0, 172, 169, 0, 0, 173, 0, 0, 174,
1474 | 175, 0, 0, 176, 177, 0, 0, 0, 0, 0,
1475 | 0, 447, 171, 0, 172, 0, 0, 0, 173, 0,
1476 | 0, 174, 175, 0, 0, 176, 177, 0, 0, 0,
1477 | 0, 0, 0, 0, 0, 0, 499, 171, 164, 172,
1478 | 165, 142, 0, 173, 0, 0, 174, 175, 0, 0,
1479 | 176, 177, 0, 0, 0, 0, 166, 0, 167, 168,
1480 | 0, 0, 0, 164, 169, 165, 142, 0, 0, 0,
1481 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1482 | 0, 166, 0, 167, 168, 164, 0, 165, 142, 169,
1483 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 541,
1484 | 0, 0, 0, 166, 0, 167, 168, 0, 171, 0,
1485 | 172, 169, 0, 0, 173, 0, 0, 174, 175, 0,
1486 | 0, 176, 177, 0, 556, 0, 0, 0, 164, 0,
1487 | 165, 142, 0, 171, 0, 172, 0, 0, 0, 173,
1488 | 0, 0, 174, 175, 0, 0, 176, 177, 167, 168,
1489 | 164, 0, 165, 142, 169, 171, 0, 172, 0, 0,
1490 | 0, 173, 0, 0, 174, 175, 0, 0, 176, 177,
1491 | 167, 168, 0, 0, 0, 164, 169, 165, 142, 0,
1492 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1493 | 0, 0, 477, 0, 0, 167, 168, 0, 171, 0,
1494 | 172, 169, 0, 0, 173, 0, 0, 174, 175, 0,
1495 | 0, 176, 177, 0, 0, 0, 0, 0, 0, 0,
1496 | 171, 0, 172, 0, 0, 0, 173, 0, 0, 174,
1497 | 175, 0, 0, 176, 177, 1, 2, 0, 0, 0,
1498 | 0, 0, 0, 0, 0, 254, 0, 172, 0, 0,
1499 | 0, 173, 0, 0, 174, 175, 0, 0, 176, 177,
1500 | 0, 0, 3, 4, 5, 6, 7, 8, 9, 10,
1501 | 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1502 | 21, 22, 23, 1, 2, 0, 0, 0, 0, 0,
1503 | 0, 0, 0, 0, 0, 24, 25, 0, 0, 0,
1504 | 0, 2, 0, 0, 0, 26, 0, 27, 0, 0,
1505 | 3, 4, 5, 6, 7, 8, 88, 10, 11, 12,
1506 | 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1507 | 23, 2, 8, 88, 10, 0, 12, 13, 14, 15,
1508 | 16, 17, 18, 19, 20, 21, 22, 23, 0, 0,
1509 | 0, 360, 0, 361, 449, 27, 0, 3, 4, 5,
1510 | 6, 7, 8, 88, 10, 11, 12, 13, 14, 15,
1511 | 16, 17, 18, 19, 20, 21, 22, 23, 2, 0,
1512 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1513 | 0, 0, 0, 0, 0, 0, 0, 0, 360, 0,
1514 | 398, 449, 27, 0, 3, 4, 5, 6, 7, 8,
1515 | 88, 10, 11, 12, 13, 14, 15, 16, 17, 18,
1516 | 19, 20, 21, 22, 23, 223, 2, 0, 0, 0,
1517 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1518 | 0, 0, 0, 0, 0, 0, 0, 2, 501, 0,
1519 | 456, 0, 3, 4, 5, 6, 7, 8, 88, 10,
1520 | 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1521 | 21, 22, 23, 3, 4, 5, 6, 7, 8, 88,
1522 | 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
1523 | 20, 21, 22, 23, 2, 0, 0, 0, 0, 0,
1524 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1525 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1526 | 3, 4, 5, 6, 7, 8, 88, 10, 11, 12,
1527 | 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1528 | 23
1529 | };
1530 |
1531 | static const yytype_int16 yycheck[] =
1532 | {
1533 | 32, 115, 0, 0, 0, 137, 141, 131, 60, 259,
1534 | 110, 409, 131, 328, 3, 420, 27, 3, 365, 167,
1535 | 168, 169, 3, 22, 172, 173, 174, 175, 176, 177,
1536 | 27, 29, 29, 29, 6, 32, 6, 0, 34, 171,
1537 | 6, 3, 3, 38, 39, 40, 3, 6, 100, 163,
1538 | 0, 170, 6, 400, 224, 3, 3, 4, 27, 111,
1539 | 3, 4, 63, 26, 3, 4, 29, 46, 71, 32,
1540 | 73, 34, 477, 323, 6, 44, 0, 76, 42, 29,
1541 | 69, 113, 134, 64, 73, 483, 75, 73, 3, 85,
1542 | 5, 6, 73, 90, 75, 258, 266, 65, 36, 69,
1543 | 68, 73, 64, 99, 74, 29, 21, 73, 23, 24,
1544 | 360, 73, 73, 75, 29, 74, 73, 231, 75, 73,
1545 | 67, 90, 254, 71, 67, 73, 245, 259, 67, 277,
1546 | 162, 279, 280, 281, 282, 146, 99, 285, 101, 71,
1547 | 3, 63, 290, 141, 66, 293, 278, 116, 296, 118,
1548 | 313, 0, 300, 316, 65, 35, 36, 276, 73, 74,
1549 | 75, 35, 36, 74, 79, 25, 26, 82, 83, 269,
1550 | 222, 86, 87, 171, 65, 71, 145, 146, 75, 73,
1551 | 65, 150, 118, 74, 153, 317, 155, 84, 85, 74,
1552 | 73, 323, 224, 312, 20, 75, 67, 23, 24, 318,
1553 | 319, 333, 452, 235, 74, 520, 521, 522, 71, 116,
1554 | 73, 118, 75, 3, 4, 5, 6, 153, 74, 155,
1555 | 80, 81, 65, 473, 72, 68, 65, 224, 360, 544,
1556 | 69, 21, 67, 23, 24, 74, 551, 487, 145, 29,
1557 | 71, 6, 73, 150, 70, 71, 153, 73, 155, 65,
1558 | 65, 3, 68, 401, 69, 67, 254, 376, 66, 74,
1559 | 73, 409, 70, 71, 71, 234, 73, 67, 75, 266,
1560 | 71, 395, 73, 397, 393, 66, 395, 67, 397, 74,
1561 | 70, 71, 64, 73, 64, 75, 338, 64, 65, 79,
1562 | 3, 4, 82, 83, 18, 19, 86, 87, 430, 431,
1563 | 432, 420, 27, 28, 3, 68, 5, 6, 8, 9,
1564 | 10, 11, 12, 13, 14, 15, 16, 17, 453, 68,
1565 | 452, 68, 21, 471, 23, 24, 82, 83, 460, 65,
1566 | 29, 3, 4, 3, 4, 483, 64, 65, 116, 66,
1567 | 118, 473, 374, 375, 64, 65, 21, 461, 462, 468,
1568 | 64, 65, 374, 375, 73, 487, 77, 79, 477, 6,
1569 | 492, 480, 78, 361, 361, 116, 66, 118, 67, 365,
1570 | 368, 65, 150, 74, 73, 153, 75, 155, 65, 65,
1571 | 79, 64, 74, 82, 83, 69, 68, 86, 87, 503,
1572 | 504, 523, 524, 69, 68, 63, 64, 65, 66, 150,
1573 | 398, 398, 153, 71, 155, 73, 68, 74, 72, 541,
1574 | 69, 69, 73, 545, 546, 547, 73, 73, 3, 64,
1575 | 534, 4, 554, 64, 556, 39, 40, 41, 42, 43,
1576 | 44, 69, 69, 69, 566, 64, 3, 69, 470, 74,
1577 | 56, 72, 7, 69, 72, 7, 560, 64, 73, 64,
1578 | 68, 72, 35, 36, 37, 453, 39, 40, 41, 42,
1579 | 43, 44, 45, 46, 47, 48, 49, 50, 74, 3,
1580 | 4, 5, 6, 74, 72, 72, 64, 54, 74, 74,
1581 | 74, 64, 74, 73, 64, 72, 64, 21, 74, 23,
1582 | 24, 64, 74, 525, 492, 29, 30, 31, 32, 33,
1583 | 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
1584 | 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1585 | 74, 55, 56, 57, 58, 59, 60, 61, 62, 63,
1586 | 64, 74, 65, 67, 64, 64, 74, 74, 64, 73,
1587 | 29, 75, 100, 525, 133, 79, 393, 264, 82, 83,
1588 | 162, 43, 86, 87, 3, 4, 5, 6, 254, 161,
1589 | 470, 32, 468, 244, 368, 338, 150, 166, 277, 279,
1590 | 281, 461, 21, 280, 23, 24, 282, 285, 290, 318,
1591 | 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1592 | 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1593 | 49, 50, 293, 296, 462, -1, -1, -1, -1, -1,
1594 | -1, -1, -1, -1, -1, 64, -1, -1, -1, -1,
1595 | -1, -1, -1, -1, 73, -1, 75, -1, -1, -1,
1596 | 79, -1, -1, 82, 83, -1, -1, 86, 87, 3,
1597 | 4, 5, 6, -1, -1, -1, -1, -1, -1, -1,
1598 | -1, -1, -1, -1, -1, -1, -1, 21, -1, 23,
1599 | 24, -1, -1, -1, -1, 29, 30, 31, 32, 33,
1600 | 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
1601 | 44, 45, 46, 47, 48, 49, 50, 3, 4, 5,
1602 | 6, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1603 | -1, -1, -1, -1, -1, 21, -1, 23, 24, 73,
1604 | -1, 75, -1, 29, -1, 79, -1, -1, 82, 83,
1605 | 36, -1, 86, 87, -1, -1, -1, -1, -1, -1,
1606 | -1, -1, -1, -1, -1, 51, 52, 53, -1, 55,
1607 | 56, 57, 58, 59, 60, 61, 62, 63, 64, -1,
1608 | -1, 67, -1, -1, -1, -1, -1, 73, 3, 75,
1609 | 5, 6, -1, 79, -1, -1, 82, 83, -1, -1,
1610 | 86, 87, -1, -1, -1, -1, 21, -1, 23, 24,
1611 | 3, -1, 5, 6, 29, -1, -1, -1, -1, -1,
1612 | -1, -1, -1, -1, -1, -1, -1, -1, 21, -1,
1613 | 23, 24, -1, -1, -1, 3, 29, 5, 6, -1,
1614 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1615 | -1, -1, -1, 21, 69, 23, 24, -1, 73, -1,
1616 | 75, 29, -1, -1, 79, -1, -1, 82, 83, -1,
1617 | -1, 86, 87, -1, 67, -1, -1, -1, -1, -1,
1618 | 73, -1, 75, -1, -1, -1, 79, -1, -1, 82,
1619 | 83, -1, -1, 86, 87, -1, -1, -1, -1, -1,
1620 | -1, -1, -1, -1, -1, 73, 74, 75, -1, -1,
1621 | 3, 79, 5, 6, 82, 83, -1, -1, 86, 87,
1622 | -1, -1, -1, -1, -1, -1, -1, -1, 21, -1,
1623 | 23, 24, 3, -1, 5, 6, 29, -1, -1, -1,
1624 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1625 | 21, -1, 23, 24, -1, -1, -1, 3, 29, 5,
1626 | 6, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1627 | -1, 64, -1, -1, -1, 21, -1, 23, 24, -1,
1628 | 73, -1, 75, 29, -1, -1, 79, -1, -1, 82,
1629 | 83, -1, -1, 86, 87, -1, -1, -1, -1, -1,
1630 | -1, 72, 73, -1, 75, -1, -1, -1, 79, -1,
1631 | -1, 82, 83, -1, -1, 86, 87, -1, -1, -1,
1632 | -1, -1, -1, -1, -1, -1, 72, 73, 3, 75,
1633 | 5, 6, -1, 79, -1, -1, 82, 83, -1, -1,
1634 | 86, 87, -1, -1, -1, -1, 21, -1, 23, 24,
1635 | -1, -1, -1, 3, 29, 5, 6, -1, -1, -1,
1636 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1637 | -1, 21, -1, 23, 24, 3, -1, 5, 6, 29,
1638 | -1, -1, -1, -1, -1, -1, -1, -1, -1, 64,
1639 | -1, -1, -1, 21, -1, 23, 24, -1, 73, -1,
1640 | 75, 29, -1, -1, 79, -1, -1, 82, 83, -1,
1641 | -1, 86, 87, -1, 64, -1, -1, -1, 3, -1,
1642 | 5, 6, -1, 73, -1, 75, -1, -1, -1, 79,
1643 | -1, -1, 82, 83, -1, -1, 86, 87, 23, 24,
1644 | 3, -1, 5, 6, 29, 73, -1, 75, -1, -1,
1645 | -1, 79, -1, -1, 82, 83, -1, -1, 86, 87,
1646 | 23, 24, -1, -1, -1, 3, 29, 5, 6, -1,
1647 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1648 | -1, -1, 67, -1, -1, 23, 24, -1, 73, -1,
1649 | 75, 29, -1, -1, 79, -1, -1, 82, 83, -1,
1650 | -1, 86, 87, -1, -1, -1, -1, -1, -1, -1,
1651 | 73, -1, 75, -1, -1, -1, 79, -1, -1, 82,
1652 | 83, -1, -1, 86, 87, 3, 4, -1, -1, -1,
1653 | -1, -1, -1, -1, -1, 73, -1, 75, -1, -1,
1654 | -1, 79, -1, -1, 82, 83, -1, -1, 86, 87,
1655 | -1, -1, 30, 31, 32, 33, 34, 35, 36, 37,
1656 | 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1657 | 48, 49, 50, 3, 4, -1, -1, -1, -1, -1,
1658 | -1, -1, -1, -1, -1, 63, 64, -1, -1, -1,
1659 | -1, 4, -1, -1, -1, 73, -1, 75, -1, -1,
1660 | 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1661 | 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1662 | 50, 4, 35, 36, 37, -1, 39, 40, 41, 42,
1663 | 43, 44, 45, 46, 47, 48, 49, 50, -1, -1,
1664 | -1, 71, -1, 73, 74, 75, -1, 30, 31, 32,
1665 | 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1666 | 43, 44, 45, 46, 47, 48, 49, 50, 4, -1,
1667 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1668 | -1, -1, -1, -1, -1, -1, -1, -1, 71, -1,
1669 | 73, 74, 75, -1, 30, 31, 32, 33, 34, 35,
1670 | 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1671 | 46, 47, 48, 49, 50, 3, 4, -1, -1, -1,
1672 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1673 | -1, -1, -1, -1, -1, -1, -1, 4, 74, -1,
1674 | 7, -1, 30, 31, 32, 33, 34, 35, 36, 37,
1675 | 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1676 | 48, 49, 50, 30, 31, 32, 33, 34, 35, 36,
1677 | 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1678 | 47, 48, 49, 50, 4, -1, -1, -1, -1, -1,
1679 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1680 | -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1681 | 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1682 | 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
1683 | 50
1684 | };
1685 |
1686 | /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1687 | symbol of state STATE-NUM. */
1688 | static const yytype_int16 yystos[] =
1689 | {
1690 | 0, 3, 4, 30, 31, 32, 33, 34, 35, 36,
1691 | 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
1692 | 47, 48, 49, 50, 63, 64, 73, 75, 89, 90,
1693 | 91, 93, 94, 95, 110, 111, 112, 113, 117, 119,
1694 | 120, 121, 122, 123, 124, 125, 126, 127, 129, 130,
1695 | 137, 139, 140, 143, 145, 146, 149, 164, 166, 167,
1696 | 168, 169, 170, 172, 204, 253, 254, 63, 46, 42,
1697 | 3, 4, 67, 144, 3, 4, 67, 150, 3, 4,
1698 | 67, 138, 36, 73, 109, 110, 111, 170, 36, 110,
1699 | 118, 119, 0, 91, 64, 96, 98, 99, 109, 110,
1700 | 168, 73, 170, 71, 95, 95, 95, 42, 124, 119,
1701 | 165, 92, 93, 94, 73, 73, 141, 67, 147, 67,
1702 | 131, 67, 170, 74, 111, 74, 110, 119, 64, 65,
1703 | 63, 66, 100, 258, 92, 170, 72, 114, 67, 179,
1704 | 93, 171, 6, 247, 64, 118, 120, 140, 146, 151,
1705 | 152, 153, 154, 142, 151, 148, 3, 133, 134, 135,
1706 | 136, 132, 97, 73, 3, 5, 21, 23, 24, 29,
1707 | 67, 73, 75, 79, 82, 83, 86, 87, 101, 116,
1708 | 208, 210, 211, 212, 213, 214, 215, 216, 218, 220,
1709 | 222, 224, 226, 227, 228, 229, 230, 231, 232, 233,
1710 | 234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
1711 | 244, 245, 246, 247, 248, 259, 100, 74, 206, 207,
1712 | 208, 251, 180, 3, 94, 173, 174, 175, 176, 177,
1713 | 6, 69, 74, 120, 118, 155, 64, 64, 68, 153,
1714 | 151, 68, 151, 68, 65, 66, 133, 98, 247, 3,
1715 | 4, 198, 226, 226, 73, 226, 3, 4, 70, 71,
1716 | 101, 102, 103, 104, 105, 163, 94, 128, 206, 249,
1717 | 226, 226, 226, 226, 226, 226, 73, 22, 76, 21,
1718 | 77, 78, 79, 18, 19, 217, 25, 26, 80, 81,
1719 | 219, 27, 28, 221, 82, 83, 223, 75, 84, 85,
1720 | 225, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1721 | 17, 66, 209, 20, 23, 24, 70, 71, 73, 65,
1722 | 115, 3, 4, 51, 52, 53, 55, 56, 57, 58,
1723 | 59, 60, 61, 62, 93, 178, 179, 182, 183, 184,
1724 | 185, 186, 187, 188, 189, 190, 194, 195, 196, 197,
1725 | 198, 199, 200, 201, 202, 203, 204, 205, 206, 253,
1726 | 71, 73, 107, 108, 109, 110, 74, 65, 65, 71,
1727 | 247, 255, 256, 64, 156, 157, 69, 109, 158, 159,
1728 | 160, 161, 68, 68, 135, 208, 68, 74, 128, 3,
1729 | 163, 106, 251, 65, 68, 66, 104, 69, 73, 107,
1730 | 110, 74, 74, 179, 74, 208, 252, 212, 226, 69,
1731 | 206, 213, 214, 215, 216, 218, 220, 222, 224, 226,
1732 | 67, 208, 163, 163, 206, 74, 252, 208, 72, 251,
1733 | 73, 73, 73, 36, 178, 191, 3, 64, 64, 64,
1734 | 206, 181, 184, 69, 69, 69, 64, 72, 251, 74,
1735 | 107, 175, 71, 73, 108, 3, 7, 177, 3, 4,
1736 | 73, 65, 69, 74, 158, 158, 162, 208, 69, 64,
1737 | 65, 74, 72, 7, 103, 101, 101, 67, 226, 250,
1738 | 65, 74, 210, 69, 102, 72, 74, 7, 206, 206,
1739 | 206, 56, 73, 64, 64, 68, 72, 74, 74, 72,
1740 | 251, 74, 175, 72, 72, 206, 256, 255, 64, 64,
1741 | 64, 162, 159, 251, 102, 74, 208, 210, 68, 251,
1742 | 74, 74, 74, 73, 64, 94, 192, 193, 206, 72,
1743 | 74, 247, 247, 74, 69, 74, 68, 178, 178, 178,
1744 | 206, 64, 206, 96, 74, 64, 73, 73, 247, 257,
1745 | 64, 54, 74, 206, 64, 178, 64, 206, 206, 206,
1746 | 65, 74, 178, 64, 206, 206, 64, 74, 74, 247,
1747 | 64, 206
1748 | };
1749 |
1750 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1751 | static const yytype_int16 yyr1[] =
1752 | {
1753 | 0, 88, 89, 89, 90, 90, 91, 91, 91, 91,
1754 | 92, 92, 93, 93, 94, 95, 95, 95, 95, 95,
1755 | 95, 96, 97, 96, 98, 99, 99, 99, 99, 100,
1756 | 101, 101, 102, 102, 102, 102, 103, 103, 103, 104,
1757 | 104, 105, 105, 106, 106, 107, 107, 107, 108, 108,
1758 | 108, 108, 108, 108, 108, 108, 108, 109, 109, 110,
1759 | 110, 110, 110, 111, 111, 111, 111, 112, 113, 114,
1760 | 115, 113, 116, 117, 117, 117, 117, 117, 117, 118,
1761 | 118, 119, 119, 120, 121, 121, 121, 121, 121, 121,
1762 | 121, 121, 122, 122, 122, 122, 123, 123, 123, 124,
1763 | 124, 124, 124, 124, 124, 125, 126, 127, 128, 128,
1764 | 129, 129, 131, 130, 132, 130, 133, 133, 134, 134,
1765 | 135, 135, 136, 137, 138, 138, 139, 139, 141, 140,
1766 | 142, 140, 143, 144, 144, 145, 145, 147, 146, 148,
1767 | 146, 149, 150, 150, 151, 151, 152, 152, 153, 153,
1768 | 153, 153, 155, 154, 156, 154, 157, 154, 158, 158,
1769 | 159, 159, 160, 161, 161, 162, 163, 163, 165, 164,
1770 | 166, 167, 167, 167, 167, 168, 169, 169, 169, 169,
1771 | 171, 170, 172, 173, 173, 173, 174, 174, 175, 175,
1772 | 176, 176, 177, 177, 177, 178, 178, 178, 178, 178,
1773 | 178, 178, 178, 178, 178, 178, 178, 180, 181, 179,
1774 | 182, 182, 183, 183, 184, 184, 185, 185, 186, 187,
1775 | 188, 188, 188, 189, 191, 190, 192, 192, 192, 192,
1776 | 192, 192, 192, 192, 193, 193, 193, 194, 195, 195,
1777 | 195, 196, 196, 197, 198, 198, 199, 200, 201, 202,
1778 | 203, 204, 205, 205, 206, 207, 207, 208, 208, 208,
1779 | 208, 209, 209, 209, 209, 209, 209, 209, 209, 209,
1780 | 209, 209, 210, 210, 210, 211, 211, 212, 212, 213,
1781 | 213, 214, 214, 215, 215, 216, 216, 217, 217, 218,
1782 | 218, 219, 219, 219, 219, 220, 220, 221, 221, 222,
1783 | 222, 223, 223, 224, 224, 225, 225, 225, 226, 226,
1784 | 226, 226, 226, 226, 226, 226, 226, 226, 226, 227,
1785 | 228, 229, 229, 230, 231, 232, 233, 234, 234, 235,
1786 | 236, 237, 237, 237, 237, 237, 237, 237, 238, 238,
1787 | 239, 240, 241, 241, 242, 242, 243, 244, 245, 246,
1788 | 246, 246, 246, 247, 247, 248, 249, 250, 248, 251,
1789 | 252, 252, 253, 253, 253, 253, 254, 254, 254, 255,
1790 | 255, 255, 256, 256, 256, 257, 257, 257, 258, 259
1791 | };
1792 |
1793 | /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1794 | static const yytype_int8 yyr2[] =
1795 | {
1796 | 0, 2, 0, 1, 1, 2, 1, 1, 1, 1,
1797 | 1, 2, 3, 2, 1, 1, 2, 1, 2, 1,
1798 | 2, 1, 0, 4, 1, 1, 2, 2, 3, 2,
1799 | 1, 3, 0, 1, 3, 2, 1, 3, 3, 2,
1800 | 3, 1, 2, 1, 3, 1, 2, 1, 3, 2,
1801 | 3, 3, 4, 2, 3, 3, 4, 1, 2, 1,
1802 | 2, 2, 3, 1, 3, 1, 1, 1, 3, 0,
1803 | 0, 6, 1, 1, 1, 1, 1, 1, 1, 1,
1804 | 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1805 | 1, 1, 1, 1, 2, 2, 1, 2, 2, 1,
1806 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
1807 | 1, 1, 0, 5, 0, 6, 1, 2, 1, 3,
1808 | 1, 3, 1, 2, 1, 1, 1, 1, 0, 5,
1809 | 0, 6, 2, 1, 1, 1, 1, 0, 5, 0,
1810 | 6, 2, 1, 1, 0, 1, 1, 2, 1, 2,
1811 | 2, 1, 0, 4, 0, 5, 0, 5, 1, 3,
1812 | 1, 1, 1, 2, 3, 1, 1, 1, 0, 3,
1813 | 1, 1, 2, 2, 3, 1, 1, 3, 2, 4,
1814 | 0, 5, 1, 0, 1, 1, 1, 3, 1, 3,
1815 | 1, 3, 2, 1, 2, 1, 1, 1, 1, 1,
1816 | 1, 1, 1, 1, 1, 1, 1, 0, 0, 5,
1817 | 0, 1, 1, 2, 1, 1, 1, 1, 7, 5,
1818 | 1, 1, 1, 7, 0, 6, 2, 3, 3, 3,
1819 | 4, 4, 4, 5, 1, 2, 1, 5, 2, 2,
1820 | 2, 2, 4, 1, 1, 1, 5, 2, 2, 2,
1821 | 3, 1, 2, 3, 1, 1, 3, 1, 1, 3,
1822 | 5, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1823 | 1, 1, 1, 5, 4, 1, 3, 1, 3, 1,
1824 | 3, 1, 3, 1, 3, 1, 3, 1, 1, 1,
1825 | 3, 1, 1, 1, 1, 1, 3, 1, 1, 1,
1826 | 3, 1, 1, 1, 3, 1, 1, 1, 1, 1,
1827 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
1828 | 2, 4, 6, 2, 2, 2, 2, 4, 2, 2,
1829 | 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1830 | 3, 3, 3, 4, 3, 4, 2, 2, 4, 1,
1831 | 1, 1, 1, 1, 2, 3, 0, 0, 5, 1,
1832 | 1, 3, 5, 7, 9, 11, 1, 2, 2, 0,
1833 | 1, 3, 7, 7, 4, 0, 1, 3, 4, 2
1834 | };
1835 |
1836 |
1837 | enum { YYENOMEM = -2 };
1838 |
1839 | #define yyerrok (yyerrstatus = 0)
1840 | #define yyclearin (yychar = YYEMPTY)
1841 |
1842 | #define YYACCEPT goto yyacceptlab
1843 | #define YYABORT goto yyabortlab
1844 | #define YYERROR goto yyerrorlab
1845 |
1846 |
1847 | #define YYRECOVERING() (!!yyerrstatus)
1848 |
1849 | #define YYBACKUP(Token, Value) \
1850 | do \
1851 | if (yychar == YYEMPTY) \
1852 | { \
1853 | yychar = (Token); \
1854 | yylval = (Value); \
1855 | YYPOPSTACK (yylen); \
1856 | yystate = *yyssp; \
1857 | goto yybackup; \
1858 | } \
1859 | else \
1860 | { \
1861 | yyerror (YY_("syntax error: cannot back up")); \
1862 | YYERROR; \
1863 | } \
1864 | while (0)
1865 |
1866 | /* Backward compatibility with an undocumented macro.
1867 | Use YYerror or YYUNDEF. */
1868 | #define YYERRCODE YYUNDEF
1869 |
1870 |
1871 | /* Enable debugging if requested. */
1872 | #if YYDEBUG
1873 |
1874 | # ifndef YYFPRINTF
1875 | # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1876 | # define YYFPRINTF fprintf
1877 | # endif
1878 |
1879 | # define YYDPRINTF(Args) \
1880 | do { \
1881 | if (yydebug) \
1882 | YYFPRINTF Args; \
1883 | } while (0)
1884 |
1885 | /* This macro is provided for backward compatibility. */
1886 | # ifndef YY_LOCATION_PRINT
1887 | # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1888 | # endif
1889 |
1890 |
1891 | # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
1892 | do { \
1893 | if (yydebug) \
1894 | { \
1895 | YYFPRINTF (stderr, "%s ", Title); \
1896 | yy_symbol_print (stderr, \
1897 | Kind, Value); \
1898 | YYFPRINTF (stderr, "\n"); \
1899 | } \
1900 | } while (0)
1901 |
1902 |
1903 | /*-----------------------------------.
1904 | | Print this symbol's value on YYO. |
1905 | `-----------------------------------*/
1906 |
1907 | static void
1908 | yy_symbol_value_print (FILE *yyo,
1909 | yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1910 | {
1911 | FILE *yyoutput = yyo;
1912 | YYUSE (yyoutput);
1913 | if (!yyvaluep)
1914 | return;
1915 | # ifdef YYPRINT
1916 | if (yykind < YYNTOKENS)
1917 | YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
1918 | # endif
1919 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1920 | YYUSE (yykind);
1921 | YY_IGNORE_MAYBE_UNINITIALIZED_END
1922 | }
1923 |
1924 |
1925 | /*---------------------------.
1926 | | Print this symbol on YYO. |
1927 | `---------------------------*/
1928 |
1929 | static void
1930 | yy_symbol_print (FILE *yyo,
1931 | yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1932 | {
1933 | YYFPRINTF (yyo, "%s %s (",
1934 | yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1935 |
1936 | yy_symbol_value_print (yyo, yykind, yyvaluep);
1937 | YYFPRINTF (yyo, ")");
1938 | }
1939 |
1940 | /*------------------------------------------------------------------.
1941 | | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1942 | | TOP (included). |
1943 | `------------------------------------------------------------------*/
1944 |
1945 | static void
1946 | yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1947 | {
1948 | YYFPRINTF (stderr, "Stack now");
1949 | for (; yybottom <= yytop; yybottom++)
1950 | {
1951 | int yybot = *yybottom;
1952 | YYFPRINTF (stderr, " %d", yybot);
1953 | }
1954 | YYFPRINTF (stderr, "\n");
1955 | }
1956 |
1957 | # define YY_STACK_PRINT(Bottom, Top) \
1958 | do { \
1959 | if (yydebug) \
1960 | yy_stack_print ((Bottom), (Top)); \
1961 | } while (0)
1962 |
1963 |
1964 | /*------------------------------------------------.
1965 | | Report that the YYRULE is going to be reduced. |
1966 | `------------------------------------------------*/
1967 |
1968 | static void
1969 | yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
1970 | int yyrule)
1971 | {
1972 | int yylno = yyrline[yyrule];
1973 | int yynrhs = yyr2[yyrule];
1974 | int yyi;
1975 | YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1976 | yyrule - 1, yylno);
1977 | /* The symbols being reduced. */
1978 | for (yyi = 0; yyi < yynrhs; yyi++)
1979 | {
1980 | YYFPRINTF (stderr, " $%d = ", yyi + 1);
1981 | yy_symbol_print (stderr,
1982 | YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1983 | &yyvsp[(yyi + 1) - (yynrhs)]);
1984 | YYFPRINTF (stderr, "\n");
1985 | }
1986 | }
1987 |
1988 | # define YY_REDUCE_PRINT(Rule) \
1989 | do { \
1990 | if (yydebug) \
1991 | yy_reduce_print (yyssp, yyvsp, Rule); \
1992 | } while (0)
1993 |
1994 | /* Nonzero means print parse trace. It is left uninitialized so that
1995 | multiple parsers can coexist. */
1996 | int yydebug;
1997 | #else /* !YYDEBUG */
1998 | # define YYDPRINTF(Args) ((void) 0)
1999 | # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
2000 | # define YY_STACK_PRINT(Bottom, Top)
2001 | # define YY_REDUCE_PRINT(Rule)
2002 | #endif /* !YYDEBUG */
2003 |
2004 |
2005 | /* YYINITDEPTH -- initial size of the parser's stacks. */
2006 | #ifndef YYINITDEPTH
2007 | # define YYINITDEPTH 200
2008 | #endif
2009 |
2010 | /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2011 | if the built-in stack extension method is used).
2012 |
2013 | Do not make this value too large; the results are undefined if
2014 | YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2015 | evaluated with infinite-precision integer arithmetic. */
2016 |
2017 | #ifndef YYMAXDEPTH
2018 | # define YYMAXDEPTH 10000
2019 | #endif
2020 |
2021 |
2022 |
2023 |
2024 |
2025 |
2026 | /*-----------------------------------------------.
2027 | | Release the memory associated to this symbol. |
2028 | `-----------------------------------------------*/
2029 |
2030 | static void
2031 | yydestruct (const char *yymsg,
2032 | yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
2033 | {
2034 | YYUSE (yyvaluep);
2035 | if (!yymsg)
2036 | yymsg = "Deleting";
2037 | YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
2038 |
2039 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2040 | YYUSE (yykind);
2041 | YY_IGNORE_MAYBE_UNINITIALIZED_END
2042 | }
2043 |
2044 |
2045 | /* Lookahead token kind. */
2046 | int yychar;
2047 |
2048 | /* The semantic value of the lookahead symbol. */
2049 | YYSTYPE yylval;
2050 | /* Number of syntax errors so far. */
2051 | int yynerrs;
2052 |
2053 |
2054 |
2055 |
2056 | /*----------.
2057 | | yyparse. |
2058 | `----------*/
2059 |
2060 | int
2061 | yyparse (void)
2062 | {
2063 | yy_state_fast_t yystate = 0;
2064 | /* Number of tokens to shift before error messages enabled. */
2065 | int yyerrstatus = 0;
2066 |
2067 | /* Refer to the stacks through separate pointers, to allow yyoverflow
2068 | to reallocate them elsewhere. */
2069 |
2070 | /* Their size. */
2071 | YYPTRDIFF_T yystacksize = YYINITDEPTH;
2072 |
2073 | /* The state stack: array, bottom, top. */
2074 | yy_state_t yyssa[YYINITDEPTH];
2075 | yy_state_t *yyss = yyssa;
2076 | yy_state_t *yyssp = yyss;
2077 |
2078 | /* The semantic value stack: array, bottom, top. */
2079 | YYSTYPE yyvsa[YYINITDEPTH];
2080 | YYSTYPE *yyvs = yyvsa;
2081 | YYSTYPE *yyvsp = yyvs;
2082 |
2083 | int yyn;
2084 | /* The return value of yyparse. */
2085 | int yyresult;
2086 | /* Lookahead symbol kind. */
2087 | yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
2088 | /* The variables used to return semantic value and location from the
2089 | action routines. */
2090 | YYSTYPE yyval;
2091 |
2092 |
2093 |
2094 | #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2095 |
2096 | /* The number of symbols on the RHS of the reduced rule.
2097 | Keep to zero when no symbol should be popped. */
2098 | int yylen = 0;
2099 |
2100 | YYDPRINTF ((stderr, "Starting parse\n"));
2101 |
2102 | yychar = YYEMPTY; /* Cause a token to be read. */
2103 | goto yysetstate;
2104 |
2105 |
2106 | /*------------------------------------------------------------.
2107 | | yynewstate -- push a new state, which is found in yystate. |
2108 | `------------------------------------------------------------*/
2109 | yynewstate:
2110 | /* In all cases, when you get here, the value and location stacks
2111 | have just been pushed. So pushing a state here evens the stacks. */
2112 | yyssp++;
2113 |
2114 |
2115 | /*--------------------------------------------------------------------.
2116 | | yysetstate -- set current state (the top of the stack) to yystate. |
2117 | `--------------------------------------------------------------------*/
2118 | yysetstate:
2119 | YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2120 | YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
2121 | YY_IGNORE_USELESS_CAST_BEGIN
2122 | *yyssp = YY_CAST (yy_state_t, yystate);
2123 | YY_IGNORE_USELESS_CAST_END
2124 | YY_STACK_PRINT (yyss, yyssp);
2125 |
2126 | if (yyss + yystacksize - 1 <= yyssp)
2127 | #if !defined yyoverflow && !defined YYSTACK_RELOCATE
2128 | goto yyexhaustedlab;
2129 | #else
2130 | {
2131 | /* Get the current used size of the three stacks, in elements. */
2132 | YYPTRDIFF_T yysize = yyssp - yyss + 1;
2133 |
2134 | # if defined yyoverflow
2135 | {
2136 | /* Give user a chance to reallocate the stack. Use copies of
2137 | these so that the &'s don't force the real ones into
2138 | memory. */
2139 | yy_state_t *yyss1 = yyss;
2140 | YYSTYPE *yyvs1 = yyvs;
2141 |
2142 | /* Each stack pointer address is followed by the size of the
2143 | data in use in that stack, in bytes. This used to be a
2144 | conditional around just the two extra args, but that might
2145 | be undefined if yyoverflow is a macro. */
2146 | yyoverflow (YY_("memory exhausted"),
2147 | &yyss1, yysize * YYSIZEOF (*yyssp),
2148 | &yyvs1, yysize * YYSIZEOF (*yyvsp),
2149 | &yystacksize);
2150 | yyss = yyss1;
2151 | yyvs = yyvs1;
2152 | }
2153 | # else /* defined YYSTACK_RELOCATE */
2154 | /* Extend the stack our own way. */
2155 | if (YYMAXDEPTH <= yystacksize)
2156 | goto yyexhaustedlab;
2157 | yystacksize *= 2;
2158 | if (YYMAXDEPTH < yystacksize)
2159 | yystacksize = YYMAXDEPTH;
2160 |
2161 | {
2162 | yy_state_t *yyss1 = yyss;
2163 | union yyalloc *yyptr =
2164 | YY_CAST (union yyalloc *,
2165 | YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
2166 | if (! yyptr)
2167 | goto yyexhaustedlab;
2168 | YYSTACK_RELOCATE (yyss_alloc, yyss);
2169 | YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2170 | # undef YYSTACK_RELOCATE
2171 | if (yyss1 != yyssa)
2172 | YYSTACK_FREE (yyss1);
2173 | }
2174 | # endif
2175 |
2176 | yyssp = yyss + yysize - 1;
2177 | yyvsp = yyvs + yysize - 1;
2178 |
2179 | YY_IGNORE_USELESS_CAST_BEGIN
2180 | YYDPRINTF ((stderr, "Stack size increased to %ld\n",
2181 | YY_CAST (long, yystacksize)));
2182 | YY_IGNORE_USELESS_CAST_END
2183 |
2184 | if (yyss + yystacksize - 1 <= yyssp)
2185 | YYABORT;
2186 | }
2187 | #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
2188 |
2189 | if (yystate == YYFINAL)
2190 | YYACCEPT;
2191 |
2192 | goto yybackup;
2193 |
2194 |
2195 | /*-----------.
2196 | | yybackup. |
2197 | `-----------*/
2198 | yybackup:
2199 | /* Do appropriate processing given the current state. Read a
2200 | lookahead token if we need one and don't already have one. */
2201 |
2202 | /* First try to decide what to do without reference to lookahead token. */
2203 | yyn = yypact[yystate];
2204 | if (yypact_value_is_default (yyn))
2205 | goto yydefault;
2206 |
2207 | /* Not known => get a lookahead token if don't already have one. */
2208 |
2209 | /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
2210 | if (yychar == YYEMPTY)
2211 | {
2212 | YYDPRINTF ((stderr, "Reading a token\n"));
2213 | yychar = yylex ();
2214 | }
2215 |
2216 | if (yychar <= YYEOF)
2217 | {
2218 | yychar = YYEOF;
2219 | yytoken = YYSYMBOL_YYEOF;
2220 | YYDPRINTF ((stderr, "Now at end of input.\n"));
2221 | }
2222 | else if (yychar == YYerror)
2223 | {
2224 | /* The scanner already issued an error message, process directly
2225 | to error recovery. But do not keep the error token as
2226 | lookahead, it is too special and may lead us to an endless
2227 | loop in error recovery. */
2228 | yychar = YYUNDEF;
2229 | yytoken = YYSYMBOL_YYerror;
2230 | goto yyerrlab1;
2231 | }
2232 | else
2233 | {
2234 | yytoken = YYTRANSLATE (yychar);
2235 | YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2236 | }
2237 |
2238 | /* If the proper action on seeing token YYTOKEN is to reduce or to
2239 | detect an error, take that action. */
2240 | yyn += yytoken;
2241 | if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2242 | goto yydefault;
2243 | yyn = yytable[yyn];
2244 | if (yyn <= 0)
2245 | {
2246 | if (yytable_value_is_error (yyn))
2247 | goto yyerrlab;
2248 | yyn = -yyn;
2249 | goto yyreduce;
2250 | }
2251 |
2252 | /* Count tokens shifted since error; after three, turn off error
2253 | status. */
2254 | if (yyerrstatus)
2255 | yyerrstatus--;
2256 |
2257 | /* Shift the lookahead token. */
2258 | YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2259 | yystate = yyn;
2260 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2261 | *++yyvsp = yylval;
2262 | YY_IGNORE_MAYBE_UNINITIALIZED_END
2263 |
2264 | /* Discard the shifted token. */
2265 | yychar = YYEMPTY;
2266 | goto yynewstate;
2267 |
2268 |
2269 | /*-----------------------------------------------------------.
2270 | | yydefault -- do the default action for the current state. |
2271 | `-----------------------------------------------------------*/
2272 | yydefault:
2273 | yyn = yydefact[yystate];
2274 | if (yyn == 0)
2275 | goto yyerrlab;
2276 | goto yyreduce;
2277 |
2278 |
2279 | /*-----------------------------.
2280 | | yyreduce -- do a reduction. |
2281 | `-----------------------------*/
2282 | yyreduce:
2283 | /* yyn is the number of a rule to reduce with. */
2284 | yylen = yyr2[yyn];
2285 |
2286 | /* If YYLEN is nonzero, implement the default value of the action:
2287 | '$$ = $1'.
2288 |
2289 | Otherwise, the following line sets YYVAL to garbage.
2290 | This behavior is undocumented and Bison
2291 | users should not rely upon it. Assigning to YYVAL
2292 | unconditionally makes the parser a bit smaller, and it avoids a
2293 | GCC warning that YYVAL may be used uninitialized. */
2294 | yyval = yyvsp[1-yylen];
2295 |
2296 |
2297 | YY_REDUCE_PRINT (yyn);
2298 | switch (yyn)
2299 | {
2300 | case 6: /* top_level_declaration: declaration */
2301 | #line 178 "./parse.y"
2302 | { scope=0; reset(); common_comment=NULL; in_typedef=0; GetCurrentComment(); }
2303 | #line 2304 "y.tab.c"
2304 | break;
2305 |
2306 | case 7: /* top_level_declaration: function_definition */
2307 | #line 180 "./parse.y"
2308 | { scope=0; reset(); common_comment=NULL; in_typedef=0; GetCurrentComment(); }
2309 | #line 2310 "y.tab.c"
2310 | break;
2311 |
2312 | case 10: /* declaration_list: declaration */
2313 | #line 189 "./parse.y"
2314 | { scope=0; reset(); common_comment=NULL; in_typedef=0; }
2315 | #line 2316 "y.tab.c"
2316 | break;
2317 |
2318 | case 11: /* declaration_list: declaration_list declaration */
2319 | #line 191 "./parse.y"
2320 | { scope=0; reset(); common_comment=NULL; in_typedef=0;
2321 | yyval=yyvsp[0]; }
2322 | #line 2323 "y.tab.c"
2323 | break;
2324 |
2325 | case 12: /* declaration: declaration_specifiers initialized_declarator_list ';' */
2326 | #line 197 "./parse.y"
2327 | { in_type_spec=0; }
2328 | #line 2329 "y.tab.c"
2329 | break;
2330 |
2331 | case 13: /* declaration: declaration_specifiers ';' */
2332 | #line 199 "./parse.y"
2333 | { in_type_spec=0; }
2334 | #line 2335 "y.tab.c"
2335 | break;
2336 |
2337 | case 14: /* declaration_specifiers: declaration_specifiers1 */
2338 | #line 204 "./parse.y"
2339 | { if(!in_structunion && !in_typedef && !in_function && !common_comment)
2340 | {common_comment=CopyString(GetCurrentComment()); SetCurrentComment(common_comment);} }
2341 | #line 2342 "y.tab.c"
2342 | break;
2343 |
2344 | case 16: /* declaration_specifiers1: storage_class_specifier declaration_specifiers1 */
2345 | #line 211 "./parse.y"
2346 | { if(yyvsp[-1]) yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); else yyval=yyvsp[0]; }
2347 | #line 2348 "y.tab.c"
2348 | break;
2349 |
2350 | case 17: /* declaration_specifiers1: type_specifier */
2351 | #line 213 "./parse.y"
2352 | { if(!current->type) current->type=yyvsp[0]; }
2353 | #line 2354 "y.tab.c"
2354 | break;
2355 |
2356 | case 18: /* declaration_specifiers1: type_specifier declaration_specifiers1 */
2357 | #line 215 "./parse.y"
2358 | { if(!current->type) current->type=yyvsp[-1];
2359 | yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2360 | #line 2361 "y.tab.c"
2361 | break;
2362 |
2363 | case 20: /* declaration_specifiers1: type_qualifier declaration_specifiers1 */
2364 | #line 219 "./parse.y"
2365 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2366 | #line 2367 "y.tab.c"
2367 | break;
2368 |
2369 | case 22: /* $@1: %empty */
2370 | #line 226 "./parse.y"
2371 | { in_type_spec=1; }
2372 | #line 2373 "y.tab.c"
2373 | break;
2374 |
2375 | case 24: /* initialized_declarator: initialized_declarator1 */
2376 | #line 231 "./parse.y"
2377 | {
2378 | if((in_function==0 || in_function==3) && !in_funcdef && !in_structunion)
2379 | {
2380 | char* specific_comment=GetCurrentComment();
2381 | if(!common_comment) SetCurrentComment(specific_comment); else
2382 | if(!specific_comment) SetCurrentComment(common_comment); else
2383 | if(strcmp(common_comment,specific_comment)) SetCurrentComment(ConcatStrings(3,common_comment," ",specific_comment)); else
2384 | SetCurrentComment(common_comment);
2385 | }
2386 |
2387 | if(in_typedef)
2388 | {
2389 | char* vname=strstr(yyvsp[0],current->name);
2390 | SeenTypedefName(current->name,vname[strlen(current->name)]=='('?-1:1);
2391 | if(!in_header)
2392 | SeenTypedef(current->name,ConcatStrings(3,current->qual,current->type,yyvsp[0]));
2393 | if(in_function==3)
2394 | DownScope();
2395 | }
2396 | else if(in_function==2)
2397 | SeenFunctionArg(current->name,ConcatStrings(3,current->qual,current->type,yyvsp[0]));
2398 | else
2399 | {
2400 | char* vname=strstr(yyvsp[0],current->name);
2401 | if(vname[strlen(current->name)]!='(' && IsATypeName(current->type)!='f')
2402 | {
2403 | if((in_funcbody==0 || scope&EXTERN_F) && !in_structunion && !(in_header==GLOBAL && scope&EXTERN_H))
2404 | SeenVariableDefinition(current->name,ConcatStrings(3,current->qual,current->type,yyvsp[0]),SCOPE);
2405 | else
2406 | if(in_funcbody)
2407 | SeenScopeVariable(current->name);
2408 | }
2409 | else
2410 | SeenFunctionProto(current->name,in_funcbody);
2411 | if(in_function==3)
2412 | DownScope();
2413 | }
2414 |
2415 | if(in_function==3 && !in_structunion) in_function=0;
2416 | }
2417 | #line 2418 "y.tab.c"
2418 | break;
2419 |
2420 | case 46: /* abstract_declarator: pointer direct_abstract_declarator */
2421 | #line 322 "./parse.y"
2422 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2423 | #line 2424 "y.tab.c"
2424 | break;
2425 |
2426 | case 48: /* direct_abstract_declarator: '(' abstract_declarator ')' */
2427 | #line 328 "./parse.y"
2428 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]);
2429 | { int i=0; while(yyvsp[-1][i] && yyvsp[-1][i]=='*') i++; if(!yyvsp[-1][i]) in_type_spec=0; } }
2430 | #line 2431 "y.tab.c"
2431 | break;
2432 |
2433 | case 49: /* direct_abstract_declarator: '[' ']' */
2434 | #line 331 "./parse.y"
2435 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2436 | #line 2437 "y.tab.c"
2437 | break;
2438 |
2439 | case 50: /* direct_abstract_declarator: direct_abstract_declarator '[' ']' */
2440 | #line 333 "./parse.y"
2441 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2442 | #line 2443 "y.tab.c"
2443 | break;
2444 |
2445 | case 51: /* direct_abstract_declarator: '[' constant_expression ']' */
2446 | #line 335 "./parse.y"
2447 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2448 | #line 2449 "y.tab.c"
2449 | break;
2450 |
2451 | case 52: /* direct_abstract_declarator: direct_abstract_declarator '[' constant_expression ']' */
2452 | #line 337 "./parse.y"
2453 | { yyval=ConcatStrings(4,yyvsp[-3],yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2454 | #line 2455 "y.tab.c"
2455 | break;
2456 |
2457 | case 53: /* direct_abstract_declarator: '(' ')' */
2458 | #line 339 "./parse.y"
2459 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2460 | #line 2461 "y.tab.c"
2461 | break;
2462 |
2463 | case 54: /* direct_abstract_declarator: direct_abstract_declarator '(' ')' */
2464 | #line 341 "./parse.y"
2465 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2466 | #line 2467 "y.tab.c"
2467 | break;
2468 |
2469 | case 55: /* direct_abstract_declarator: '(' parameter_type_list ')' */
2470 | #line 343 "./parse.y"
2471 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2472 | #line 2473 "y.tab.c"
2473 | break;
2474 |
2475 | case 56: /* direct_abstract_declarator: direct_abstract_declarator '(' parameter_type_list ')' */
2476 | #line 345 "./parse.y"
2477 | { yyval=ConcatStrings(4,yyvsp[-3],yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2478 | #line 2479 "y.tab.c"
2479 | break;
2480 |
2481 | case 57: /* declarator: direct_declarator */
2482 | #line 352 "./parse.y"
2483 | { in_type_spec=0; }
2484 | #line 2485 "y.tab.c"
2485 | break;
2486 |
2487 | case 58: /* declarator: pointer direct_declarator */
2488 | #line 354 "./parse.y"
2489 | { in_type_spec=0; yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2490 | #line 2491 "y.tab.c"
2491 | break;
2492 |
2493 | case 60: /* pointer: '*' type_qualifier_list */
2494 | #line 360 "./parse.y"
2495 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2496 | #line 2497 "y.tab.c"
2497 | break;
2498 |
2499 | case 61: /* pointer: '*' pointer */
2500 | #line 362 "./parse.y"
2501 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2502 | #line 2503 "y.tab.c"
2503 | break;
2504 |
2505 | case 62: /* pointer: '*' type_qualifier_list pointer */
2506 | #line 364 "./parse.y"
2507 | { yyval=ConcatStrings(4,yyvsp[-2]," ",yyvsp[-1],yyvsp[0]); }
2508 | #line 2509 "y.tab.c"
2509 | break;
2510 |
2511 | case 64: /* direct_declarator: '(' declarator ')' */
2512 | #line 370 "./parse.y"
2513 | { if(yyvsp[-1][0]=='*' && yyvsp[-1][1]==' ') { yyvsp[-1]=&yyvsp[-1][1]; yyvsp[-1][0]='*'; }
2514 | yyval=ConcatStrings(4," ",yyvsp[-2],yyvsp[-1],yyvsp[0]);
2515 | }
2516 | #line 2517 "y.tab.c"
2517 | break;
2518 |
2519 | case 67: /* simple_declarator: IDENTIFIER */
2520 | #line 379 "./parse.y"
2521 | { yyval=ConcatStrings(2," ",yyvsp[0]); current->name=yyvsp[0];
2522 | if(!current->type) current->type="int";
2523 | if(in_funcdef==1 && in_function!=3 && !in_structunion) SeenScopeVariable(yyvsp[0]); }
2524 | #line 2525 "y.tab.c"
2525 | break;
2526 |
2527 | case 68: /* array_declarator: direct_declarator '[' ']' */
2528 | #line 386 "./parse.y"
2529 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2530 | #line 2531 "y.tab.c"
2531 | break;
2532 |
2533 | case 69: /* $@2: %empty */
2534 | #line 387 "./parse.y"
2535 | { in_type_spec=0; }
2536 | #line 2537 "y.tab.c"
2537 | break;
2538 |
2539 | case 70: /* $@3: %empty */
2540 | #line 387 "./parse.y"
2541 | { in_type_spec=1; }
2542 | #line 2543 "y.tab.c"
2543 | break;
2544 |
2545 | case 71: /* array_declarator: direct_declarator '[' $@2 constant_expression $@3 ']' */
2546 | #line 388 "./parse.y"
2547 | { yyval=ConcatStrings(4,yyvsp[-5],yyvsp[-4],yyvsp[-2],yyvsp[0]); }
2548 | #line 2549 "y.tab.c"
2549 | break;
2550 |
2551 | case 73: /* storage_class_specifier: AUTO */
2552 | #line 399 "./parse.y"
2553 | { yyval=NULL; }
2554 | #line 2555 "y.tab.c"
2555 | break;
2556 |
2557 | case 74: /* storage_class_specifier: EXTERN */
2558 | #line 401 "./parse.y"
2559 | { yyval=NULL;
2560 | if(in_funcbody) scope|=EXTERN_F;
2561 | else if(in_header) scope|=EXTERN_H;
2562 | else scope|=EXTERNAL; }
2563 | #line 2564 "y.tab.c"
2564 | break;
2565 |
2566 | case 75: /* storage_class_specifier: REGISTER */
2567 | #line 406 "./parse.y"
2568 | { yyval=NULL; }
2569 | #line 2570 "y.tab.c"
2570 | break;
2571 |
2572 | case 76: /* storage_class_specifier: STATIC */
2573 | #line 408 "./parse.y"
2574 | { yyval=NULL; scope |= LOCAL; }
2575 | #line 2576 "y.tab.c"
2576 | break;
2577 |
2578 | case 77: /* storage_class_specifier: TYPEDEF */
2579 | #line 410 "./parse.y"
2580 | { yyval=NULL;
2581 | in_typedef=1; if(!in_header) SeenTypedef(NULL,NULL);
2582 | common_comment=CopyString(GetCurrentComment()); }
2583 | #line 2584 "y.tab.c"
2584 | break;
2585 |
2586 | case 78: /* storage_class_specifier: INLINE */
2587 | #line 414 "./parse.y"
2588 | { yyval=NULL; scope |= INLINED; }
2589 | #line 2590 "y.tab.c"
2590 | break;
2591 |
2592 | case 80: /* type_qualifier_list: type_qualifier_list type_qualifier */
2593 | #line 420 "./parse.y"
2594 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2595 | #line 2596 "y.tab.c"
2596 | break;
2597 |
2598 | case 81: /* type_qualifier: CONST */
2599 | #line 425 "./parse.y"
2600 | { if(!current->type) current->qual=ConcatStrings(3,current->qual,yyvsp[0]," "); }
2601 | #line 2602 "y.tab.c"
2602 | break;
2603 |
2604 | case 82: /* type_qualifier: VOLATILE */
2605 | #line 427 "./parse.y"
2606 | { if(!current->type) current->qual=ConcatStrings(3,current->qual,yyvsp[0]," "); }
2607 | #line 2608 "y.tab.c"
2608 | break;
2609 |
2610 | case 83: /* type_specifier: type_specifier1 */
2611 | #line 434 "./parse.y"
2612 | { in_type_spec=1; }
2613 | #line 2614 "y.tab.c"
2614 | break;
2615 |
2616 | case 94: /* floating_type_specifier: DOUBLE LONG */
2617 | #line 452 "./parse.y"
2618 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2619 | #line 2620 "y.tab.c"
2620 | break;
2621 |
2622 | case 95: /* floating_type_specifier: LONG DOUBLE */
2623 | #line 454 "./parse.y"
2624 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2625 | #line 2626 "y.tab.c"
2626 | break;
2627 |
2628 | case 97: /* integer_type_specifier: integer_type_specifier_part type_qualifier */
2629 | #line 460 "./parse.y"
2630 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2631 | #line 2632 "y.tab.c"
2632 | break;
2633 |
2634 | case 98: /* integer_type_specifier: integer_type_specifier integer_type_specifier_part */
2635 | #line 462 "./parse.y"
2636 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2637 | #line 2638 "y.tab.c"
2638 | break;
2639 |
2640 | case 108: /* type_name: declaration_specifiers */
2641 | #line 488 "./parse.y"
2642 | { in_type_spec=0; }
2643 | #line 2644 "y.tab.c"
2644 | break;
2645 |
2646 | case 109: /* type_name: declaration_specifiers abstract_declarator */
2647 | #line 490 "./parse.y"
2648 | { in_type_spec=0; yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2649 | #line 2650 "y.tab.c"
2650 | break;
2651 |
2652 | case 112: /* $@4: %empty */
2653 | #line 502 "./parse.y"
2654 | { push();
2655 | if(!in_header)
2656 | {
2657 | if(in_structunion) SeenStructUnionComp(yyvsp[-1],in_structunion);
2658 | else SeenStructUnionStart(yyvsp[-1]);
2659 | }
2660 | in_structunion++; }
2661 | #line 2662 "y.tab.c"
2662 | break;
2663 |
2664 | case 113: /* enumeration_type_definition: ENUM '{' $@4 enumeration_definition_list '}' */
2665 | #line 510 "./parse.y"
2666 | { pop(); in_structunion--;
2667 | if(!in_structunion && !current->type) current->type=ConcatStrings(2,yyvsp[-4]," {...}");
2668 | if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd();
2669 | yyval=ConcatStrings(5,yyvsp[-4]," ",yyvsp[-3],yyvsp[-1],yyvsp[0]); }
2670 | #line 2671 "y.tab.c"
2671 | break;
2672 |
2673 | case 114: /* $@5: %empty */
2674 | #line 515 "./parse.y"
2675 | { push();
2676 | if(!in_header)
2677 | {
2678 | if(in_structunion) SeenStructUnionComp(ConcatStrings(3,yyvsp[-2]," ",yyvsp[-1]),in_structunion);
2679 | else SeenStructUnionStart(ConcatStrings(3,yyvsp[-2]," ",yyvsp[-1]));
2680 | }
2681 | in_structunion++; }
2682 | #line 2683 "y.tab.c"
2683 | break;
2684 |
2685 | case 115: /* enumeration_type_definition: ENUM enumeration_tag '{' $@5 enumeration_definition_list '}' */
2686 | #line 523 "./parse.y"
2687 | { pop(); in_structunion--;
2688 | if(!in_structunion && !current->type) current->type=ConcatStrings(3,yyvsp[-5]," ",yyvsp[-4]);
2689 | if(!in_header && !in_structunion) SeenStructUnionEnd();
2690 | yyval=ConcatStrings(7,yyvsp[-5]," ",yyvsp[-4]," ",yyvsp[-3],yyvsp[-1],yyvsp[0]); }
2691 | #line 2692 "y.tab.c"
2692 | break;
2693 |
2694 | case 119: /* enumeration_definition_list1: enumeration_definition_list1 ',' enumeration_constant_definition */
2695 | #line 537 "./parse.y"
2696 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2697 | #line 2698 "y.tab.c"
2698 | break;
2699 |
2700 | case 120: /* enumeration_constant_definition: enumeration_constant */
2701 | #line 542 "./parse.y"
2702 | { if(!in_header) SeenStructUnionComp(yyvsp[0],in_structunion); }
2703 | #line 2704 "y.tab.c"
2704 | break;
2705 |
2706 | case 121: /* enumeration_constant_definition: enumeration_constant '=' assignment_expression */
2707 | #line 544 "./parse.y"
2708 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); if(!in_header) SeenStructUnionComp(yyvsp[-2],in_structunion); }
2709 | #line 2710 "y.tab.c"
2710 | break;
2711 |
2712 | case 123: /* enumeration_type_reference: ENUM enumeration_tag */
2713 | #line 553 "./parse.y"
2714 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2715 | #line 2716 "y.tab.c"
2716 | break;
2717 |
2718 | case 128: /* $@6: %empty */
2719 | #line 570 "./parse.y"
2720 | { push();
2721 | if(!in_header)
2722 | {
2723 | if(in_structunion) SeenStructUnionComp(yyvsp[-1],in_structunion);
2724 | else SeenStructUnionStart(yyvsp[-1]);
2725 | }
2726 | in_structunion++; }
2727 | #line 2728 "y.tab.c"
2728 | break;
2729 |
2730 | case 129: /* structure_type_definition: STRUCT '{' $@6 field_list '}' */
2731 | #line 578 "./parse.y"
2732 | { pop(); in_structunion--;
2733 | if(!in_structunion && !current->type) current->type=ConcatStrings(2,yyvsp[-4]," {...}");
2734 | if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd();
2735 | yyval=ConcatStrings(5,yyvsp[-4]," ",yyvsp[-3],yyvsp[-1],yyvsp[0]); }
2736 | #line 2737 "y.tab.c"
2737 | break;
2738 |
2739 | case 130: /* $@7: %empty */
2740 | #line 583 "./parse.y"
2741 | { push();
2742 | if(!in_header)
2743 | {
2744 | if(in_structunion) SeenStructUnionComp(ConcatStrings(3,yyvsp[-2]," ",yyvsp[-1]),in_structunion);
2745 | else SeenStructUnionStart(ConcatStrings(3,yyvsp[-2]," ",yyvsp[-1]));
2746 | }
2747 | in_structunion++; }
2748 | #line 2749 "y.tab.c"
2749 | break;
2750 |
2751 | case 131: /* structure_type_definition: STRUCT structure_tag '{' $@7 field_list '}' */
2752 | #line 591 "./parse.y"
2753 | { pop(); in_structunion--;
2754 | if(!in_structunion && !current->type) current->type=ConcatStrings(3,yyvsp[-5]," ",yyvsp[-4]);
2755 | if(!in_header && !in_structunion) SeenStructUnionEnd();
2756 | yyval=ConcatStrings(7,yyvsp[-5]," ",yyvsp[-4]," ",yyvsp[-3],yyvsp[-1],yyvsp[0]); }
2757 | #line 2758 "y.tab.c"
2758 | break;
2759 |
2760 | case 132: /* structure_type_reference: STRUCT structure_tag */
2761 | #line 599 "./parse.y"
2762 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2763 | #line 2764 "y.tab.c"
2764 | break;
2765 |
2766 | case 137: /* $@8: %empty */
2767 | #line 616 "./parse.y"
2768 | { push();
2769 | if(!in_header)
2770 | {
2771 | if(in_structunion) SeenStructUnionComp(yyvsp[-1],in_structunion);
2772 | else SeenStructUnionStart(yyvsp[-1]);
2773 | }
2774 | in_structunion++; }
2775 | #line 2776 "y.tab.c"
2776 | break;
2777 |
2778 | case 138: /* union_type_definition: UNION '{' $@8 field_list '}' */
2779 | #line 624 "./parse.y"
2780 | { pop(); in_structunion--;
2781 | if(!in_structunion && !current->type) current->type=ConcatStrings(2,yyvsp[-4]," {...}");
2782 | if(!in_header && !in_structunion && in_typedef) SeenStructUnionEnd();
2783 | yyval=ConcatStrings(5,yyvsp[-4]," ",yyvsp[-3],yyvsp[-1],yyvsp[0]); }
2784 | #line 2785 "y.tab.c"
2785 | break;
2786 |
2787 | case 139: /* $@9: %empty */
2788 | #line 629 "./parse.y"
2789 | { push();
2790 | if(!in_header)
2791 | {
2792 | if(in_structunion) SeenStructUnionComp(ConcatStrings(3,yyvsp[-2]," ",yyvsp[-1]),in_structunion);
2793 | else SeenStructUnionStart(ConcatStrings(3,yyvsp[-2]," ",yyvsp[-1]));
2794 | }
2795 | in_structunion++; }
2796 | #line 2797 "y.tab.c"
2797 | break;
2798 |
2799 | case 140: /* union_type_definition: UNION union_tag '{' $@9 field_list '}' */
2800 | #line 637 "./parse.y"
2801 | { pop(); in_structunion--;
2802 | if(!in_structunion && !current->type) current->type=ConcatStrings(3,yyvsp[-5]," ",yyvsp[-4]);
2803 | if(!in_header && !in_structunion) SeenStructUnionEnd();
2804 | yyval=ConcatStrings(7,yyvsp[-5]," ",yyvsp[-4]," ",yyvsp[-3],yyvsp[-1],yyvsp[0]); }
2805 | #line 2806 "y.tab.c"
2806 | break;
2807 |
2808 | case 141: /* union_type_reference: UNION union_tag */
2809 | #line 645 "./parse.y"
2810 | { yyval=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2811 | #line 2812 "y.tab.c"
2812 | break;
2813 |
2814 | case 147: /* field_list1: field_list1 field_list2 */
2815 | #line 663 "./parse.y"
2816 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2817 | #line 2818 "y.tab.c"
2818 | break;
2819 |
2820 | case 149: /* field_list2: structure_type_definition ';' */
2821 | #line 669 "./parse.y"
2822 | { yyval = ConcatStrings(3, yyvsp[-1], " ", yyvsp[0]);
2823 | if(!in_header) SeenStructUnionComp(yyvsp[-1],in_structunion); }
2824 | #line 2825 "y.tab.c"
2825 | break;
2826 |
2827 | case 150: /* field_list2: union_type_definition ';' */
2828 | #line 672 "./parse.y"
2829 | { yyval = ConcatStrings(3, yyvsp[-1], " ", yyvsp[0]);
2830 | if(!in_header) SeenStructUnionComp(yyvsp[-1],in_structunion); }
2831 | #line 2832 "y.tab.c"
2832 | break;
2833 |
2834 | case 152: /* $@10: %empty */
2835 | #line 679 "./parse.y"
2836 | { comp_type=yyvsp[0]; }
2837 | #line 2838 "y.tab.c"
2838 | break;
2839 |
2840 | case 153: /* component_declaration: type_specifier $@10 component_declarator_list ';' */
2841 | #line 681 "./parse.y"
2842 | { yyval=ConcatStrings(3,yyvsp[-3],yyvsp[-1],yyvsp[0]); reset(); in_type_spec=0; }
2843 | #line 2844 "y.tab.c"
2844 | break;
2845 |
2846 | case 154: /* $@11: %empty */
2847 | #line 683 "./parse.y"
2848 | { comp_type=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2849 | #line 2850 "y.tab.c"
2850 | break;
2851 |
2852 | case 155: /* component_declaration: type_qualifier_list type_specifier $@11 component_declarator_list ';' */
2853 | #line 685 "./parse.y"
2854 | { yyval=ConcatStrings(4,yyvsp[-4],yyvsp[-3],yyvsp[-1],yyvsp[0]); reset(); in_type_spec=0; }
2855 | #line 2856 "y.tab.c"
2856 | break;
2857 |
2858 | case 156: /* $@12: %empty */
2859 | #line 687 "./parse.y"
2860 | { comp_type=ConcatStrings(3,yyvsp[-1]," ",yyvsp[0]); }
2861 | #line 2862 "y.tab.c"
2862 | break;
2863 |
2864 | case 157: /* component_declaration: type_specifier type_qualifier_list $@12 component_declarator_list ';' */
2865 | #line 689 "./parse.y"
2866 | { yyval=ConcatStrings(4,yyvsp[-4],yyvsp[-3],yyvsp[-1],yyvsp[0]); reset(); in_type_spec=0; }
2867 | #line 2868 "y.tab.c"
2868 | break;
2869 |
2870 | case 158: /* component_declarator_list: component_declarator */
2871 | #line 694 "./parse.y"
2872 | { if(!in_header) SeenStructUnionComp(ConcatStrings(2,comp_type,yyvsp[0]),in_structunion); }
2873 | #line 2874 "y.tab.c"
2874 | break;
2875 |
2876 | case 159: /* component_declarator_list: component_declarator_list ',' component_declarator */
2877 | #line 696 "./parse.y"
2878 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]);
2879 | if(!in_header) SeenStructUnionComp(ConcatStrings(2,comp_type,yyvsp[0]),in_structunion); }
2880 | #line 2881 "y.tab.c"
2881 | break;
2882 |
2883 | case 162: /* simple_component: declarator */
2884 | #line 707 "./parse.y"
2885 | { if(in_function==2 && !in_structunion) { DownScope(); pop(); in_function=0; } }
2886 | #line 2887 "y.tab.c"
2887 | break;
2888 |
2889 | case 163: /* bit_field: ':' width */
2890 | #line 712 "./parse.y"
2891 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2892 | #line 2893 "y.tab.c"
2893 | break;
2894 |
2895 | case 164: /* bit_field: declarator ':' width */
2896 | #line 714 "./parse.y"
2897 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
2898 | #line 2899 "y.tab.c"
2899 | break;
2900 |
2901 | case 168: /* $@13: %empty */
2902 | #line 732 "./parse.y"
2903 | { pop(); in_funcbody=1; in_function=0; }
2904 | #line 2905 "y.tab.c"
2905 | break;
2906 |
2907 | case 169: /* function_definition: function_specifier $@13 compound_statement */
2908 | #line 734 "./parse.y"
2909 | { in_funcbody=in_function=0; DownScope(); SeenFunctionDefinition(NULL); }
2910 | #line 2911 "y.tab.c"
2911 | break;
2912 |
2913 | case 170: /* function_specifier: function_specifier1 */
2914 | #line 739 "./parse.y"
2915 | { char *func_type,*fname=strstr(yyvsp[0],(current-1)->name),*parenth=strstr(yyvsp[0],"(");
2916 | if(parenth>fname)
2917 | {parenth[0]=0;func_type=ConcatStrings(3,(current-1)->qual,(current-1)->type,yyvsp[0]);}
2918 | else
2919 | {
2920 | int open=1;
2921 | char *argbeg=strstr(&parenth[1],"("),*argend;
2922 | argbeg[1]=0;
2923 | for(argend=argbeg+2;*argend;argend++)
2924 | {
2925 | if(*argend=='(') open++;
2926 | if(*argend==')') open--;
2927 | if(!open) break;
2928 | }
2929 | func_type=ConcatStrings(4,(current-1)->qual,(current-1)->type,yyvsp[0],argend);
2930 | }
2931 | SeenFunctionDefinition(func_type);
2932 | common_comment=NULL;
2933 | }
2934 | #line 2935 "y.tab.c"
2935 | break;
2936 |
2937 | case 172: /* function_specifier1: declaration_specifiers function_declarator */
2938 | #line 763 "./parse.y"
2939 | { yyval=ConcatStrings(3,current->qual,current->type,yyvsp[0]); }
2940 | #line 2941 "y.tab.c"
2941 | break;
2942 |
2943 | case 174: /* function_specifier1: declaration_specifiers function_declarator declaration_list */
2944 | #line 766 "./parse.y"
2945 | { yyval=ConcatStrings(3,current->qual,current->type,yyvsp[-1]); }
2946 | #line 2947 "y.tab.c"
2947 | break;
2948 |
2949 | case 175: /* function_declarator: function_declarator0 */
2950 | #line 773 "./parse.y"
2951 | { if(!in_structunion) { push(); in_function=2; } }
2952 | #line 2953 "y.tab.c"
2953 | break;
2954 |
2955 | case 178: /* function_declarator0: pointer function_direct_declarator */
2956 | #line 780 "./parse.y"
2957 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
2958 | #line 2959 "y.tab.c"
2959 | break;
2960 |
2961 | case 179: /* function_declarator0: pointer '(' function_direct_declarator ')' */
2962 | #line 782 "./parse.y"
2963 | { yyval=ConcatStrings(2,yyvsp[-3],yyvsp[-1]); }
2964 | #line 2965 "y.tab.c"
2965 | break;
2966 |
2967 | case 180: /* $@14: %empty */
2968 | #line 787 "./parse.y"
2969 | { if(!in_structunion)
2970 | { push(); if(in_function==0) UpScope();
2971 | if(in_function==0 && !in_funcdef) in_function=1; if(in_function!=3) in_funcdef++; } }
2972 | #line 2973 "y.tab.c"
2973 | break;
2974 |
2975 | case 181: /* function_direct_declarator: function_declarator1 '(' $@14 function_declarator2 ')' */
2976 | #line 791 "./parse.y"
2977 | { if(!in_structunion)
2978 | { pop(); if(in_function!=3) in_funcdef--; if(in_funcdef==0) in_function=3; }
2979 | yyval=ConcatStrings(4,yyvsp[-4],yyvsp[-3],yyvsp[-1],yyvsp[0]); }
2980 | #line 2981 "y.tab.c"
2981 | break;
2982 |
2983 | case 182: /* function_declarator1: direct_declarator */
2984 | #line 798 "./parse.y"
2985 | {
2986 | if(!in_funcdef && !in_function && !in_funcbody && !in_structunion) SeenFunctionDeclaration(current->name,SCOPE);
2987 | in_type_spec=0;
2988 | }
2989 | #line 2990 "y.tab.c"
2990 | break;
2991 |
2992 | case 183: /* function_declarator2: %empty */
2993 | #line 806 "./parse.y"
2994 | { if(in_function==1 && in_funcdef==1 && !in_structunion) SeenFunctionArg("void","void");
2995 | if(in_structunion) yyval=NULL; else yyval="void"; }
2996 | #line 2997 "y.tab.c"
2997 | break;
2998 |
2999 | case 186: /* identifier_list: IDENTIFIER */
3000 | #line 814 "./parse.y"
3001 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) { SeenFunctionArg(yyvsp[0],NULL); SeenScopeVariable(yyvsp[0]); } }
3002 | #line 3003 "y.tab.c"
3003 | break;
3004 |
3005 | case 187: /* identifier_list: identifier_list ',' IDENTIFIER */
3006 | #line 816 "./parse.y"
3007 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) { SeenFunctionArg(yyvsp[0],NULL); SeenScopeVariable(yyvsp[0]); }
3008 | yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3009 | #line 3010 "y.tab.c"
3010 | break;
3011 |
3012 | case 189: /* parameter_type_list: parameter_list ',' ELLIPSES */
3013 | #line 823 "./parse.y"
3014 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg(yyvsp[0],yyvsp[0]);
3015 | yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3016 | #line 3017 "y.tab.c"
3017 | break;
3018 |
3019 | case 190: /* parameter_list: parameter_declaration */
3020 | #line 829 "./parse.y"
3021 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg(strcmp("void",yyvsp[0])?current->name:"void",yyvsp[0]);
3022 | in_type_spec=0; }
3023 | #line 3024 "y.tab.c"
3024 | break;
3025 |
3026 | case 191: /* parameter_list: parameter_list ',' parameter_declaration */
3027 | #line 832 "./parse.y"
3028 | { if(in_function==1 && in_funcdef==1 && in_funcbody==0 && !in_structunion) SeenFunctionArg(current->name,yyvsp[0]);
3029 | in_type_spec=0; yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3030 | #line 3031 "y.tab.c"
3031 | break;
3032 |
3033 | case 192: /* parameter_declaration: declaration_specifiers declarator */
3034 | #line 838 "./parse.y"
3035 | { in_type_spec=0; yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
3036 | #line 3037 "y.tab.c"
3037 | break;
3038 |
3039 | case 193: /* parameter_declaration: declaration_specifiers */
3040 | #line 840 "./parse.y"
3041 | { in_type_spec=0; }
3042 | #line 3043 "y.tab.c"
3043 | break;
3044 |
3045 | case 194: /* parameter_declaration: declaration_specifiers abstract_declarator */
3046 | #line 842 "./parse.y"
3047 | { in_type_spec=0; yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
3048 | #line 3049 "y.tab.c"
3049 | break;
3050 |
3051 | case 207: /* $@15: %empty */
3052 | #line 866 "./parse.y"
3053 | { UpScope(); reset(); }
3054 | #line 3055 "y.tab.c"
3055 | break;
3056 |
3057 | case 208: /* $@16: %empty */
3058 | #line 868 "./parse.y"
3059 | { DownScope(); }
3060 | #line 3061 "y.tab.c"
3061 | break;
3062 |
3063 | case 215: /* block_item: declaration */
3064 | #line 885 "./parse.y"
3065 | { scope=0; reset(); common_comment=NULL; in_typedef=0; }
3066 | #line 3067 "y.tab.c"
3067 | break;
3068 |
3069 | case 224: /* $@17: %empty */
3070 | #line 917 "./parse.y"
3071 | { UpScope(); reset(); }
3072 | #line 3073 "y.tab.c"
3073 | break;
3074 |
3075 | case 225: /* for_statement: FOR $@17 '(' for_expressions ')' statement */
3076 | #line 919 "./parse.y"
3077 | { DownScope(); }
3078 | #line 3079 "y.tab.c"
3079 | break;
3080 |
3081 | case 235: /* for_expression_or_declaration: declaration_specifiers initialized_declarator_list */
3082 | #line 936 "./parse.y"
3083 | { in_type_spec=0; }
3084 | #line 3085 "y.tab.c"
3085 | break;
3086 |
3087 | case 236: /* for_expression_or_declaration: declaration_specifiers */
3088 | #line 938 "./parse.y"
3089 | { in_type_spec=0; }
3090 | #line 3091 "y.tab.c"
3091 | break;
3092 |
3093 | case 256: /* comma_expression: comma_expression ',' assignment_expression */
3094 | #line 1011 "./parse.y"
3095 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3096 | #line 3097 "y.tab.c"
3097 | break;
3098 |
3099 | case 273: /* conditional_expression: logical_or_expression '?' expression ':' conditional_expression */
3100 | #line 1042 "./parse.y"
3101 | { yyval=ConcatStrings(5,yyvsp[-4],yyvsp[-3],yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3102 | #line 3103 "y.tab.c"
3103 | break;
3104 |
3105 | case 274: /* conditional_expression: logical_or_expression '?' ':' conditional_expression */
3106 | #line 1044 "./parse.y"
3107 | { yyval=ConcatStrings(4,yyvsp[-3],yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3108 | #line 3109 "y.tab.c"
3109 | break;
3110 |
3111 | case 276: /* logical_or_expression: logical_or_expression OR_OP logical_and_expression */
3112 | #line 1052 "./parse.y"
3113 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3114 | #line 3115 "y.tab.c"
3115 | break;
3116 |
3117 | case 278: /* logical_and_expression: logical_and_expression AND_OP bitwise_or_expression */
3118 | #line 1060 "./parse.y"
3119 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3120 | #line 3121 "y.tab.c"
3121 | break;
3122 |
3123 | case 280: /* bitwise_or_expression: bitwise_or_expression '|' bitwise_xor_expression */
3124 | #line 1068 "./parse.y"
3125 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3126 | #line 3127 "y.tab.c"
3127 | break;
3128 |
3129 | case 282: /* bitwise_xor_expression: bitwise_xor_expression '^' bitwise_and_expression */
3130 | #line 1076 "./parse.y"
3131 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3132 | #line 3133 "y.tab.c"
3133 | break;
3134 |
3135 | case 284: /* bitwise_and_expression: bitwise_and_expression '&' equality_expression */
3136 | #line 1084 "./parse.y"
3137 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3138 | #line 3139 "y.tab.c"
3139 | break;
3140 |
3141 | case 286: /* equality_expression: equality_expression equality_op relational_expression */
3142 | #line 1092 "./parse.y"
3143 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3144 | #line 3145 "y.tab.c"
3145 | break;
3146 |
3147 | case 290: /* relational_expression: relational_expression relational_op shift_expression */
3148 | #line 1105 "./parse.y"
3149 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3150 | #line 3151 "y.tab.c"
3151 | break;
3152 |
3153 | case 296: /* shift_expression: shift_expression shift_op additive_expression */
3154 | #line 1120 "./parse.y"
3155 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3156 | #line 3157 "y.tab.c"
3157 | break;
3158 |
3159 | case 300: /* additive_expression: additive_expression add_op multiplicative_expression */
3160 | #line 1133 "./parse.y"
3161 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3162 | #line 3163 "y.tab.c"
3163 | break;
3164 |
3165 | case 304: /* multiplicative_expression: multiplicative_expression mult_op unary_expression */
3166 | #line 1146 "./parse.y"
3167 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3168 | #line 3169 "y.tab.c"
3169 | break;
3170 |
3171 | case 320: /* bitwise_negation_expression: '~' unary_expression */
3172 | #line 1177 "./parse.y"
3173 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
3174 | #line 3175 "y.tab.c"
3175 | break;
3176 |
3177 | case 321: /* cast_expression: '(' type_name ')' unary_expression */
3178 | #line 1182 "./parse.y"
3179 | { yyval=ConcatStrings(4,yyvsp[-3],yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3180 | #line 3181 "y.tab.c"
3181 | break;
3182 |
3183 | case 324: /* logical_negation_expression: '!' unary_expression */
3184 | #line 1192 "./parse.y"
3185 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
3186 | #line 3187 "y.tab.c"
3187 | break;
3188 |
3189 | case 327: /* sizeof_expression: SIZEOF '(' type_name ')' */
3190 | #line 1205 "./parse.y"
3191 | { yyval=ConcatStrings(4,yyvsp[-3],yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3192 | #line 3193 "y.tab.c"
3193 | break;
3194 |
3195 | case 328: /* sizeof_expression: SIZEOF unary_expression */
3196 | #line 1207 "./parse.y"
3197 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
3198 | #line 3199 "y.tab.c"
3199 | break;
3200 |
3201 | case 329: /* unary_minus_expression: '-' unary_expression */
3202 | #line 1212 "./parse.y"
3203 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
3204 | #line 3205 "y.tab.c"
3205 | break;
3206 |
3207 | case 330: /* unary_plus_expression: '+' unary_expression */
3208 | #line 1217 "./parse.y"
3209 | { yyval=ConcatStrings(2,yyvsp[-1],yyvsp[0]); }
3210 | #line 3211 "y.tab.c"
3211 | break;
3212 |
3213 | case 333: /* postfix_expression: function_call_direct */
3214 | #line 1226 "./parse.y"
3215 | { if(!IsAScopeVariable(yyvsp[0])) SeenFunctionCall(yyvsp[0]); }
3216 | #line 3217 "y.tab.c"
3217 | break;
3218 |
3219 | case 349: /* primary_expression: name */
3220 | #line 1270 "./parse.y"
3221 | { CheckFunctionVariableRef(yyvsp[0],in_funcbody); }
3222 | #line 3223 "y.tab.c"
3223 | break;
3224 |
3225 | case 355: /* parenthesized_expression: '(' expression ')' */
3226 | #line 1283 "./parse.y"
3227 | { yyval=ConcatStrings(3,yyvsp[-2],yyvsp[-1],yyvsp[0]); }
3228 | #line 3229 "y.tab.c"
3229 | break;
3230 |
3231 | case 356: /* $@18: %empty */
3232 | #line 1284 "./parse.y"
3233 | { push(); }
3234 | #line 3235 "y.tab.c"
3235 | break;
3236 |
3237 | case 357: /* $@19: %empty */
3238 | #line 1284 "./parse.y"
3239 | { pop(); }
3240 | #line 3241 "y.tab.c"
3241 | break;
3242 |
3243 |
3244 | #line 3245 "y.tab.c"
3245 |
3246 | default: break;
3247 | }
3248 | /* User semantic actions sometimes alter yychar, and that requires
3249 | that yytoken be updated with the new translation. We take the
3250 | approach of translating immediately before every use of yytoken.
3251 | One alternative is translating here after every semantic action,
3252 | but that translation would be missed if the semantic action invokes
3253 | YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3254 | if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
3255 | incorrect destructor might then be invoked immediately. In the
3256 | case of YYERROR or YYBACKUP, subsequent parser actions might lead
3257 | to an incorrect destructor call or verbose syntax error message
3258 | before the lookahead is translated. */
3259 | YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
3260 |
3261 | YYPOPSTACK (yylen);
3262 | yylen = 0;
3263 |
3264 | *++yyvsp = yyval;
3265 |
3266 | /* Now 'shift' the result of the reduction. Determine what state
3267 | that goes to, based on the state we popped back to and the rule
3268 | number reduced by. */
3269 | {
3270 | const int yylhs = yyr1[yyn] - YYNTOKENS;
3271 | const int yyi = yypgoto[yylhs] + *yyssp;
3272 | yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
3273 | ? yytable[yyi]
3274 | : yydefgoto[yylhs]);
3275 | }
3276 |
3277 | goto yynewstate;
3278 |
3279 |
3280 | /*--------------------------------------.
3281 | | yyerrlab -- here on detecting error. |
3282 | `--------------------------------------*/
3283 | yyerrlab:
3284 | /* Make sure we have latest lookahead translation. See comments at
3285 | user semantic actions for why this is necessary. */
3286 | yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
3287 | /* If not already recovering from an error, report this error. */
3288 | if (!yyerrstatus)
3289 | {
3290 | ++yynerrs;
3291 | yyerror (YY_("syntax error"));
3292 | }
3293 |
3294 | if (yyerrstatus == 3)
3295 | {
3296 | /* If just tried and failed to reuse lookahead token after an
3297 | error, discard it. */
3298 |
3299 | if (yychar <= YYEOF)
3300 | {
3301 | /* Return failure if at end of input. */
3302 | if (yychar == YYEOF)
3303 | YYABORT;
3304 | }
3305 | else
3306 | {
3307 | yydestruct ("Error: discarding",
3308 | yytoken, &yylval);
3309 | yychar = YYEMPTY;
3310 | }
3311 | }
3312 |
3313 | /* Else will try to reuse lookahead token after shifting the error
3314 | token. */
3315 | goto yyerrlab1;
3316 |
3317 |
3318 | /*---------------------------------------------------.
3319 | | yyerrorlab -- error raised explicitly by YYERROR. |
3320 | `---------------------------------------------------*/
3321 | yyerrorlab:
3322 | /* Pacify compilers when the user code never invokes YYERROR and the
3323 | label yyerrorlab therefore never appears in user code. */
3324 | if (0)
3325 | YYERROR;
3326 |
3327 | /* Do not reclaim the symbols of the rule whose action triggered
3328 | this YYERROR. */
3329 | YYPOPSTACK (yylen);
3330 | yylen = 0;
3331 | YY_STACK_PRINT (yyss, yyssp);
3332 | yystate = *yyssp;
3333 | goto yyerrlab1;
3334 |
3335 |
3336 | /*-------------------------------------------------------------.
3337 | | yyerrlab1 -- common code for both syntax error and YYERROR. |
3338 | `-------------------------------------------------------------*/
3339 | yyerrlab1:
3340 | yyerrstatus = 3; /* Each real token shifted decrements this. */
3341 |
3342 | /* Pop stack until we find a state that shifts the error token. */
3343 | for (;;)
3344 | {
3345 | yyn = yypact[yystate];
3346 | if (!yypact_value_is_default (yyn))
3347 | {
3348 | yyn += YYSYMBOL_YYerror;
3349 | if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
3350 | {
3351 | yyn = yytable[yyn];
3352 | if (0 < yyn)
3353 | break;
3354 | }
3355 | }
3356 |
3357 | /* Pop the current state because it cannot handle the error token. */
3358 | if (yyssp == yyss)
3359 | YYABORT;
3360 |
3361 |
3362 | yydestruct ("Error: popping",
3363 | YY_ACCESSING_SYMBOL (yystate), yyvsp);
3364 | YYPOPSTACK (1);
3365 | yystate = *yyssp;
3366 | YY_STACK_PRINT (yyss, yyssp);
3367 | }
3368 |
3369 | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3370 | *++yyvsp = yylval;
3371 | YY_IGNORE_MAYBE_UNINITIALIZED_END
3372 |
3373 |
3374 | /* Shift the error token. */
3375 | YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
3376 |
3377 | yystate = yyn;
3378 | goto yynewstate;
3379 |
3380 |
3381 | /*-------------------------------------.
3382 | | yyacceptlab -- YYACCEPT comes here. |
3383 | `-------------------------------------*/
3384 | yyacceptlab:
3385 | yyresult = 0;
3386 | goto yyreturn;
3387 |
3388 |
3389 | /*-----------------------------------.
3390 | | yyabortlab -- YYABORT comes here. |
3391 | `-----------------------------------*/
3392 | yyabortlab:
3393 | yyresult = 1;
3394 | goto yyreturn;
3395 |
3396 |
3397 | #if !defined yyoverflow
3398 | /*-------------------------------------------------.
3399 | | yyexhaustedlab -- memory exhaustion comes here. |
3400 | `-------------------------------------------------*/
3401 | yyexhaustedlab:
3402 | yyerror (YY_("memory exhausted"));
3403 | yyresult = 2;
3404 | goto yyreturn;
3405 | #endif
3406 |
3407 |
3408 | /*-------------------------------------------------------.
3409 | | yyreturn -- parsing is finished, clean up and return. |
3410 | `-------------------------------------------------------*/
3411 | yyreturn:
3412 | if (yychar != YYEMPTY)
3413 | {
3414 | /* Make sure we have latest lookahead translation. See comments at
3415 | user semantic actions for why this is necessary. */
3416 | yytoken = YYTRANSLATE (yychar);
3417 | yydestruct ("Cleanup: discarding lookahead",
3418 | yytoken, &yylval);
3419 | }
3420 | /* Do not reclaim the symbols of the rule whose action triggered
3421 | this YYABORT or YYACCEPT. */
3422 | YYPOPSTACK (yylen);
3423 | YY_STACK_PRINT (yyss, yyssp);
3424 | while (yyssp != yyss)
3425 | {
3426 | yydestruct ("Cleanup: popping",
3427 | YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
3428 | YYPOPSTACK (1);
3429 | }
3430 | #ifndef yyoverflow
3431 | if (yyss != yyssa)
3432 | YYSTACK_FREE (yyss);
3433 | #endif
3434 |
3435 | return yyresult;
3436 | }
3437 |
3438 | #line 1343 "./parse.y"
3439 |
3440 |
3441 | #if YYDEBUG
3442 |
3443 | static int last_yylex[11];
3444 | static char *last_yylval[11];
3445 | static int count=0,modcount=0;
3446 |
3447 | #endif /* YYDEBUG */
3448 |
3449 |
3450 | /*++++++++++++++++++++++++++++++++++++++
3451 | Stop parsing the current file, due to an error.
3452 |
3453 | char *s The error message to print out.
3454 | ++++++++++++++++++++++++++++++++++++++*/
3455 |
3456 | static void yyerror( const char *s )
3457 | {
3458 | #if YYDEBUG
3459 | int i;
3460 | #endif
3461 |
3462 | fflush(stdout);
3463 | fprintf(stderr,"%s:%d: cxref: %s\n\n",parse_file,parse_line,s);
3464 |
3465 | #if YYDEBUG
3466 |
3467 | fprintf(stderr,"The previous 10, current and next 10 symbols are:\n");
3468 |
3469 | for(i=count>10?count-11:0,modcount=i%11;i<count-1;i++,modcount=i%11)
3470 | #ifdef YYBISON
3471 | fprintf(stderr,"%3d | %3d : %16s : %s\n",i+1-count,last_yylex[modcount],yytname[YYTRANSLATE(last_yylex[modcount])],last_yylval[modcount]);
3472 | #else
3473 | fprintf(stderr,"%3d | %3d : %s\n",i+1-count,last_yylex[modcount],last_yylval[modcount]);
3474 | #endif
3475 |
3476 | #ifdef YYBISON
3477 | fprintf(stderr," 0 | %3d : %16s : %s\n",yychar,yytname[YYTRANSLATE(yychar)],yylval);
3478 | #else
3479 | fprintf(stderr," 0 | %3d : %s\n",yychar,yylval);
3480 | #endif
3481 |
3482 | for(i=0;i<10;i++)
3483 | {
3484 | yychar=yylex();
3485 | if(!yychar)
3486 | {fprintf(stderr,"END OF FILE\n");break;}
3487 | #ifdef YYBISON
3488 | fprintf(stderr,"%3d | %3d : %16s : %s\n",i+1,yychar,yytname[YYTRANSLATE(yychar)],yylval);
3489 | #else
3490 | fprintf(stderr,"%3d | %3d : %s\n",i+1,yychar,yylval);
3491 | #endif
3492 | }
3493 |
3494 | fprintf(stderr,"\n");
3495 |
3496 | #endif /* YYDEBUG */
3497 |
3498 | /* Finish off the input. */
3499 |
3500 | #undef yylex
3501 |
3502 | if(yychar)
3503 | while((yychar=yylex()));
3504 | }
3505 |
3506 |
3507 | /*++++++++++++++++++++++++++++++++++++++
3508 | Call the lexer, the feedback from the parser to the lexer is applied here.
3509 |
3510 | int cxref_yylex Returns the value from the lexer, modified due to parser feedback.
3511 | ++++++++++++++++++++++++++++++++++++++*/
3512 |
3513 | static int cxref_yylex(void)
3514 | {
3515 | static int last_yyl=0;
3516 | int yyl=yylex();
3517 |
3518 | if(yyl==TYPE_NAME)
3519 | if(in_type_spec || (in_structunion && last_yyl=='}') || last_yyl==TYPE_NAME ||
3520 | last_yyl==GOTO ||
3521 | last_yyl==CHAR || last_yyl==SHORT || last_yyl==INT || last_yyl==LONG ||
3522 | last_yyl==SIGNED || last_yyl==UNSIGNED ||
3523 | last_yyl==FLOAT || last_yyl==DOUBLE ||
3524 | last_yyl==BOOL)
3525 | yyl=IDENTIFIER;
3526 |
3527 | last_yyl=yyl;
3528 |
3529 | #if YYDEBUG
3530 |
3531 | last_yylex [modcount]=yyl;
3532 | last_yylval[modcount]=yylval;
3533 |
3534 | if(yyl)
3535 | {
3536 | count++;
3537 | modcount=count%11;
3538 | }
3539 | else
3540 | {
3541 | count=0;
3542 | modcount=0;
3543 | }
3544 |
3545 | #if YYDEBUG == 2
3546 |
3547 | if(yyl)
3548 | #ifdef YYBISON
3549 | printf("#parse.y# %6d | %16s:%4d | %3d : %16s : %s\n",count,parse_file,parse_line,yyl,yytname[YYTRANSLATE(yyl)],yylval);
3550 | #else
3551 | printf("#parse.y# %6d | %16s:%4d | %3d : %s\n",count,parse_file,parse_line,yyl,yylval);
3552 | #endif /* YYBISON */
3553 | else
3554 | printf("#parse.y# %6d | %16s:%4d | END OF FILE\n",count,parse_file,parse_line);
3555 |
3556 | fflush(stdout);
3557 |
3558 | #endif /* YYDEBUG==2 */
3559 |
3560 | #endif /* YYDEBUG */
3561 |
3562 | return(yyl);
3563 | }