1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4
5 #define YYBYACC 1
6 #define YYMAJOR 1
7 #define YYMINOR 9
8 #define YYCHECK "yyyymmdd"
9
10 #define YYEMPTY (-1)
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
14 #define YYENOMEM (-2)
15 #define YYEOF 0
16 #undef YYBTYACC
17 #define YYBTYACC 0
18 #define YYDEBUGSTR YYPREFIX "debug"
19
20 #ifndef yyparse
21 #define yyparse grammar_parse
22 #endif /* yyparse */
23
24 #ifndef yylex
25 #define yylex grammar_lex
26 #endif /* yylex */
27
28 #ifndef yyerror
29 #define yyerror grammar_error
30 #endif /* yyerror */
31
32 #ifndef yychar
33 #define yychar grammar_char
34 #endif /* yychar */
35
36 #ifndef yyval
37 #define yyval grammar_val
38 #endif /* yyval */
39
40 #ifndef yylval
41 #define yylval grammar_lval
42 #endif /* yylval */
43
44 #ifndef yydebug
45 #define yydebug grammar_debug
46 #endif /* yydebug */
47
48 #ifndef yynerrs
49 #define yynerrs grammar_nerrs
50 #endif /* yynerrs */
51
52 #ifndef yyerrflag
53 #define yyerrflag grammar_errflag
54 #endif /* yyerrflag */
55
56 #ifndef yylhs
57 #define yylhs grammar_lhs
58 #endif /* yylhs */
59
60 #ifndef yylen
61 #define yylen grammar_len
62 #endif /* yylen */
63
64 #ifndef yydefred
65 #define yydefred grammar_defred
66 #endif /* yydefred */
67
68 #ifndef yystos
69 #define yystos grammar_stos
70 #endif /* yystos */
71
72 #ifndef yydgoto
73 #define yydgoto grammar_dgoto
74 #endif /* yydgoto */
75
76 #ifndef yysindex
77 #define yysindex grammar_sindex
78 #endif /* yysindex */
79
80 #ifndef yyrindex
81 #define yyrindex grammar_rindex
82 #endif /* yyrindex */
83
84 #ifndef yygindex
85 #define yygindex grammar_gindex
86 #endif /* yygindex */
87
88 #ifndef yytable
89 #define yytable grammar_table
90 #endif /* yytable */
91
92 #ifndef yycheck
93 #define yycheck grammar_check
94 #endif /* yycheck */
95
96 #ifndef yyname
97 #define yyname grammar_name
98 #endif /* yyname */
99
100 #ifndef yyrule
101 #define yyrule grammar_rule
102 #endif /* yyrule */
103
104 #if YYBTYACC
105
106 #ifndef yycindex
107 #define yycindex grammar_cindex
108 #endif /* yycindex */
109
110 #ifndef yyctable
111 #define yyctable grammar_ctable
112 #endif /* yyctable */
113
114 #endif /* YYBTYACC */
115
116 #define YYPREFIX "grammar_"
117
118 #define YYPURE 0
119
120 #line 9 "grammar.y"
121 #ifdef YYBISON
122 #include <stdlib.h>
123 #define YYSTYPE_IS_DECLARED
124 #define yyerror yaccError
125 #endif
126
127 #if defined(YYBISON) || !defined(YYBYACC)
128 static void yyerror(const char *s);
129 #endif
130 #line 81 "grammar.y"
131 #include <stdio.h>
132 #include <ctype.h>
133 #include <string.h>
134
135 #define OPT_LINTLIBRARY 1
136
137 #ifndef TRUE
138 #define TRUE (1)
139 #endif
140
141 #ifndef FALSE
142 #define FALSE (0)
143 #endif
144
145 /* #include "cproto.h" */
146 #define MAX_TEXT_SIZE 1024
147
148 /* Prototype styles */
149 #if OPT_LINTLIBRARY
150 #define PROTO_ANSI_LLIB -2 /* form ANSI lint-library source */
151 #define PROTO_LINTLIBRARY -1 /* form lint-library source */
152 #endif
153 #define PROTO_NONE 0 /* do not output any prototypes */
154 #define PROTO_TRADITIONAL 1 /* comment out parameters */
155 #define PROTO_ABSTRACT 2 /* comment out parameter names */
156 #define PROTO_ANSI 3 /* ANSI C prototype */
157
158 typedef int PrototypeStyle;
159
160 typedef char boolean;
161
162 extern boolean types_out;
163 extern PrototypeStyle proto_style;
164
165 #define ansiLintLibrary() (proto_style == PROTO_ANSI_LLIB)
166 #define knrLintLibrary() (proto_style == PROTO_LINTLIBRARY)
167 #define lintLibrary() (knrLintLibrary() || ansiLintLibrary())
168
169 #if OPT_LINTLIBRARY
170 #define FUNC_UNKNOWN -1 /* unspecified */
171 #else
172 #define FUNC_UNKNOWN 0 /* unspecified (same as FUNC_NONE) */
173 #endif
174 #define FUNC_NONE 0 /* not a function definition */
175 #define FUNC_TRADITIONAL 1 /* traditional style */
176 #define FUNC_ANSI 2 /* ANSI style */
177 #define FUNC_BOTH 3 /* both styles */
178
179 typedef int FuncDefStyle;
180
181 /* Source file text */
182 typedef struct text {
183 char text[MAX_TEXT_SIZE]; /* source text */
184 long begin; /* offset in temporary file */
185 } Text;
186
187 /* Declaration specifier flags */
188 #define DS_NONE 0 /* default */
189 #define DS_EXTERN 1 /* contains "extern" specifier */
190 #define DS_STATIC 2 /* contains "static" specifier */
191 #define DS_CHAR 4 /* contains "char" type specifier */
192 #define DS_SHORT 8 /* contains "short" type specifier */
193 #define DS_FLOAT 16 /* contains "float" type specifier */
194 #define DS_INLINE 32 /* contains "inline" specifier */
195 #define DS_JUNK 64 /* we're not interested in this declaration */
196
197 /* This structure stores information about a declaration specifier. */
198 typedef struct decl_spec {
199 unsigned short flags; /* flags defined above */
200 char *text; /* source text */
201 long begin; /* offset in temporary file */
202 } DeclSpec;
203
204 /* This is a list of function parameters. */
205 typedef struct _ParameterList {
206 struct parameter *first; /* pointer to first parameter in list */
207 struct parameter *last; /* pointer to last parameter in list */
208 long begin_comment; /* begin offset of comment */
209 long end_comment; /* end offset of comment */
210 char *comment; /* comment at start of parameter list */
211 } ParameterList;
212
213 /* This structure stores information about a declarator. */
214 typedef struct _Declarator {
215 char *name; /* name of variable or function */
216 char *text; /* source text */
217 long begin; /* offset in temporary file */
218 long begin_comment; /* begin offset of comment */
219 long end_comment; /* end offset of comment */
220 FuncDefStyle func_def; /* style of function definition */
221 ParameterList params; /* function parameters */
222 boolean pointer; /* TRUE if it declares a pointer */
223 struct _Declarator *head; /* head function declarator */
224 struct _Declarator *func_stack; /* stack of function declarators */
225 struct _Declarator *next; /* next declarator in list */
226 } Declarator;
227
228 /* This structure stores information about a function parameter. */
229 typedef struct parameter {
230 struct parameter *next; /* next parameter in list */
231 DeclSpec decl_spec;
232 Declarator *declarator;
233 char *comment; /* comment following the parameter */
234 } Parameter;
235
236 /* This is a list of declarators. */
237 typedef struct declarator_list {
238 Declarator *first; /* pointer to first declarator in list */
239 Declarator *last; /* pointer to last declarator in list */
240 } DeclaratorList;
241
242 /* #include "symbol.h" */
243 typedef struct symbol {
244 struct symbol *next; /* next symbol in list */
245 char *name; /* name of symbol */
246 char *value; /* value of symbol (for defines) */
247 short flags; /* symbol attributes */
248 } Symbol;
249
250 /* parser stack entry type */
251 typedef union {
252 Text text;
253 DeclSpec decl_spec;
254 Parameter *parameter;
255 ParameterList param_list;
256 Declarator *declarator;
257 DeclaratorList decl_list;
258 } YYSTYPE;
259
260 /* The hash table length should be a prime number. */
261 #define SYM_MAX_HASH 251
262
263 typedef struct symbol_table {
264 Symbol *bucket[SYM_MAX_HASH]; /* hash buckets */
265 } SymbolTable;
266
267 extern SymbolTable *new_symbol_table /* Create symbol table */
268 (void);
269 extern void free_symbol_table /* Destroy symbol table */
270 (SymbolTable *s);
271 extern Symbol *find_symbol /* Lookup symbol name */
272 (SymbolTable *s, const char *n);
273 extern Symbol *new_symbol /* Define new symbol */
274 (SymbolTable *s, const char *n, const char *v, int f);
275
276 /* #include "semantic.h" */
277 extern void new_decl_spec (DeclSpec *, const char *, long, int);
278 extern void free_decl_spec (DeclSpec *);
279 extern void join_decl_specs (DeclSpec *, DeclSpec *, DeclSpec *);
280 extern void check_untagged (DeclSpec *);
281 extern Declarator *new_declarator (const char *, const char *, long);
282 extern void free_declarator (Declarator *);
283 extern void new_decl_list (DeclaratorList *, Declarator *);
284 extern void free_decl_list (DeclaratorList *);
285 extern void add_decl_list (DeclaratorList *, DeclaratorList *, Declarator *);
286 extern Parameter *new_parameter (DeclSpec *, Declarator *);
287 extern void free_parameter (Parameter *);
288 extern void new_param_list (ParameterList *, Parameter *);
289 extern void free_param_list (ParameterList *);
290 extern void add_param_list (ParameterList *, ParameterList *, Parameter *);
291 extern void new_ident_list (ParameterList *);
292 extern void add_ident_list (ParameterList *, ParameterList *, const char *);
293 extern void set_param_types (ParameterList *, DeclSpec *, DeclaratorList *);
294 extern void gen_declarations (DeclSpec *, DeclaratorList *);
295 extern void gen_prototype (DeclSpec *, Declarator *);
296 extern void gen_func_declarator (Declarator *);
297 extern void gen_func_definition (DeclSpec *, Declarator *);
298
299 extern void init_parser (void);
300 extern void process_file (FILE *infile, char *name);
301 extern char *cur_text (void);
302 extern char *cur_file_name (void);
303 extern char *implied_typedef (void);
304 extern void include_file (char *name, int convert);
305 extern char *supply_parm (int count);
306 extern char *xstrdup (const char *);
307 extern int already_declared (char *name);
308 extern int is_actual_func (Declarator *d);
309 extern int lint_ellipsis (Parameter *p);
310 extern int want_typedef (void);
311 extern void begin_tracking (void);
312 extern void begin_typedef (void);
313 extern void copy_typedef (char *s);
314 extern void ellipsis_varargs (Declarator *d);
315 extern void end_typedef (void);
316 extern void flush_varargs (void);
317 extern void fmt_library (int code);
318 extern void imply_typedef (const char *s);
319 extern void indent (FILE *outf);
320 extern void put_blankline (FILE *outf);
321 extern void put_body (FILE *outf, DeclSpec *decl_spec, Declarator *declarator);
322 extern void put_char (FILE *outf, int c);
323 extern void put_error (void);
324 extern void put_newline (FILE *outf);
325 extern void put_padded (FILE *outf, const char *s);
326 extern void put_string (FILE *outf, const char *s);
327 extern void track_in (void);
328
329 extern boolean file_comments;
330 extern FuncDefStyle func_style;
331 extern char base_file[];
332
333 extern int yylex (void);
334
335 /* declaration specifier attributes for the typedef statement currently being
336 * scanned
337 */
338 static int cur_decl_spec_flags;
339
340 /* pointer to parameter list for the current function definition */
341 static ParameterList *func_params;
342
343 /* A parser semantic action sets this pointer to the current declarator in
344 * a function parameter declaration in order to catch any comments following
345 * the parameter declaration on the same line. If the lexer scans a comment
346 * and <cur_declarator> is not NULL, then the comment is attached to the
347 * declarator. To ignore subsequent comments, the lexer sets this to NULL
348 * after scanning a comment or end of line.
349 */
350 static Declarator *cur_declarator;
351
352 /* temporary string buffer */
353 static char buf[MAX_TEXT_SIZE];
354
355 /* table of typedef names */
356 static SymbolTable *typedef_names;
357
358 /* table of define names */
359 static SymbolTable *define_names;
360
361 /* table of type qualifiers */
362 static SymbolTable *type_qualifiers;
363
364 /* information about the current input file */
365 typedef struct {
366 char *base_name; /* base input file name */
367 char *file_name; /* current file name */
368 FILE *file; /* input file */
369 unsigned line_num; /* current line number in input file */
370 FILE *tmp_file; /* temporary file */
371 long begin_comment; /* tmp file offset after last written ) or ; */
372 long end_comment; /* tmp file offset after last comment */
373 boolean convert; /* if TRUE, convert function definitions */
374 boolean changed; /* TRUE if conversion done in this file */
375 } IncludeStack;
376
377 static IncludeStack *cur_file; /* current input file */
378
379 /* #include "yyerror.c" */
380
381 static int haveAnsiParam (void);
382
383
384 /* Flags to enable us to find if a procedure returns a value.
385 */
386 static int return_val; /* nonzero on BRACES iff return-expression found */
387
388 static const char *
dft_decl_spec(void)389 dft_decl_spec (void)
390 {
391 return (lintLibrary() && !return_val) ? "void" : "int";
392 }
393
394 static int
haveAnsiParam(void)395 haveAnsiParam (void)
396 {
397 Parameter *p;
398 if (func_params != 0) {
399 for (p = func_params->first; p != 0; p = p->next) {
400 if (p->declarator->func_def == FUNC_ANSI) {
401 return TRUE;
402 }
403 }
404 }
405 return FALSE;
406 }
407 #line 408 "grammar.tab.c"
408
409 /* compatibility with bison */
410 #ifdef YYPARSE_PARAM
411 /* compatibility with FreeBSD */
412 # ifdef YYPARSE_PARAM_TYPE
413 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
414 # else
415 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
416 # endif
417 #else
418 # define YYPARSE_DECL() yyparse(void)
419 #endif
420
421 /* Parameters sent to lex. */
422 #ifdef YYLEX_PARAM
423 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
424 # define YYLEX yylex(YYLEX_PARAM)
425 #else
426 # define YYLEX_DECL() yylex(void)
427 # define YYLEX yylex()
428 #endif
429
430 /* Parameters sent to yyerror. */
431 #ifndef YYERROR_DECL
432 #define YYERROR_DECL() yyerror(const char *s)
433 #endif
434 #ifndef YYERROR_CALL
435 #define YYERROR_CALL(msg) yyerror(msg)
436 #endif
437
438 extern int YYPARSE_DECL();
439
440 #define T_IDENTIFIER 257
441 #define T_TYPEDEF_NAME 258
442 #define T_DEFINE_NAME 259
443 #define T_AUTO 260
444 #define T_EXTERN 261
445 #define T_REGISTER 262
446 #define T_STATIC 263
447 #define T_TYPEDEF 264
448 #define T_INLINE 265
449 #define T_EXTENSION 266
450 #define T_CHAR 267
451 #define T_DOUBLE 268
452 #define T_FLOAT 269
453 #define T_INT 270
454 #define T_VOID 271
455 #define T_LONG 272
456 #define T_SHORT 273
457 #define T_SIGNED 274
458 #define T_UNSIGNED 275
459 #define T_ENUM 276
460 #define T_STRUCT 277
461 #define T_UNION 278
462 #define T_Bool 279
463 #define T_Complex 280
464 #define T_Imaginary 281
465 #define T_TYPE_QUALIFIER 282
466 #define T_BRACKETS 283
467 #define T_LBRACE 284
468 #define T_MATCHRBRACE 285
469 #define T_ELLIPSIS 286
470 #define T_INITIALIZER 287
471 #define T_STRING_LITERAL 288
472 #define T_ASM 289
473 #define T_ASMARG 290
474 #define T_VA_DCL 291
475 #define YYERRCODE 256
476 typedef short YYINT;
477 static const YYINT grammar_lhs[] = { -1,
478 0, 0, 26, 26, 27, 27, 27, 27, 27, 27,
479 27, 31, 30, 30, 28, 28, 34, 28, 32, 32,
480 33, 33, 35, 35, 37, 38, 29, 39, 29, 36,
481 36, 36, 40, 40, 1, 1, 2, 2, 2, 3,
482 3, 3, 3, 3, 3, 4, 4, 4, 4, 4,
483 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
484 5, 5, 6, 6, 6, 19, 19, 8, 8, 9,
485 41, 9, 7, 7, 7, 25, 23, 23, 10, 10,
486 11, 11, 11, 11, 11, 20, 20, 21, 21, 22,
487 22, 14, 14, 15, 15, 16, 16, 16, 17, 17,
488 18, 18, 24, 24, 12, 12, 12, 13, 13, 13,
489 13, 13, 13, 13,
490 };
491 static const YYINT grammar_len[] = { 2,
492 0, 1, 1, 2, 1, 1, 1, 1, 3, 2,
493 2, 2, 3, 3, 2, 3, 0, 5, 2, 1,
494 0, 1, 1, 3, 0, 0, 7, 0, 5, 0,
495 1, 1, 1, 2, 1, 2, 1, 1, 1, 1,
496 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
497 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
498 1, 1, 3, 2, 2, 1, 1, 1, 3, 1,
499 0, 4, 3, 2, 2, 1, 1, 1, 2, 1,
500 1, 3, 2, 4, 4, 2, 3, 0, 1, 1,
501 2, 1, 3, 1, 3, 2, 2, 1, 0, 1,
502 1, 3, 1, 2, 1, 2, 1, 3, 2, 1,
503 4, 3, 3, 2,
504 };
505 static const YYINT grammar_defred[] = { 0,
506 0, 0, 0, 0, 77, 0, 62, 40, 0, 42,
507 43, 20, 44, 0, 46, 47, 48, 49, 54, 50,
508 51, 52, 53, 76, 66, 67, 55, 56, 57, 61,
509 0, 7, 0, 0, 35, 37, 38, 39, 59, 60,
510 28, 0, 0, 0, 103, 81, 0, 0, 3, 5,
511 6, 8, 0, 10, 11, 78, 0, 90, 0, 0,
512 104, 0, 19, 0, 41, 45, 15, 36, 0, 68,
513 0, 0, 0, 83, 0, 0, 64, 0, 0, 74,
514 4, 58, 0, 82, 87, 91, 0, 14, 13, 9,
515 16, 0, 71, 0, 31, 33, 0, 0, 0, 0,
516 0, 94, 0, 0, 101, 12, 63, 73, 0, 0,
517 69, 0, 0, 0, 34, 0, 110, 96, 97, 0,
518 0, 84, 0, 85, 0, 23, 0, 0, 72, 26,
519 29, 114, 0, 0, 0, 109, 0, 93, 95, 102,
520 18, 0, 0, 108, 113, 112, 0, 24, 27, 111,
521 };
522 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
523 static const YYINT grammar_stos[] = { 0,
524 256, 40, 42, 38, 257, 258, 259, 260, 261, 262,
525 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
526 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
527 289, 59, 293, 294, 295, 296, 297, 298, 299, 300,
528 303, 304, 312, 313, 316, 317, 318, 319, 320, 321,
529 322, 323, 325, 285, 59, 258, 303, 298, 314, 315,
530 316, 288, 264, 290, 261, 266, 59, 295, 301, 302,
531 303, 332, 40, 283, 284, 316, 324, 304, 316, 324,
532 320, 258, 294, 41, 313, 298, 294, 321, 324, 59,
533 59, 44, 61, 330, 291, 321, 329, 333, 294, 307,
534 308, 309, 310, 311, 316, 285, 324, 324, 327, 303,
535 302, 334, 329, 284, 321, 40, 283, 303, 305, 306,
536 313, 41, 44, 41, 44, 303, 326, 328, 287, 284,
537 285, 41, 305, 307, 40, 283, 306, 286, 309, 316,
538 59, 44, 331, 41, 41, 41, 307, 303, 285, 41,
539 };
540 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
541 static const YYINT grammar_dgoto[] = { 33,
542 87, 35, 36, 37, 38, 39, 40, 69, 70, 41,
543 42, 119, 120, 100, 101, 102, 103, 104, 43, 44,
544 59, 60, 45, 46, 47, 48, 49, 50, 51, 52,
545 77, 53, 127, 109, 128, 97, 94, 143, 72, 98,
546 112,
547 };
548 static const YYINT grammar_sindex[] = { -2,
549 -3, 27, -239, -177, 0, 0, 0, 0, -274, 0,
550 0, 0, 0, -246, 0, 0, 0, 0, 0, 0,
551 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
552 -266, 0, 0, 455, 0, 0, 0, 0, 0, 0,
553 0, -35, -245, 128, 0, 0, -245, -2, 0, 0,
554 0, 0, 642, 0, 0, 0, -15, 0, -12, -239,
555 0, 590, 0, -27, 0, 0, 0, 0, -10, 0,
556 -11, 534, -72, 0, -237, -232, 0, -35, -232, 0,
557 0, 0, 642, 0, 0, 0, 455, 0, 0, 0,
558 0, 27, 0, 534, 0, 0, -222, 617, 209, 34,
559 39, 0, 44, 42, 0, 0, 0, 0, 27, -11,
560 0, -200, -196, -195, 0, 174, 0, 0, 0, -33,
561 243, 0, 561, 0, -177, 0, 33, 49, 0, 0,
562 0, 0, 53, 55, 417, 0, -33, 0, 0, 0,
563 0, 27, -188, 0, 0, 0, 57, 0, 0, 0,
564 };
565 static const YYINT grammar_rindex[] = { 99,
566 0, 0, 275, 0, 0, -38, 0, 0, 481, 0,
567 0, 0, 0, 509, 0, 0, 0, 0, 0, 0,
568 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
569 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
570 0, 30, 0, 0, 0, 0, 0, 101, 0, 0,
571 0, 0, 0, 0, 0, 0, 0, 0, 343, 309,
572 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
573 98, -182, 62, 0, 0, 133, 0, 64, 379, 0,
574 0, 0, -5, 0, 0, 0, 0, 0, 0, 0,
575 0, 0, 0, -182, 0, 0, 0, -180, -19, 0,
576 65, 0, 0, 68, 0, 0, 0, 0, 51, 9,
577 0, 0, 0, 0, 0, 0, 0, 0, 0, -13,
578 19, 0, 0, 0, 0, 0, 0, 52, 0, 0,
579 0, 0, 0, 0, 0, 0, 35, 0, 0, 0,
580 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
581 };
582 #if YYBTYACC
583 static const YYINT grammar_cindex[] = { 0,
584 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
585 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
586 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
587 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
588 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
589 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
590 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
591 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
592 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
593 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
594 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
595 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
596 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
597 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
598 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
599 };
600 #endif
601 static const YYINT grammar_gindex[] = { 0,
602 11, -17, 0, 0, 13, 0, 0, 0, 20, 8,
603 -43, -1, -8, -89, 0, -9, 0, 0, 0, -44,
604 0, 0, 4, 0, 0, 0, 70, -53, 0, 0,
605 -18, 0, 0, 0, 0, 22, 0, 0, 0, 0,
606 0,
607 };
608 #define YYTABLESIZE 924
609 static const YYINT grammar_table[] = { 58,
610 78, 58, 58, 58, 73, 58, 135, 61, 88, 57,
611 34, 5, 56, 62, 85, 58, 68, 63, 96, 7,
612 58, 98, 78, 64, 98, 84, 134, 107, 80, 3,
613 107, 90, 17, 92, 17, 4, 17, 2, 75, 3,
614 96, 71, 30, 89, 115, 147, 76, 106, 91, 93,
615 79, 75, 70, 17, 121, 55, 32, 107, 34, 105,
616 108, 114, 105, 83, 4, 68, 2, 70, 3, 68,
617 80, 121, 86, 80, 122, 106, 105, 78, 106, 5,
618 56, 68, 123, 99, 124, 125, 129, 130, 80, 131,
619 80, 141, 142, 144, 110, 145, 149, 150, 1, 110,
620 2, 30, 99, 32, 79, 92, 118, 79, 100, 21,
621 22, 111, 137, 139, 133, 113, 126, 81, 0, 0,
622 0, 0, 79, 57, 79, 0, 99, 0, 140, 0,
623 0, 0, 0, 99, 0, 0, 0, 0, 0, 0,
624 0, 70, 0, 0, 0, 99, 0, 0, 0, 148,
625 0, 0, 0, 0, 0, 0, 70, 0, 0, 0,
626 0, 0, 0, 0, 0, 4, 0, 2, 0, 0,
627 65, 0, 65, 65, 65, 0, 65, 0, 0, 0,
628 0, 0, 0, 0, 5, 6, 7, 8, 65, 10,
629 11, 65, 13, 66, 15, 16, 17, 18, 19, 20,
630 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
631 0, 4, 0, 116, 132, 3, 0, 0, 58, 58,
632 58, 58, 58, 58, 58, 78, 58, 58, 58, 58,
633 58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
634 58, 58, 58, 58, 58, 78, 4, 74, 116, 136,
635 3, 17, 78, 1, 5, 6, 7, 8, 9, 10,
636 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
637 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
638 4, 54, 116, 5, 56, 0, 31, 80, 80, 80,
639 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
640 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
641 80, 80, 88, 80, 88, 88, 88, 0, 88, 0,
642 80, 79, 79, 79, 79, 79, 79, 79, 79, 79,
643 79, 79, 79, 79, 79, 79, 79, 79, 79, 79,
644 79, 79, 79, 79, 79, 79, 89, 79, 89, 89,
645 89, 0, 89, 0, 79, 25, 25, 25, 25, 25,
646 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
647 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
648 86, 25, 86, 86, 5, 56, 86, 0, 25, 65,
649 65, 65, 65, 65, 65, 65, 0, 65, 65, 65,
650 65, 65, 65, 65, 65, 65, 65, 65, 65, 65,
651 65, 65, 65, 65, 65, 65, 75, 0, 75, 75,
652 75, 0, 75, 0, 0, 0, 0, 0, 0, 0,
653 5, 6, 7, 8, 65, 10, 11, 75, 13, 66,
654 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
655 25, 26, 27, 28, 29, 30, 117, 146, 0, 0,
656 0, 0, 0, 0, 0, 5, 6, 7, 8, 65,
657 10, 11, 0, 13, 66, 15, 16, 17, 18, 19,
658 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
659 30, 117, 4, 0, 2, 0, 3, 0, 0, 5,
660 56, 0, 0, 0, 0, 0, 0, 0, 0, 0,
661 0, 0, 0, 67, 0, 0, 0, 0, 41, 0,
662 41, 0, 41, 0, 0, 117, 0, 0, 0, 0,
663 0, 88, 88, 0, 0, 0, 0, 0, 0, 41,
664 0, 0, 0, 0, 0, 0, 45, 0, 45, 0,
665 45, 0, 0, 0, 0, 0, 0, 88, 0, 0,
666 0, 0, 0, 0, 0, 89, 89, 45, 0, 0,
667 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
668 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
669 0, 89, 0, 0, 0, 0, 0, 0, 0, 86,
670 86, 0, 0, 0, 0, 0, 0, 0, 0, 0,
671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
672 0, 0, 0, 0, 0, 86, 0, 0, 0, 0,
673 0, 0, 0, 0, 0, 75, 75, 75, 75, 75,
674 75, 75, 0, 75, 75, 75, 75, 75, 75, 75,
675 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
676 75, 75, 0, 0, 0, 0, 0, 0, 0, 0,
677 0, 0, 0, 0, 82, 7, 8, 65, 10, 11,
678 0, 13, 66, 15, 16, 17, 18, 19, 20, 21,
679 22, 23, 24, 25, 26, 27, 28, 29, 30, 0,
680 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
681 0, 5, 6, 7, 8, 65, 10, 11, 0, 13,
682 66, 15, 16, 17, 18, 19, 20, 21, 22, 23,
683 24, 25, 26, 27, 28, 29, 30, 41, 41, 41,
684 41, 41, 41, 41, 0, 41, 41, 41, 41, 41,
685 41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
686 41, 41, 41, 0, 0, 45, 45, 45, 45, 45,
687 45, 45, 0, 45, 45, 45, 45, 45, 45, 45,
688 45, 45, 45, 45, 45, 45, 45, 45, 45, 45,
689 45, 82, 7, 8, 65, 10, 11, 12, 13, 14,
690 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
691 25, 26, 27, 28, 29, 30, 0, 0, 82, 7,
692 8, 65, 10, 11, 95, 13, 66, 15, 16, 17,
693 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
694 28, 29, 30, 0, 0, 0, 138, 82, 7, 8,
695 65, 10, 11, 12, 13, 14, 15, 16, 17, 18,
696 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
697 29, 30, 0, 75, 82, 7, 8, 65, 10, 11,
698 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
699 22, 23, 24, 25, 26, 27, 28, 29, 30, 82,
700 7, 8, 65, 10, 11, 0, 13, 66, 15, 16,
701 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
702 27, 28, 29, 30,
703 };
704 static const YYINT grammar_check[] = { 38,
705 44, 40, 41, 42, 40, 44, 40, 4, 62, 2,
706 0, 257, 258, 288, 59, 3, 34, 264, 72, 259,
707 59, 41, 61, 290, 44, 41, 116, 41, 47, 42,
708 44, 59, 38, 44, 40, 38, 42, 40, 284, 42,
709 94, 34, 282, 62, 98, 135, 43, 285, 59, 61,
710 47, 284, 44, 59, 99, 59, 59, 76, 48, 41,
711 79, 284, 44, 53, 38, 83, 40, 59, 42, 87,
712 41, 116, 60, 44, 41, 41, 73, 121, 44, 257,
713 258, 99, 44, 73, 41, 44, 287, 284, 59, 285,
714 61, 59, 44, 41, 87, 41, 285, 41, 0, 92,
715 0, 284, 41, 284, 41, 41, 99, 44, 41, 59,
716 59, 92, 121, 123, 116, 94, 109, 48, -1, -1,
717 -1, -1, 59, 116, 61, -1, 116, -1, 125, -1,
718 -1, -1, -1, 123, -1, -1, -1, -1, -1, -1,
719 -1, 44, -1, -1, -1, 135, -1, -1, -1, 142,
720 -1, -1, -1, -1, -1, -1, 59, -1, -1, -1,
721 -1, -1, -1, -1, -1, 38, -1, 40, -1, -1,
722 38, -1, 40, 41, 42, -1, 44, -1, -1, -1,
723 -1, -1, -1, -1, 257, 258, 259, 260, 261, 262,
724 263, 59, 265, 266, 267, 268, 269, 270, 271, 272,
725 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
726 -1, 38, -1, 40, 41, 42, -1, -1, 257, 258,
727 259, 260, 261, 262, 263, 264, 265, 266, 267, 268,
728 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
729 279, 280, 281, 282, 283, 284, 38, 283, 40, 283,
730 42, 257, 291, 256, 257, 258, 259, 260, 261, 262,
731 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
732 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
733 38, 285, 40, 257, 258, -1, 289, 258, 259, 260,
734 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
735 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
736 281, 282, 38, 284, 40, 41, 42, -1, 44, -1,
737 291, 258, 259, 260, 261, 262, 263, 264, 265, 266,
738 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
739 277, 278, 279, 280, 281, 282, 38, 284, 40, 41,
740 42, -1, 44, -1, 291, 258, 259, 260, 261, 262,
741 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
742 273, 274, 275, 276, 277, 278, 279, 280, 281, 282,
743 38, 284, 40, 41, 257, 258, 44, -1, 291, 257,
744 258, 259, 260, 261, 262, 263, -1, 265, 266, 267,
745 268, 269, 270, 271, 272, 273, 274, 275, 276, 277,
746 278, 279, 280, 281, 282, 283, 38, -1, 40, 41,
747 42, -1, 44, -1, -1, -1, -1, -1, -1, -1,
748 257, 258, 259, 260, 261, 262, 263, 59, 265, 266,
749 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
750 277, 278, 279, 280, 281, 282, 283, 41, -1, -1,
751 -1, -1, -1, -1, -1, 257, 258, 259, 260, 261,
752 262, 263, -1, 265, 266, 267, 268, 269, 270, 271,
753 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
754 282, 283, 38, -1, 40, -1, 42, -1, -1, 257,
755 258, -1, -1, -1, -1, -1, -1, -1, -1, -1,
756 -1, -1, -1, 59, -1, -1, -1, -1, 38, -1,
757 40, -1, 42, -1, -1, 283, -1, -1, -1, -1,
758 -1, 257, 258, -1, -1, -1, -1, -1, -1, 59,
759 -1, -1, -1, -1, -1, -1, 38, -1, 40, -1,
760 42, -1, -1, -1, -1, -1, -1, 283, -1, -1,
761 -1, -1, -1, -1, -1, 257, 258, 59, -1, -1,
762 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
763 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
764 -1, 283, -1, -1, -1, -1, -1, -1, -1, 257,
765 258, -1, -1, -1, -1, -1, -1, -1, -1, -1,
766 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
767 -1, -1, -1, -1, -1, 283, -1, -1, -1, -1,
768 -1, -1, -1, -1, -1, 257, 258, 259, 260, 261,
769 262, 263, -1, 265, 266, 267, 268, 269, 270, 271,
770 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
771 282, 283, -1, -1, -1, -1, -1, -1, -1, -1,
772 -1, -1, -1, -1, 258, 259, 260, 261, 262, 263,
773 -1, 265, 266, 267, 268, 269, 270, 271, 272, 273,
774 274, 275, 276, 277, 278, 279, 280, 281, 282, -1,
775 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
776 -1, 257, 258, 259, 260, 261, 262, 263, -1, 265,
777 266, 267, 268, 269, 270, 271, 272, 273, 274, 275,
778 276, 277, 278, 279, 280, 281, 282, 257, 258, 259,
779 260, 261, 262, 263, -1, 265, 266, 267, 268, 269,
780 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
781 280, 281, 282, -1, -1, 257, 258, 259, 260, 261,
782 262, 263, -1, 265, 266, 267, 268, 269, 270, 271,
783 272, 273, 274, 275, 276, 277, 278, 279, 280, 281,
784 282, 258, 259, 260, 261, 262, 263, 264, 265, 266,
785 267, 268, 269, 270, 271, 272, 273, 274, 275, 276,
786 277, 278, 279, 280, 281, 282, -1, -1, 258, 259,
787 260, 261, 262, 263, 291, 265, 266, 267, 268, 269,
788 270, 271, 272, 273, 274, 275, 276, 277, 278, 279,
789 280, 281, 282, -1, -1, -1, 286, 258, 259, 260,
790 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
791 271, 272, 273, 274, 275, 276, 277, 278, 279, 280,
792 281, 282, -1, 284, 258, 259, 260, 261, 262, 263,
793 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,
794 274, 275, 276, 277, 278, 279, 280, 281, 282, 258,
795 259, 260, 261, 262, 263, -1, 265, 266, 267, 268,
796 269, 270, 271, 272, 273, 274, 275, 276, 277, 278,
797 279, 280, 281, 282,
798 };
799 #if YYBTYACC
800 static const YYINT grammar_ctable[] = { -1,
801 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
802 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
803 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
804 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
805 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
806 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
807 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
808 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
809 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
810 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
811 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
812 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
813 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
814 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
815 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
816 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
817 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
818 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
819 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
820 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
821 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
822 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
823 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
824 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
825 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
826 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
827 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
828 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
829 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
830 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
831 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
832 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
833 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
834 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
835 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
836 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
837 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
838 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
839 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
840 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
841 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
842 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
843 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
844 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
845 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
846 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
847 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
848 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
849 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
850 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
851 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
852 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
853 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
854 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
855 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
856 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
857 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
858 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
859 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
860 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
861 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
862 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
863 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
864 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
865 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
866 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
867 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
868 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
869 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
870 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
871 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
872 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
873 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
874 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
875 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
876 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
877 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
878 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
879 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
880 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
881 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
882 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
883 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
884 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
885 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
886 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
887 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
888 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
889 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
890 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
891 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
892 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
893 -1, -1, -1,
894 };
895 #endif
896 #define YYFINAL 33
897 #ifndef YYDEBUG
898 #define YYDEBUG 0
899 #endif
900 #define YYMAXTOKEN 291
901 #define YYUNDFTOKEN 335
902 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
903 #if YYDEBUG
904 static const char *const grammar_name[] = {
905
906 "$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
907 0,"'&'",0,"'('","')'","'*'",0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,"';'",0,"'='",0,
908 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
909 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
910 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
911 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
912 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"error",
913 "T_IDENTIFIER","T_TYPEDEF_NAME","T_DEFINE_NAME","T_AUTO","T_EXTERN",
914 "T_REGISTER","T_STATIC","T_TYPEDEF","T_INLINE","T_EXTENSION","T_CHAR",
915 "T_DOUBLE","T_FLOAT","T_INT","T_VOID","T_LONG","T_SHORT","T_SIGNED",
916 "T_UNSIGNED","T_ENUM","T_STRUCT","T_UNION","T_Bool","T_Complex","T_Imaginary",
917 "T_TYPE_QUALIFIER","T_BRACKETS","T_LBRACE","T_MATCHRBRACE","T_ELLIPSIS",
918 "T_INITIALIZER","T_STRING_LITERAL","T_ASM","T_ASMARG","T_VA_DCL","$accept",
919 "program","decl_specifiers","decl_specifier","storage_class","type_specifier",
920 "type_qualifier","struct_or_union_specifier","enum_specifier",
921 "init_declarator_list","init_declarator","declarator","direct_declarator",
922 "abs_declarator","direct_abs_declarator","parameter_type_list","parameter_list",
923 "parameter_declaration","opt_identifier_list","identifier_list",
924 "struct_or_union","pointer","opt_type_qualifiers","type_qualifier_list",
925 "any_id","identifier_or_ref","enumeration","translation_unit",
926 "external_declaration","declaration","function_definition",
927 "linkage_specification","braces","any_typedef","opt_declarator_list","$$1",
928 "declarator_list","opt_declaration_list","$$2","$$3","$$4","declaration_list",
929 "$$5","illegal-symbol",
930 };
931 static const char *const grammar_rule[] = {
932 "$accept : program",
933 "program :",
934 "program : translation_unit",
935 "translation_unit : external_declaration",
936 "translation_unit : translation_unit external_declaration",
937 "external_declaration : declaration",
938 "external_declaration : function_definition",
939 "external_declaration : ';'",
940 "external_declaration : linkage_specification",
941 "external_declaration : T_ASM T_ASMARG ';'",
942 "external_declaration : error T_MATCHRBRACE",
943 "external_declaration : error ';'",
944 "braces : T_LBRACE T_MATCHRBRACE",
945 "linkage_specification : T_EXTERN T_STRING_LITERAL braces",
946 "linkage_specification : T_EXTERN T_STRING_LITERAL declaration",
947 "declaration : decl_specifiers ';'",
948 "declaration : decl_specifiers init_declarator_list ';'",
949 "$$1 :",
950 "declaration : any_typedef decl_specifiers $$1 opt_declarator_list ';'",
951 "any_typedef : T_EXTENSION T_TYPEDEF",
952 "any_typedef : T_TYPEDEF",
953 "opt_declarator_list :",
954 "opt_declarator_list : declarator_list",
955 "declarator_list : declarator",
956 "declarator_list : declarator_list ',' declarator",
957 "$$2 :",
958 "$$3 :",
959 "function_definition : decl_specifiers declarator $$2 opt_declaration_list T_LBRACE $$3 T_MATCHRBRACE",
960 "$$4 :",
961 "function_definition : declarator $$4 opt_declaration_list T_LBRACE T_MATCHRBRACE",
962 "opt_declaration_list :",
963 "opt_declaration_list : T_VA_DCL",
964 "opt_declaration_list : declaration_list",
965 "declaration_list : declaration",
966 "declaration_list : declaration_list declaration",
967 "decl_specifiers : decl_specifier",
968 "decl_specifiers : decl_specifiers decl_specifier",
969 "decl_specifier : storage_class",
970 "decl_specifier : type_specifier",
971 "decl_specifier : type_qualifier",
972 "storage_class : T_AUTO",
973 "storage_class : T_EXTERN",
974 "storage_class : T_REGISTER",
975 "storage_class : T_STATIC",
976 "storage_class : T_INLINE",
977 "storage_class : T_EXTENSION",
978 "type_specifier : T_CHAR",
979 "type_specifier : T_DOUBLE",
980 "type_specifier : T_FLOAT",
981 "type_specifier : T_INT",
982 "type_specifier : T_LONG",
983 "type_specifier : T_SHORT",
984 "type_specifier : T_SIGNED",
985 "type_specifier : T_UNSIGNED",
986 "type_specifier : T_VOID",
987 "type_specifier : T_Bool",
988 "type_specifier : T_Complex",
989 "type_specifier : T_Imaginary",
990 "type_specifier : T_TYPEDEF_NAME",
991 "type_specifier : struct_or_union_specifier",
992 "type_specifier : enum_specifier",
993 "type_qualifier : T_TYPE_QUALIFIER",
994 "type_qualifier : T_DEFINE_NAME",
995 "struct_or_union_specifier : struct_or_union any_id braces",
996 "struct_or_union_specifier : struct_or_union braces",
997 "struct_or_union_specifier : struct_or_union any_id",
998 "struct_or_union : T_STRUCT",
999 "struct_or_union : T_UNION",
1000 "init_declarator_list : init_declarator",
1001 "init_declarator_list : init_declarator_list ',' init_declarator",
1002 "init_declarator : declarator",
1003 "$$5 :",
1004 "init_declarator : declarator '=' $$5 T_INITIALIZER",
1005 "enum_specifier : enumeration any_id braces",
1006 "enum_specifier : enumeration braces",
1007 "enum_specifier : enumeration any_id",
1008 "enumeration : T_ENUM",
1009 "any_id : T_IDENTIFIER",
1010 "any_id : T_TYPEDEF_NAME",
1011 "declarator : pointer direct_declarator",
1012 "declarator : direct_declarator",
1013 "direct_declarator : identifier_or_ref",
1014 "direct_declarator : '(' declarator ')'",
1015 "direct_declarator : direct_declarator T_BRACKETS",
1016 "direct_declarator : direct_declarator '(' parameter_type_list ')'",
1017 "direct_declarator : direct_declarator '(' opt_identifier_list ')'",
1018 "pointer : '*' opt_type_qualifiers",
1019 "pointer : '*' opt_type_qualifiers pointer",
1020 "opt_type_qualifiers :",
1021 "opt_type_qualifiers : type_qualifier_list",
1022 "type_qualifier_list : type_qualifier",
1023 "type_qualifier_list : type_qualifier_list type_qualifier",
1024 "parameter_type_list : parameter_list",
1025 "parameter_type_list : parameter_list ',' T_ELLIPSIS",
1026 "parameter_list : parameter_declaration",
1027 "parameter_list : parameter_list ',' parameter_declaration",
1028 "parameter_declaration : decl_specifiers declarator",
1029 "parameter_declaration : decl_specifiers abs_declarator",
1030 "parameter_declaration : decl_specifiers",
1031 "opt_identifier_list :",
1032 "opt_identifier_list : identifier_list",
1033 "identifier_list : any_id",
1034 "identifier_list : identifier_list ',' any_id",
1035 "identifier_or_ref : any_id",
1036 "identifier_or_ref : '&' any_id",
1037 "abs_declarator : pointer",
1038 "abs_declarator : pointer direct_abs_declarator",
1039 "abs_declarator : direct_abs_declarator",
1040 "direct_abs_declarator : '(' abs_declarator ')'",
1041 "direct_abs_declarator : direct_abs_declarator T_BRACKETS",
1042 "direct_abs_declarator : T_BRACKETS",
1043 "direct_abs_declarator : direct_abs_declarator '(' parameter_type_list ')'",
1044 "direct_abs_declarator : direct_abs_declarator '(' ')'",
1045 "direct_abs_declarator : '(' parameter_type_list ')'",
1046 "direct_abs_declarator : '(' ')'",
1047
1048 };
1049 #endif
1050
1051 int yydebug;
1052 int yynerrs;
1053
1054 int yyerrflag;
1055 int yychar;
1056 YYSTYPE yyval;
1057 YYSTYPE yylval;
1058 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1059 YYLTYPE yyloc; /* position returned by actions */
1060 YYLTYPE yylloc; /* position from the lexer */
1061 #endif
1062
1063 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1064 #ifndef YYLLOC_DEFAULT
1065 #define YYLLOC_DEFAULT(loc, rhs, n) \
1066 do \
1067 { \
1068 if (n == 0) \
1069 { \
1070 (loc).first_line = ((rhs)[-1]).last_line; \
1071 (loc).first_column = ((rhs)[-1]).last_column; \
1072 (loc).last_line = ((rhs)[-1]).last_line; \
1073 (loc).last_column = ((rhs)[-1]).last_column; \
1074 } \
1075 else \
1076 { \
1077 (loc).first_line = ((rhs)[ 0 ]).first_line; \
1078 (loc).first_column = ((rhs)[ 0 ]).first_column; \
1079 (loc).last_line = ((rhs)[n-1]).last_line; \
1080 (loc).last_column = ((rhs)[n-1]).last_column; \
1081 } \
1082 } while (0)
1083 #endif /* YYLLOC_DEFAULT */
1084 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1085 #if YYBTYACC
1086
1087 #ifndef YYLVQUEUEGROWTH
1088 #define YYLVQUEUEGROWTH 32
1089 #endif
1090 #endif /* YYBTYACC */
1091
1092 /* define the initial stack-sizes */
1093 #ifdef YYSTACKSIZE
1094 #undef YYMAXDEPTH
1095 #define YYMAXDEPTH YYSTACKSIZE
1096 #else
1097 #ifdef YYMAXDEPTH
1098 #define YYSTACKSIZE YYMAXDEPTH
1099 #else
1100 #define YYSTACKSIZE 10000
1101 #define YYMAXDEPTH 10000
1102 #endif
1103 #endif
1104
1105 #ifndef YYINITSTACKSIZE
1106 #define YYINITSTACKSIZE 200
1107 #endif
1108
1109 typedef struct {
1110 unsigned stacksize;
1111 YYINT *s_base;
1112 YYINT *s_mark;
1113 YYINT *s_last;
1114 YYSTYPE *l_base;
1115 YYSTYPE *l_mark;
1116 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1117 YYLTYPE *p_base;
1118 YYLTYPE *p_mark;
1119 #endif
1120 } YYSTACKDATA;
1121 #if YYBTYACC
1122
1123 struct YYParseState_s
1124 {
1125 struct YYParseState_s *save; /* Previously saved parser state */
1126 YYSTACKDATA yystack; /* saved parser stack */
1127 int state; /* saved parser state */
1128 int errflag; /* saved error recovery status */
1129 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
1130 YYINT ctry; /* saved index in yyctable[] for this conflict */
1131 };
1132 typedef struct YYParseState_s YYParseState;
1133 #endif /* YYBTYACC */
1134 /* variables for the parser stack */
1135 static YYSTACKDATA yystack;
1136 #if YYBTYACC
1137
1138 /* Current parser state */
1139 static YYParseState *yyps = 0;
1140
1141 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
1142 static YYParseState *yypath = 0;
1143
1144 /* Base of the lexical value queue */
1145 static YYSTYPE *yylvals = 0;
1146
1147 /* Current position at lexical value queue */
1148 static YYSTYPE *yylvp = 0;
1149
1150 /* End position of lexical value queue */
1151 static YYSTYPE *yylve = 0;
1152
1153 /* The last allocated position at the lexical value queue */
1154 static YYSTYPE *yylvlim = 0;
1155
1156 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1157 /* Base of the lexical position queue */
1158 static YYLTYPE *yylpsns = 0;
1159
1160 /* Current position at lexical position queue */
1161 static YYLTYPE *yylpp = 0;
1162
1163 /* End position of lexical position queue */
1164 static YYLTYPE *yylpe = 0;
1165
1166 /* The last allocated position at the lexical position queue */
1167 static YYLTYPE *yylplim = 0;
1168 #endif
1169
1170 /* Current position at lexical token queue */
1171 static YYINT *yylexp = 0;
1172
1173 static YYINT *yylexemes = 0;
1174 #endif /* YYBTYACC */
1175 #line 1014 "grammar.y"
1176
1177 /* lex.yy.c */
1178 #define BEGIN yy_start = 1 + 2 *
1179
1180 #define CPP1 1
1181 #define INIT1 2
1182 #define INIT2 3
1183 #define CURLY 4
1184 #define LEXYACC 5
1185 #define ASM 6
1186 #define CPP_INLINE 7
1187
1188 extern char *yytext;
1189 extern FILE *yyin, *yyout;
1190
1191 static int curly; /* number of curly brace nesting levels */
1192 static int ly_count; /* number of occurances of %% */
1193 static int inc_depth; /* include nesting level */
1194 static SymbolTable *included_files; /* files already included */
1195 static int yy_start = 0; /* start state number */
1196
1197 #define grammar_error(s) yaccError(s)
1198
1199 static void
yaccError(const char * msg)1200 yaccError (const char *msg)
1201 {
1202 func_params = NULL;
1203 put_error(); /* tell what line we're on, and what file */
1204 fprintf(stderr, "%s at token '%s'\n", msg, yytext);
1205 }
1206
1207 /* Initialize the table of type qualifier keywords recognized by the lexical
1208 * analyzer.
1209 */
1210 void
init_parser(void)1211 init_parser (void)
1212 {
1213 static const char *keywords[] = {
1214 "const",
1215 "restrict",
1216 "volatile",
1217 "interrupt",
1218 #ifdef vms
1219 "noshare",
1220 "readonly",
1221 #endif
1222 #if defined(MSDOS) || defined(OS2)
1223 "__cdecl",
1224 "__export",
1225 "__far",
1226 "__fastcall",
1227 "__fortran",
1228 "__huge",
1229 "__inline",
1230 "__interrupt",
1231 "__loadds",
1232 "__near",
1233 "__pascal",
1234 "__saveregs",
1235 "__segment",
1236 "__stdcall",
1237 "__syscall",
1238 "_cdecl",
1239 "_cs",
1240 "_ds",
1241 "_es",
1242 "_export",
1243 "_far",
1244 "_fastcall",
1245 "_fortran",
1246 "_huge",
1247 "_interrupt",
1248 "_loadds",
1249 "_near",
1250 "_pascal",
1251 "_saveregs",
1252 "_seg",
1253 "_segment",
1254 "_ss",
1255 "cdecl",
1256 "far",
1257 "huge",
1258 "near",
1259 "pascal",
1260 #ifdef OS2
1261 "__far16",
1262 #endif
1263 #endif
1264 #ifdef __GNUC__
1265 /* gcc aliases */
1266 "__builtin_va_arg",
1267 "__builtin_va_list",
1268 "__const",
1269 "__const__",
1270 "__inline",
1271 "__inline__",
1272 "__restrict",
1273 "__restrict__",
1274 "__volatile",
1275 "__volatile__",
1276 #endif
1277 };
1278 unsigned i;
1279
1280 /* Initialize type qualifier table. */
1281 type_qualifiers = new_symbol_table();
1282 for (i = 0; i < sizeof(keywords)/sizeof(keywords[0]); ++i) {
1283 new_symbol(type_qualifiers, keywords[i], NULL, DS_NONE);
1284 }
1285 }
1286
1287 /* Process the C source file. Write function prototypes to the standard
1288 * output. Convert function definitions and write the converted source
1289 * code to a temporary file.
1290 */
1291 void
process_file(FILE * infile,char * name)1292 process_file (FILE *infile, char *name)
1293 {
1294 char *s;
1295
1296 if (strlen(name) > 2) {
1297 s = name + strlen(name) - 2;
1298 if (*s == '.') {
1299 ++s;
1300 if (*s == 'l' || *s == 'y')
1301 BEGIN LEXYACC;
1302 #if defined(MSDOS) || defined(OS2)
1303 if (*s == 'L' || *s == 'Y')
1304 BEGIN LEXYACC;
1305 #endif
1306 }
1307 }
1308
1309 included_files = new_symbol_table();
1310 typedef_names = new_symbol_table();
1311 define_names = new_symbol_table();
1312 inc_depth = -1;
1313 curly = 0;
1314 ly_count = 0;
1315 func_params = NULL;
1316 yyin = infile;
1317 include_file(strcpy(base_file, name), func_style != FUNC_NONE);
1318 if (file_comments) {
1319 #if OPT_LINTLIBRARY
1320 if (lintLibrary()) {
1321 put_blankline(stdout);
1322 begin_tracking();
1323 }
1324 #endif
1325 put_string(stdout, "/* ");
1326 put_string(stdout, cur_file_name());
1327 put_string(stdout, " */\n");
1328 }
1329 yyparse();
1330 free_symbol_table(define_names);
1331 free_symbol_table(typedef_names);
1332 free_symbol_table(included_files);
1333 }
1334
1335 #ifdef NO_LEAKS
1336 void
free_parser(void)1337 free_parser(void)
1338 {
1339 free_symbol_table (type_qualifiers);
1340 #ifdef FLEX_SCANNER
1341 if (yy_current_buffer != 0)
1342 yy_delete_buffer(yy_current_buffer);
1343 #endif
1344 }
1345 #endif
1346 #line 1347 "grammar.tab.c"
1347
1348 /* For use in generated program */
1349 #define yydepth (int)(yystack.s_mark - yystack.s_base)
1350 #if YYBTYACC
1351 #define yytrial (yyps->save)
1352 #endif /* YYBTYACC */
1353
1354 #if YYDEBUG
1355 #include <stdio.h> /* needed for printf */
1356 #endif
1357
1358 #include <stdlib.h> /* needed for malloc, etc */
1359 #include <string.h> /* needed for memset */
1360
1361 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)1362 static int yygrowstack(YYSTACKDATA *data)
1363 {
1364 int i;
1365 unsigned newsize;
1366 YYINT *newss;
1367 YYSTYPE *newvs;
1368 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1369 YYLTYPE *newps;
1370 #endif
1371
1372 if ((newsize = data->stacksize) == 0)
1373 newsize = YYINITSTACKSIZE;
1374 else if (newsize >= YYMAXDEPTH)
1375 return YYENOMEM;
1376 else if ((newsize *= 2) > YYMAXDEPTH)
1377 newsize = YYMAXDEPTH;
1378
1379 i = (int) (data->s_mark - data->s_base);
1380 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1381 if (newss == 0)
1382 return YYENOMEM;
1383
1384 data->s_base = newss;
1385 data->s_mark = newss + i;
1386
1387 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1388 if (newvs == 0)
1389 return YYENOMEM;
1390
1391 data->l_base = newvs;
1392 data->l_mark = newvs + i;
1393
1394 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1395 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
1396 if (newps == 0)
1397 return YYENOMEM;
1398
1399 data->p_base = newps;
1400 data->p_mark = newps + i;
1401 #endif
1402
1403 data->stacksize = newsize;
1404 data->s_last = data->s_base + newsize - 1;
1405
1406 #if YYDEBUG
1407 if (yydebug)
1408 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
1409 #endif
1410 return 0;
1411 }
1412
1413 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)1414 static void yyfreestack(YYSTACKDATA *data)
1415 {
1416 free(data->s_base);
1417 free(data->l_base);
1418 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1419 free(data->p_base);
1420 #endif
1421 memset(data, 0, sizeof(*data));
1422 }
1423 #else
1424 #define yyfreestack(data) /* nothing */
1425 #endif /* YYPURE || defined(YY_NO_LEAKS) */
1426 #if YYBTYACC
1427
1428 static YYParseState *
yyNewState(unsigned size)1429 yyNewState(unsigned size)
1430 {
1431 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
1432 if (p == NULL) return NULL;
1433
1434 p->yystack.stacksize = size;
1435 if (size == 0)
1436 {
1437 p->yystack.s_base = NULL;
1438 p->yystack.l_base = NULL;
1439 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1440 p->yystack.p_base = NULL;
1441 #endif
1442 return p;
1443 }
1444 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
1445 if (p->yystack.s_base == NULL) return NULL;
1446 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
1447 if (p->yystack.l_base == NULL) return NULL;
1448 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
1449 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1450 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
1451 if (p->yystack.p_base == NULL) return NULL;
1452 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
1453 #endif
1454
1455 return p;
1456 }
1457
1458 static void
yyFreeState(YYParseState * p)1459 yyFreeState(YYParseState *p)
1460 {
1461 yyfreestack(&p->yystack);
1462 free(p);
1463 }
1464 #endif /* YYBTYACC */
1465
1466 #define YYABORT goto yyabort
1467 #define YYREJECT goto yyabort
1468 #define YYACCEPT goto yyaccept
1469 #define YYERROR goto yyerrlab
1470 #if YYBTYACC
1471 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
1472 #define YYVALID_NESTED do { if (yyps->save && \
1473 yyps->save->save == 0) goto yyvalid; } while(0)
1474 #endif /* YYBTYACC */
1475
1476 int
YYPARSE_DECL()1477 YYPARSE_DECL()
1478 {
1479 int yym, yyn, yystate, yyresult;
1480 #if YYBTYACC
1481 int yynewerrflag;
1482 YYParseState *yyerrctx = NULL;
1483 #endif /* YYBTYACC */
1484 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1485 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
1486 #endif
1487 #if YYDEBUG
1488 const char *yys;
1489
1490 if ((yys = getenv("YYDEBUG")) != 0)
1491 {
1492 yyn = *yys;
1493 if (yyn >= '0' && yyn <= '9')
1494 yydebug = yyn - '0';
1495 }
1496 if (yydebug)
1497 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
1498 #endif
1499
1500 #if YYBTYACC
1501 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
1502 yyps->save = 0;
1503 #endif /* YYBTYACC */
1504 yym = 0;
1505 yyn = 0;
1506 yynerrs = 0;
1507 yyerrflag = 0;
1508 yychar = YYEMPTY;
1509 yystate = 0;
1510
1511 #if YYPURE
1512 memset(&yystack, 0, sizeof(yystack));
1513 #endif
1514
1515 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1516 yystack.s_mark = yystack.s_base;
1517 yystack.l_mark = yystack.l_base;
1518 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1519 yystack.p_mark = yystack.p_base;
1520 #endif
1521 yystate = 0;
1522 *yystack.s_mark = 0;
1523
1524 yyloop:
1525 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1526 if (yychar < 0)
1527 {
1528 #if YYBTYACC
1529 do {
1530 if (yylvp < yylve)
1531 {
1532 /* we're currently re-reading tokens */
1533 yylval = *yylvp++;
1534 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1535 yylloc = *yylpp++;
1536 #endif
1537 yychar = *yylexp++;
1538 break;
1539 }
1540 if (yyps->save)
1541 {
1542 /* in trial mode; save scanner results for future parse attempts */
1543 if (yylvp == yylvlim)
1544 { /* Enlarge lexical value queue */
1545 size_t p = (size_t) (yylvp - yylvals);
1546 size_t s = (size_t) (yylvlim - yylvals);
1547
1548 s += YYLVQUEUEGROWTH;
1549 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
1550 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
1551 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1552 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
1553 #endif
1554 yylvp = yylve = yylvals + p;
1555 yylvlim = yylvals + s;
1556 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1557 yylpp = yylpe = yylpsns + p;
1558 yylplim = yylpsns + s;
1559 #endif
1560 yylexp = yylexemes + p;
1561 }
1562 *yylexp = (YYINT) YYLEX;
1563 *yylvp++ = yylval;
1564 yylve++;
1565 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1566 *yylpp++ = yylloc;
1567 yylpe++;
1568 #endif
1569 yychar = *yylexp++;
1570 break;
1571 }
1572 /* normal operation, no conflict encountered */
1573 #endif /* YYBTYACC */
1574 yychar = YYLEX;
1575 #if YYBTYACC
1576 } while (0);
1577 #endif /* YYBTYACC */
1578 if (yychar < 0) yychar = YYEOF;
1579 #if YYDEBUG
1580 if (yydebug)
1581 {
1582 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1583 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
1584 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1585 #ifdef YYSTYPE_TOSTRING
1586 #if YYBTYACC
1587 if (!yytrial)
1588 #endif /* YYBTYACC */
1589 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
1590 #endif
1591 fputc('\n', stderr);
1592 }
1593 #endif
1594 }
1595 #if YYBTYACC
1596
1597 /* Do we have a conflict? */
1598 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1599 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1600 {
1601 YYINT ctry;
1602
1603 if (yypath)
1604 {
1605 YYParseState *save;
1606 #if YYDEBUG
1607 if (yydebug)
1608 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
1609 YYDEBUGSTR, yydepth, yystate);
1610 #endif
1611 /* Switch to the next conflict context */
1612 save = yypath;
1613 yypath = save->save;
1614 save->save = NULL;
1615 ctry = save->ctry;
1616 if (save->state != yystate) YYABORT;
1617 yyFreeState(save);
1618
1619 }
1620 else
1621 {
1622
1623 /* Unresolved conflict - start/continue trial parse */
1624 YYParseState *save;
1625 #if YYDEBUG
1626 if (yydebug)
1627 {
1628 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
1629 if (yyps->save)
1630 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
1631 else
1632 fputs("Starting trial parse.\n", stderr);
1633 }
1634 #endif
1635 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1636 if (save == NULL) goto yyenomem;
1637 save->save = yyps->save;
1638 save->state = yystate;
1639 save->errflag = yyerrflag;
1640 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
1641 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1642 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
1643 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1644 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1645 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
1646 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1647 #endif
1648 ctry = yytable[yyn];
1649 if (yyctable[ctry] == -1)
1650 {
1651 #if YYDEBUG
1652 if (yydebug && yychar >= YYEOF)
1653 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
1654 #endif
1655 ctry++;
1656 }
1657 save->ctry = ctry;
1658 if (yyps->save == NULL)
1659 {
1660 /* If this is a first conflict in the stack, start saving lexemes */
1661 if (!yylexemes)
1662 {
1663 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
1664 if (yylexemes == NULL) goto yyenomem;
1665 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
1666 if (yylvals == NULL) goto yyenomem;
1667 yylvlim = yylvals + YYLVQUEUEGROWTH;
1668 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1669 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
1670 if (yylpsns == NULL) goto yyenomem;
1671 yylplim = yylpsns + YYLVQUEUEGROWTH;
1672 #endif
1673 }
1674 if (yylvp == yylve)
1675 {
1676 yylvp = yylve = yylvals;
1677 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1678 yylpp = yylpe = yylpsns;
1679 #endif
1680 yylexp = yylexemes;
1681 if (yychar >= YYEOF)
1682 {
1683 *yylve++ = yylval;
1684 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1685 *yylpe++ = yylloc;
1686 #endif
1687 *yylexp = (YYINT) yychar;
1688 yychar = YYEMPTY;
1689 }
1690 }
1691 }
1692 if (yychar >= YYEOF)
1693 {
1694 yylvp--;
1695 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1696 yylpp--;
1697 #endif
1698 yylexp--;
1699 yychar = YYEMPTY;
1700 }
1701 save->lexeme = (int) (yylvp - yylvals);
1702 yyps->save = save;
1703 }
1704 if (yytable[yyn] == ctry)
1705 {
1706 #if YYDEBUG
1707 if (yydebug)
1708 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1709 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1710 #endif
1711 if (yychar < 0)
1712 {
1713 yylvp++;
1714 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1715 yylpp++;
1716 #endif
1717 yylexp++;
1718 }
1719 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1720 goto yyoverflow;
1721 yystate = yyctable[ctry];
1722 *++yystack.s_mark = (YYINT) yystate;
1723 *++yystack.l_mark = yylval;
1724 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1725 *++yystack.p_mark = yylloc;
1726 #endif
1727 yychar = YYEMPTY;
1728 if (yyerrflag > 0) --yyerrflag;
1729 goto yyloop;
1730 }
1731 else
1732 {
1733 yyn = yyctable[ctry];
1734 goto yyreduce;
1735 }
1736 } /* End of code dealing with conflicts */
1737 #endif /* YYBTYACC */
1738 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1739 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1740 {
1741 #if YYDEBUG
1742 if (yydebug)
1743 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1744 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1745 #endif
1746 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1747 yystate = yytable[yyn];
1748 *++yystack.s_mark = yytable[yyn];
1749 *++yystack.l_mark = yylval;
1750 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1751 *++yystack.p_mark = yylloc;
1752 #endif
1753 yychar = YYEMPTY;
1754 if (yyerrflag > 0) --yyerrflag;
1755 goto yyloop;
1756 }
1757 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1758 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1759 {
1760 yyn = yytable[yyn];
1761 goto yyreduce;
1762 }
1763 if (yyerrflag != 0) goto yyinrecovery;
1764 #if YYBTYACC
1765
1766 yynewerrflag = 1;
1767 goto yyerrhandler;
1768 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1769
1770 yyerrlab:
1771 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
1772 * before looking for error recovery */
1773 yystack.s_mark -= yym;
1774 yystate = *yystack.s_mark;
1775 yystack.l_mark -= yym;
1776 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1777 yystack.p_mark -= yym;
1778 #endif
1779
1780 yynewerrflag = 0;
1781 yyerrhandler:
1782 while (yyps->save)
1783 {
1784 int ctry;
1785 YYParseState *save = yyps->save;
1786 #if YYDEBUG
1787 if (yydebug)
1788 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1789 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1790 (int)(yylvp - yylvals - yyps->save->lexeme));
1791 #endif
1792 /* Memorize most forward-looking error state in case it's really an error. */
1793 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1794 {
1795 /* Free old saved error context state */
1796 if (yyerrctx) yyFreeState(yyerrctx);
1797 /* Create and fill out new saved error context state */
1798 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1799 if (yyerrctx == NULL) goto yyenomem;
1800 yyerrctx->save = yyps->save;
1801 yyerrctx->state = yystate;
1802 yyerrctx->errflag = yyerrflag;
1803 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1804 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1805 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1806 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1807 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1808 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1809 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1810 #endif
1811 yyerrctx->lexeme = (int) (yylvp - yylvals);
1812 }
1813 yylvp = yylvals + save->lexeme;
1814 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1815 yylpp = yylpsns + save->lexeme;
1816 #endif
1817 yylexp = yylexemes + save->lexeme;
1818 yychar = YYEMPTY;
1819 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1820 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1821 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1822 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1823 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1824 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1825 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1826 #endif
1827 ctry = ++save->ctry;
1828 yystate = save->state;
1829 /* We tried shift, try reduce now */
1830 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1831 yyps->save = save->save;
1832 save->save = NULL;
1833 yyFreeState(save);
1834
1835 /* Nothing left on the stack -- error */
1836 if (!yyps->save)
1837 {
1838 #if YYDEBUG
1839 if (yydebug)
1840 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1841 YYPREFIX, yydepth);
1842 #endif
1843 /* Restore state as it was in the most forward-advanced error */
1844 yylvp = yylvals + yyerrctx->lexeme;
1845 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1846 yylpp = yylpsns + yyerrctx->lexeme;
1847 #endif
1848 yylexp = yylexemes + yyerrctx->lexeme;
1849 yychar = yylexp[-1];
1850 yylval = yylvp[-1];
1851 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1852 yylloc = yylpp[-1];
1853 #endif
1854 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1855 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1856 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1857 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1858 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1859 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1860 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1861 #endif
1862 yystate = yyerrctx->state;
1863 yyFreeState(yyerrctx);
1864 yyerrctx = NULL;
1865 }
1866 yynewerrflag = 1;
1867 }
1868 if (yynewerrflag == 0) goto yyinrecovery;
1869 #endif /* YYBTYACC */
1870
1871 YYERROR_CALL("syntax error");
1872 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1873 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1874 #endif
1875
1876 #if !YYBTYACC
1877 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1878 yyerrlab:
1879 #endif
1880 ++yynerrs;
1881
1882 yyinrecovery:
1883 if (yyerrflag < 3)
1884 {
1885 yyerrflag = 3;
1886 for (;;)
1887 {
1888 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1889 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1890 {
1891 #if YYDEBUG
1892 if (yydebug)
1893 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1894 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1895 #endif
1896 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1897 yystate = yytable[yyn];
1898 *++yystack.s_mark = yytable[yyn];
1899 *++yystack.l_mark = yylval;
1900 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1901 /* lookahead position is error end position */
1902 yyerror_loc_range[1] = yylloc;
1903 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1904 *++yystack.p_mark = yyloc;
1905 #endif
1906 goto yyloop;
1907 }
1908 else
1909 {
1910 #if YYDEBUG
1911 if (yydebug)
1912 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1913 YYDEBUGSTR, yydepth, *yystack.s_mark);
1914 #endif
1915 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1916 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1917 /* the current TOS position is the error start position */
1918 yyerror_loc_range[0] = *yystack.p_mark;
1919 #endif
1920 #if defined(YYDESTRUCT_CALL)
1921 #if YYBTYACC
1922 if (!yytrial)
1923 #endif /* YYBTYACC */
1924 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1925 YYDESTRUCT_CALL("error: discarding state",
1926 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1927 #else
1928 YYDESTRUCT_CALL("error: discarding state",
1929 yystos[*yystack.s_mark], yystack.l_mark);
1930 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1931 #endif /* defined(YYDESTRUCT_CALL) */
1932 --yystack.s_mark;
1933 --yystack.l_mark;
1934 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1935 --yystack.p_mark;
1936 #endif
1937 }
1938 }
1939 }
1940 else
1941 {
1942 if (yychar == YYEOF) goto yyabort;
1943 #if YYDEBUG
1944 if (yydebug)
1945 {
1946 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1947 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1948 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1949 }
1950 #endif
1951 #if defined(YYDESTRUCT_CALL)
1952 #if YYBTYACC
1953 if (!yytrial)
1954 #endif /* YYBTYACC */
1955 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1956 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1957 #else
1958 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1959 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1960 #endif /* defined(YYDESTRUCT_CALL) */
1961 yychar = YYEMPTY;
1962 goto yyloop;
1963 }
1964
1965 yyreduce:
1966 yym = yylen[yyn];
1967 #if YYDEBUG
1968 if (yydebug)
1969 {
1970 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1971 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1972 #ifdef YYSTYPE_TOSTRING
1973 #if YYBTYACC
1974 if (!yytrial)
1975 #endif /* YYBTYACC */
1976 if (yym > 0)
1977 {
1978 int i;
1979 fputc('<', stderr);
1980 for (i = yym; i > 0; i--)
1981 {
1982 if (i != yym) fputs(", ", stderr);
1983 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1984 yystack.l_mark[1-i]), stderr);
1985 }
1986 fputc('>', stderr);
1987 }
1988 #endif
1989 fputc('\n', stderr);
1990 }
1991 #endif
1992 if (yym > 0)
1993 yyval = yystack.l_mark[1-yym];
1994 else
1995 memset(&yyval, 0, sizeof yyval);
1996 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1997
1998 /* Perform position reduction */
1999 memset(&yyloc, 0, sizeof(yyloc));
2000 #if YYBTYACC
2001 if (!yytrial)
2002 #endif /* YYBTYACC */
2003 {
2004 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
2005 /* just in case YYERROR is invoked within the action, save
2006 the start of the rhs as the error start position */
2007 yyerror_loc_range[0] = yystack.p_mark[1-yym];
2008 }
2009 #endif
2010
2011 switch (yyn)
2012 {
2013 case 10:
2014 #line 377 "grammar.y"
2015 {
2016 yyerrok;
2017 }
2018 break;
2019 case 11:
2020 #line 381 "grammar.y"
2021 {
2022 yyerrok;
2023 }
2024 break;
2025 case 13:
2026 #line 392 "grammar.y"
2027 {
2028 /* Provide an empty action here so bison will not complain about
2029 * incompatible types in the default action it normally would
2030 * have generated.
2031 */
2032 }
2033 break;
2034 case 14:
2035 #line 399 "grammar.y"
2036 {
2037 /* empty */
2038 }
2039 break;
2040 case 15:
2041 #line 406 "grammar.y"
2042 {
2043 #if OPT_LINTLIBRARY
2044 if (types_out && want_typedef()) {
2045 gen_declarations(&yystack.l_mark[-1].decl_spec, (DeclaratorList *)0);
2046 flush_varargs();
2047 }
2048 #endif
2049 free_decl_spec(&yystack.l_mark[-1].decl_spec);
2050 end_typedef();
2051 }
2052 break;
2053 case 16:
2054 #line 417 "grammar.y"
2055 {
2056 if (func_params != NULL) {
2057 set_param_types(func_params, &yystack.l_mark[-2].decl_spec, &yystack.l_mark[-1].decl_list);
2058 } else {
2059 gen_declarations(&yystack.l_mark[-2].decl_spec, &yystack.l_mark[-1].decl_list);
2060 #if OPT_LINTLIBRARY
2061 flush_varargs();
2062 #endif
2063 free_decl_list(&yystack.l_mark[-1].decl_list);
2064 }
2065 free_decl_spec(&yystack.l_mark[-2].decl_spec);
2066 end_typedef();
2067 }
2068 break;
2069 case 17:
2070 #line 431 "grammar.y"
2071 {
2072 cur_decl_spec_flags = yystack.l_mark[0].decl_spec.flags;
2073 free_decl_spec(&yystack.l_mark[0].decl_spec);
2074 }
2075 break;
2076 case 18:
2077 #line 436 "grammar.y"
2078 {
2079 end_typedef();
2080 }
2081 break;
2082 case 19:
2083 #line 443 "grammar.y"
2084 {
2085 begin_typedef();
2086 }
2087 break;
2088 case 20:
2089 #line 447 "grammar.y"
2090 {
2091 begin_typedef();
2092 }
2093 break;
2094 case 23:
2095 #line 459 "grammar.y"
2096 {
2097 int flags = cur_decl_spec_flags;
2098
2099 /* If the typedef is a pointer type, then reset the short type
2100 * flags so it does not get promoted.
2101 */
2102 if (strcmp(yystack.l_mark[0].declarator->text, yystack.l_mark[0].declarator->name) != 0)
2103 flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
2104 new_symbol(typedef_names, yystack.l_mark[0].declarator->name, NULL, flags);
2105 free_declarator(yystack.l_mark[0].declarator);
2106 }
2107 break;
2108 case 24:
2109 #line 471 "grammar.y"
2110 {
2111 int flags = cur_decl_spec_flags;
2112
2113 if (strcmp(yystack.l_mark[0].declarator->text, yystack.l_mark[0].declarator->name) != 0)
2114 flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
2115 new_symbol(typedef_names, yystack.l_mark[0].declarator->name, NULL, flags);
2116 free_declarator(yystack.l_mark[0].declarator);
2117 }
2118 break;
2119 case 25:
2120 #line 483 "grammar.y"
2121 {
2122 check_untagged(&yystack.l_mark[-1].decl_spec);
2123 if (yystack.l_mark[0].declarator->func_def == FUNC_NONE) {
2124 yyerror("syntax error");
2125 YYERROR;
2126 }
2127 func_params = &(yystack.l_mark[0].declarator->head->params);
2128 func_params->begin_comment = cur_file->begin_comment;
2129 func_params->end_comment = cur_file->end_comment;
2130 }
2131 break;
2132 case 26:
2133 #line 494 "grammar.y"
2134 {
2135 /* If we're converting to K&R and we've got a nominally K&R
2136 * function which has a parameter which is ANSI (i.e., a prototyped
2137 * function pointer), then we must override the deciphered value of
2138 * 'func_def' so that the parameter will be converted.
2139 */
2140 if (func_style == FUNC_TRADITIONAL
2141 && haveAnsiParam()
2142 && yystack.l_mark[-3].declarator->head->func_def == func_style) {
2143 yystack.l_mark[-3].declarator->head->func_def = FUNC_BOTH;
2144 }
2145
2146 func_params = NULL;
2147
2148 if (cur_file->convert)
2149 gen_func_definition(&yystack.l_mark[-4].decl_spec, yystack.l_mark[-3].declarator);
2150 gen_prototype(&yystack.l_mark[-4].decl_spec, yystack.l_mark[-3].declarator);
2151 #if OPT_LINTLIBRARY
2152 flush_varargs();
2153 #endif
2154 free_decl_spec(&yystack.l_mark[-4].decl_spec);
2155 free_declarator(yystack.l_mark[-3].declarator);
2156 }
2157 break;
2158 case 28:
2159 #line 519 "grammar.y"
2160 {
2161 if (yystack.l_mark[0].declarator->func_def == FUNC_NONE) {
2162 yyerror("syntax error");
2163 YYERROR;
2164 }
2165 func_params = &(yystack.l_mark[0].declarator->head->params);
2166 func_params->begin_comment = cur_file->begin_comment;
2167 func_params->end_comment = cur_file->end_comment;
2168 }
2169 break;
2170 case 29:
2171 #line 529 "grammar.y"
2172 {
2173 DeclSpec decl_spec;
2174
2175 func_params = NULL;
2176
2177 new_decl_spec(&decl_spec, dft_decl_spec(), yystack.l_mark[-4].declarator->begin, DS_NONE);
2178 if (cur_file->convert)
2179 gen_func_definition(&decl_spec, yystack.l_mark[-4].declarator);
2180 gen_prototype(&decl_spec, yystack.l_mark[-4].declarator);
2181 #if OPT_LINTLIBRARY
2182 flush_varargs();
2183 #endif
2184 free_decl_spec(&decl_spec);
2185 free_declarator(yystack.l_mark[-4].declarator);
2186 }
2187 break;
2188 case 36:
2189 #line 560 "grammar.y"
2190 {
2191 join_decl_specs(&yyval.decl_spec, &yystack.l_mark[-1].decl_spec, &yystack.l_mark[0].decl_spec);
2192 free(yystack.l_mark[-1].decl_spec.text);
2193 free(yystack.l_mark[0].decl_spec.text);
2194 }
2195 break;
2196 case 40:
2197 #line 575 "grammar.y"
2198 {
2199 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2200 }
2201 break;
2202 case 41:
2203 #line 579 "grammar.y"
2204 {
2205 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_EXTERN);
2206 }
2207 break;
2208 case 42:
2209 #line 583 "grammar.y"
2210 {
2211 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2212 }
2213 break;
2214 case 43:
2215 #line 587 "grammar.y"
2216 {
2217 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_STATIC);
2218 }
2219 break;
2220 case 44:
2221 #line 591 "grammar.y"
2222 {
2223 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_INLINE);
2224 }
2225 break;
2226 case 45:
2227 #line 595 "grammar.y"
2228 {
2229 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_JUNK);
2230 }
2231 break;
2232 case 46:
2233 #line 602 "grammar.y"
2234 {
2235 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_CHAR);
2236 }
2237 break;
2238 case 47:
2239 #line 606 "grammar.y"
2240 {
2241 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2242 }
2243 break;
2244 case 48:
2245 #line 610 "grammar.y"
2246 {
2247 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_FLOAT);
2248 }
2249 break;
2250 case 49:
2251 #line 614 "grammar.y"
2252 {
2253 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2254 }
2255 break;
2256 case 50:
2257 #line 618 "grammar.y"
2258 {
2259 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2260 }
2261 break;
2262 case 51:
2263 #line 622 "grammar.y"
2264 {
2265 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_SHORT);
2266 }
2267 break;
2268 case 52:
2269 #line 626 "grammar.y"
2270 {
2271 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2272 }
2273 break;
2274 case 53:
2275 #line 630 "grammar.y"
2276 {
2277 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2278 }
2279 break;
2280 case 54:
2281 #line 634 "grammar.y"
2282 {
2283 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2284 }
2285 break;
2286 case 55:
2287 #line 638 "grammar.y"
2288 {
2289 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_CHAR);
2290 }
2291 break;
2292 case 56:
2293 #line 642 "grammar.y"
2294 {
2295 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2296 }
2297 break;
2298 case 57:
2299 #line 646 "grammar.y"
2300 {
2301 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2302 }
2303 break;
2304 case 58:
2305 #line 650 "grammar.y"
2306 {
2307 Symbol *s;
2308 s = find_symbol(typedef_names, yystack.l_mark[0].text.text);
2309 if (s != NULL)
2310 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, s->flags);
2311 }
2312 break;
2313 case 61:
2314 #line 662 "grammar.y"
2315 {
2316 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
2317 }
2318 break;
2319 case 62:
2320 #line 666 "grammar.y"
2321 {
2322 /* This rule allows the <pointer> nonterminal to scan #define
2323 * names as if they were type modifiers.
2324 */
2325 Symbol *s;
2326 s = find_symbol(define_names, yystack.l_mark[0].text.text);
2327 if (s != NULL)
2328 new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, s->flags);
2329 }
2330 break;
2331 case 63:
2332 #line 679 "grammar.y"
2333 {
2334 char *s;
2335 if ((s = implied_typedef()) == 0)
2336 (void)sprintf(s = buf, "%s %s", yystack.l_mark[-2].text.text, yystack.l_mark[-1].text.text);
2337 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-2].text.begin, DS_NONE);
2338 }
2339 break;
2340 case 64:
2341 #line 686 "grammar.y"
2342 {
2343 char *s;
2344 if ((s = implied_typedef()) == 0)
2345 (void)sprintf(s = buf, "%s {}", yystack.l_mark[-1].text.text);
2346 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-1].text.begin, DS_NONE);
2347 }
2348 break;
2349 case 65:
2350 #line 693 "grammar.y"
2351 {
2352 (void)sprintf(buf, "%s %s", yystack.l_mark[-1].text.text, yystack.l_mark[0].text.text);
2353 new_decl_spec(&yyval.decl_spec, buf, yystack.l_mark[-1].text.begin, DS_NONE);
2354 }
2355 break;
2356 case 66:
2357 #line 701 "grammar.y"
2358 {
2359 imply_typedef(yyval.text.text);
2360 }
2361 break;
2362 case 67:
2363 #line 705 "grammar.y"
2364 {
2365 imply_typedef(yyval.text.text);
2366 }
2367 break;
2368 case 68:
2369 #line 712 "grammar.y"
2370 {
2371 new_decl_list(&yyval.decl_list, yystack.l_mark[0].declarator);
2372 }
2373 break;
2374 case 69:
2375 #line 716 "grammar.y"
2376 {
2377 add_decl_list(&yyval.decl_list, &yystack.l_mark[-2].decl_list, yystack.l_mark[0].declarator);
2378 }
2379 break;
2380 case 70:
2381 #line 723 "grammar.y"
2382 {
2383 if (yystack.l_mark[0].declarator->func_def != FUNC_NONE && func_params == NULL &&
2384 func_style == FUNC_TRADITIONAL && cur_file->convert) {
2385 gen_func_declarator(yystack.l_mark[0].declarator);
2386 fputs(cur_text(), cur_file->tmp_file);
2387 }
2388 cur_declarator = yyval.declarator;
2389 }
2390 break;
2391 case 71:
2392 #line 732 "grammar.y"
2393 {
2394 if (yystack.l_mark[-1].declarator->func_def != FUNC_NONE && func_params == NULL &&
2395 func_style == FUNC_TRADITIONAL && cur_file->convert) {
2396 gen_func_declarator(yystack.l_mark[-1].declarator);
2397 fputs(" =", cur_file->tmp_file);
2398 }
2399 }
2400 break;
2401 case 73:
2402 #line 744 "grammar.y"
2403 {
2404 char *s;
2405 if ((s = implied_typedef()) == 0)
2406 (void)sprintf(s = buf, "enum %s", yystack.l_mark[-1].text.text);
2407 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-2].text.begin, DS_NONE);
2408 }
2409 break;
2410 case 74:
2411 #line 751 "grammar.y"
2412 {
2413 char *s;
2414 if ((s = implied_typedef()) == 0)
2415 (void)sprintf(s = buf, "%s {}", yystack.l_mark[-1].text.text);
2416 new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-1].text.begin, DS_NONE);
2417 }
2418 break;
2419 case 75:
2420 #line 758 "grammar.y"
2421 {
2422 (void)sprintf(buf, "enum %s", yystack.l_mark[0].text.text);
2423 new_decl_spec(&yyval.decl_spec, buf, yystack.l_mark[-1].text.begin, DS_NONE);
2424 }
2425 break;
2426 case 76:
2427 #line 766 "grammar.y"
2428 {
2429 imply_typedef("enum");
2430 yyval.text = yystack.l_mark[0].text;
2431 }
2432 break;
2433 case 79:
2434 #line 779 "grammar.y"
2435 {
2436 yyval.declarator = yystack.l_mark[0].declarator;
2437 (void)sprintf(buf, "%s%s", yystack.l_mark[-1].text.text, yyval.declarator->text);
2438 free(yyval.declarator->text);
2439 yyval.declarator->text = xstrdup(buf);
2440 yyval.declarator->begin = yystack.l_mark[-1].text.begin;
2441 yyval.declarator->pointer = TRUE;
2442 }
2443 break;
2444 case 81:
2445 #line 792 "grammar.y"
2446 {
2447 yyval.declarator = new_declarator(yystack.l_mark[0].text.text, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin);
2448 }
2449 break;
2450 case 82:
2451 #line 796 "grammar.y"
2452 {
2453 yyval.declarator = yystack.l_mark[-1].declarator;
2454 (void)sprintf(buf, "(%s)", yyval.declarator->text);
2455 free(yyval.declarator->text);
2456 yyval.declarator->text = xstrdup(buf);
2457 yyval.declarator->begin = yystack.l_mark[-2].text.begin;
2458 }
2459 break;
2460 case 83:
2461 #line 804 "grammar.y"
2462 {
2463 yyval.declarator = yystack.l_mark[-1].declarator;
2464 (void)sprintf(buf, "%s%s", yyval.declarator->text, yystack.l_mark[0].text.text);
2465 free(yyval.declarator->text);
2466 yyval.declarator->text = xstrdup(buf);
2467 }
2468 break;
2469 case 84:
2470 #line 811 "grammar.y"
2471 {
2472 yyval.declarator = new_declarator("%s()", yystack.l_mark[-3].declarator->name, yystack.l_mark[-3].declarator->begin);
2473 yyval.declarator->params = yystack.l_mark[-1].param_list;
2474 yyval.declarator->func_stack = yystack.l_mark[-3].declarator;
2475 yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head;
2476 yyval.declarator->func_def = FUNC_ANSI;
2477 }
2478 break;
2479 case 85:
2480 #line 819 "grammar.y"
2481 {
2482 yyval.declarator = new_declarator("%s()", yystack.l_mark[-3].declarator->name, yystack.l_mark[-3].declarator->begin);
2483 yyval.declarator->params = yystack.l_mark[-1].param_list;
2484 yyval.declarator->func_stack = yystack.l_mark[-3].declarator;
2485 yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head;
2486 yyval.declarator->func_def = FUNC_TRADITIONAL;
2487 }
2488 break;
2489 case 86:
2490 #line 830 "grammar.y"
2491 {
2492 (void)sprintf(yyval.text.text, "*%s", yystack.l_mark[0].text.text);
2493 yyval.text.begin = yystack.l_mark[-1].text.begin;
2494 }
2495 break;
2496 case 87:
2497 #line 835 "grammar.y"
2498 {
2499 (void)sprintf(yyval.text.text, "*%s%s", yystack.l_mark[-1].text.text, yystack.l_mark[0].text.text);
2500 yyval.text.begin = yystack.l_mark[-2].text.begin;
2501 }
2502 break;
2503 case 88:
2504 #line 843 "grammar.y"
2505 {
2506 strcpy(yyval.text.text, "");
2507 yyval.text.begin = 0L;
2508 }
2509 break;
2510 case 90:
2511 #line 852 "grammar.y"
2512 {
2513 (void)sprintf(yyval.text.text, "%s ", yystack.l_mark[0].decl_spec.text);
2514 yyval.text.begin = yystack.l_mark[0].decl_spec.begin;
2515 free(yystack.l_mark[0].decl_spec.text);
2516 }
2517 break;
2518 case 91:
2519 #line 858 "grammar.y"
2520 {
2521 (void)sprintf(yyval.text.text, "%s%s ", yystack.l_mark[-1].text.text, yystack.l_mark[0].decl_spec.text);
2522 yyval.text.begin = yystack.l_mark[-1].text.begin;
2523 free(yystack.l_mark[0].decl_spec.text);
2524 }
2525 break;
2526 case 93:
2527 #line 868 "grammar.y"
2528 {
2529 add_ident_list(&yyval.param_list, &yystack.l_mark[-2].param_list, "...");
2530 }
2531 break;
2532 case 94:
2533 #line 875 "grammar.y"
2534 {
2535 new_param_list(&yyval.param_list, yystack.l_mark[0].parameter);
2536 }
2537 break;
2538 case 95:
2539 #line 879 "grammar.y"
2540 {
2541 add_param_list(&yyval.param_list, &yystack.l_mark[-2].param_list, yystack.l_mark[0].parameter);
2542 }
2543 break;
2544 case 96:
2545 #line 886 "grammar.y"
2546 {
2547 check_untagged(&yystack.l_mark[-1].decl_spec);
2548 yyval.parameter = new_parameter(&yystack.l_mark[-1].decl_spec, yystack.l_mark[0].declarator);
2549 }
2550 break;
2551 case 97:
2552 #line 891 "grammar.y"
2553 {
2554 check_untagged(&yystack.l_mark[-1].decl_spec);
2555 yyval.parameter = new_parameter(&yystack.l_mark[-1].decl_spec, yystack.l_mark[0].declarator);
2556 }
2557 break;
2558 case 98:
2559 #line 896 "grammar.y"
2560 {
2561 check_untagged(&yystack.l_mark[0].decl_spec);
2562 yyval.parameter = new_parameter(&yystack.l_mark[0].decl_spec, (Declarator *)0);
2563 }
2564 break;
2565 case 99:
2566 #line 904 "grammar.y"
2567 {
2568 new_ident_list(&yyval.param_list);
2569 }
2570 break;
2571 case 101:
2572 #line 912 "grammar.y"
2573 {
2574 new_ident_list(&yyval.param_list);
2575 add_ident_list(&yyval.param_list, &yyval.param_list, yystack.l_mark[0].text.text);
2576 }
2577 break;
2578 case 102:
2579 #line 917 "grammar.y"
2580 {
2581 add_ident_list(&yyval.param_list, &yystack.l_mark[-2].param_list, yystack.l_mark[0].text.text);
2582 }
2583 break;
2584 case 103:
2585 #line 924 "grammar.y"
2586 {
2587 yyval.text = yystack.l_mark[0].text;
2588 }
2589 break;
2590 case 104:
2591 #line 928 "grammar.y"
2592 {
2593 #if OPT_LINTLIBRARY
2594 if (lintLibrary()) { /* Lint doesn't grok C++ ref variables */
2595 yyval.text = yystack.l_mark[0].text;
2596 } else
2597 #endif
2598 (void)sprintf(yyval.text.text, "&%s", yystack.l_mark[0].text.text);
2599 yyval.text.begin = yystack.l_mark[-1].text.begin;
2600 }
2601 break;
2602 case 105:
2603 #line 941 "grammar.y"
2604 {
2605 yyval.declarator = new_declarator(yystack.l_mark[0].text.text, "", yystack.l_mark[0].text.begin);
2606 }
2607 break;
2608 case 106:
2609 #line 945 "grammar.y"
2610 {
2611 yyval.declarator = yystack.l_mark[0].declarator;
2612 (void)sprintf(buf, "%s%s", yystack.l_mark[-1].text.text, yyval.declarator->text);
2613 free(yyval.declarator->text);
2614 yyval.declarator->text = xstrdup(buf);
2615 yyval.declarator->begin = yystack.l_mark[-1].text.begin;
2616 }
2617 break;
2618 case 108:
2619 #line 957 "grammar.y"
2620 {
2621 yyval.declarator = yystack.l_mark[-1].declarator;
2622 (void)sprintf(buf, "(%s)", yyval.declarator->text);
2623 free(yyval.declarator->text);
2624 yyval.declarator->text = xstrdup(buf);
2625 yyval.declarator->begin = yystack.l_mark[-2].text.begin;
2626 }
2627 break;
2628 case 109:
2629 #line 965 "grammar.y"
2630 {
2631 yyval.declarator = yystack.l_mark[-1].declarator;
2632 (void)sprintf(buf, "%s%s", yyval.declarator->text, yystack.l_mark[0].text.text);
2633 free(yyval.declarator->text);
2634 yyval.declarator->text = xstrdup(buf);
2635 }
2636 break;
2637 case 110:
2638 #line 972 "grammar.y"
2639 {
2640 yyval.declarator = new_declarator(yystack.l_mark[0].text.text, "", yystack.l_mark[0].text.begin);
2641 }
2642 break;
2643 case 111:
2644 #line 976 "grammar.y"
2645 {
2646 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-3].declarator->begin);
2647 yyval.declarator->params = yystack.l_mark[-1].param_list;
2648 yyval.declarator->func_stack = yystack.l_mark[-3].declarator;
2649 yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head;
2650 yyval.declarator->func_def = FUNC_ANSI;
2651 }
2652 break;
2653 case 112:
2654 #line 984 "grammar.y"
2655 {
2656 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-2].declarator->begin);
2657 yyval.declarator->func_stack = yystack.l_mark[-2].declarator;
2658 yyval.declarator->head = (yystack.l_mark[-2].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-2].declarator->head;
2659 yyval.declarator->func_def = FUNC_ANSI;
2660 }
2661 break;
2662 case 113:
2663 #line 991 "grammar.y"
2664 {
2665 Declarator *d;
2666
2667 d = new_declarator("", "", yystack.l_mark[-2].text.begin);
2668 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-2].text.begin);
2669 yyval.declarator->params = yystack.l_mark[-1].param_list;
2670 yyval.declarator->func_stack = d;
2671 yyval.declarator->head = yyval.declarator;
2672 yyval.declarator->func_def = FUNC_ANSI;
2673 }
2674 break;
2675 case 114:
2676 #line 1002 "grammar.y"
2677 {
2678 Declarator *d;
2679
2680 d = new_declarator("", "", yystack.l_mark[-1].text.begin);
2681 yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-1].text.begin);
2682 yyval.declarator->func_stack = d;
2683 yyval.declarator->head = yyval.declarator;
2684 yyval.declarator->func_def = FUNC_ANSI;
2685 }
2686 break;
2687 #line 2688 "grammar.tab.c"
2688 default:
2689 break;
2690 }
2691 yystack.s_mark -= yym;
2692 yystate = *yystack.s_mark;
2693 yystack.l_mark -= yym;
2694 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2695 yystack.p_mark -= yym;
2696 #endif
2697 yym = yylhs[yyn];
2698 if (yystate == 0 && yym == 0)
2699 {
2700 #if YYDEBUG
2701 if (yydebug)
2702 {
2703 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2704 #ifdef YYSTYPE_TOSTRING
2705 #if YYBTYACC
2706 if (!yytrial)
2707 #endif /* YYBTYACC */
2708 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
2709 #endif
2710 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
2711 }
2712 #endif
2713 yystate = YYFINAL;
2714 *++yystack.s_mark = YYFINAL;
2715 *++yystack.l_mark = yyval;
2716 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2717 *++yystack.p_mark = yyloc;
2718 #endif
2719 if (yychar < 0)
2720 {
2721 #if YYBTYACC
2722 do {
2723 if (yylvp < yylve)
2724 {
2725 /* we're currently re-reading tokens */
2726 yylval = *yylvp++;
2727 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2728 yylloc = *yylpp++;
2729 #endif
2730 yychar = *yylexp++;
2731 break;
2732 }
2733 if (yyps->save)
2734 {
2735 /* in trial mode; save scanner results for future parse attempts */
2736 if (yylvp == yylvlim)
2737 { /* Enlarge lexical value queue */
2738 size_t p = (size_t) (yylvp - yylvals);
2739 size_t s = (size_t) (yylvlim - yylvals);
2740
2741 s += YYLVQUEUEGROWTH;
2742 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
2743 goto yyenomem;
2744 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
2745 goto yyenomem;
2746 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2747 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
2748 goto yyenomem;
2749 #endif
2750 yylvp = yylve = yylvals + p;
2751 yylvlim = yylvals + s;
2752 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2753 yylpp = yylpe = yylpsns + p;
2754 yylplim = yylpsns + s;
2755 #endif
2756 yylexp = yylexemes + p;
2757 }
2758 *yylexp = (YYINT) YYLEX;
2759 *yylvp++ = yylval;
2760 yylve++;
2761 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2762 *yylpp++ = yylloc;
2763 yylpe++;
2764 #endif
2765 yychar = *yylexp++;
2766 break;
2767 }
2768 /* normal operation, no conflict encountered */
2769 #endif /* YYBTYACC */
2770 yychar = YYLEX;
2771 #if YYBTYACC
2772 } while (0);
2773 #endif /* YYBTYACC */
2774 if (yychar < 0) yychar = YYEOF;
2775 #if YYDEBUG
2776 if (yydebug)
2777 {
2778 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2779 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
2780 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
2781 }
2782 #endif
2783 }
2784 if (yychar == YYEOF) goto yyaccept;
2785 goto yyloop;
2786 }
2787 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
2788 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
2789 yystate = yytable[yyn];
2790 else
2791 yystate = yydgoto[yym];
2792 #if YYDEBUG
2793 if (yydebug)
2794 {
2795 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
2796 #ifdef YYSTYPE_TOSTRING
2797 #if YYBTYACC
2798 if (!yytrial)
2799 #endif /* YYBTYACC */
2800 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
2801 #endif
2802 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
2803 }
2804 #endif
2805 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2806 *++yystack.s_mark = (YYINT) yystate;
2807 *++yystack.l_mark = yyval;
2808 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2809 *++yystack.p_mark = yyloc;
2810 #endif
2811 goto yyloop;
2812 #if YYBTYACC
2813
2814 /* Reduction declares that this path is valid. Set yypath and do a full parse */
2815 yyvalid:
2816 if (yypath) YYABORT;
2817 while (yyps->save)
2818 {
2819 YYParseState *save = yyps->save;
2820 yyps->save = save->save;
2821 save->save = yypath;
2822 yypath = save;
2823 }
2824 #if YYDEBUG
2825 if (yydebug)
2826 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
2827 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
2828 #endif
2829 if (yyerrctx)
2830 {
2831 yyFreeState(yyerrctx);
2832 yyerrctx = NULL;
2833 }
2834 yylvp = yylvals + yypath->lexeme;
2835 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2836 yylpp = yylpsns + yypath->lexeme;
2837 #endif
2838 yylexp = yylexemes + yypath->lexeme;
2839 yychar = YYEMPTY;
2840 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
2841 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2842 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
2843 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2845 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
2846 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2847 #endif
2848 yystate = yypath->state;
2849 goto yyloop;
2850 #endif /* YYBTYACC */
2851
2852 yyoverflow:
2853 YYERROR_CALL("yacc stack overflow");
2854 #if YYBTYACC
2855 goto yyabort_nomem;
2856 yyenomem:
2857 YYERROR_CALL("memory exhausted");
2858 yyabort_nomem:
2859 #endif /* YYBTYACC */
2860 yyresult = 2;
2861 goto yyreturn;
2862
2863 yyabort:
2864 yyresult = 1;
2865 goto yyreturn;
2866
2867 yyaccept:
2868 #if YYBTYACC
2869 if (yyps->save) goto yyvalid;
2870 #endif /* YYBTYACC */
2871 yyresult = 0;
2872
2873 yyreturn:
2874 #if defined(YYDESTRUCT_CALL)
2875 if (yychar != YYEOF && yychar != YYEMPTY)
2876 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2877 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
2878 #else
2879 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
2880 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2881
2882 {
2883 YYSTYPE *pv;
2884 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2885 YYLTYPE *pp;
2886
2887 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
2888 YYDESTRUCT_CALL("cleanup: discarding state",
2889 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
2890 #else
2891 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
2892 YYDESTRUCT_CALL("cleanup: discarding state",
2893 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
2894 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2895 }
2896 #endif /* defined(YYDESTRUCT_CALL) */
2897
2898 #if YYBTYACC
2899 if (yyerrctx)
2900 {
2901 yyFreeState(yyerrctx);
2902 yyerrctx = NULL;
2903 }
2904 while (yyps)
2905 {
2906 YYParseState *save = yyps;
2907 yyps = save->save;
2908 save->save = NULL;
2909 yyFreeState(save);
2910 }
2911 while (yypath)
2912 {
2913 YYParseState *save = yypath;
2914 yypath = save->save;
2915 save->save = NULL;
2916 yyFreeState(save);
2917 }
2918 #endif /* YYBTYACC */
2919 yyfreestack(&yystack);
2920 return (yyresult);
2921 }
2922