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