xref: /freebsd/contrib/byacc/test/btyacc/grammar.tab.c (revision 5e386598a6d77973b93c073080f0cc574edda9e2)
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 *
389 dft_decl_spec (void)
390 {
391     return (lintLibrary() && !return_val) ? "void" : "int";
392 }
393 
394 static int
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
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
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
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
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 */
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)
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 *
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
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
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