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