contrib/byacc/test/btyacc/grammar.tab.c

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