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