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