ReactOS  0.4.13-dev-464-g6b95727
parser.tab.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.0. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
6 
7  This program is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /* As a special exception, you may create a larger work that contains
21  part or all of the Bison parser skeleton and distribute that work
22  under terms of your choice, so long as that work isn't itself a
23  parser generator using the skeleton or a modified version thereof
24  as a parser skeleton. Alternatively, if you modify or redistribute
25  the parser skeleton itself, you may (at your option) remove this
26  special exception, which will cause the skeleton and the resulting
27  Bison output files to be licensed under the GNU General Public
28  License without this special exception.
29 
30  This special exception was added by the Free Software Foundation in
31  version 2.2 of Bison. */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34  simplifying the original so-called "semantic" parser. */
35 
36 /* All symbols defined below should begin with yy or YY, to avoid
37  infringing on user name space. This should be done even for local
38  variables, as they might otherwise be expanded by user macros.
39  There are some unavoidable exceptions within include files to
40  define necessary library symbols; they are noted "INFRINGES ON
41  USER NAME SPACE" below. */
42 
43 /* Identify Bison output. */
44 #define YYBISON 1
45 
46 /* Bison version. */
47 #define YYBISON_VERSION "3.0"
48 
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers. */
53 #define YYPURE 0
54 
55 /* Push parsers. */
56 #define YYPUSH 0
57 
58 /* Pull parsers. */
59 #define YYPULL 1
60 
61 
62 /* Substitute the variable and function names. */
63 #define yyparse parser_parse
64 #define yylex parser_lex
65 #define yyerror parser_error
66 #define yydebug parser_debug
67 #define yynerrs parser_nerrs
68 
69 #define yylval parser_lval
70 #define yychar parser_char
71 
72 /* Copy the first part of user declarations. */
73 #line 1 "parser.y" /* yacc.c:339 */
74 
75 /*
76  * IDL Compiler
77  *
78  * Copyright 2002 Ove Kaaven
79  * Copyright 2006-2008 Robert Shearman
80  *
81  * This library is free software; you can redistribute it and/or
82  * modify it under the terms of the GNU Lesser General Public
83  * License as published by the Free Software Foundation; either
84  * version 2.1 of the License, or (at your option) any later version.
85  *
86  * This library is distributed in the hope that it will be useful,
87  * but WITHOUT ANY WARRANTY; without even the implied warranty of
88  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
89  * Lesser General Public License for more details.
90  *
91  * You should have received a copy of the GNU Lesser General Public
92  * License along with this library; if not, write to the Free Software
93  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
94  */
95 
96 #include "config.h"
97 
98 #include <stdio.h>
99 #include <stdlib.h>
100 #include <stdarg.h>
101 #include <assert.h>
102 #include <ctype.h>
103 #include <string.h>
104 
105 #include "widl.h"
106 #include "utils.h"
107 #include "parser.h"
108 #include "header.h"
109 #include "typelib.h"
110 #include "typegen.h"
111 #include "expr.h"
112 #include "typetree.h"
113 
114 static unsigned char pointer_default = FC_UP;
115 
116 typedef struct list typelist_t;
117 struct typenode {
119  struct list entry;
120 };
121 
122 struct _import_t
123 {
124  char *name;
126 };
127 
128 typedef struct _decl_spec_t
129 {
133 } decl_spec_t;
134 
136 
137 static void fix_incomplete(void);
138 static void fix_incomplete_types(type_t *complete_type);
139 
140 static str_list_t *append_str(str_list_t *list, char *str);
142 static attr_list_t *append_attr_list(attr_list_t *new_list, attr_list_t *old_list);
144 static attr_t *make_attr(enum attr_type type);
145 static attr_t *make_attrv(enum attr_type type, unsigned int val);
146 static attr_t *make_attrp(enum attr_type type, void *val);
149 static var_t *declare_var(attr_list_t *attrs, decl_spec_t *decl_spec, const declarator_t *decl, int top);
150 static var_list_t *set_var_types(attr_list_t *attrs, decl_spec_t *decl_spec, declarator_list_t *decls);
152 static ifref_t *make_ifref(type_t *iface);
155 static declarator_t *make_declarator(var_t *var);
156 static type_t *make_safearray(type_t *type);
157 static typelib_t *make_library(const char *name, const attr_list_t *attrs);
160 
161 static type_t *reg_typedefs(decl_spec_t *decl_spec, var_list_t *names, attr_list_t *attrs);
162 static type_t *find_type_or_error(const char *name, int t);
163 static type_t *find_type_or_error2(char *name, int t);
164 
165 static var_t *reg_const(var_t *var);
166 
167 static void push_namespace(const char *name);
168 static void pop_namespace(const char *name);
169 
170 static char *gen_name(void);
171 static void check_arg_attrs(const var_t *arg);
172 static void check_statements(const statement_list_t *stmts, int is_inside_library);
173 static void check_all_user_types(const statement_list_t *stmts);
174 static attr_list_t *check_iface_attrs(const char *name, attr_list_t *attrs);
175 static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs);
180 static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs);
181 static attr_list_t *check_library_attrs(const char *name, attr_list_t *attrs);
182 static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs);
183 static attr_list_t *check_module_attrs(const char *name, attr_list_t *attrs);
184 static attr_list_t *check_coclass_attrs(const char *name, attr_list_t *attrs);
185 const char *get_attr_display_name(enum attr_type type);
186 static void add_explicit_handle_if_necessary(const type_t *iface, var_t *func);
187 static void check_def(const type_t *t);
188 
189 static void check_async_uuid(type_t *iface);
190 
196 static statement_t *make_statement_pragma(const char *str);
197 static statement_t *make_statement_cppquote(const char *str);
198 static statement_t *make_statement_importlib(const char *str);
201 static statement_t *make_statement_import(const char *str);
205 
206 static struct namespace global_namespace = {
208 };
209 
211 
212 #ifndef __REACTOS__
214 #endif
215 
216 
217 #line 218 "parser.tab.c" /* yacc.c:339 */
218 
219 # ifndef YY_NULL
220 # if defined __cplusplus && 201103L <= __cplusplus
221 # define YY_NULL nullptr
222 # else
223 # define YY_NULL 0
224 # endif
225 # endif
226 
227 /* Enabling verbose error messages. */
228 #ifdef YYERROR_VERBOSE
229 # undef YYERROR_VERBOSE
230 # define YYERROR_VERBOSE 1
231 #else
232 # define YYERROR_VERBOSE 1
233 #endif
234 
235 /* In a future release of Bison, this section will be replaced
236  by #include "parser.tab.h". */
237 #ifndef YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED
238 # define YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED
239 /* Debug traces. */
240 #ifndef YYDEBUG
241 # define YYDEBUG 0
242 #endif
243 #if YYDEBUG
244 extern int parser_debug;
245 #endif
246 
247 /* Token type. */
248 #ifndef YYTOKENTYPE
249 # define YYTOKENTYPE
251  {
252  aIDENTIFIER = 258,
253  aPRAGMA = 259,
254  aKNOWNTYPE = 260,
255  aNUM = 261,
256  aHEXNUM = 262,
257  aDOUBLE = 263,
258  aSTRING = 264,
259  aWSTRING = 265,
260  aSQSTRING = 266,
261  aUUID = 267,
262  aEOF = 268,
263  aACF = 269,
264  SHL = 270,
265  SHR = 271,
266  MEMBERPTR = 272,
267  EQUALITY = 273,
268  INEQUALITY = 274,
270  LESSEQUAL = 276,
271  LOGICALOR = 277,
272  LOGICALAND = 278,
273  ELLIPSIS = 279,
275  tALLOCATE = 281,
276  tANNOTATION = 282,
277  tAPPOBJECT = 283,
278  tASYNC = 284,
279  tASYNCUUID = 285,
280  tAUTOHANDLE = 286,
281  tBINDABLE = 287,
282  tBOOLEAN = 288,
283  tBROADCAST = 289,
284  tBYTE = 290,
285  tBYTECOUNT = 291,
286  tCALLAS = 292,
287  tCALLBACK = 293,
288  tCASE = 294,
289  tCDECL = 295,
290  tCHAR = 296,
291  tCOCLASS = 297,
292  tCODE = 298,
293  tCOMMSTATUS = 299,
294  tCONST = 300,
298  tCONTROL = 304,
299  tCPPQUOTE = 305,
300  tDECODE = 306,
301  tDEFAULT = 307,
309  tDLLNAME = 315,
310  tDOUBLE = 316,
311  tDUAL = 317,
313  tENCODE = 319,
314  tENDPOINT = 320,
315  tENTRY = 321,
316  tENUM = 322,
319  tEXTERN = 325,
320  tFALSE = 326,
321  tFASTCALL = 327,
323  tFLOAT = 329,
325  tHANDLE = 331,
326  tHANDLET = 332,
328  tHELPFILE = 334,
329  tHELPSTRING = 335,
332  tHIDDEN = 338,
333  tHYPER = 339,
334  tID = 340,
335  tIDEMPOTENT = 341,
336  tIGNORE = 342,
337  tIIDIS = 343,
340  tIMPORT = 346,
341  tIMPORTLIB = 347,
342  tIN = 348,
343  tIN_LINE = 349,
344  tINLINE = 350,
345  tINPUTSYNC = 351,
346  tINT = 352,
347  tINT32 = 353,
348  tINT3264 = 354,
349  tINT64 = 355,
350  tINTERFACE = 356,
351  tLCID = 357,
352  tLENGTHIS = 358,
353  tLIBRARY = 359,
354  tLICENSED = 360,
355  tLOCAL = 361,
356  tLONG = 362,
357  tMAYBE = 363,
358  tMESSAGE = 364,
359  tMETHODS = 365,
360  tMODULE = 366,
361  tNAMESPACE = 367,
362  tNOCODE = 368,
366  tNOTIFY = 372,
367  tNOTIFYFLAG = 373,
368  tNULL = 374,
369  tOBJECT = 375,
370  tODL = 376,
372  tOPTIMIZE = 378,
373  tOPTIONAL = 379,
374  tOUT = 380,
376  tPASCAL = 382,
379  tPROGID = 385,
380  tPROPERTIES = 386,
381  tPROPGET = 387,
382  tPROPPUT = 388,
383  tPROPPUTREF = 389,
384  tPROXY = 390,
385  tPTR = 391,
386  tPUBLIC = 392,
387  tRANGE = 393,
388  tREADONLY = 394,
389  tREF = 395,
390  tREGISTER = 396,
393  tRESTRICTED = 399,
394  tRETVAL = 400,
395  tSAFEARRAY = 401,
396  tSHORT = 402,
397  tSIGNED = 403,
398  tSIZEIS = 404,
399  tSIZEOF = 405,
400  tSMALL = 406,
401  tSOURCE = 407,
402  tSTATIC = 408,
403  tSTDCALL = 409,
405  tSTRING = 411,
406  tSTRUCT = 412,
407  tSWITCH = 413,
408  tSWITCHIS = 414,
409  tSWITCHTYPE = 415,
410  tTHREADING = 416,
411  tTRANSMITAS = 417,
412  tTRUE = 418,
413  tTYPEDEF = 419,
414  tUIDEFAULT = 420,
415  tUNION = 421,
416  tUNIQUE = 422,
417  tUNSIGNED = 423,
420  tUUID = 426,
421  tV1ENUM = 427,
422  tVARARG = 428,
423  tVERSION = 429,
424  tVIPROGID = 430,
425  tVOID = 431,
426  tWCHAR = 432,
428  tAPARTMENT = 434,
429  tNEUTRAL = 435,
430  tSINGLE = 436,
431  tFREE = 437,
432  tBOTH = 438,
433  CAST = 439,
434  PPTR = 440,
435  POS = 441,
436  NEG = 442,
437  ADDRESSOF = 443
438  };
439 #endif
440 
441 /* Value type. */
442 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
443 typedef union YYSTYPE YYSTYPE;
444 union YYSTYPE
445 {
446 #line 144 "parser.y" /* yacc.c:355 */
447 
464  char *str;
466  unsigned int num;
467  double dbl;
470  struct _import_t *import;
473 
474 #line 475 "parser.tab.c" /* yacc.c:355 */
475 };
476 # define YYSTYPE_IS_TRIVIAL 1
477 # define YYSTYPE_IS_DECLARED 1
478 #endif
479 
480 
481 extern YYSTYPE parser_lval;
482 
483 int parser_parse (void);
484 
485 #endif /* !YY_PARSER_E_REACTOSSYNC_MSVC_HOST_TOOLS_SDK_TOOLS_WIDL_PARSER_TAB_H_INCLUDED */
486 
487 /* Copy the second part of user declarations. */
488 
489 #line 490 "parser.tab.c" /* yacc.c:358 */
490 
491 #ifdef short
492 # undef short
493 #endif
494 
495 #ifdef YYTYPE_UINT8
496 typedef YYTYPE_UINT8 yytype_uint8;
497 #else
498 typedef unsigned char yytype_uint8;
499 #endif
500 
501 #ifdef YYTYPE_INT8
502 typedef YYTYPE_INT8 yytype_int8;
503 #else
504 typedef signed char yytype_int8;
505 #endif
506 
507 #ifdef YYTYPE_UINT16
508 typedef YYTYPE_UINT16 yytype_uint16;
509 #else
510 typedef unsigned short int yytype_uint16;
511 #endif
512 
513 #ifdef YYTYPE_INT16
514 typedef YYTYPE_INT16 yytype_int16;
515 #else
516 typedef short int yytype_int16;
517 #endif
518 
519 #ifndef YYSIZE_T
520 # ifdef __SIZE_TYPE__
521 # define YYSIZE_T __SIZE_TYPE__
522 # elif defined size_t
523 # define YYSIZE_T size_t
524 # elif ! defined YYSIZE_T
525 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
526 # define YYSIZE_T size_t
527 # else
528 # define YYSIZE_T unsigned int
529 # endif
530 #endif
531 
532 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
533 
534 #ifndef YY_
535 # if defined YYENABLE_NLS && YYENABLE_NLS
536 # if ENABLE_NLS
537 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
538 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
539 # endif
540 # endif
541 # ifndef YY_
542 # define YY_(Msgid) Msgid
543 # endif
544 #endif
545 
546 #ifndef __attribute__
547 /* This feature is available in gcc versions 2.5 and later. */
548 # if (! defined __GNUC__ || __GNUC__ < 2 \
549  || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
550 # define __attribute__(Spec) /* empty */
551 # endif
552 #endif
553 
554 /* Suppress unused-variable warnings by "using" E. */
555 #if ! defined lint || defined __GNUC__
556 # define YYUSE(E) ((void) (E))
557 #else
558 # define YYUSE(E) /* empty */
559 #endif
560 
561 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
562 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
563 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
564  _Pragma ("GCC diagnostic push") \
565  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
566  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
567 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
568  _Pragma ("GCC diagnostic pop")
569 #else
570 # define YY_INITIAL_VALUE(Value) Value
571 #endif
572 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
573 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
574 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
575 #endif
576 #ifndef YY_INITIAL_VALUE
577 # define YY_INITIAL_VALUE(Value) /* Nothing. */
578 #endif
579 
580 
581 #if ! defined yyoverflow || YYERROR_VERBOSE
582 
583 /* The parser invokes alloca or malloc; define the necessary symbols. */
584 
585 # ifdef YYSTACK_USE_ALLOCA
586 # if YYSTACK_USE_ALLOCA
587 # ifdef __GNUC__
588 # define YYSTACK_ALLOC __builtin_alloca
589 # elif defined __BUILTIN_VA_ARG_INCR
590 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
591 # elif defined _AIX
592 # define YYSTACK_ALLOC __alloca
593 # elif defined _MSC_VER
594 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
595 # define alloca _alloca
596 # else
597 # define YYSTACK_ALLOC alloca
598 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
599 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
600  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
601 # ifndef EXIT_SUCCESS
602 # define EXIT_SUCCESS 0
603 # endif
604 # endif
605 # endif
606 # endif
607 # endif
608 
609 # ifdef YYSTACK_ALLOC
610  /* Pacify GCC's 'empty if-body' warning. */
611 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
612 # ifndef YYSTACK_ALLOC_MAXIMUM
613  /* The OS might guarantee only one guard page at the bottom of the stack,
614  and a page size can be as small as 4096 bytes. So we cannot safely
615  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
616  to allow for a few compiler-allocated temporary stack slots. */
617 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
618 # endif
619 # else
620 # define YYSTACK_ALLOC YYMALLOC
621 # define YYSTACK_FREE YYFREE
622 # ifndef YYSTACK_ALLOC_MAXIMUM
623 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
624 # endif
625 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
626  && ! ((defined YYMALLOC || defined malloc) \
627  && (defined YYFREE || defined free)))
628 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
629 # ifndef EXIT_SUCCESS
630 # define EXIT_SUCCESS 0
631 # endif
632 # endif
633 # ifndef YYMALLOC
634 # define YYMALLOC malloc
635 # if ! defined malloc && ! defined EXIT_SUCCESS
636 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
637 # endif
638 # endif
639 # ifndef YYFREE
640 # define YYFREE free
641 # if ! defined free && ! defined EXIT_SUCCESS
642 void free (void *); /* INFRINGES ON USER NAME SPACE */
643 # endif
644 # endif
645 # endif
646 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
647 
648 
649 #if (! defined yyoverflow \
650  && (! defined __cplusplus \
651  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
652 
653 /* A type that is properly aligned for any stack member. */
654 union yyalloc
655 {
658 };
659 
660 /* The size of the maximum gap between one aligned stack and the next. */
661 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
662 
663 /* The size of an array large to enough to hold all stacks, each with
664  N elements. */
665 # define YYSTACK_BYTES(N) \
666  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
667  + YYSTACK_GAP_MAXIMUM)
668 
669 # define YYCOPY_NEEDED 1
670 
671 /* Relocate STACK from its old location to the new one. The
672  local variables YYSIZE and YYSTACKSIZE give the old and new number of
673  elements in the stack, and YYPTR gives the new location of the
674  stack. Advance YYPTR to a properly aligned location for the next
675  stack. */
676 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
677  do \
678  { \
679  YYSIZE_T yynewbytes; \
680  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
681  Stack = &yyptr->Stack_alloc; \
682  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
683  yyptr += yynewbytes / sizeof (*yyptr); \
684  } \
685  while (0)
686 
687 #endif
688 
689 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
690 /* Copy COUNT objects from SRC to DST. The source and destination do
691  not overlap. */
692 # ifndef YYCOPY
693 # if defined __GNUC__ && 1 < __GNUC__
694 # define YYCOPY(Dst, Src, Count) \
695  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
696 # else
697 # define YYCOPY(Dst, Src, Count) \
698  do \
699  { \
700  YYSIZE_T yyi; \
701  for (yyi = 0; yyi < (Count); yyi++) \
702  (Dst)[yyi] = (Src)[yyi]; \
703  } \
704  while (0)
705 # endif
706 # endif
707 #endif /* !YYCOPY_NEEDED */
708 
709 /* YYFINAL -- State number of the termination state. */
710 #define YYFINAL 3
711 /* YYLAST -- Last index in YYTABLE. */
712 #define YYLAST 3047
713 
714 /* YYNTOKENS -- Number of terminals. */
715 #define YYNTOKENS 213
716 /* YYNNTS -- Number of nonterminals. */
717 #define YYNNTS 113
718 /* YYNRULES -- Number of rules. */
719 #define YYNRULES 410
720 /* YYNSTATES -- Number of states. */
721 #define YYNSTATES 718
722 
723 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
724  by yylex, with out-of-bounds checking. */
725 #define YYUNDEFTOK 2
726 #define YYMAXUTOK 443
727 
728 #define YYTRANSLATE(YYX) \
729  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
730 
731 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
732  as returned by yylex, without out-of-bounds checking. */
733 static const yytype_uint8 yytranslate[] =
734 {
735  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
736  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
737  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
738  2, 2, 2, 197, 2, 2, 2, 196, 189, 2,
739  210, 211, 194, 193, 184, 192, 204, 195, 2, 2,
740  2, 2, 2, 2, 2, 2, 2, 2, 186, 209,
741  190, 212, 191, 185, 2, 2, 2, 2, 2, 2,
742  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
743  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
744  2, 205, 2, 206, 188, 2, 2, 2, 2, 2,
745  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
746  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
747  2, 2, 2, 207, 187, 208, 198, 2, 2, 2,
748  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
749  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
750  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
751  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
752  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
753  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
754  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
755  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
756  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
757  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
758  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
759  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
760  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
761  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
762  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
763  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
764  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
765  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
766  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
767  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
768  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
769  85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
770  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
771  105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
772  115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
773  125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
774  135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
775  145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
776  155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
777  165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
778  175, 176, 177, 178, 179, 180, 181, 182, 183, 199,
779  200, 201, 202, 203
780 };
781 
782 #if YYDEBUG
783  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
784 static const yytype_uint16 yyrline[] =
785 {
786  0, 327, 327, 344, 344, 346, 347, 347, 349, 350,
787  351, 354, 357, 358, 359, 362, 363, 364, 364, 366,
788  367, 368, 371, 372, 373, 374, 377, 378, 381, 382,
789  386, 387, 388, 389, 390, 391, 392, 395, 406, 407,
790  411, 412, 413, 414, 415, 416, 417, 418, 419, 422,
791  424, 432, 438, 446, 447, 449, 457, 468, 469, 472,
792  473, 476, 477, 481, 486, 493, 497, 498, 501, 502,
793  506, 509, 510, 511, 514, 515, 518, 519, 520, 521,
794  522, 523, 524, 525, 526, 527, 528, 529, 530, 531,
795  532, 533, 534, 535, 536, 537, 538, 539, 540, 541,
796  542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
797  552, 553, 554, 555, 556, 557, 558, 559, 560, 561,
798  562, 563, 564, 565, 566, 567, 568, 569, 570, 571,
799  572, 573, 574, 575, 576, 577, 578, 579, 580, 581,
800  582, 583, 584, 585, 586, 587, 588, 589, 590, 591,
801  592, 593, 597, 598, 599, 600, 601, 602, 603, 604,
802  605, 606, 607, 608, 609, 610, 611, 612, 613, 614,
803  615, 616, 617, 618, 619, 620, 624, 625, 630, 631,
804  632, 633, 636, 637, 640, 644, 650, 651, 652, 655,
805  659, 671, 675, 680, 683, 684, 687, 688, 691, 692,
806  693, 694, 695, 696, 697, 698, 699, 700, 701, 702,
807  703, 704, 705, 706, 707, 708, 709, 710, 711, 712,
808  713, 714, 715, 716, 717, 718, 719, 720, 721, 722,
809  723, 724, 725, 726, 727, 728, 730, 732, 733, 736,
810  737, 740, 746, 752, 753, 756, 761, 768, 769, 772,
811  773, 777, 778, 781, 785, 791, 799, 803, 808, 809,
812  812, 813, 814, 817, 819, 822, 823, 824, 825, 826,
813  827, 828, 829, 830, 831, 832, 835, 836, 839, 840,
814  841, 842, 843, 844, 845, 846, 847, 850, 851, 859,
815  865, 869, 872, 873, 877, 880, 881, 884, 893, 894,
816  897, 898, 901, 907, 913, 914, 917, 918, 921, 931,
817  941, 947, 951, 952, 955, 956, 959, 964, 971, 972,
818  973, 977, 981, 984, 985, 988, 989, 993, 994, 998,
819  999, 1000, 1004, 1006, 1008, 1012, 1013, 1014, 1015, 1023,
820  1025, 1027, 1032, 1034, 1039, 1040, 1045, 1046, 1047, 1048,
821  1053, 1062, 1064, 1065, 1070, 1072, 1076, 1077, 1084, 1085,
822  1086, 1087, 1088, 1093, 1101, 1102, 1105, 1106, 1109, 1116,
823  1117, 1122, 1123, 1127, 1128, 1129, 1130, 1131, 1135, 1136,
824  1137, 1140, 1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150,
825  1151, 1152, 1155, 1162, 1164, 1170, 1171, 1172, 1175, 1177,
826  1179, 1181, 1184, 1189, 1197, 1198, 1201, 1202, 1205, 1206,
827  1207
828 };
829 #endif
830 
831 #if YYDEBUG || YYERROR_VERBOSE || 1
832 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
833  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
834 static const char *const yytname[] =
835 {
836  "$end", "error", "$undefined", "aIDENTIFIER", "aPRAGMA", "aKNOWNTYPE",
837  "aNUM", "aHEXNUM", "aDOUBLE", "aSTRING", "aWSTRING", "aSQSTRING",
838  "aUUID", "aEOF", "aACF", "SHL", "SHR", "MEMBERPTR", "EQUALITY",
839  "INEQUALITY", "GREATEREQUAL", "LESSEQUAL", "LOGICALOR", "LOGICALAND",
840  "ELLIPSIS", "tAGGREGATABLE", "tALLOCATE", "tANNOTATION", "tAPPOBJECT",
841  "tASYNC", "tASYNCUUID", "tAUTOHANDLE", "tBINDABLE", "tBOOLEAN",
842  "tBROADCAST", "tBYTE", "tBYTECOUNT", "tCALLAS", "tCALLBACK", "tCASE",
843  "tCDECL", "tCHAR", "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST",
844  "tCONTEXTHANDLE", "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE",
845  "tCONTROL", "tCPPQUOTE", "tDECODE", "tDEFAULT", "tDEFAULTBIND",
846  "tDEFAULTCOLLELEM", "tDEFAULTVALUE", "tDEFAULTVTABLE",
847  "tDISABLECONSISTENCYCHECK", "tDISPLAYBIND", "tDISPINTERFACE", "tDLLNAME",
848  "tDOUBLE", "tDUAL", "tENABLEALLOCATE", "tENCODE", "tENDPOINT", "tENTRY",
849  "tENUM", "tERRORSTATUST", "tEXPLICITHANDLE", "tEXTERN", "tFALSE",
850  "tFASTCALL", "tFAULTSTATUS", "tFLOAT", "tFORCEALLOCATE", "tHANDLE",
851  "tHANDLET", "tHELPCONTEXT", "tHELPFILE", "tHELPSTRING",
852  "tHELPSTRINGCONTEXT", "tHELPSTRINGDLL", "tHIDDEN", "tHYPER", "tID",
853  "tIDEMPOTENT", "tIGNORE", "tIIDIS", "tIMMEDIATEBIND", "tIMPLICITHANDLE",
854  "tIMPORT", "tIMPORTLIB", "tIN", "tIN_LINE", "tINLINE", "tINPUTSYNC",
855  "tINT", "tINT32", "tINT3264", "tINT64", "tINTERFACE", "tLCID",
856  "tLENGTHIS", "tLIBRARY", "tLICENSED", "tLOCAL", "tLONG", "tMAYBE",
857  "tMESSAGE", "tMETHODS", "tMODULE", "tNAMESPACE", "tNOCODE",
858  "tNONBROWSABLE", "tNONCREATABLE", "tNONEXTENSIBLE", "tNOTIFY",
859  "tNOTIFYFLAG", "tNULL", "tOBJECT", "tODL", "tOLEAUTOMATION", "tOPTIMIZE",
860  "tOPTIONAL", "tOUT", "tPARTIALIGNORE", "tPASCAL", "tPOINTERDEFAULT",
861  "tPRAGMA_WARNING", "tPROGID", "tPROPERTIES", "tPROPGET", "tPROPPUT",
862  "tPROPPUTREF", "tPROXY", "tPTR", "tPUBLIC", "tRANGE", "tREADONLY",
863  "tREF", "tREGISTER", "tREPRESENTAS", "tREQUESTEDIT", "tRESTRICTED",
864  "tRETVAL", "tSAFEARRAY", "tSHORT", "tSIGNED", "tSIZEIS", "tSIZEOF",
865  "tSMALL", "tSOURCE", "tSTATIC", "tSTDCALL", "tSTRICTCONTEXTHANDLE",
866  "tSTRING", "tSTRUCT", "tSWITCH", "tSWITCHIS", "tSWITCHTYPE",
867  "tTHREADING", "tTRANSMITAS", "tTRUE", "tTYPEDEF", "tUIDEFAULT", "tUNION",
868  "tUNIQUE", "tUNSIGNED", "tUSESGETLASTERROR", "tUSERMARSHAL", "tUUID",
869  "tV1ENUM", "tVARARG", "tVERSION", "tVIPROGID", "tVOID", "tWCHAR",
870  "tWIREMARSHAL", "tAPARTMENT", "tNEUTRAL", "tSINGLE", "tFREE", "tBOTH",
871  "','", "'?'", "':'", "'|'", "'^'", "'&'", "'<'", "'>'", "'-'", "'+'",
872  "'*'", "'/'", "'%'", "'!'", "'~'", "CAST", "PPTR", "POS", "NEG",
873  "ADDRESSOF", "'.'", "'['", "']'", "'{'", "'}'", "';'", "'('", "')'",
874  "'='", "$accept", "input", "m_acf", "gbl_statements", "$@1",
875  "imp_statements", "$@2", "int_statements", "semicolon_opt", "statement",
876  "pragma_warning", "warnings", "typedecl", "cppquote", "import_start",
877  "import", "importlib", "libraryhdr", "library_start", "librarydef",
878  "m_args", "arg_list", "args", "arg", "array", "m_attributes",
879  "attributes", "attrib_list", "str_list", "attribute", "uuid_string",
880  "callconv", "cases", "case", "enums", "enum_list", "enum", "enumdef",
881  "m_exprs", "m_expr", "expr", "expr_list_int_const", "expr_int_const",
882  "expr_const", "fields", "field", "ne_union_field", "ne_union_fields",
883  "union_field", "s_field", "funcdef", "declaration", "m_ident", "t_ident",
884  "ident", "base_type", "m_int", "int_std", "coclass", "coclasshdr",
885  "coclassdef", "namespacedef", "coclass_ints", "coclass_int",
886  "dispinterface", "dispinterfacehdr", "dispint_props", "dispint_meths",
887  "dispinterfacedef", "inherit", "interface", "interfacehdr",
888  "interfacedef", "interfacedec", "module", "modulehdr", "moduledef",
889  "storage_cls_spec", "function_specifier", "type_qualifier",
890  "m_type_qual_list", "decl_spec", "m_decl_spec_no_type",
891  "decl_spec_no_type", "declarator", "direct_declarator",
892  "abstract_declarator", "abstract_declarator_no_direct",
893  "m_abstract_declarator", "abstract_direct_declarator", "any_declarator",
894  "any_declarator_no_direct", "m_any_declarator", "any_direct_declarator",
895  "declarator_list", "m_bitfield", "struct_declarator",
896  "struct_declarator_list", "init_declarator", "threading_type",
897  "pointer_type", "structdef", "type", "typedef", "uniondef", "version",
898  "acf_statements", "acf_int_statements", "acf_int_statement",
899  "acf_interface", "acf_attributes", "acf_attribute_list", "acf_attribute", YY_NULL
900 };
901 #endif
902 
903 # ifdef YYPRINT
904 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
905  (internal) symbol number NUM (which must be that of a token). */
906 static const yytype_uint16 yytoknum[] =
907 {
908  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
909  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
910  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
911  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
912  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
913  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
914  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
915  325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
916  335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
917  345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
918  355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
919  365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
920  375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
921  385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
922  395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
923  405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
924  415, 416, 417, 418, 419, 420, 421, 422, 423, 424,
925  425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
926  435, 436, 437, 438, 44, 63, 58, 124, 94, 38,
927  60, 62, 45, 43, 42, 47, 37, 33, 126, 439,
928  440, 441, 442, 443, 46, 91, 93, 123, 125, 59,
929  40, 41, 61
930 };
931 # endif
932 
933 #define YYPACT_NINF -560
934 
935 #define yypact_value_is_default(Yystate) \
936  (!!((Yystate) == (-560)))
937 
938 #define YYTABLE_NINF -405
939 
940 #define yytable_value_is_error(Yytable_value) \
941  0
942 
943  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
944  STATE-NUM. */
945 static const yytype_int16 yypact[] =
946 {
947  -560, 94, 1606, -560, -560, -560, -57, -560, -560, -560,
948  147, -560, -89, 165, -560, 169, -560, -560, -560, -560,
949  35, 149, -560, -560, -560, -560, -560, 172, 35, 164,
950  -34, -560, -29, 35, 333, -560, -560, 192, 197, 333,
951  -560, -560, 2869, -560, -560, -560, -27, -560, -560, -560,
952  -560, -560, 21, 2567, -13, -10, -560, -560, 9, -36,
953  -560, 2, 12, 38, 23, 46, 41, -560, -560, 57,
954  -560, 128, 128, 128, 175, 2716, 76, 128, 81, 88,
955  61, -560, -57, 219, -560, -560, 315, -560, -560, 15,
956  -560, 121, -560, -560, 123, -560, -560, -560, -560, 331,
957  2716, -560, -560, 58, 129, -94, -112, -560, -560, 130,
958  -560, -560, 131, -560, -560, -560, 132, 134, -560, -560,
959  -560, -560, -560, -560, -560, -560, -560, -560, 138, -560,
960  -560, -560, 140, -560, -560, -560, 141, 146, -560, -560,
961  -560, -560, 150, 151, 153, 157, 158, -560, 160, -560,
962  -560, 161, -560, 163, -560, -560, 166, 167, -560, -560,
963  -560, -560, -560, -560, -560, -560, -560, -560, -560, -560,
964  -560, 168, -560, -560, -560, 170, 171, -560, -560, -560,
965  -560, -560, -560, 174, -560, -560, 185, -560, -560, -560,
966  187, -560, -560, -560, 188, 189, 190, 191, -560, -560,
967  -560, 195, 196, -560, -560, 206, 209, 211, -132, -560,
968  -560, -560, 1736, 851, 133, 267, 270, 273, 283, 286,
969  220, 148, -560, -560, -560, -560, 175, 173, 216, -560,
970  -560, -560, -560, -560, -42, -560, -560, -560, 290, 222,
971  -560, -560, -560, -560, -560, -560, -560, -560, -560, -560,
972  -560, -560, 175, 175, -560, 127, -101, -560, -560, -560,
973  128, -560, -560, -560, -560, -560, -560, -119, -560, -560,
974  374, 215, 291, -560, 249, 225, -560, 227, -560, 429,
975  84, 291, 710, 710, 430, 432, 710, 710, 435, 458,
976  710, 461, 710, 710, 2097, 710, 710, 463, -68, 464,
977  710, 2716, 710, 710, 2716, -38, 2716, 2716, 84, 324,
978  466, 2716, 2869, 271, -560, 268, -560, -560, -560, 272,
979  -560, 278, -560, -560, -560, 23, 2612, -560, 279, -560,
980  -560, -560, -560, 279, -91, -560, -560, -122, -560, 293,
981  -65, 280, 284, -560, -560, 1193, 52, 266, -560, 710,
982  542, 2097, -560, -560, 61, -560, 285, -560, 282, 303,
983  -560, 281, 488, -560, -49, 133, -39, 294, -560, -560,
984  295, 296, -560, -560, -560, -560, -560, -560, -560, -560,
985  -560, 305, -560, 710, 710, 710, 710, 710, 710, 596,
986  2299, -135, -560, 2299, 306, 307, -560, -111, 308, 309,
987  314, 316, 317, 323, 326, 371, 327, 2612, 77, 328,
988  -106, -560, 2299, 329, 330, 332, 311, 335, -100, 1397,
989  343, -560, -560, -560, -560, -560, 344, 346, 359, 360,
990  292, -560, 361, 362, 367, -560, 2869, 492, -560, -560,
991  -560, 175, 23, -11, -560, 1089, -560, 340, 2612, 370,
992  1476, 334, 413, 1297, 23, -560, 2612, -560, -560, -560,
993  -560, 611, -560, 2190, 377, 402, -560, -560, -560, 380,
994  -560, 291, 710, -560, 18, -560, 2612, -560, 378, -560,
995  384, -560, 389, -560, -560, -560, 2612, 36, 36, 36,
996  36, 36, 36, 2102, 496, 710, 710, 597, 710, 710,
997  710, 710, 710, 710, 710, 710, 710, 710, 710, 710,
998  710, 710, 710, 710, 710, 605, 710, 710, -560, -560,
999  -560, 600, -560, -560, -560, -560, -560, -560, -560, -560,
1000  -560, -560, 77, -560, 1833, -560, 77, -560, -560, -560,
1001  -87, -560, 710, -560, -560, -560, -560, 710, -560, -560,
1002  -560, -560, -560, -560, -560, -560, 604, -560, -560, -560,
1003  -560, 400, -560, -560, 428, -560, -560, -560, -560, 175,
1004  116, -560, -560, 2612, 407, -560, -560, -560, 23, -560,
1005  -560, -560, -560, 2009, 419, 417, 380, -560, -560, -560,
1006  -560, 77, 418, 291, -560, -560, 496, -560, -560, 1921,
1007  -560, 496, -560, 415, -74, 318, 318, -560, 575, 575,
1008  482, 482, 2318, 2337, 2260, 2372, 2394, 218, 482, 482,
1009  54, 54, 36, 36, 36, -560, 2212, -560, -560, -560,
1010  74, -560, 421, 77, 422, -560, 2097, -560, -560, 424,
1011  -560, 23, 970, 175, -560, -560, 1401, -560, -560, -560,
1012  623, -560, -560, 444, -560, -103, -560, 431, -560, 425,
1013  375, -560, 434, 77, 437, -560, 710, 2097, -560, 710,
1014  -560, -560, 74, -560, -560, -560, 440, -560, -560, -560,
1015  -560, 23, 433, 710, -560, 77, -560, -560, -560, -560,
1016  74, -560, -560, -560, 36, 441, 2299, -560, -560, -560,
1017  -560, -560, -560, -1, -560, -560, 710, 453, -560, -560,
1018  468, -58, -58, -560, -560, 447, -560, -560
1019 };
1020 
1021  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1022  Performed when YYTABLE does not specify something else to do. Zero
1023  means the default is an error. */
1024 static const yytype_uint16 yydefact[] =
1025 {
1026  5, 0, 3, 1, 35, 383, 398, 273, 265, 284,
1027  0, 322, 0, 0, 272, 260, 274, 318, 271, 275,
1028  276, 0, 321, 278, 285, 286, 283, 0, 276, 0,
1029  0, 320, 0, 276, 0, 280, 319, 260, 260, 270,
1030  382, 266, 76, 2, 14, 36, 0, 30, 15, 33,
1031  15, 13, 0, 69, 385, 0, 384, 267, 0, 0,
1032  11, 0, 0, 0, 28, 0, 304, 9, 8, 0,
1033  12, 327, 327, 327, 0, 0, 387, 327, 0, 389,
1034  0, 4, 398, 0, 287, 288, 0, 295, 296, 386,
1035  262, 0, 277, 282, 0, 306, 307, 281, 291, 0,
1036  0, 279, 268, 388, 0, 390, 0, 269, 77, 0,
1037  79, 80, 0, 81, 82, 83, 0, 0, 86, 87,
1038  88, 89, 90, 91, 92, 93, 94, 95, 0, 97,
1039  98, 99, 0, 101, 102, 103, 0, 0, 106, 107,
1040  108, 109, 0, 0, 0, 0, 0, 115, 0, 117,
1041  118, 0, 120, 0, 122, 123, 126, 0, 127, 128,
1042  129, 130, 131, 132, 133, 134, 135, 136, 137, 138,
1043  139, 0, 141, 142, 143, 0, 0, 146, 147, 148,
1044  149, 380, 150, 0, 152, 378, 0, 154, 155, 156,
1045  0, 158, 159, 160, 0, 0, 0, 0, 165, 379,
1046  166, 0, 0, 170, 171, 0, 0, 0, 0, 71,
1047  175, 31, 68, 68, 68, 260, 0, 0, 260, 260,
1048  0, 385, 289, 297, 308, 316, 0, 387, 389, 32,
1049  10, 292, 6, 313, 0, 29, 311, 312, 0, 0,
1050  26, 331, 328, 330, 329, 263, 264, 178, 179, 180,
1051  181, 323, 0, 0, 335, 371, 334, 257, 385, 387,
1052  327, 389, 325, 34, 409, 408, 410, 0, 406, 399,
1053  0, 0, 186, 50, 0, 0, 243, 0, 249, 0,
1054  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1055  0, 0, 0, 0, 0, 0, 196, 0, 0, 0,
1056  0, 0, 196, 0, 0, 0, 0, 0, 0, 0,
1057  0, 0, 76, 70, 51, 0, 23, 24, 25, 0,
1058  21, 0, 19, 16, 22, 28, 0, 69, 386, 53,
1059  54, 314, 315, 388, 390, 55, 256, 68, 5, 0,
1060  68, 0, 0, 305, 26, 68, 0, 0, 333, 0,
1061  0, 57, 337, 326, 0, 405, 0, 49, 0, 188,
1062  189, 192, 0, 391, 68, 68, 68, 0, 177, 176,
1063  0, 0, 207, 198, 199, 200, 204, 205, 206, 201,
1064  202, 0, 203, 0, 0, 0, 0, 0, 0, 0,
1065  241, 0, 239, 242, 0, 0, 74, 0, 0, 0,
1066  0, 0, 0, 0, 0, 0, 0, 0, 356, 0,
1067  0, 194, 197, 0, 0, 0, 0, 0, 0, 0,
1068  0, 373, 374, 375, 376, 377, 0, 0, 0, 0,
1069  395, 397, 0, 0, 0, 72, 76, 0, 20, 17,
1070  56, 0, 28, 0, 293, 68, 298, 0, 0, 0,
1071  0, 0, 0, 68, 28, 27, 69, 324, 332, 336,
1072  372, 0, 67, 0, 0, 61, 58, 59, 407, 400,
1073  193, 187, 0, 38, 0, 381, 0, 244, 0, 393,
1074  69, 250, 0, 78, 169, 84, 0, 231, 230, 229,
1075  232, 227, 228, 0, 344, 0, 0, 0, 0, 0,
1076  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1077  0, 0, 0, 0, 0, 0, 0, 0, 85, 96,
1078  100, 0, 104, 105, 110, 111, 112, 113, 114, 116,
1079  119, 121, 356, 323, 57, 361, 356, 358, 357, 64,
1080  353, 125, 196, 124, 140, 144, 145, 0, 153, 157,
1081  161, 162, 164, 163, 167, 168, 0, 172, 173, 174,
1082  73, 0, 15, 364, 392, 290, 294, 7, 300, 0,
1083  387, 299, 302, 0, 0, 255, 303, 26, 28, 317,
1084  66, 65, 338, 0, 404, 0, 400, 190, 191, 39,
1085  37, 0, 389, 258, 248, 247, 344, 238, 323, 57,
1086  348, 344, 345, 0, 341, 220, 221, 233, 214, 215,
1087  218, 219, 209, 210, 0, 211, 212, 213, 217, 216,
1088  223, 222, 225, 226, 224, 234, 0, 240, 75, 63,
1089  356, 323, 0, 356, 0, 352, 57, 360, 195, 0,
1090  396, 28, 68, 0, 253, 301, 68, 309, 62, 60,
1091  0, 403, 401, 366, 369, 0, 246, 0, 259, 0,
1092  344, 323, 0, 356, 0, 340, 0, 57, 347, 0,
1093  237, 351, 356, 362, 355, 359, 0, 151, 52, 18,
1094  365, 28, 0, 0, 368, 0, 245, 182, 236, 339,
1095  356, 349, 343, 346, 235, 0, 208, 354, 363, 310,
1096  402, 367, 370, 0, 342, 350, 0, 0, 394, 183,
1097  0, 68, 68, 252, 185, 0, 184, 251
1098 };
1099 
1100  /* YYPGOTO[NTERM-NUM]. */
1101 static const yytype_int16 yypgoto[] =
1102 {
1103  -560, -560, -560, 320, -560, -46, -560, -317, -315, 0,
1104  -560, -560, -560, -560, -560, 208, -560, -560, -560, 10,
1105  -514, -560, -560, -261, -242, -203, -2, -560, -560, -272,
1106  354, -66, -560, -560, -560, -560, 198, 13, 366, 137,
1107  -195, -560, -264, -280, -560, -560, -560, -560, -41, -237,
1108  -560, 233, -560, 25, -69, -560, 42, 99, 5, -560,
1109  11, 17, -560, -560, 619, -560, -560, -560, -560, -560,
1110  -18, -560, 19, 16, -560, -560, 20, -560, -560, -307,
1111  -496, -52, -43, -30, -236, -560, -560, -560, -540, -560,
1112  -559, -560, 51, -560, -560, -560, 3, -560, 459, -560,
1113  391, 1, -50, -560, 7, -560, 615, 112, -560, -560,
1114  115, -560, 348
1115 };
1116 
1117  /* YYDEFGOTO[NTERM-NUM]. */
1118 static const yytype_int16 yydefgoto[] =
1119 {
1120  -1, 1, 43, 2, 338, 212, 562, 345, 236, 316,
1121  45, 474, 46, 47, 48, 49, 317, 220, 50, 318,
1122  464, 465, 466, 467, 535, 52, 327, 208, 397, 209,
1123  370, 536, 703, 709, 358, 359, 360, 258, 410, 411,
1124  390, 391, 392, 394, 364, 477, 481, 366, 714, 715,
1125  574, 55, 657, 91, 537, 56, 93, 57, 319, 59,
1126  320, 321, 337, 444, 62, 63, 340, 450, 64, 239,
1127  65, 66, 322, 323, 225, 69, 324, 71, 72, 73,
1128  346, 74, 241, 75, 255, 256, 602, 664, 603, 604,
1129  538, 634, 539, 540, 564, 684, 654, 655, 257, 426,
1130  210, 259, 77, 78, 261, 432, 81, 585, 586, 82,
1131  83, 267, 268
1132 };
1133 
1134  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1135  positive, shift that token. If negative, reduce the rule whose
1136  number is the opposite. If YYTABLE_NINF, syntax error. */
1137 static const yytype_int16 yytable[] =
1138 {
1139  53, 226, 44, 76, 213, 254, 398, 58, 253, 79,
1140  440, 326, 51, 60, 352, 54, 347, 348, 68, 61,
1141  632, 67, 70, 399, 589, 260, 402, 453, 404, 243,
1142  244, 409, 653, 406, 262, 224, 416, 630, 706, 457,
1143  435, 242, 242, 242, -404, 447, 277, 242, 13, 517,
1144  275, 707, 312, 497, 227, 245, 659, 246, 222, 27,
1145  228, 665, 104, 106, -261, 354, 221, -261, 181, 460,
1146  97, 497, 185, 521, 313, 101, 518, 245, 542, 246,
1147  245, 685, 246, 42, 542, 662, 442, 355, 393, 339,
1148  27, 393, 247, 368, 3, 278, 369, 11, 405, 199,
1149  522, 412, 660, 449, 350, 543, 686, 412, 419, 351,
1150  458, 549, 264, -261, 247, -45, -261, 247, 350, 11,
1151  689, 86, 676, 636, 248, 265, 653, 565, 478, 482,
1152  266, 350, 92, 102, 443, 672, 667, 448, 107, 579,
1153  42, 421, 422, 423, 424, 425, 248, 42, 80, 248,
1154  84, 713, 85, 695, 393, 463, 42, 254, 94, 475,
1155  253, 476, 448, 448, 560, 690, 42, 98, 87, 479,
1156  88, 231, 89, 11, 90, 95, 99, 96, 245, 249,
1157  246, 100, 211, 254, 254, 214, 253, 253, 487, 488,
1158  489, 490, 491, 492, 493, 103, -40, 90, 17, 229,
1159  105, 249, 90, 361, 249, 563, 250, 708, 588, 232,
1160  53, 53, 371, 76, 76, 247, 341, 353, 230, 79,
1161  79, 233, -261, 22, -41, 54, 54, 238, 250, 590,
1162  242, 250, 235, 495, 496, 497, 498, 499, 500, 501,
1163  515, 516, 408, 104, 106, 234, 251, 248, 512, 513,
1164  514, 417, 600, 627, 420, 237, 427, 428, 515, 516,
1165  646, 434, 252, 647, 240, -261, 490, -43, 533, 31,
1166  328, 533, 90, 329, 441, 330, 331, 254, 332, 350,
1167  253, 36, 350, 639, 534, -42, 333, 534, 90, 334,
1168  263, 90, 407, 342, 245, 343, 246, -44, 637, 408,
1169  605, 606, 249, 608, 609, 610, 611, 612, 613, 614,
1170  615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
1171  270, 626, 649, 457, 271, -254, 678, -254, 272, 250,
1172  430, 431, 273, 644, 274, 497, 276, 494, 42, 349,
1173  279, 280, 281, 456, 282, 455, 76, 412, 283, 407,
1174  284, 285, 79, 457, 600, 532, 286, -46, 54, 600,
1175  287, 288, 668, 289, 480, 457, 699, 290, 291, 251,
1176  292, 293, 254, 294, 9, 253, 295, 296, 297, 356,
1177  298, 299, -47, 457, 300, 252, 495, 496, 497, 498,
1178  499, 500, 501, 502, 503, 301, 569, 302, 303, 304,
1179  305, 306, 361, 701, 226, 307, 308, 680, 508, 509,
1180  510, 511, 512, 513, 514, 247, 309, 20, 600, 310,
1181  11, 311, 515, 516, 591, -48, 357, 335, 601, 344,
1182  23, 24, 25, 26, 596, 362, 363, 365, 367, 395,
1183  28, 396, 710, 53, 400, 44, 76, 248, 573, 570,
1184  58, 456, 79, 455, 76, 51, 60, 227, 54, 566,
1185  79, 68, 61, 228, 67, 70, 54, 401, 633, 221,
1186  403, 694, 413, 415, 696, 433, 436, 459, 437, 446,
1187  33, 438, 408, 592, 35, 439, -261, 471, 393, 451,
1188  470, 452, 469, 472, 473, 547, 556, 495, 496, 497,
1189  254, 561, 249, 253, 21, 483, 484, 485, 448, 448,
1190  510, 511, 512, 513, 514, 486, 642, 519, 520, 523,
1191  524, 226, 515, 516, 658, 525, 568, 526, 527, 250,
1192  601, 408, 407, 663, 528, 601, 247, 529, 531, 541,
1193  544, 545, 576, 546, 584, 372, 548, 408, 373, 374,
1194  375, 376, 377, 378, 551, 552, 504, 553, 505, 506,
1195  507, 508, 509, 510, 511, 512, 513, 514, 248, 598,
1196  554, 555, 557, 558, 254, 515, 516, 253, 559, 571,
1197  350, 407, 530, 629, 408, 599, 583, 635, 582, 593,
1198  495, 496, 497, 594, 601, 500, 501, 407, 595, 372,
1199  607, 5, 373, 374, 375, 376, 377, 378, 625, 628,
1200  640, 641, 643, 379, 372, 408, 645, 373, 374, 375,
1201  376, 377, 378, 249, 80, 651, 666, 656, 682, 7,
1202  683, 8, 673, 675, 407, 677, 688, 9, 687, 711,
1203  53, 11, 700, 76, 456, 691, 455, 76, 693, 79,
1204  250, 698, 705, 79, 712, 54, 717, 14, 445, 54,
1205  577, 380, 429, 215, 16, 407, 17, 379, 418, 587,
1206  18, 716, 223, 19, 510, 511, 512, 513, 514, 638,
1207  20, 671, 379, 575, 674, 336, 515, 516, 702, 414,
1208  598, 22, 381, 23, 24, 25, 26, 269, 652, 650,
1209  0, 350, 468, 28, 0, 382, 599, 0, 0, 0,
1210  0, 0, 0, 372, 692, 380, 373, 374, 375, 376,
1211  377, 378, 0, 697, 0, 0, 0, 0, 0, 0,
1212  380, 383, 0, 0, 384, 385, 461, 31, 0, 387,
1213  388, 704, 32, 33, 34, 0, 381, 35, 462, 36,
1214  0, 0, 389, 218, 0, 0, 0, 0, 0, 382,
1215  0, 381, 219, 0, 39, 508, 509, 510, 511, 512,
1216  513, 514, 40, 41, 382, 0, 0, 0, 0, 515,
1217  516, 379, 0, 0, 0, 383, 0, 0, 384, 385,
1218  386, 0, 0, 387, 388, 0, 0, 0, 0, 0,
1219  383, 0, 0, 384, 385, 386, 389, 0, 387, 388,
1220  0, 0, 0, 0, 0, 0, 0, 580, 0, 0,
1221  0, 389, 0, 0, 0, 0, 0, 0, 0, 380,
1222  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1223  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1224  0, 0, 0, 0, 0, 4, 5, 0, 0, 0,
1225  381, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1226  0, 0, 0, 382, 0, 0, 0, 0, 0, 0,
1227  0, 0, 0, 0, 7, 0, 8, 0, 0, 0,
1228  0, 0, 9, 10, 0, 0, 11, 0, 0, 383,
1229  0, 12, 384, 385, 386, 0, 0, 387, 388, 0,
1230  13, 0, 14, 0, 0, 0, 0, 0, 15, 16,
1231  389, 17, 0, 0, 0, 18, 0, 0, 19, 0,
1232  0, 0, 0, 0, 0, 20, 0, 0, 0, 0,
1233  0, 0, 21, 315, 0, 0, 22, 0, 23, 24,
1234  25, 26, 27, 0, 0, 0, 0, 0, 28, 0,
1235  0, 0, 0, 29, 0, 0, 0, 0, 0, 0,
1236  0, 0, 0, 0, 4, 5, 0, 0, 0, 0,
1237  30, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1238  0, 0, 31, 0, 0, 0, 0, 32, 33, 34,
1239  0, 0, 35, 7, 36, 8, 0, 0, 37, 0,
1240  0, 9, 10, 0, 0, 11, 0, 38, 0, 39,
1241  12, 0, 0, 0, 0, 0, 0, 40, 41, 13,
1242  0, 14, 0, 0, 0, 0, 0, 15, 16, 0,
1243  17, 0, 0, 0, 18, 0, 0, 19, 0, 0,
1244  0, 0, 0, 0, 20, 0, 42, 0, 0, 325,
1245  0, 21, 315, 0, 0, 22, 0, 23, 24, 25,
1246  26, 27, 0, 0, 0, 0, 0, 28, 0, 0,
1247  0, 0, 29, 0, 0, 0, 0, 0, 0, 0,
1248  0, 0, 0, 4, 5, 0, 0, 0, 0, 30,
1249  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1250  0, 31, 0, 0, 0, 0, 32, 33, 34, 0,
1251  0, 35, 7, 36, 8, 0, 0, 37, 0, 0,
1252  9, 10, 0, 0, 11, 0, 38, 0, 39, 12,
1253  0, 0, 0, 0, 0, 0, 40, 41, 13, 0,
1254  14, 0, 0, 0, 0, 0, 15, 16, 0, 17,
1255  0, 0, 0, 18, 0, 0, 19, 0, 0, 0,
1256  0, 0, 0, 20, 0, 42, 0, 0, 679, 0,
1257  21, 0, 0, 0, 22, 0, 23, 24, 25, 26,
1258  27, 0, 0, 0, 0, 0, 28, 4, 5, 0,
1259  0, 29, 0, 0, 0, 0, 0, 0, 0, 0,
1260  0, 0, 0, 0, 0, 0, 0, 0, 30, 0,
1261  0, 0, 0, 0, 0, 0, 7, 0, 8, 0,
1262  31, 0, 0, 0, 9, 32, 33, 34, 11, 0,
1263  35, 0, 36, 12, 0, 0, 37, 0, 0, 0,
1264  0, 0, 0, 0, 14, 38, 0, 39, 0, 0,
1265  15, 16, 0, 17, 0, 40, 41, 18, 0, 0,
1266  19, 0, 0, 0, 0, 0, 0, 20, 0, 0,
1267  0, 0, 0, 0, 21, 0, 0, 0, 22, 0,
1268  23, 24, 25, 26, 42, 0, 0, 567, 0, 0,
1269  28, 4, 5, 0, 0, 0, 0, 0, 0, 0,
1270  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1271  0, 0, 30, 0, 0, 0, 0, 0, 0, 0,
1272  7, 0, 8, 0, 31, 0, 0, 0, 9, 32,
1273  33, 34, 11, 0, 35, 0, 36, 12, 0, 0,
1274  37, 0, 0, 0, 0, 0, 0, 0, 14, 38,
1275  0, 39, 0, 0, 15, 16, 0, 17, 0, 40,
1276  41, 18, 0, 0, 19, 0, 0, 0, 0, 0,
1277  0, 20, 0, 0, 0, 0, 0, 0, 21, 0,
1278  0, 0, 22, 0, 23, 24, 25, 26, 42, 0,
1279  0, 454, 0, 0, 28, 4, 5, 0, 0, 0,
1280  0, 0, 495, 496, 497, 498, 499, 500, 501, 502,
1281  503, 0, 0, 0, 0, 0, 30, 0, 0, 0,
1282  0, 0, 0, 0, 7, 0, 8, 0, 31, 0,
1283  0, 0, 9, 32, 33, 34, 11, 0, 35, 0,
1284  36, 12, 0, 0, 37, 0, 0, 0, 0, 0,
1285  0, 0, 14, 38, 0, 39, 0, 0, 15, 16,
1286  0, 17, 0, 40, 41, 18, 0, 0, 19, 0,
1287  0, 5, 0, 0, 0, 20, 0, 0, 0, 0,
1288  0, 0, 21, 0, 0, 0, 22, 0, 23, 24,
1289  25, 26, 42, 0, 0, 578, 0, 0, 28, 7,
1290  0, 8, 0, 0, 0, 0, 0, 9, 0, 0,
1291  0, 11, 0, 0, 0, 0, 0, 0, 0, 0,
1292  30, 0, 0, 0, 0, 0, 0, 14, 0, 0,
1293  0, 0, 31, 215, 16, 0, 17, 32, 33, 34,
1294  18, 0, 35, 19, 36, 0, 0, 0, 37, 0,
1295  20, 0, 0, 0, 0, 0, 0, 38, 0, 39,
1296  0, 22, 0, 23, 24, 25, 26, 40, 41, 0,
1297  0, 0, 504, 28, 505, 506, 507, 508, 509, 510,
1298  511, 512, 513, 514, 0, 0, 0, 0, 0, 0,
1299  0, 515, 516, 0, 0, 0, 42, 0, 550, 681,
1300  4, 5, 0, 0, 0, 0, 0, 31, 0, 0,
1301  6, 0, 32, 33, 34, 0, 0, 35, 0, 36,
1302  0, 0, 0, 218, 0, 0, 0, 0, 0, 7,
1303  0, 8, 219, 0, 39, 0, 0, 9, 10, 0,
1304  0, 11, 40, 41, 0, 0, 12, 0, 0, 0,
1305  0, 0, 0, 0, 0, 13, 0, 14, 0, 0,
1306  0, 0, 0, 15, 16, 0, 17, 0, 0, 0,
1307  18, 42, 0, 19, 572, 0, 0, 0, 0, 0,
1308  20, 0, 0, 0, 0, 0, 0, 21, 0, 0,
1309  0, 22, 0, 23, 24, 25, 26, 27, 0, 0,
1310  0, 0, 0, 28, 0, 0, 0, 0, 29, 0,
1311  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1312  0, 0, 0, 0, 0, 30, 0, 0, 0, 0,
1313  4, 5, 0, 0, 0, 0, 0, 31, 0, 314,
1314  0, 0, 32, 33, 34, 0, 0, 35, 0, 36,
1315  0, 0, 0, 37, 0, 0, 0, 0, 0, 7,
1316  -68, 8, 38, 0, 39, 0, 0, 9, 10, 0,
1317  0, 11, 40, 41, 0, 0, 12, 0, 0, 0,
1318  0, 0, 0, 0, 0, 13, 0, 14, 0, 0,
1319  0, 0, 0, 15, 16, 0, 17, 0, 0, 0,
1320  18, 42, 0, 19, 0, 0, 0, 0, 0, 0,
1321  20, 0, 0, 0, 0, 0, 0, 21, 315, 0,
1322  0, 22, 0, 23, 24, 25, 26, 27, 5, 0,
1323  0, 0, 0, 28, 0, 0, 0, 0, 29, 0,
1324  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1325  0, 0, 0, 0, 0, 30, 7, 0, 8, 0,
1326  0, 0, 0, 247, 9, 0, 0, 31, 11, 0,
1327  0, 0, 32, 33, 34, 0, 0, 35, 0, 36,
1328  0, 0, 0, 37, 14, 0, 0, 0, 0, 0,
1329  215, 16, 38, 17, 39, 248, 0, 18, 0, 0,
1330  19, 0, 40, 41, 0, 0, 0, 20, 0, 0,
1331  0, 0, 0, 0, 0, 0, 5, 0, 22, 0,
1332  23, 24, 25, 26, 0, 0, 0, 0, 0, 0,
1333  28, 42, 0, 0, 0, 0, 0, 0, 0, 0,
1334  0, 0, 0, 0, 7, 0, 8, 0, 0, 0,
1335  249, 247, 9, 0, 0, 0, 11, 0, 0, 0,
1336  0, 0, 0, 0, 31, 0, 0, 0, 0, 32,
1337  33, 34, 14, 0, 35, 0, 36, 250, 215, 16,
1338  218, 17, 0, 248, 0, 18, 0, 0, 19, 219,
1339  0, 39, 0, 0, 0, 20, 0, 0, 0, 40,
1340  41, 0, 0, 0, 5, 0, 22, 0, 23, 24,
1341  25, 26, 0, 0, 0, 0, 0, 631, 28, 0,
1342  0, 0, 0, 648, 0, 0, 0, 0, 42, 0,
1343  0, 0, 7, 0, 8, 0, 0, 0, 249, 0,
1344  9, 0, 0, 0, 11, 0, 0, 0, 0, 0,
1345  0, 0, 31, 0, 0, 0, 0, 32, 33, 34,
1346  14, 0, 35, 0, 36, 250, 215, 16, 218, 17,
1347  0, 0, 0, 18, 0, 0, 19, 219, 0, 39,
1348  0, 0, 0, 20, 0, 0, 0, 40, 41, 0,
1349  0, 0, 5, 0, 22, 0, 23, 24, 25, 26,
1350  0, 0, 0, 0, 0, 661, 28, 495, 496, 497,
1351  498, 499, 500, 501, 502, 503, 42, 0, 0, 0,
1352  7, 0, 8, 0, 0, 0, 0, 0, 9, 0,
1353  0, 0, 11, 0, 0, 0, 0, 0, 0, 0,
1354  31, 0, 0, 0, 0, 32, 33, 34, 14, 0,
1355  35, 0, 36, 0, 215, 16, 218, 17, 0, 0,
1356  0, 18, 0, 0, 19, 219, 0, 39, 0, 0,
1357  0, 20, 0, 0, 0, 40, 41, 0, 0, 0,
1358  0, 0, 22, 0, 23, 24, 25, 26, 0, 0,
1359  0, 0, 0, 0, 28, 495, 496, 497, 498, 499,
1360  500, 501, 502, 503, 42, 0, 0, 0, 0, 0,
1361  0, 0, 0, 0, 0, 0, 0, 495, 496, 497,
1362  498, 499, 500, 501, 502, 503, 0, 0, 31, 0,
1363  0, 0, 0, 32, 33, 34, 0, 0, 35, 0,
1364  36, 0, 0, 0, 218, 0, 0, 0, 0, 0,
1365  0, 0, 0, 219, 0, 39, 0, 0, 0, 0,
1366  0, 0, 0, 40, 41, 495, 496, 497, 498, 499,
1367  500, 501, 502, 503, 0, 0, 0, 504, 0, 505,
1368  506, 507, 508, 509, 510, 511, 512, 513, 514, 0,
1369  0, 0, 42, 0, 0, 0, 515, 516, 0, 0,
1370  0, 0, 0, 597, 495, 496, 497, 498, 499, 500,
1371  501, 502, 503, 0, 0, 0, 0, 0, 0, 0,
1372  0, 0, 0, 495, 496, 497, 498, 499, 500, 501,
1373  0, 503, 0, 0, 0, 0, 0, 0, 0, 0,
1374  0, 0, 495, 496, 497, 498, 499, 500, 501, 0,
1375  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1376  0, 0, 0, 0, 0, 504, 0, 505, 506, 507,
1377  508, 509, 510, 511, 512, 513, 514, 495, 496, 497,
1378  498, 499, 500, 501, 515, 516, 581, 504, 0, 505,
1379  506, 507, 508, 509, 510, 511, 512, 513, 514, 495,
1380  496, 497, 498, 499, 500, 501, 515, 516, 670, 0,
1381  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1382  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1383  0, 0, 0, 0, 0, 504, 669, 505, 506, 507,
1384  508, 509, 510, 511, 512, 513, 514, 0, 0, 0,
1385  0, 0, 0, 0, 515, 516, 0, 0, 0, 0,
1386  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1387  0, 0, 0, 0, 504, 0, 505, 506, 507, 508,
1388  509, 510, 511, 512, 513, 514, 0, 0, 0, 0,
1389  0, 0, 0, 515, 516, 505, 506, 507, 508, 509,
1390  510, 511, 512, 513, 514, 0, 0, 0, 0, 0,
1391  0, 0, 515, 516, 505, 506, 507, 508, 509, 510,
1392  511, 512, 513, 514, 0, 0, 0, 0, 0, 0,
1393  0, 515, 516, 0, 0, 0, 0, 0, 0, 0,
1394  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1395  506, 507, 508, 509, 510, 511, 512, 513, 514, 0,
1396  0, 0, 5, 0, 0, 0, 515, 516, 0, 0,
1397  0, 0, 0, 507, 508, 509, 510, 511, 512, 513,
1398  514, 0, 0, 0, 0, 0, 0, 0, 515, 516,
1399  7, 0, 8, 0, 0, 0, 0, 0, 9, 10,
1400  0, 0, 11, 0, 0, 0, 0, 5, 0, 0,
1401  0, 0, 0, 0, 0, 0, 13, 0, 14, 0,
1402  0, 0, 0, 0, 215, 16, 0, 17, 0, 0,
1403  0, 18, 0, 0, 19, 7, 0, 8, 0, 0,
1404  0, 20, 0, 9, 0, 0, 0, 11, 0, 0,
1405  0, 0, 22, 0, 23, 24, 25, 26, 27, 0,
1406  0, 216, 0, 14, 28, 0, 0, 0, 217, 215,
1407  16, 0, 17, 0, 0, 0, 18, 0, 0, 19,
1408  0, 0, 0, 0, 0, 0, 20, 0, 0, 0,
1409  0, 0, 0, 0, 0, 0, 0, 22, 31, 23,
1410  24, 25, 26, 32, 33, 34, 0, 0, 35, 28,
1411  36, 5, 0, 0, 218, 0, 0, 0, 0, 0,
1412  0, 0, 0, 219, 0, 39, 0, 0, 0, 0,
1413  0, 0, 0, 40, 41, 0, 0, 0, 0, 7,
1414  0, 8, 0, 31, 0, 0, 0, 9, 32, 33,
1415  34, 0, 0, 35, 0, 36, 0, 0, 0, 218,
1416  0, 0, 0, 0, 0, 0, 0, 14, 219, 0,
1417  39, 0, 0, 215, 16, 0, 0, 0, 40, 41,
1418  18, 0, 0, 19, 0, 0, 0, 0, 0, 0,
1419  20, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1420  0, 0, 0, 23, 24, 25, 26, 0, 0, 0,
1421  0, 0, 0, 28, 0, 0, 0, 0, 0, 0,
1422  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1423  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1424  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1425  0, 0, 32, 33, 34, 0, 0, 35, 0, 0,
1426  0, 0, 0, 218, 0, 0, 0, 0, 0, 0,
1427  0, 0, 219, 0, 39, 0, 0, 0, 0, 0,
1428  0, 0, 40, 41, 108, 0, 109, 110, 111, 112,
1429  113, 114, 0, 115, 0, 0, 116, 0, 117, 0,
1430  0, 0, 118, 119, 0, 120, 121, 122, 123, 0,
1431  124, 125, 126, 127, 128, 129, 130, 131, 0, 132,
1432  0, 133, 134, 135, 136, 137, 0, 0, 138, 0,
1433  0, 0, 139, 0, 140, 141, 0, 142, 143, 144,
1434  145, 146, 147, 0, 148, 149, 150, 151, 152, 153,
1435  0, 0, 154, 0, 0, 155, 0, 0, 0, 0,
1436  0, 156, 157, 0, 158, 159, 0, 160, 161, 0,
1437  0, 0, 162, 163, 164, 165, 166, 167, 0, 168,
1438  169, 170, 171, 172, 173, 174, 0, 175, 0, 176,
1439  0, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1440  0, 186, 187, 188, 189, 0, 0, 0, 190, 0,
1441  0, 191, 0, 0, 192, 193, 0, 0, 194, 195,
1442  196, 197, 0, 0, 198, 0, 199, 0, 200, 201,
1443  202, 203, 204, 205, 206, 0, 0, 207
1444 };
1445 
1446 static const yytype_int16 yycheck[] =
1447 {
1448  2, 53, 2, 2, 50, 74, 286, 2, 74, 2,
1449  325, 214, 2, 2, 256, 2, 252, 253, 2, 2,
1450  534, 2, 2, 287, 6, 75, 290, 344, 292, 72,
1451  73, 295, 591, 294, 77, 53, 300, 533, 39, 346,
1452  312, 71, 72, 73, 101, 110, 158, 77, 59, 184,
1453  100, 52, 184, 17, 53, 3, 596, 5, 53, 101,
1454  53, 601, 37, 38, 158, 184, 53, 158, 136, 349,
1455  28, 17, 140, 184, 206, 33, 211, 3, 184, 5,
1456  3, 184, 5, 205, 184, 599, 208, 206, 283, 131,
1457  101, 286, 40, 9, 0, 207, 12, 45, 293, 167,
1458  211, 296, 598, 340, 205, 211, 209, 302, 303, 210,
1459  346, 211, 51, 207, 40, 209, 207, 40, 205, 45,
1460  660, 210, 636, 210, 72, 64, 685, 442, 365, 366,
1461  69, 205, 97, 34, 337, 631, 210, 340, 39, 454,
1462  205, 179, 180, 181, 182, 183, 72, 205, 205, 72,
1463  3, 209, 5, 667, 349, 350, 205, 226, 9, 208,
1464  226, 364, 365, 366, 436, 661, 205, 3, 3, 208,
1465  5, 207, 3, 45, 5, 3, 210, 5, 3, 127,
1466  5, 210, 209, 252, 253, 164, 252, 253, 383, 384,
1467  385, 386, 387, 388, 389, 3, 209, 5, 70, 209,
1468  3, 127, 5, 272, 127, 441, 154, 208, 472, 207,
1469  212, 213, 281, 212, 213, 40, 234, 260, 209, 212,
1470  213, 209, 207, 95, 209, 212, 213, 186, 154, 211,
1471  260, 154, 209, 15, 16, 17, 18, 19, 20, 21,
1472  204, 205, 294, 218, 219, 207, 194, 72, 194, 195,
1473  196, 301, 494, 517, 304, 209, 306, 307, 204, 205,
1474  577, 311, 210, 578, 207, 207, 461, 209, 194, 141,
1475  3, 194, 5, 3, 326, 5, 3, 346, 5, 205,
1476  346, 153, 205, 547, 210, 209, 3, 210, 5, 3,
1477  209, 5, 294, 3, 3, 5, 5, 209, 540, 351,
1478  495, 496, 127, 498, 499, 500, 501, 502, 503, 504,
1479  505, 506, 507, 508, 509, 510, 511, 512, 513, 514,
1480  101, 516, 583, 630, 9, 209, 641, 211, 207, 154,
1481  6, 7, 209, 569, 3, 17, 207, 389, 205, 212,
1482  210, 210, 210, 345, 210, 345, 345, 542, 210, 351,
1483  210, 210, 345, 660, 596, 407, 210, 209, 345, 601,
1484  210, 210, 604, 210, 366, 672, 681, 210, 210, 194,
1485  210, 210, 441, 210, 41, 441, 210, 210, 210, 5,
1486  210, 210, 209, 690, 210, 210, 15, 16, 17, 18,
1487  19, 20, 21, 22, 23, 210, 448, 210, 210, 210,
1488  210, 210, 471, 683, 456, 210, 210, 643, 190, 191,
1489  192, 193, 194, 195, 196, 40, 210, 84, 660, 210,
1490  45, 210, 204, 205, 476, 209, 211, 207, 494, 207,
1491  97, 98, 99, 100, 486, 186, 211, 210, 9, 9,
1492  107, 9, 706, 445, 9, 445, 445, 72, 450, 448,
1493  445, 453, 445, 453, 453, 445, 445, 456, 445, 443,
1494  453, 445, 445, 456, 445, 445, 453, 9, 534, 456,
1495  9, 666, 9, 9, 669, 9, 205, 211, 210, 186,
1496  147, 209, 534, 476, 151, 207, 207, 184, 683, 209,
1497  208, 207, 207, 212, 6, 184, 204, 15, 16, 17,
1498  569, 9, 127, 569, 91, 211, 211, 211, 711, 712,
1499  192, 193, 194, 195, 196, 210, 562, 211, 211, 211,
1500  211, 573, 204, 205, 593, 211, 186, 211, 211, 154,
1501  596, 583, 534, 599, 211, 601, 40, 211, 211, 211,
1502  211, 211, 208, 211, 164, 3, 211, 599, 6, 7,
1503  8, 9, 10, 11, 211, 211, 185, 211, 187, 188,
1504  189, 190, 191, 192, 193, 194, 195, 196, 72, 194,
1505  211, 211, 211, 211, 643, 204, 205, 643, 211, 209,
1506  205, 583, 211, 532, 636, 210, 184, 536, 211, 211,
1507  15, 16, 17, 209, 660, 20, 21, 599, 209, 3,
1508  3, 5, 6, 7, 8, 9, 10, 11, 3, 9,
1509  6, 211, 184, 71, 3, 667, 209, 6, 7, 8,
1510  9, 10, 11, 127, 205, 208, 211, 209, 5, 33,
1511  186, 35, 211, 211, 636, 211, 211, 41, 207, 186,
1512  642, 45, 209, 642, 646, 211, 646, 646, 211, 642,
1513  154, 211, 211, 646, 186, 642, 209, 61, 338, 646,
1514  452, 119, 308, 67, 68, 667, 70, 71, 302, 471,
1515  74, 712, 53, 77, 192, 193, 194, 195, 196, 542,
1516  84, 630, 71, 450, 633, 226, 204, 205, 685, 298,
1517  194, 95, 150, 97, 98, 99, 100, 82, 586, 584,
1518  -1, 205, 354, 107, -1, 163, 210, -1, -1, -1,
1519  -1, -1, -1, 3, 663, 119, 6, 7, 8, 9,
1520  10, 11, -1, 672, -1, -1, -1, -1, -1, -1,
1521  119, 189, -1, -1, 192, 193, 194, 141, -1, 197,
1522  198, 690, 146, 147, 148, -1, 150, 151, 206, 153,
1523  -1, -1, 210, 157, -1, -1, -1, -1, -1, 163,
1524  -1, 150, 166, -1, 168, 190, 191, 192, 193, 194,
1525  195, 196, 176, 177, 163, -1, -1, -1, -1, 204,
1526  205, 71, -1, -1, -1, 189, -1, -1, 192, 193,
1527  194, -1, -1, 197, 198, -1, -1, -1, -1, -1,
1528  189, -1, -1, 192, 193, 194, 210, -1, 197, 198,
1529  -1, -1, -1, -1, -1, -1, -1, 206, -1, -1,
1530  -1, 210, -1, -1, -1, -1, -1, -1, -1, 119,
1531  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1532  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1533  -1, -1, -1, -1, -1, 4, 5, -1, -1, -1,
1534  150, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1535  -1, -1, -1, 163, -1, -1, -1, -1, -1, -1,
1536  -1, -1, -1, -1, 33, -1, 35, -1, -1, -1,
1537  -1, -1, 41, 42, -1, -1, 45, -1, -1, 189,
1538  -1, 50, 192, 193, 194, -1, -1, 197, 198, -1,
1539  59, -1, 61, -1, -1, -1, -1, -1, 67, 68,
1540  210, 70, -1, -1, -1, 74, -1, -1, 77, -1,
1541  -1, -1, -1, -1, -1, 84, -1, -1, -1, -1,
1542  -1, -1, 91, 92, -1, -1, 95, -1, 97, 98,
1543  99, 100, 101, -1, -1, -1, -1, -1, 107, -1,
1544  -1, -1, -1, 112, -1, -1, -1, -1, -1, -1,
1545  -1, -1, -1, -1, 4, 5, -1, -1, -1, -1,
1546  129, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1547  -1, -1, 141, -1, -1, -1, -1, 146, 147, 148,
1548  -1, -1, 151, 33, 153, 35, -1, -1, 157, -1,
1549  -1, 41, 42, -1, -1, 45, -1, 166, -1, 168,
1550  50, -1, -1, -1, -1, -1, -1, 176, 177, 59,
1551  -1, 61, -1, -1, -1, -1, -1, 67, 68, -1,
1552  70, -1, -1, -1, 74, -1, -1, 77, -1, -1,
1553  -1, -1, -1, -1, 84, -1, 205, -1, -1, 208,
1554  -1, 91, 92, -1, -1, 95, -1, 97, 98, 99,
1555  100, 101, -1, -1, -1, -1, -1, 107, -1, -1,
1556  -1, -1, 112, -1, -1, -1, -1, -1, -1, -1,
1557  -1, -1, -1, 4, 5, -1, -1, -1, -1, 129,
1558  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1559  -1, 141, -1, -1, -1, -1, 146, 147, 148, -1,
1560  -1, 151, 33, 153, 35, -1, -1, 157, -1, -1,
1561  41, 42, -1, -1, 45, -1, 166, -1, 168, 50,
1562  -1, -1, -1, -1, -1, -1, 176, 177, 59, -1,
1563  61, -1, -1, -1, -1, -1, 67, 68, -1, 70,
1564  -1, -1, -1, 74, -1, -1, 77, -1, -1, -1,
1565  -1, -1, -1, 84, -1, 205, -1, -1, 208, -1,
1566  91, -1, -1, -1, 95, -1, 97, 98, 99, 100,
1567  101, -1, -1, -1, -1, -1, 107, 4, 5, -1,
1568  -1, 112, -1, -1, -1, -1, -1, -1, -1, -1,
1569  -1, -1, -1, -1, -1, -1, -1, -1, 129, -1,
1570  -1, -1, -1, -1, -1, -1, 33, -1, 35, -1,
1571  141, -1, -1, -1, 41, 146, 147, 148, 45, -1,
1572  151, -1, 153, 50, -1, -1, 157, -1, -1, -1,
1573  -1, -1, -1, -1, 61, 166, -1, 168, -1, -1,
1574  67, 68, -1, 70, -1, 176, 177, 74, -1, -1,
1575  77, -1, -1, -1, -1, -1, -1, 84, -1, -1,
1576  -1, -1, -1, -1, 91, -1, -1, -1, 95, -1,
1577  97, 98, 99, 100, 205, -1, -1, 208, -1, -1,
1578  107, 4, 5, -1, -1, -1, -1, -1, -1, -1,
1579  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1580  -1, -1, 129, -1, -1, -1, -1, -1, -1, -1,
1581  33, -1, 35, -1, 141, -1, -1, -1, 41, 146,
1582  147, 148, 45, -1, 151, -1, 153, 50, -1, -1,
1583  157, -1, -1, -1, -1, -1, -1, -1, 61, 166,
1584  -1, 168, -1, -1, 67, 68, -1, 70, -1, 176,
1585  177, 74, -1, -1, 77, -1, -1, -1, -1, -1,
1586  -1, 84, -1, -1, -1, -1, -1, -1, 91, -1,
1587  -1, -1, 95, -1, 97, 98, 99, 100, 205, -1,
1588  -1, 208, -1, -1, 107, 4, 5, -1, -1, -1,
1589  -1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
1590  23, -1, -1, -1, -1, -1, 129, -1, -1, -1,
1591  -1, -1, -1, -1, 33, -1, 35, -1, 141, -1,
1592  -1, -1, 41, 146, 147, 148, 45, -1, 151, -1,
1593  153, 50, -1, -1, 157, -1, -1, -1, -1, -1,
1594  -1, -1, 61, 166, -1, 168, -1, -1, 67, 68,
1595  -1, 70, -1, 176, 177, 74, -1, -1, 77, -1,
1596  -1, 5, -1, -1, -1, 84, -1, -1, -1, -1,
1597  -1, -1, 91, -1, -1, -1, 95, -1, 97, 98,
1598  99, 100, 205, -1, -1, 208, -1, -1, 107, 33,
1599  -1, 35, -1, -1, -1, -1, -1, 41, -1, -1,
1600  -1, 45, -1, -1, -1, -1, -1, -1, -1, -1,
1601  129, -1, -1, -1, -1, -1, -1, 61, -1, -1,
1602  -1, -1, 141, 67, 68, -1, 70, 146, 147, 148,
1603  74, -1, 151, 77, 153, -1, -1, -1, 157, -1,
1604  84, -1, -1, -1, -1, -1, -1, 166, -1, 168,
1605  -1, 95, -1, 97, 98, 99, 100, 176, 177, -1,
1606  -1, -1, 185, 107, 187, 188, 189, 190, 191, 192,
1607  193, 194, 195, 196, -1, -1, -1, -1, -1, -1,
1608  -1, 204, 205, -1, -1, -1, 205, -1, 211, 208,
1609  4, 5, -1, -1, -1, -1, -1, 141, -1, -1,
1610  14, -1, 146, 147, 148, -1, -1, 151, -1, 153,
1611  -1, -1, -1, 157, -1, -1, -1, -1, -1, 33,
1612  -1, 35, 166, -1, 168, -1, -1, 41, 42, -1,
1613  -1, 45, 176, 177, -1, -1, 50, -1, -1, -1,
1614  -1, -1, -1, -1, -1, 59, -1, 61, -1, -1,
1615  -1, -1, -1, 67, 68, -1, 70, -1, -1, -1,
1616  74, 205, -1, 77, 208, -1, -1, -1, -1, -1,
1617  84, -1, -1, -1, -1, -1, -1, 91, -1, -1,
1618  -1, 95, -1, 97, 98, 99, 100, 101, -1, -1,
1619  -1, -1, -1, 107, -1, -1, -1, -1, 112, -1,
1620  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1621  -1, -1, -1, -1, -1, 129, -1, -1, -1, -1,
1622  4, 5, -1, -1, -1, -1, -1, 141, -1, 13,
1623  -1, -1, 146, 147, 148, -1, -1, 151, -1, 153,
1624  -1, -1, -1, 157, -1, -1, -1, -1, -1, 33,
1625  164, 35, 166, -1, 168, -1, -1, 41, 42, -1,
1626  -1, 45, 176, 177, -1, -1, 50, -1, -1, -1,
1627  -1, -1, -1, -1, -1, 59, -1, 61, -1, -1,
1628  -1, -1, -1, 67, 68, -1, 70, -1, -1, -1,
1629  74, 205, -1, 77, -1, -1, -1, -1, -1, -1,
1630  84, -1, -1, -1, -1, -1, -1, 91, 92, -1,
1631  -1, 95, -1, 97, 98, 99, 100, 101, 5, -1,
1632  -1, -1, -1, 107, -1, -1, -1, -1, 112, -1,
1633  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1634  -1, -1, -1, -1, -1, 129, 33, -1, 35, -1,
1635  -1, -1, -1, 40, 41, -1, -1, 141, 45, -1,
1636  -1, -1, 146, 147, 148, -1, -1, 151, -1, 153,
1637  -1, -1, -1, 157, 61, -1, -1, -1, -1, -1,
1638  67, 68, 166, 70, 168, 72, -1, 74, -1, -1,
1639  77, -1, 176, 177, -1, -1, -1, 84, -1, -1,
1640  -1, -1, -1, -1, -1, -1, 5, -1, 95, -1,
1641  97, 98, 99, 100, -1, -1, -1, -1, -1, -1,
1642  107, 205, -1, -1, -1, -1, -1, -1, -1, -1,
1643  -1, -1, -1, -1, 33, -1, 35, -1, -1, -1,
1644  127, 40, 41, -1, -1, -1, 45, -1, -1, -1,
1645  -1, -1, -1, -1, 141, -1, -1, -1, -1, 146,
1646  147, 148, 61, -1, 151, -1, 153, 154, 67, 68,
1647  157, 70, -1, 72, -1, 74, -1, -1, 77, 166,
1648  -1, 168, -1, -1, -1, 84, -1, -1, -1, 176,
1649  177, -1, -1, -1, 5, -1, 95, -1, 97, 98,
1650  99, 100, -1, -1, -1, -1, -1, 194, 107, -1,
1651  -1, -1, -1, 24, -1, -1, -1, -1, 205, -1,
1652  -1, -1, 33, -1, 35, -1, -1, -1, 127, -1,
1653  41, -1, -1, -1, 45, -1, -1, -1, -1, -1,
1654  -1, -1, 141, -1, -1, -1, -1, 146, 147, 148,
1655  61, -1, 151, -1, 153, 154, 67, 68, 157, 70,
1656  -1, -1, -1, 74, -1, -1, 77, 166, -1, 168,
1657  -1, -1, -1, 84, -1, -1, -1, 176, 177, -1,
1658  -1, -1, 5, -1, 95, -1, 97, 98, 99, 100,
1659  -1, -1, -1, -1, -1, 194, 107, 15, 16, 17,
1660  18, 19, 20, 21, 22, 23, 205, -1, -1, -1,
1661  33, -1, 35, -1, -1, -1, -1, -1, 41, -1,
1662  -1, -1, 45, -1, -1, -1, -1, -1, -1, -1,
1663  141, -1, -1, -1, -1, 146, 147, 148, 61, -1,
1664  151, -1, 153, -1, 67, 68, 157, 70, -1, -1,
1665  -1, 74, -1, -1, 77, 166, -1, 168, -1, -1,
1666  -1, 84, -1, -1, -1, 176, 177, -1, -1, -1,
1667  -1, -1, 95, -1, 97, 98, 99, 100, -1, -1,
1668  -1, -1, -1, -1, 107, 15, 16, 17, 18, 19,
1669  20, 21, 22, 23, 205, -1, -1, -1, -1, -1,
1670  -1, -1, -1, -1, -1, -1, -1, 15, 16, 17,
1671  18, 19, 20, 21, 22, 23, -1, -1, 141, -1,
1672  -1, -1, -1, 146, 147, 148, -1, -1, 151, -1,
1673  153, -1, -1, -1, 157, -1, -1, -1, -1, -1,
1674  -1, -1, -1, 166, -1, 168, -1, -1, -1, -1,
1675  -1, -1, -1, 176, 177, 15, 16, 17, 18, 19,
1676  20, 21, 22, 23, -1, -1, -1, 185, -1, 187,
1677  188, 189, 190, 191, 192, 193, 194, 195, 196, -1,
1678  -1, -1, 205, -1, -1, -1, 204, 205, -1, -1,
1679  -1, -1, -1, 211, 15, 16, 17, 18, 19, 20,
1680  21, 22, 23, -1, -1, -1, -1, -1, -1, -1,
1681  -1, -1, -1, 15, 16, 17, 18, 19, 20, 21,
1682  -1, 23, -1, -1, -1, -1, -1, -1, -1, -1,
1683  -1, -1, 15, 16, 17, 18, 19, 20, 21, -1,
1684  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1685  -1, -1, -1, -1, -1, 185, -1, 187, 188, 189,
1686  190, 191, 192, 193, 194, 195, 196, 15, 16, 17,
1687  18, 19, 20, 21, 204, 205, 206, 185, -1, 187,
1688  188, 189, 190, 191, 192, 193, 194, 195, 196, 15,
1689  16, 17, 18, 19, 20, 21, 204, 205, 206, -1,
1690  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1691  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1692  -1, -1, -1, -1, -1, 185, 186, 187, 188, 189,
1693  190, 191, 192, 193, 194, 195, 196, -1, -1, -1,
1694  -1, -1, -1, -1, 204, 205, -1, -1, -1, -1,
1695  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1696  -1, -1, -1, -1, 185, -1, 187, 188, 189, 190,
1697  191, 192, 193, 194, 195, 196, -1, -1, -1, -1,
1698  -1, -1, -1, 204, 205, 187, 188, 189, 190, 191,
1699  192, 193, 194, 195, 196, -1, -1, -1, -1, -1,
1700  -1, -1, 204, 205, 187, 188, 189, 190, 191, 192,
1701  193, 194, 195, 196, -1, -1, -1, -1, -1, -1,
1702  -1, 204, 205, -1, -1, -1, -1, -1, -1, -1,
1703  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1704  188, 189, 190, 191, 192, 193, 194, 195, 196, -1,
1705  -1, -1, 5, -1, -1, -1, 204, 205, -1, -1,
1706  -1, -1, -1, 189, 190, 191, 192, 193, 194, 195,
1707  196, -1, -1, -1, -1, -1, -1, -1, 204, 205,
1708  33, -1, 35, -1, -1, -1, -1, -1, 41, 42,
1709  -1, -1, 45, -1, -1, -1, -1, 5, -1, -1,
1710  -1, -1, -1, -1, -1, -1, 59, -1, 61, -1,
1711  -1, -1, -1, -1, 67, 68, -1, 70, -1, -1,
1712  -1, 74, -1, -1, 77, 33, -1, 35, -1, -1,
1713  -1, 84, -1, 41, -1, -1, -1, 45, -1, -1,
1714  -1, -1, 95, -1, 97, 98, 99, 100, 101, -1,
1715  -1, 104, -1, 61, 107, -1, -1, -1, 111, 67,
1716  68, -1, 70, -1, -1, -1, 74, -1, -1, 77,
1717  -1, -1, -1, -1, -1, -1, 84, -1, -1, -1,
1718  -1, -1, -1, -1, -1, -1, -1, 95, 141, 97,
1719  98, 99, 100, 146, 147, 148, -1, -1, 151, 107,
1720  153, 5, -1, -1, 157, -1, -1, -1, -1, -1,
1721  -1, -1, -1, 166, -1, 168, -1, -1, -1, -1,
1722  -1, -1, -1, 176, 177, -1, -1, -1, -1, 33,
1723  -1, 35, -1, 141, -1, -1, -1, 41, 146, 147,
1724  148, -1, -1, 151, -1, 153, -1, -1, -1, 157,
1725  -1, -1, -1, -1, -1, -1, -1, 61, 166, -1,
1726  168, -1, -1, 67, 68, -1, -1, -1, 176, 177,
1727  74, -1, -1, 77, -1, -1, -1, -1, -1, -1,
1728  84, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1729  -1, -1, -1, 97, 98, 99, 100, -1, -1, -1,
1730  -1, -1, -1, 107, -1, -1, -1, -1, -1, -1,
1731  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1732  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1733  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1734  -1, -1, 146, 147, 148, -1, -1, 151, -1, -1,
1735  -1, -1, -1, 157, -1, -1, -1, -1, -1, -1,
1736  -1, -1, 166, -1, 168, -1, -1, -1, -1, -1,
1737  -1, -1, 176, 177, 25, -1, 27, 28, 29, 30,
1738  31, 32, -1, 34, -1, -1, 37, -1, 39, -1,
1739  -1, -1, 43, 44, -1, 46, 47, 48, 49, -1,
1740  51, 52, 53, 54, 55, 56, 57, 58, -1, 60,
1741  -1, 62, 63, 64, 65, 66, -1, -1, 69, -1,
1742  -1, -1, 73, -1, 75, 76, -1, 78, 79, 80,
1743  81, 82, 83, -1, 85, 86, 87, 88, 89, 90,
1744  -1, -1, 93, -1, -1, 96, -1, -1, -1, -1,
1745  -1, 102, 103, -1, 105, 106, -1, 108, 109, -1,
1746  -1, -1, 113, 114, 115, 116, 117, 118, -1, 120,
1747  121, 122, 123, 124, 125, 126, -1, 128, -1, 130,
1748  -1, 132, 133, 134, 135, 136, 137, 138, 139, 140,
1749  -1, 142, 143, 144, 145, -1, -1, -1, 149, -1,
1750  -1, 152, -1, -1, 155, 156, -1, -1, 159, 160,
1751  161, 162, -1, -1, 165, -1, 167, -1, 169, 170,
1752  171, 172, 173, 174, 175, -1, -1, 178
1753 };
1754 
1755  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1756  symbol of state STATE-NUM. */
1757 static const yytype_uint16 yystos[] =
1758 {
1759  0, 214, 216, 0, 4, 5, 14, 33, 35, 41,
1760  42, 45, 50, 59, 61, 67, 68, 70, 74, 77,
1761  84, 91, 95, 97, 98, 99, 100, 101, 107, 112,
1762  129, 141, 146, 147, 148, 151, 153, 157, 166, 168,
1763  176, 177, 205, 215, 222, 223, 225, 226, 227, 228,
1764  231, 232, 238, 239, 250, 264, 268, 270, 271, 272,
1765  273, 274, 277, 278, 281, 283, 284, 285, 286, 288,
1766  289, 290, 291, 292, 294, 296, 314, 315, 316, 317,
1767  205, 319, 322, 323, 3, 5, 210, 3, 5, 3,
1768  5, 266, 97, 269, 9, 3, 5, 269, 3, 210,
1769  210, 269, 270, 3, 266, 3, 266, 270, 25, 27,
1770  28, 29, 30, 31, 32, 34, 37, 39, 43, 44,
1771  46, 47, 48, 49, 51, 52, 53, 54, 55, 56,
1772  57, 58, 60, 62, 63, 64, 65, 66, 69, 73,
1773  75, 76, 78, 79, 80, 81, 82, 83, 85, 86,
1774  87, 88, 89, 90, 93, 96, 102, 103, 105, 106,
1775  108, 109, 113, 114, 115, 116, 117, 118, 120, 121,
1776  122, 123, 124, 125, 126, 128, 130, 132, 133, 134,
1777  135, 136, 137, 138, 139, 140, 142, 143, 144, 145,
1778  149, 152, 155, 156, 159, 160, 161, 162, 165, 167,
1779  169, 170, 171, 172, 173, 174, 175, 178, 240, 242,
1780  313, 209, 218, 218, 164, 67, 104, 111, 157, 166,
1781  230, 250, 271, 277, 283, 287, 294, 314, 317, 209,
1782  209, 207, 207, 209, 207, 209, 221, 209, 186, 282,
1783  207, 295, 296, 295, 295, 3, 5, 40, 72, 127,
1784  154, 194, 210, 244, 267, 297, 298, 311, 250, 314,
1785  315, 317, 295, 209, 51, 64, 69, 324, 325, 319,
1786  101, 9, 207, 209, 3, 315, 207, 158, 207, 210,
1787  210, 210, 210, 210, 210, 210, 210, 210, 210, 210,
1788  210, 210, 210, 210, 210, 210, 210, 210, 210, 210,
1789  210, 210, 210, 210, 210, 210, 210, 210, 210, 210,
1790  210, 210, 184, 206, 13, 92, 222, 229, 232, 271,
1791  273, 274, 285, 286, 289, 208, 238, 239, 3, 3,
1792  5, 3, 5, 3, 3, 207, 311, 275, 217, 131,
1793  279, 283, 3, 5, 207, 220, 293, 297, 297, 212,
1794  205, 210, 237, 295, 184, 206, 5, 211, 247, 248,
1795  249, 267, 186, 211, 257, 210, 260, 9, 9, 12,
1796  243, 267, 3, 6, 7, 8, 9, 10, 11, 71,
1797  119, 150, 163, 189, 192, 193, 194, 197, 198, 210,
1798  253, 254, 255, 253, 256, 9, 9, 241, 256, 255,
1799  9, 9, 255, 9, 255, 253, 236, 239, 294, 255,
1800  251, 252, 253, 9, 313, 9, 255, 315, 251, 253,
1801  315, 179, 180, 181, 182, 183, 312, 315, 315, 243,
1802  6, 7, 318, 9, 315, 242, 205, 210, 209, 207,
1803  221, 294, 208, 238, 276, 216, 186, 110, 238, 262,
1804  280, 209, 207, 220, 208, 222, 239, 292, 297, 211,
1805  256, 194, 206, 253, 233, 234, 235, 236, 325, 207,
1806  208, 184, 212, 6, 224, 208, 238, 258, 262, 208,
1807  239, 259, 262, 211, 211, 211, 210, 253, 253, 253,
1808  253, 253, 253, 253, 294, 15, 16, 17, 18, 19,
1809  20, 21, 22, 23, 185, 187, 188, 189, 190, 191,
1810  192, 193, 194, 195, 196, 204, 205, 184, 211, 211,
1811  211, 184, 211, 211, 211, 211, 211, 211, 211, 211,
1812  211, 211, 294, 194, 210, 237, 244, 267, 303, 305,
1813  306, 211, 184, 211, 211, 211, 211, 184, 211, 211,
1814  211, 211, 211, 211, 211, 211, 204, 211, 211, 211,
1815  242, 9, 219, 297, 307, 221, 286, 208, 186, 294,
1816  314, 209, 208, 239, 263, 264, 208, 228, 208, 221,
1817  206, 206, 211, 184, 164, 320, 321, 249, 255, 6,
1818  211, 294, 317, 211, 209, 209, 294, 211, 194, 210,
1819  237, 244, 299, 301, 302, 253, 253, 3, 253, 253,
1820  253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
1821  253, 253, 253, 253, 253, 3, 253, 255, 9, 305,
1822  293, 194, 233, 244, 304, 305, 210, 237, 252, 255,
1823  6, 211, 218, 184, 297, 209, 220, 221, 24, 236,
1824  323, 208, 320, 303, 309, 310, 209, 265, 267, 301,
1825  293, 194, 233, 244, 300, 301, 211, 210, 237, 186,
1826  206, 305, 293, 211, 305, 211, 233, 211, 221, 208,
1827  297, 208, 5, 186, 308, 184, 209, 207, 211, 301,
1828  293, 211, 305, 211, 253, 233, 253, 305, 211, 221,
1829  209, 256, 309, 245, 305, 211, 39, 52, 208, 246,
1830  255, 186, 186, 209, 261, 262, 261, 209
1831 };
1832 
1833  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1834 static const yytype_uint16 yyr1[] =
1835 {
1836  0, 213, 214, 215, 215, 216, 217, 216, 216, 216,
1837  216, 216, 216, 216, 216, 218, 218, 219, 218, 218,
1838  218, 218, 218, 218, 218, 218, 220, 220, 221, 221,
1839  222, 222, 222, 222, 222, 222, 222, 223, 224, 224,
1840  225, 225, 225, 225, 225, 225, 225, 225, 225, 226,
1841  227, 228, 229, 230, 230, 231, 232, 233, 233, 234,
1842  234, 235, 235, 236, 236, 237, 237, 237, 238, 238,
1843  239, 240, 240, 240, 241, 241, 242, 242, 242, 242,
1844  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1845  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1846  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1847  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1848  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1849  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1850  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1851  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1852  242, 242, 242, 242, 242, 242, 242, 242, 242, 242,
1853  242, 242, 242, 242, 242, 242, 243, 243, 244, 244,
1854  244, 244, 245, 245, 246, 246, 247, 247, 247, 248,
1855  248, 249, 249, 250, 251, 251, 252, 252, 253, 253,
1856  253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
1857  253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
1858  253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
1859  253, 253, 253, 253, 253, 253, 253, 253, 253, 254,
1860  254, 255, 256, 257, 257, 258, 258, 259, 259, 260,
1861  260, 261, 261, 262, 262, 263, 264, 264, 265, 265,
1862  266, 266, 266, 267, 267, 268, 268, 268, 268, 268,
1863  268, 268, 268, 268, 268, 268, 269, 269, 270, 270,
1864  270, 270, 270, 270, 270, 270, 270, 271, 271, 272,
1865  273, 274, 275, 275, 276, 277, 277, 278, 279, 279,
1866  280, 280, 281, 281, 282, 282, 283, 283, 284, 285,
1867  285, 285, 286, 286, 287, 287, 288, 289, 290, 290,
1868  290, 291, 292, 293, 293, 294, 294, 295, 295, 296,
1869  296, 296, 297, 297, 297, 298, 298, 298, 298, 299,
1870  299, 299, 300, 300, 301, 301, 302, 302, 302, 302,
1871  302, 303, 303, 303, 304, 304, 305, 305, 306, 306,
1872  306, 306, 306, 306, 307, 307, 308, 308, 309, 310,
1873  310, 311, 311, 312, 312, 312, 312, 312, 313, 313,
1874  313, 314, 315, 315, 315, 315, 315, 315, 315, 315,
1875  315, 315, 316, 317, 317, 318, 318, 318, 319, 319,
1876  320, 320, 321, 322, 323, 323, 324, 324, 325, 325,
1877  325
1878 };
1879 
1880  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1881 static const yytype_uint8 yyr2[] =
1882 {
1883  0, 2, 2, 0, 2, 0, 0, 6, 2, 2,
1884  3, 2, 2, 2, 2, 0, 2, 0, 6, 2,
1885  3, 2, 2, 2, 2, 2, 0, 2, 0, 1,
1886  1, 2, 2, 1, 2, 1, 1, 6, 1, 2,
1887  1, 2, 1, 2, 1, 2, 2, 2, 2, 4,
1888  3, 3, 5, 2, 2, 3, 4, 0, 1, 1,
1889  3, 1, 3, 3, 2, 3, 3, 2, 0, 1,
1890  3, 1, 3, 4, 1, 3, 0, 1, 4, 1,
1891  1, 1, 1, 1, 4, 4, 1, 1, 1, 1,
1892  1, 1, 1, 1, 1, 1, 4, 1, 1, 1,
1893  4, 1, 1, 1, 4, 4, 1, 1, 1, 1,
1894  4, 4, 4, 4, 4, 1, 4, 1, 1, 4,
1895  1, 4, 1, 1, 4, 4, 1, 1, 1, 1,
1896  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1897  4, 1, 1, 1, 4, 4, 1, 1, 1, 1,
1898  1, 6, 1, 4, 1, 1, 1, 4, 1, 1,
1899  1, 4, 4, 4, 4, 1, 1, 4, 4, 4,
1900  1, 1, 4, 4, 4, 1, 1, 1, 1, 1,
1901  1, 1, 0, 2, 4, 3, 0, 2, 1, 1,
1902  3, 3, 1, 5, 1, 3, 0, 1, 1, 1,
1903  1, 1, 1, 1, 1, 1, 1, 1, 5, 3,
1904  3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1905  3, 3, 3, 3, 3, 3, 3, 2, 2, 2,
1906  2, 2, 2, 3, 3, 5, 5, 4, 3, 1,
1907  3, 1, 1, 0, 2, 4, 3, 2, 2, 0,
1908  2, 2, 1, 3, 2, 1, 3, 2, 0, 1,
1909  0, 1, 1, 1, 1, 1, 1, 1, 2, 2,
1910  1, 1, 1, 1, 1, 1, 0, 1, 1, 2,
1911  1, 2, 2, 1, 1, 1, 1, 2, 2, 2,
1912  5, 2, 0, 2, 2, 2, 2, 2, 2, 3,
1913  2, 3, 5, 5, 0, 2, 2, 2, 2, 6,
1914  8, 2, 2, 2, 2, 2, 2, 5, 1, 1,
1915  1, 1, 1, 0, 2, 2, 3, 0, 1, 2,
1916  2, 2, 3, 2, 1, 1, 3, 2, 4, 3,
1917  2, 1, 3, 2, 0, 1, 3, 2, 1, 3,
1918  4, 3, 2, 1, 3, 2, 0, 1, 1, 3,
1919  2, 1, 3, 4, 1, 3, 0, 2, 2, 1,
1920  3, 1, 3, 1, 1, 1, 1, 1, 1, 1,
1921  1, 5, 1, 1, 1, 1, 2, 1, 2, 1,
1922  2, 4, 5, 5, 10, 1, 3, 1, 0, 2,
1923  0, 2, 4, 6, 0, 3, 1, 3, 1, 1,
1924  1
1925 };
1926 
1927 
1928 #define yyerrok (yyerrstatus = 0)
1929 #define yyclearin (yychar = YYEMPTY)
1930 #define YYEMPTY (-2)
1931 #define YYEOF 0
1932 
1933 #define YYACCEPT goto yyacceptlab
1934 #define YYABORT goto yyabortlab
1935 #define YYERROR goto yyerrorlab
1936 
1937 
1938 #define YYRECOVERING() (!!yyerrstatus)
1939 
1940 #define YYBACKUP(Token, Value) \
1941 do \
1942  if (yychar == YYEMPTY) \
1943  { \
1944  yychar = (Token); \
1945  yylval = (Value); \
1946  YYPOPSTACK (yylen); \
1947  yystate = *yyssp; \
1948  goto yybackup; \
1949  } \
1950  else \
1951  { \
1952  yyerror (YY_("syntax error: cannot back up")); \
1953  YYERROR; \
1954  } \
1955 while (0)
1956 
1957 /* Error token number */
1958 #define YYTERROR 1
1959 #define YYERRCODE 256
1960 
1961 
1962 
1963 /* Enable debugging if requested. */
1964 #if YYDEBUG
1965 
1966 # ifndef YYFPRINTF
1967 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1968 # define YYFPRINTF fprintf
1969 # endif
1970 
1971 # define YYDPRINTF(Args) \
1972 do { \
1973  if (yydebug) \
1974  YYFPRINTF Args; \
1975 } while (0)
1976 
1977 /* This macro is provided for backward compatibility. */
1978 #ifndef YY_LOCATION_PRINT
1979 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1980 #endif
1981 
1982 
1983 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1984 do { \
1985  if (yydebug) \
1986  { \
1987  YYFPRINTF (stderr, "%s ", Title); \
1988  yy_symbol_print (stderr, \
1989  Type, Value); \
1990  YYFPRINTF (stderr, "\n"); \
1991  } \
1992 } while (0)
1993 
1994 
1995 /*----------------------------------------.
1996 | Print this symbol's value on YYOUTPUT. |
1997 `----------------------------------------*/
1998 
1999 static void
2000 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2001 {
2002  FILE *yyo = yyoutput;
2003  YYUSE (yyo);
2004  if (!yyvaluep)
2005  return;
2006 # ifdef YYPRINT
2007  if (yytype < YYNTOKENS)
2008  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
2009 # endif
2010  YYUSE (yytype);
2011 }
2012 
2013 
2014 /*--------------------------------.
2015 | Print this symbol on YYOUTPUT. |
2016 `--------------------------------*/
2017 
2018 static void
2019 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
2020 {
2021  YYFPRINTF (yyoutput, "%s %s (",
2022  yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
2023 
2024  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
2025  YYFPRINTF (yyoutput, ")");
2026 }
2027 
2028 /*------------------------------------------------------------------.
2029 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
2030 | TOP (included). |
2031 `------------------------------------------------------------------*/
2032 
2033 static void
2034 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
2035 {
2036  YYFPRINTF (stderr, "Stack now");
2037  for (; yybottom <= yytop; yybottom++)
2038  {
2039  int yybot = *yybottom;
2040  YYFPRINTF (stderr, " %d", yybot);
2041  }
2042  YYFPRINTF (stderr, "\n");
2043 }
2044 
2045 # define YY_STACK_PRINT(Bottom, Top) \
2046 do { \
2047  if (yydebug) \
2048  yy_stack_print ((Bottom), (Top)); \
2049 } while (0)
2050 
2051 
2052 /*------------------------------------------------.
2053 | Report that the YYRULE is going to be reduced. |
2054 `------------------------------------------------*/
2055 
2056 static void
2057 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
2058 {
2059  unsigned long int yylno = yyrline[yyrule];
2060  int yynrhs = yyr2[yyrule];
2061  int yyi;
2062  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
2063  yyrule - 1, yylno);
2064  /* The symbols being reduced. */
2065  for (yyi = 0; yyi < yynrhs; yyi++)
2066  {
2067  YYFPRINTF (stderr, " $%d = ", yyi + 1);
2068  yy_symbol_print (stderr,
2069  yystos[yyssp[yyi + 1 - yynrhs]],
2070  &(yyvsp[(yyi + 1) - (yynrhs)])
2071  );
2072  YYFPRINTF (stderr, "\n");
2073  }
2074 }
2075 
2076 # define YY_REDUCE_PRINT(Rule) \
2077 do { \
2078  if (yydebug) \
2079  yy_reduce_print (yyssp, yyvsp, Rule); \
2080 } while (0)
2081 
2082 /* Nonzero means print parse trace. It is left uninitialized so that
2083  multiple parsers can coexist. */
2084 int yydebug;
2085 #else /* !YYDEBUG */
2086 # define YYDPRINTF(Args)
2087 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2088 # define YY_STACK_PRINT(Bottom, Top)
2089 # define YY_REDUCE_PRINT(Rule)
2090 #endif /* !YYDEBUG */
2091 
2092 
2093 /* YYINITDEPTH -- initial size of the parser's stacks. */
2094 #ifndef YYINITDEPTH
2095 # define YYINITDEPTH 200
2096 #endif
2097 
2098 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2099  if the built-in stack extension method is used).
2100 
2101  Do not make this value too large; the results are undefined if
2102  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2103  evaluated with infinite-precision integer arithmetic. */
2104 
2105 #ifndef YYMAXDEPTH
2106 # define YYMAXDEPTH 10000
2107 #endif
2108 
2109 
2110 #if YYERROR_VERBOSE
2111 
2112 # ifndef yystrlen
2113 # if defined __GLIBC__ && defined _STRING_H
2114 # define yystrlen strlen
2115 # else
2116 /* Return the length of YYSTR. */
2117 static YYSIZE_T
2118 yystrlen (const char *yystr)
2119 {
2120  YYSIZE_T yylen;
2121  for (yylen = 0; yystr[yylen]; yylen++)
2122  continue;
2123  return yylen;
2124 }
2125 # endif
2126 # endif
2127 
2128 # ifndef yystpcpy
2129 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2130 # define yystpcpy stpcpy
2131 # else
2132 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2133  YYDEST. */
2134 static char *
2135 yystpcpy (char *yydest, const char *yysrc)
2136 {
2137  char *yyd = yydest;
2138  const char *yys = yysrc;
2139 
2140  while ((*yyd++ = *yys++) != '\0')
2141  continue;
2142 
2143  return yyd - 1;
2144 }
2145 # endif
2146 # endif
2147 
2148 # ifndef yytnamerr
2149 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2150  quotes and backslashes, so that it's suitable for yyerror. The
2151  heuristic is that double-quoting is unnecessary unless the string
2152  contains an apostrophe, a comma, or backslash (other than
2153  backslash-backslash). YYSTR is taken from yytname. If YYRES is
2154  null, do not copy; instead, return the length of what the result
2155  would have been. */
2156 static YYSIZE_T
2157 yytnamerr (char *yyres, const char *yystr)
2158 {
2159  if (*yystr == '"')
2160  {
2161  YYSIZE_T yyn = 0;
2162  char const *yyp = yystr;
2163 
2164  for (;;)
2165  switch (*++yyp)
2166  {
2167  case '\'':
2168  case ',':
2169  goto do_not_strip_quotes;
2170 
2171  case '\\':
2172  if (*++yyp != '\\')
2173  goto do_not_strip_quotes;
2174  /* Fall through. */
2175  default:
2176  if (yyres)
2177  yyres[yyn] = *yyp;
2178  yyn++;
2179  break;
2180 
2181  case '"':
2182  if (yyres)
2183  yyres[yyn] = '\0';
2184  return yyn;
2185  }
2186  do_not_strip_quotes: ;
2187  }
2188 
2189  if (! yyres)
2190  return yystrlen (yystr);
2191 
2192  return yystpcpy (yyres, yystr) - yyres;
2193 }
2194 # endif
2195 
2196 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
2197  about the unexpected token YYTOKEN for the state stack whose top is
2198  YYSSP.
2199 
2200  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
2201  not large enough to hold the message. In that case, also set
2202  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
2203  required number of bytes is too large to store. */
2204 static int
2205 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
2206  yytype_int16 *yyssp, int yytoken)
2207 {
2208  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
2209  YYSIZE_T yysize = yysize0;
2210  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2211  /* Internationalized format string. */
2212  const char *yyformat = YY_NULL;
2213  /* Arguments of yyformat. */
2214  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2215  /* Number of reported tokens (one for the "unexpected", one per
2216  "expected"). */
2217  int yycount = 0;
2218 
2219  /* There are many possibilities here to consider:
2220  - If this state is a consistent state with a default action, then
2221  the only way this function was invoked is if the default action
2222  is an error action. In that case, don't check for expected
2223  tokens because there are none.
2224  - The only way there can be no lookahead present (in yychar) is if
2225  this state is a consistent state with a default action. Thus,
2226  detecting the absence of a lookahead is sufficient to determine
2227  that there is no unexpected or expected token to report. In that
2228  case, just report a simple "syntax error".
2229  - Don't assume there isn't a lookahead just because this state is a
2230  consistent state with a default action. There might have been a
2231  previous inconsistent state, consistent state with a non-default
2232  action, or user semantic action that manipulated yychar.
2233  - Of course, the expected token list depends on states to have
2234  correct lookahead information, and it depends on the parser not
2235  to perform extra reductions after fetching a lookahead from the
2236  scanner and before detecting a syntax error. Thus, state merging
2237  (from LALR or IELR) and default reductions corrupt the expected
2238  token list. However, the list is correct for canonical LR with
2239  one exception: it will still contain any token that will not be
2240  accepted due to an error action in a later state.
2241  */
2242  if (yytoken != YYEMPTY)
2243  {
2244  int yyn = yypact[*yyssp];
2245  yyarg[yycount++] = yytname[yytoken];
2246  if (!yypact_value_is_default (yyn))
2247  {
2248  /* Start YYX at -YYN if negative to avoid negative indexes in
2249  YYCHECK. In other words, skip the first -YYN actions for
2250  this state because they are default actions. */
2251  int yyxbegin = yyn < 0 ? -yyn : 0;
2252  /* Stay within bounds of both yycheck and yytname. */
2253  int yychecklim = YYLAST - yyn + 1;
2254  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2255  int yyx;
2256 
2257  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2258  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2259  && !yytable_value_is_error (yytable[yyx + yyn]))
2260  {
2261  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2262  {
2263  yycount = 1;
2264  yysize = yysize0;
2265  break;
2266  }
2267  yyarg[yycount++] = yytname[yyx];
2268  {
2269  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
2270  if (! (yysize <= yysize1
2271  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2272  return 2;
2273  yysize = yysize1;
2274  }
2275  }
2276  }
2277  }
2278 
2279  switch (yycount)
2280  {
2281 # define YYCASE_(N, S) \
2282  case N: \
2283  yyformat = S; \
2284  break
2285  YYCASE_(0, YY_("syntax error"));
2286  YYCASE_(1, YY_("syntax error, unexpected %s"));
2287  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2288  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2289  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2290  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2291 # undef YYCASE_
2292  }
2293 
2294  {
2295  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
2296  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2297  return 2;
2298  yysize = yysize1;
2299  }
2300 
2301  if (*yymsg_alloc < yysize)
2302  {
2303  *yymsg_alloc = 2 * yysize;
2304  if (! (yysize <= *yymsg_alloc
2305  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2306  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2307  return 1;
2308  }
2309 
2310  /* Avoid sprintf, as that infringes on the user's name space.
2311  Don't have undefined behavior even if the translation
2312  produced a string with the wrong number of "%s"s. */
2313  {
2314  char *yyp = *yymsg;
2315  int yyi = 0;
2316  while ((*yyp = *yyformat) != '\0')
2317  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2318  {
2319  yyp += yytnamerr (yyp, yyarg[yyi++]);
2320  yyformat += 2;
2321  }
2322  else
2323  {
2324  yyp++;
2325  yyformat++;
2326  }
2327  }
2328  return 0;
2329 }
2330 #endif /* YYERROR_VERBOSE */
2331 
2332 /*-----------------------------------------------.
2333 | Release the memory associated to this symbol. |
2334 `-----------------------------------------------*/
2335 
2336 static void
2337 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2338 {
2339  YYUSE (yyvaluep);
2340  if (!yymsg)
2341  yymsg = "Deleting";
2342  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2343 
2345  YYUSE (yytype);
2347 }
2348 
2349 
2350 
2351 
2352 /* The lookahead symbol. */
2354 
2355 /* The semantic value of the lookahead symbol. */
2357 /* Number of syntax errors so far. */
2359 
2360 
2361 /*----------.
2362 | yyparse. |
2363 `----------*/
2364 
2365 int
2366 yyparse (void)
2367 {
2368  int yystate;
2369  /* Number of tokens to shift before error messages enabled. */
2370  int yyerrstatus;
2371 
2372  /* The stacks and their tools:
2373  'yyss': related to states.
2374  'yyvs': related to semantic values.
2375 
2376  Refer to the stacks through separate pointers, to allow yyoverflow
2377  to reallocate them elsewhere. */
2378 
2379  /* The state stack. */
2380  yytype_int16 yyssa[YYINITDEPTH];
2381  yytype_int16 *yyss;
2382  yytype_int16 *yyssp;
2383 
2384  /* The semantic value stack. */
2385  YYSTYPE yyvsa[YYINITDEPTH];
2386  YYSTYPE *yyvs;
2387  YYSTYPE *yyvsp;
2388 
2389  YYSIZE_T yystacksize;
2390 
2391  int yyn;
2392  int yyresult;
2393  /* Lookahead token as an internal (translated) token number. */
2394  int yytoken = 0;
2395  /* The variables used to return semantic value and location from the
2396  action routines. */
2397  YYSTYPE yyval;
2398 
2399 #if YYERROR_VERBOSE
2400  /* Buffer for error messages, and its allocated size. */
2401  char yymsgbuf[128];
2402  char *yymsg = yymsgbuf;
2403  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2404 #endif
2405 
2406 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2407 
2408  /* The number of symbols on the RHS of the reduced rule.
2409  Keep to zero when no symbol should be popped. */
2410  int yylen = 0;
2411 
2412  yyssp = yyss = yyssa;
2413  yyvsp = yyvs = yyvsa;
2414  yystacksize = YYINITDEPTH;
2415 
2416  YYDPRINTF ((stderr, "Starting parse\n"));
2417 
2418  yystate = 0;
2419  yyerrstatus = 0;
2420  yynerrs = 0;
2421  yychar = YYEMPTY; /* Cause a token to be read. */
2422  goto yysetstate;
2423 
2424 /*------------------------------------------------------------.
2425 | yynewstate -- Push a new state, which is found in yystate. |
2426 `------------------------------------------------------------*/
2427  yynewstate:
2428  /* In all cases, when you get here, the value and location stacks
2429  have just been pushed. So pushing a state here evens the stacks. */
2430  yyssp++;
2431 
2432  yysetstate:
2433  *yyssp = yystate;
2434 
2435  if (yyss + yystacksize - 1 <= yyssp)
2436  {
2437  /* Get the current used size of the three stacks, in elements. */
2438  YYSIZE_T yysize = yyssp - yyss + 1;
2439 
2440 #ifdef yyoverflow
2441  {
2442  /* Give user a chance to reallocate the stack. Use copies of
2443  these so that the &'s don't force the real ones into
2444  memory. */
2445  YYSTYPE *yyvs1 = yyvs;
2446  yytype_int16 *yyss1 = yyss;
2447 
2448  /* Each stack pointer address is followed by the size of the
2449  data in use in that stack, in bytes. This used to be a
2450  conditional around just the two extra args, but that might
2451  be undefined if yyoverflow is a macro. */
2452  yyoverflow (YY_("memory exhausted"),
2453  &yyss1, yysize * sizeof (*yyssp),
2454  &yyvs1, yysize * sizeof (*yyvsp),
2455  &yystacksize);
2456 
2457  yyss = yyss1;
2458  yyvs = yyvs1;
2459  }
2460 #else /* no yyoverflow */
2461 # ifndef YYSTACK_RELOCATE
2462  goto yyexhaustedlab;
2463 # else
2464  /* Extend the stack our own way. */
2465  if (YYMAXDEPTH <= yystacksize)
2466  goto yyexhaustedlab;
2467  yystacksize *= 2;
2468  if (YYMAXDEPTH < yystacksize)
2469  yystacksize = YYMAXDEPTH;
2470 
2471  {
2472  yytype_int16 *yyss1 = yyss;
2473  union yyalloc *yyptr =
2474  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2475  if (! yyptr)
2476  goto yyexhaustedlab;
2477  YYSTACK_RELOCATE (yyss_alloc, yyss);
2478  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2479 # undef YYSTACK_RELOCATE
2480  if (yyss1 != yyssa)
2481  YYSTACK_FREE (yyss1);
2482  }
2483 # endif
2484 #endif /* no yyoverflow */
2485 
2486  yyssp = yyss + yysize - 1;
2487  yyvsp = yyvs + yysize - 1;
2488 
2489  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2490  (unsigned long int) yystacksize));
2491 
2492  if (yyss + yystacksize - 1 <= yyssp)
2493  YYABORT;
2494  }
2495 
2496  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2497 
2498  if (yystate == YYFINAL)
2499  YYACCEPT;
2500 
2501  goto yybackup;
2502 
2503 /*-----------.
2504 | yybackup. |
2505 `-----------*/
2506 yybackup:
2507 
2508  /* Do appropriate processing given the current state. Read a
2509  lookahead token if we need one and don't already have one. */
2510 
2511  /* First try to decide what to do without reference to lookahead token. */
2512  yyn = yypact[yystate];
2513  if (yypact_value_is_default (yyn))
2514  goto yydefault;
2515 
2516  /* Not known => get a lookahead token if don't already have one. */
2517 
2518  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2519  if (yychar == YYEMPTY)
2520  {
2521  YYDPRINTF ((stderr, "Reading a token: "));
2522  yychar = yylex ();
2523  }
2524 
2525  if (yychar <= YYEOF)
2526  {
2527  yychar = yytoken = YYEOF;
2528  YYDPRINTF ((stderr, "Now at end of input.\n"));
2529  }
2530  else
2531  {
2532  yytoken = YYTRANSLATE (yychar);
2533  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2534  }
2535 
2536  /* If the proper action on seeing token YYTOKEN is to reduce or to
2537  detect an error, take that action. */
2538  yyn += yytoken;
2539  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2540  goto yydefault;
2541  yyn = yytable[yyn];
2542  if (yyn <= 0)
2543  {
2544  if (yytable_value_is_error (yyn))
2545  goto yyerrlab;
2546  yyn = -yyn;
2547  goto yyreduce;
2548  }
2549 
2550  /* Count tokens shifted since error; after three, turn off error
2551  status. */
2552  if (yyerrstatus)
2553  yyerrstatus--;
2554 
2555  /* Shift the lookahead token. */
2556  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2557 
2558  /* Discard the shifted token. */
2559  yychar = YYEMPTY;
2560 
2561  yystate = yyn;
2563  *++yyvsp = yylval;
2565 
2566  goto yynewstate;
2567 
2568 
2569 /*-----------------------------------------------------------.
2570 | yydefault -- do the default action for the current state. |
2571 `-----------------------------------------------------------*/
2572 yydefault:
2573  yyn = yydefact[yystate];
2574  if (yyn == 0)
2575  goto yyerrlab;
2576  goto yyreduce;
2577 
2578 
2579 /*-----------------------------.
2580 | yyreduce -- Do a reduction. |
2581 `-----------------------------*/
2582 yyreduce:
2583  /* yyn is the number of a rule to reduce with. */
2584  yylen = yyr2[yyn];
2585 
2586  /* If YYLEN is nonzero, implement the default value of the action:
2587  '$$ = $1'.
2588 
2589  Otherwise, the following line sets YYVAL to garbage.
2590  This behavior is undocumented and Bison
2591  users should not rely upon it. Assigning to YYVAL
2592  unconditionally makes the parser a bit smaller, and it avoids a
2593  GCC warning that YYVAL may be used uninitialized. */
2594  yyval = yyvsp[1-yylen];
2595 
2596 
2597  YY_REDUCE_PRINT (yyn);
2598  switch (yyn)
2599  {
2600  case 2:
2601 #line 327 "parser.y" /* yacc.c:1646 */
2602  { fix_incomplete();
2603  check_statements((yyvsp[-1].stmt_list), FALSE);
2604  check_all_user_types((yyvsp[-1].stmt_list));
2605  write_header((yyvsp[-1].stmt_list));
2606  write_id_data((yyvsp[-1].stmt_list));
2607  write_proxies((yyvsp[-1].stmt_list));
2608  write_client((yyvsp[-1].stmt_list));
2609  write_server((yyvsp[-1].stmt_list));
2610  write_regscript((yyvsp[-1].stmt_list));
2611 #ifndef __REACTOS__
2612  write_typelib_regscript((yyvsp[-1].stmt_list));
2613 #endif
2614  write_dlldata((yyvsp[-1].stmt_list));
2615  write_local_stubs((yyvsp[-1].stmt_list));
2616  }
2617 #line 2618 "parser.tab.c" /* yacc.c:1646 */
2618  break;
2619 
2620  case 5:
2621 #line 346 "parser.y" /* yacc.c:1646 */
2622  { (yyval.stmt_list) = NULL; }
2623 #line 2624 "parser.tab.c" /* yacc.c:1646 */
2624  break;
2625 
2626  case 6:
2627 #line 347 "parser.y" /* yacc.c:1646 */
2628  { push_namespace((yyvsp[-1].str)); }
2629 #line 2630 "parser.tab.c" /* yacc.c:1646 */
2630  break;
2631 
2632  case 7:
2633 #line 348 "parser.y" /* yacc.c:1646 */
2634  { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); }
2635 #line 2636 "parser.tab.c" /* yacc.c:1646 */
2636  break;
2637 
2638  case 8:
2639 #line 349 "parser.y" /* yacc.c:1646 */
2640  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); }
2641 #line 2642 "parser.tab.c" /* yacc.c:1646 */
2642  break;
2643 
2644  case 9:
2645 #line 350 "parser.y" /* yacc.c:1646 */
2646  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); }
2647 #line 2648 "parser.tab.c" /* yacc.c:1646 */
2648  break;
2649 
2650  case 10:
2651 #line 351 "parser.y" /* yacc.c:1646 */
2652  { (yyval.stmt_list) = (yyvsp[-2].stmt_list);
2653  reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0);
2654  }
2655 #line 2656 "parser.tab.c" /* yacc.c:1646 */
2656  break;
2657 
2658  case 11:
2659 #line 354 "parser.y" /* yacc.c:1646 */
2660  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type)));
2661  reg_type((yyvsp[0].type), (yyvsp[0].type)->name, current_namespace, 0);
2662  }
2663 #line 2664 "parser.tab.c" /* yacc.c:1646 */
2664  break;
2665 
2666  case 12:
2667 #line 357 "parser.y" /* yacc.c:1646 */
2668  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); }
2669 #line 2670 "parser.tab.c" /* yacc.c:1646 */
2670  break;
2671 
2672  case 13:
2673 #line 358 "parser.y" /* yacc.c:1646 */
2674  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); }
2675 #line 2676 "parser.tab.c" /* yacc.c:1646 */
2676  break;
2677 
2678  case 14:
2679 #line 359 "parser.y" /* yacc.c:1646 */
2680  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); }
2681 #line 2682 "parser.tab.c" /* yacc.c:1646 */
2682  break;
2683 
2684  case 15:
2685 #line 362 "parser.y" /* yacc.c:1646 */
2686  { (yyval.stmt_list) = NULL; }
2687 #line 2688 "parser.tab.c" /* yacc.c:1646 */
2688  break;
2689 
2690  case 16:
2691 #line 363 "parser.y" /* yacc.c:1646 */
2692  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_reference((yyvsp[0].type))); }
2693 #line 2694 "parser.tab.c" /* yacc.c:1646 */
2694  break;
2695 
2696  case 17:
2697 #line 364 "parser.y" /* yacc.c:1646 */
2698  { push_namespace((yyvsp[-1].str)); }
2699 #line 2700 "parser.tab.c" /* yacc.c:1646 */
2700  break;
2701 
2702  case 18:
2703 #line 365 "parser.y" /* yacc.c:1646 */
2704  { pop_namespace((yyvsp[-4].str)); (yyval.stmt_list) = append_statements((yyvsp[-5].stmt_list), (yyvsp[-1].stmt_list)); }
2705 #line 2706 "parser.tab.c" /* yacc.c:1646 */
2706  break;
2707 
2708  case 19:
2709 #line 366 "parser.y" /* yacc.c:1646 */
2710  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type))); }
2711 #line 2712 "parser.tab.c" /* yacc.c:1646 */
2712  break;
2713 
2714  case 20:
2715 #line 367 "parser.y" /* yacc.c:1646 */
2716  { (yyval.stmt_list) = (yyvsp[-2].stmt_list); reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, current_namespace, 0); }
2717 #line 2718 "parser.tab.c" /* yacc.c:1646 */
2718  break;
2719 
2720  case 21:
2721 #line 368 "parser.y" /* yacc.c:1646 */
2722  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_type_decl((yyvsp[0].type)));
2723  reg_type((yyvsp[0].type), (yyvsp[0].type)->name, current_namespace, 0);
2724  }
2725 #line 2726 "parser.tab.c" /* yacc.c:1646 */
2726  break;
2727 
2728  case 22:
2729 #line 371 "parser.y" /* yacc.c:1646 */
2730  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_module((yyvsp[0].type))); }
2731 #line 2732 "parser.tab.c" /* yacc.c:1646 */
2732  break;
2733 
2734  case 23:
2735 #line 372 "parser.y" /* yacc.c:1646 */
2736  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); }
2737 #line 2738 "parser.tab.c" /* yacc.c:1646 */
2738  break;
2739 
2740  case 24:
2741 #line 373 "parser.y" /* yacc.c:1646 */
2742  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_importlib((yyvsp[0].str))); }
2743 #line 2744 "parser.tab.c" /* yacc.c:1646 */
2744  break;
2745 
2746  case 25:
2747 #line 374 "parser.y" /* yacc.c:1646 */
2748  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), make_statement_library((yyvsp[0].typelib))); }
2749 #line 2750 "parser.tab.c" /* yacc.c:1646 */
2750  break;
2751 
2752  case 26:
2753 #line 377 "parser.y" /* yacc.c:1646 */
2754  { (yyval.stmt_list) = NULL; }
2755 #line 2756 "parser.tab.c" /* yacc.c:1646 */
2756  break;
2757 
2758  case 27:
2759 #line 378 "parser.y" /* yacc.c:1646 */
2760  { (yyval.stmt_list) = append_statement((yyvsp[-1].stmt_list), (yyvsp[0].statement)); }
2761 #line 2762 "parser.tab.c" /* yacc.c:1646 */
2762  break;
2763 
2764  case 30:
2765 #line 386 "parser.y" /* yacc.c:1646 */
2766  { (yyval.statement) = make_statement_cppquote((yyvsp[0].str)); }
2767 #line 2768 "parser.tab.c" /* yacc.c:1646 */
2768  break;
2769 
2770  case 31:
2771 #line 387 "parser.y" /* yacc.c:1646 */
2772  { (yyval.statement) = make_statement_type_decl((yyvsp[-1].type)); }
2773 #line 2774 "parser.tab.c" /* yacc.c:1646 */
2774  break;
2775 
2776  case 32:
2777 #line 388 "parser.y" /* yacc.c:1646 */
2778  { (yyval.statement) = make_statement_declaration((yyvsp[-1].var)); }
2779 #line 2780 "parser.tab.c" /* yacc.c:1646 */
2780  break;
2781 
2782  case 33:
2783 #line 389 "parser.y" /* yacc.c:1646 */
2784  { (yyval.statement) = make_statement_import((yyvsp[0].str)); }
2785 #line 2786 "parser.tab.c" /* yacc.c:1646 */
2786  break;
2787 
2788  case 34:
2789 #line 390 "parser.y" /* yacc.c:1646 */
2790  { (yyval.statement) = (yyvsp[-1].statement); }
2791 #line 2792 "parser.tab.c" /* yacc.c:1646 */
2792  break;
2793 
2794  case 35:
2795 #line 391 "parser.y" /* yacc.c:1646 */
2796  { (yyval.statement) = make_statement_pragma((yyvsp[0].str)); }
2797 #line 2798 "parser.tab.c" /* yacc.c:1646 */
2798  break;
2799 
2800  case 36:
2801 #line 392 "parser.y" /* yacc.c:1646 */
2802  { (yyval.statement) = NULL; }
2803 #line 2804 "parser.tab.c" /* yacc.c:1646 */
2804  break;
2805 
2806  case 37:
2807 #line 396 "parser.y" /* yacc.c:1646 */
2808  {
2809  int result;
2810  (yyval.statement) = NULL;
2811  result = do_warning((yyvsp[-3].str), (yyvsp[-1].warning_list));
2812  if(!result)
2813  error_loc("expected \"disable\" or \"enable\"\n");
2814  }
2815 #line 2816 "parser.tab.c" /* yacc.c:1646 */
2816  break;
2817 
2818  case 38:
2819 #line 406 "parser.y" /* yacc.c:1646 */
2820  { (yyval.warning_list) = append_warning(NULL, (yyvsp[0].num)); }
2821 #line 2822 "parser.tab.c" /* yacc.c:1646 */
2822  break;
2823 
2824  case 39:
2825 #line 407 "parser.y" /* yacc.c:1646 */
2826  { (yyval.warning_list) = append_warning((yyvsp[-1].warning_list), (yyvsp[0].num)); }
2827 #line 2828 "parser.tab.c" /* yacc.c:1646 */
2828  break;
2829 
2830  case 41:
2831 #line 412 "parser.y" /* yacc.c:1646 */
2832  { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); }
2833 #line 2834 "parser.tab.c" /* yacc.c:1646 */
2834  break;
2835 
2836  case 43:
2837 #line 414 "parser.y" /* yacc.c:1646 */
2838  { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); }
2839 #line 2840 "parser.tab.c" /* yacc.c:1646 */
2840  break;
2841 
2842  case 45:
2843 #line 416 "parser.y" /* yacc.c:1646 */
2844  { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); }
2845 #line 2846 "parser.tab.c" /* yacc.c:1646 */
2846  break;
2847 
2848  case 46:
2849 #line 417 "parser.y" /* yacc.c:1646 */
2850  { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_enum_attrs((yyvsp[-1].attr_list)); }
2851 #line 2852 "parser.tab.c" /* yacc.c:1646 */
2852  break;
2853 
2854  case 47:
2855 #line 418 "parser.y" /* yacc.c:1646 */
2856  { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_struct_attrs((yyvsp[-1].attr_list)); }
2857 #line 2858 "parser.tab.c" /* yacc.c:1646 */
2858  break;
2859 
2860  case 48:
2861 #line 419 "parser.y" /* yacc.c:1646 */
2862  { (yyval.type) = (yyvsp[0].type); (yyval.type)->attrs = check_union_attrs((yyvsp[-1].attr_list)); }
2863 #line 2864 "parser.tab.c" /* yacc.c:1646 */
2864  break;
2865 
2866  case 49:
2867 #line 422 "parser.y" /* yacc.c:1646 */
2868  { (yyval.str) = (yyvsp[-1].str); }
2869 #line 2870 "parser.tab.c" /* yacc.c:1646 */
2870  break;
2871 
2872  case 50:
2873 #line 424 "parser.y" /* yacc.c:1646 */
2874  { assert(yychar == YYEMPTY);
2875  (yyval.import) = xmalloc(sizeof(struct _import_t));
2876  (yyval.import)->name = (yyvsp[-1].str);
2877  (yyval.import)->import_performed = do_import((yyvsp[-1].str));
2878  if (!(yyval.import)->import_performed) yychar = aEOF;
2879  }
2880 #line 2881 "parser.tab.c" /* yacc.c:1646 */
2881  break;
2882 
2883  case 51:
2884 #line 432 "parser.y" /* yacc.c:1646 */
2885  { (yyval.str) = (yyvsp[-2].import)->name;
2886  if ((yyvsp[-2].import)->import_performed) pop_import();
2887  free((yyvsp[-2].import));
2888  }
2889 #line 2890 "parser.tab.c" /* yacc.c:1646 */
2890  break;
2891 
2892  case 52:
2893 #line 440 "parser.y" /* yacc.c:1646 */
2894  { (yyval.str) = (yyvsp[-2].str); if(!parse_only) add_importlib((yyvsp[-2].str)); }
2895 #line 2896 "parser.tab.c" /* yacc.c:1646 */
2896  break;
2897 
2898  case 53:
2899 #line 446 "parser.y" /* yacc.c:1646 */
2900  { (yyval.str) = (yyvsp[0].str); }
2901 #line 2902 "parser.tab.c" /* yacc.c:1646 */
2902  break;
2903 
2904  case 54:
2905 #line 447 "parser.y" /* yacc.c:1646 */
2906  { (yyval.str) = (yyvsp[0].str); }
2907 #line 2908 "parser.tab.c" /* yacc.c:1646 */
2908  break;
2909 
2910  case 55:
2911 #line 449 "parser.y" /* yacc.c:1646 */
2912  { (yyval.typelib) = make_library((yyvsp[-1].str), check_library_attrs((yyvsp[-1].str), (yyvsp[-2].attr_list)));
2913 /* ifdef __REACTOS__ */
2914  if (!parse_only) start_typelib((yyval.typelib));
2915 /* else
2916  if (!parse_only && do_typelib) current_typelib = $$;
2917 */
2918  }
2919 #line 2920 "parser.tab.c" /* yacc.c:1646 */
2920  break;
2921 
2922  case 56:
2923 #line 459 "parser.y" /* yacc.c:1646 */
2924  { (yyval.typelib) = (yyvsp[-3].typelib);
2925  (yyval.typelib)->stmts = (yyvsp[-2].stmt_list);
2926  if (!parse_only) end_typelib();
2927  }
2928 #line 2929 "parser.tab.c" /* yacc.c:1646 */
2929  break;
2930 
2931  case 57:
2932 #line 468 "parser.y" /* yacc.c:1646 */
2933  { (yyval.var_list) = NULL; }
2934 #line 2935 "parser.tab.c" /* yacc.c:1646 */
2935  break;
2936 
2937  case 59:
2938 #line 472 "parser.y" /* yacc.c:1646 */
2939  { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); }
2940 #line 2941 "parser.tab.c" /* yacc.c:1646 */
2941  break;
2942 
2943  case 60:
2944 #line 473 "parser.y" /* yacc.c:1646 */
2945  { check_arg_attrs((yyvsp[0].var)); (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var) ); }
2946 #line 2947 "parser.tab.c" /* yacc.c:1646 */
2947  break;
2948 
2949  case 62:
2950 #line 477 "parser.y" /* yacc.c:1646 */
2951  { (yyval.var_list) = append_var( (yyvsp[-2].var_list), make_var(strdup("...")) ); }
2952 #line 2953 "parser.tab.c" /* yacc.c:1646 */
2953  break;
2954 
2955  case 63:
2956 #line 481 "parser.y" /* yacc.c:1646 */
2957  { if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER)
2958  error_loc("invalid storage class for function parameter\n");
2959  (yyval.var) = declare_var((yyvsp[-2].attr_list), (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE);
2960  free((yyvsp[-1].declspec)); free((yyvsp[0].declarator));
2961  }
2962 #line 2963 "parser.tab.c" /* yacc.c:1646 */
2963  break;
2964 
2965  case 64:
2966 #line 486 "parser.y" /* yacc.c:1646 */
2967  { if ((yyvsp[-1].declspec)->stgclass != STG_NONE && (yyvsp[-1].declspec)->stgclass != STG_REGISTER)
2968  error_loc("invalid storage class for function parameter\n");
2969  (yyval.var) = declare_var(NULL, (yyvsp[-1].declspec), (yyvsp[0].declarator), TRUE);
2970  free((yyvsp[-1].declspec)); free((yyvsp[0].declarator));
2971  }
2972 #line 2973 "parser.tab.c" /* yacc.c:1646 */
2973  break;
2974 
2975  case 65:
2976 #line 493 "parser.y" /* yacc.c:1646 */
2977  { (yyval.expr) = (yyvsp[-1].expr);
2978  if (!(yyval.expr)->is_const || (yyval.expr)->cval <= 0)
2979  error_loc("array dimension is not a positive integer constant\n");
2980  }
2981 #line 2982 "parser.tab.c" /* yacc.c:1646 */
2982  break;
2983 
2984  case 66:
2985 #line 497 "parser.y" /* yacc.c:1646 */
2986  { (yyval.expr) = make_expr(EXPR_VOID); }
2987 #line 2988 "parser.tab.c" /* yacc.c:1646 */
2988  break;
2989 
2990  case 67:
2991 #line 498 "parser.y" /* yacc.c:1646 */
2992  { (yyval.expr) = make_expr(EXPR_VOID); }
2993 #line 2994 "parser.tab.c" /* yacc.c:1646 */
2994  break;
2995 
2996  case 68:
2997 #line 501 "parser.y" /* yacc.c:1646 */
2998  { (yyval.attr_list) = NULL; }
2999 #line 3000 "parser.tab.c" /* yacc.c:1646 */
3000  break;
3001 
3002  case 70:
3003 #line 506 "parser.y" /* yacc.c:1646 */
3004  { (yyval.attr_list) = (yyvsp[-1].attr_list); }
3005 #line 3006 "parser.tab.c" /* yacc.c:1646 */
3006  break;
3007 
3008  case 71:
3009 #line 509 "parser.y" /* yacc.c:1646 */
3010  { (yyval.attr_list) = append_attr( NULL, (yyvsp[0].attr) ); }
3011 #line 3012 "parser.tab.c" /* yacc.c:1646 */
3012  break;
3013 
3014  case 72:
3015 #line 510 "parser.y" /* yacc.c:1646 */
3016  { (yyval.attr_list) = append_attr( (yyvsp[-2].attr_list), (yyvsp[0].attr) ); }
3017 #line 3018 "parser.tab.c" /* yacc.c:1646 */
3018  break;
3019 
3020  case 73:
3021 #line 511 "parser.y" /* yacc.c:1646 */
3022  { (yyval.attr_list) = append_attr( (yyvsp[-3].attr_list), (yyvsp[0].attr) ); }
3023 #line 3024 "parser.tab.c" /* yacc.c:1646 */
3024  break;
3025 
3026  case 74:
3027 #line 514 "parser.y" /* yacc.c:1646 */
3028  { (yyval.str_list) = append_str( NULL, (yyvsp[0].str) ); }
3029 #line 3030 "parser.tab.c" /* yacc.c:1646 */
3030  break;
3031 
3032  case 75:
3033 #line 515 "parser.y" /* yacc.c:1646 */
3034  { (yyval.str_list) = append_str( (yyvsp[-2].str_list), (yyvsp[0].str) ); }
3035 #line 3036 "parser.tab.c" /* yacc.c:1646 */
3036  break;
3037 
3038  case 76:
3039 #line 518 "parser.y" /* yacc.c:1646 */
3040  { (yyval.attr) = NULL; }
3041 #line 3042 "parser.tab.c" /* yacc.c:1646 */
3042  break;
3043 
3044  case 77:
3045 #line 519 "parser.y" /* yacc.c:1646 */
3046  { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); }
3047 #line 3048 "parser.tab.c" /* yacc.c:1646 */
3048  break;
3049 
3050  case 78:
3051 #line 520 "parser.y" /* yacc.c:1646 */
3052  { (yyval.attr) = make_attrp(ATTR_ANNOTATION, (yyvsp[-1].str)); }
3053 #line 3054 "parser.tab.c" /* yacc.c:1646 */
3054  break;
3055 
3056  case 79:
3057 #line 521 "parser.y" /* yacc.c:1646 */
3058  { (yyval.attr) = make_attr(ATTR_APPOBJECT); }
3059 #line 3060 "parser.tab.c" /* yacc.c:1646 */
3060  break;
3061 
3062  case 80:
3063 #line 522 "parser.y" /* yacc.c:1646 */
3064  { (yyval.attr) = make_attr(ATTR_ASYNC); }
3065 #line 3066 "parser.tab.c" /* yacc.c:1646 */
3066  break;
3067 
3068  case 81:
3069 #line 523 "parser.y" /* yacc.c:1646 */
3070  { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); }
3071 #line 3072 "parser.tab.c" /* yacc.c:1646 */
3072  break;
3073 
3074  case 82:
3075 #line 524 "parser.y" /* yacc.c:1646 */
3076  { (yyval.attr) = make_attr(ATTR_BINDABLE); }
3077 #line 3078 "parser.tab.c" /* yacc.c:1646 */
3078  break;
3079 
3080  case 83:
3081 #line 525 "parser.y" /* yacc.c:1646 */
3082  { (yyval.attr) = make_attr(ATTR_BROADCAST); }
3083 #line 3084 "parser.tab.c" /* yacc.c:1646 */
3084  break;
3085 
3086  case 84:
3087 #line 526 "parser.y" /* yacc.c:1646 */
3088  { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[-1].var)); }
3089 #line 3090 "parser.tab.c" /* yacc.c:1646 */
3090  break;
3091 
3092  case 85:
3093 #line 527 "parser.y" /* yacc.c:1646 */
3094  { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[-1].expr_list)); }
3095 #line 3096 "parser.tab.c" /* yacc.c:1646 */
3096  break;
3097 
3098  case 86:
3099 #line 528 "parser.y" /* yacc.c:1646 */
3100  { (yyval.attr) = make_attr(ATTR_CODE); }
3101 #line 3102 "parser.tab.c" /* yacc.c:1646 */
3102  break;
3103 
3104  case 87:
3105 #line 529 "parser.y" /* yacc.c:1646 */
3106  { (yyval.attr) = make_attr(ATTR_COMMSTATUS); }
3107 #line 3108 "parser.tab.c" /* yacc.c:1646 */
3108  break;
3109 
3110  case 88:
3111 #line 530 "parser.y" /* yacc.c:1646 */
3112  { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); }
3113 #line 3114 "parser.tab.c" /* yacc.c:1646 */
3114  break;
3115 
3116  case 89:
3117 #line 531 "parser.y" /* yacc.c:1646 */
3118  { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ }
3119 #line 3120 "parser.tab.c" /* yacc.c:1646 */
3120  break;
3121 
3122  case 90:
3123 #line 532 "parser.y" /* yacc.c:1646 */
3124  { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ }
3125 #line 3126 "parser.tab.c" /* yacc.c:1646 */
3126  break;
3127 
3128  case 91:
3129 #line 533 "parser.y" /* yacc.c:1646 */
3130  { (yyval.attr) = make_attr(ATTR_CONTROL); }
3131 #line 3132 "parser.tab.c" /* yacc.c:1646 */
3132  break;
3133 
3134  case 92:
3135 #line 534 "parser.y" /* yacc.c:1646 */
3136  { (yyval.attr) = make_attr(ATTR_DECODE); }
3137 #line 3138 "parser.tab.c" /* yacc.c:1646 */
3138  break;
3139 
3140  case 93:
3141 #line 535 "parser.y" /* yacc.c:1646 */
3142  { (yyval.attr) = make_attr(ATTR_DEFAULT); }
3143 #line 3144 "parser.tab.c" /* yacc.c:1646 */
3144  break;
3145 
3146  case 94:
3147 #line 536 "parser.y" /* yacc.c:1646 */
3148  { (yyval.attr) = make_attr(ATTR_DEFAULTBIND); }
3149 #line 3150 "parser.tab.c" /* yacc.c:1646 */
3150  break;
3151 
3152  case 95:
3153 #line 537 "parser.y" /* yacc.c:1646 */
3154  { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); }
3155 #line 3156 "parser.tab.c" /* yacc.c:1646 */
3156  break;
3157 
3158  case 96:
3159 #line 538 "parser.y" /* yacc.c:1646 */
3160  { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE, (yyvsp[-1].expr)); }
3161 #line 3162 "parser.tab.c" /* yacc.c:1646 */
3162  break;
3163 
3164  case 97:
3165 #line 539 "parser.y" /* yacc.c:1646 */
3166  { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); }
3167 #line 3168 "parser.tab.c" /* yacc.c:1646 */
3168  break;
3169 
3170  case 98:
3171 #line 540 "parser.y" /* yacc.c:1646 */
3173 #line 3174 "parser.tab.c" /* yacc.c:1646 */
3174  break;
3175 
3176  case 99:
3177 #line 541 "parser.y" /* yacc.c:1646 */
3178  { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); }
3179 #line 3180 "parser.tab.c" /* yacc.c:1646 */
3180  break;
3181 
3182  case 100:
3183 #line 542 "parser.y" /* yacc.c:1646 */
3184  { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[-1].str)); }
3185 #line 3186 "parser.tab.c" /* yacc.c:1646 */
3186  break;
3187 
3188  case 101:
3189 #line 543 "parser.y" /* yacc.c:1646 */
3190  { (yyval.attr) = make_attr(ATTR_DUAL); }
3191 #line 3192 "parser.tab.c" /* yacc.c:1646 */
3192  break;
3193 
3194  case 102:
3195 #line 544 "parser.y" /* yacc.c:1646 */
3196  { (yyval.attr) = make_attr(ATTR_ENABLEALLOCATE); }
3197 #line 3198 "parser.tab.c" /* yacc.c:1646 */
3198  break;
3199 
3200  case 103:
3201 #line 545 "parser.y" /* yacc.c:1646 */
3202  { (yyval.attr) = make_attr(ATTR_ENCODE); }
3203 #line 3204 "parser.tab.c" /* yacc.c:1646 */
3204  break;
3205 
3206  case 104:
3207 #line 546 "parser.y" /* yacc.c:1646 */
3208  { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[-1].str_list)); }
3209 #line 3210 "parser.tab.c" /* yacc.c:1646 */
3210  break;
3211 
3212  case 105:
3213 #line 547 "parser.y" /* yacc.c:1646 */
3214  { (yyval.attr) = make_attrp(ATTR_ENTRY, (yyvsp[-1].expr)); }
3215 #line 3216 "parser.tab.c" /* yacc.c:1646 */
3216  break;
3217 
3218  case 106:
3219 #line 548 "parser.y" /* yacc.c:1646 */
3220  { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); }
3221 #line 3222 "parser.tab.c" /* yacc.c:1646 */
3222  break;
3223 
3224  case 107:
3225 #line 549 "parser.y" /* yacc.c:1646 */
3226  { (yyval.attr) = make_attr(ATTR_FAULTSTATUS); }
3227 #line 3228 "parser.tab.c" /* yacc.c:1646 */
3228  break;
3229 
3230  case 108:
3231 #line 550 "parser.y" /* yacc.c:1646 */
3232  { (yyval.attr) = make_attr(ATTR_FORCEALLOCATE); }
3233 #line 3234 "parser.tab.c" /* yacc.c:1646 */
3234  break;
3235 
3236  case 109:
3237 #line 551 "parser.y" /* yacc.c:1646 */
3238  { (yyval.attr) = make_attr(ATTR_HANDLE); }
3239 #line 3240 "parser.tab.c" /* yacc.c:1646 */
3240  break;
3241 
3242  case 110:
3243 #line 552 "parser.y" /* yacc.c:1646 */
3244  { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[-1].expr)); }
3245 #line 3246 "parser.tab.c" /* yacc.c:1646 */
3246  break;
3247 
3248  case 111:
3249 #line 553 "parser.y" /* yacc.c:1646 */
3250  { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[-1].str)); }
3251 #line 3252 "parser.tab.c" /* yacc.c:1646 */
3252  break;
3253 
3254  case 112:
3255 #line 554 "parser.y" /* yacc.c:1646 */
3256  { (yyval.attr) = make_attrp(ATTR_HELPSTRING, (yyvsp[-1].str)); }
3257 #line 3258 "parser.tab.c" /* yacc.c:1646 */
3258  break;
3259 
3260  case 113:
3261 #line 555 "parser.y" /* yacc.c:1646 */
3262  { (yyval.attr) = make_attrp(ATTR_HELPSTRINGCONTEXT, (yyvsp[-1].expr)); }
3263 #line 3264 "parser.tab.c" /* yacc.c:1646 */
3264  break;
3265 
3266  case 114:
3267 #line 556 "parser.y" /* yacc.c:1646 */
3268  { (yyval.attr) = make_attrp(ATTR_HELPSTRINGDLL, (yyvsp[-1].str)); }
3269 #line 3270 "parser.tab.c" /* yacc.c:1646 */
3270  break;
3271 
3272  case 115:
3273 #line 557 "parser.y" /* yacc.c:1646 */
3274  { (yyval.attr) = make_attr(ATTR_HIDDEN); }
3275 #line 3276 "parser.tab.c" /* yacc.c:1646 */
3276  break;
3277 
3278  case 116:
3279 #line 558 "parser.y" /* yacc.c:1646 */
3280  { (yyval.attr) = make_attrp(ATTR_ID, (yyvsp[-1].expr)); }
3281 #line 3282 "parser.tab.c" /* yacc.c:1646 */
3282  break;
3283 
3284  case 117:
3285 #line 559 "parser.y" /* yacc.c:1646 */
3286  { (yyval.attr) = make_attr(ATTR_IDEMPOTENT); }
3287 #line 3288 "parser.tab.c" /* yacc.c:1646 */
3288  break;
3289 
3290  case 118:
3291 #line 560 "parser.y" /* yacc.c:1646 */
3292  { (yyval.attr) = make_attr(ATTR_IGNORE); }
3293 #line 3294 "parser.tab.c" /* yacc.c:1646 */
3294  break;
3295 
3296  case 119:
3297 #line 561 "parser.y" /* yacc.c:1646 */
3298  { (yyval.attr) = make_attrp(ATTR_IIDIS, (yyvsp[-1].expr)); }
3299 #line 3300 "parser.tab.c" /* yacc.c:1646 */
3300  break;
3301 
3302  case 120:
3303 #line 562 "parser.y" /* yacc.c:1646 */
3304  { (yyval.attr) = make_attr(ATTR_IMMEDIATEBIND); }
3305 #line 3306 "parser.tab.c" /* yacc.c:1646 */
3306  break;
3307 
3308  case 121:
3309 #line 563 "parser.y" /* yacc.c:1646 */
3310  { (yyval.attr) = make_attrp(ATTR_IMPLICIT_HANDLE, (yyvsp[-1].var)); }
3311 #line 3312 "parser.tab.c" /* yacc.c:1646 */
3312  break;
3313 
3314  case 122:
3315 #line 564 "parser.y" /* yacc.c:1646 */
3316  { (yyval.attr) = make_attr(ATTR_IN); }
3317 #line 3318 "parser.tab.c" /* yacc.c:1646 */
3318  break;
3319 
3320  case 123:
3321 #line 565 "parser.y" /* yacc.c:1646 */
3322  { (yyval.attr) = make_attr(ATTR_INPUTSYNC); }
3323 #line 3324 "parser.tab.c" /* yacc.c:1646 */
3324  break;
3325 
3326  case 124:
3327 #line 566 "parser.y" /* yacc.c:1646 */
3328  { (yyval.attr) = make_attrp(ATTR_LENGTHIS, (yyvsp[-1].expr_list)); }
3329 #line 3330 "parser.tab.c" /* yacc.c:1646 */
3330  break;
3331 
3332  case 125:
3333 #line 567 "parser.y" /* yacc.c:1646 */
3334  { (yyval.attr) = make_attrp(ATTR_LIBLCID, (yyvsp[-1].expr)); }
3335 #line 3336 "parser.tab.c" /* yacc.c:1646 */
3336  break;
3337 
3338  case 126:
3339 #line 568 "parser.y" /* yacc.c:1646 */
3340  { (yyval.attr) = make_attr(ATTR_PARAMLCID); }
3341 #line 3342 "parser.tab.c" /* yacc.c:1646 */
3342  break;
3343 
3344  case 127:
3345 #line 569 "parser.y" /* yacc.c:1646 */
3346  { (yyval.attr) = make_attr(ATTR_LICENSED); }
3347 #line 3348 "parser.tab.c" /* yacc.c:1646 */
3348  break;
3349 
3350  case 128:
3351 #line 570 "parser.y" /* yacc.c:1646 */
3352  { (yyval.attr) = make_attr(ATTR_LOCAL); }
3353 #line 3354 "parser.tab.c" /* yacc.c:1646 */
3354  break;
3355 
3356  case 129:
3357 #line 571 "parser.y" /* yacc.c:1646 */
3358  { (yyval.attr) = make_attr(ATTR_MAYBE); }
3359 #line 3360 "parser.tab.c" /* yacc.c:1646 */
3360  break;
3361 
3362  case 130:
3363 #line 572 "parser.y" /* yacc.c:1646 */
3364  { (yyval.attr) = make_attr(ATTR_MESSAGE); }
3365 #line 3366 "parser.tab.c" /* yacc.c:1646 */
3366  break;
3367 
3368  case 131:
3369 #line 573 "parser.y" /* yacc.c:1646 */
3370  { (yyval.attr) = make_attr(ATTR_NOCODE); }
3371 #line 3372 "parser.tab.c" /* yacc.c:1646 */
3372  break;
3373 
3374  case 132:
3375 #line 574 "parser.y" /* yacc.c:1646 */
3376  { (yyval.attr) = make_attr(ATTR_NONBROWSABLE); }
3377 #line 3378 "parser.tab.c" /* yacc.c:1646 */
3378  break;
3379 
3380  case 133:
3381 #line 575 "parser.y" /* yacc.c:1646 */
3382  { (yyval.attr) = make_attr(ATTR_NONCREATABLE); }
3383 #line 3384 "parser.tab.c" /* yacc.c:1646 */
3384  break;
3385 
3386  case 134:
3387 #line 576 "parser.y" /* yacc.c:1646 */
3388  { (yyval.attr) = make_attr(ATTR_NONEXTENSIBLE); }
3389 #line 3390 "parser.tab.c" /* yacc.c:1646 */
3390  break;
3391 
3392  case 135:
3393 #line 577 "parser.y" /* yacc.c:1646 */
3394  { (yyval.attr) = make_attr(ATTR_NOTIFY); }
3395 #line 3396 "parser.tab.c" /* yacc.c:1646 */
3396  break;
3397 
3398  case 136:
3399 #line 578 "parser.y" /* yacc.c:1646 */
3400  { (yyval.attr) = make_attr(ATTR_NOTIFYFLAG); }
3401 #line 3402 "parser.tab.c" /* yacc.c:1646 */
3402  break;
3403 
3404  case 137:
3405 #line 579 "parser.y" /* yacc.c:1646 */
3406  { (yyval.attr) = make_attr(ATTR_OBJECT); }
3407 #line 3408 "parser.tab.c" /* yacc.c:1646 */
3408  break;
3409 
3410  case 138:
3411 #line 580 "parser.y" /* yacc.c:1646 */
3412  { (yyval.attr) = make_attr(ATTR_ODL); }
3413 #line 3414 "parser.tab.c" /* yacc.c:1646 */
3414  break;
3415 
3416  case 139:
3417 #line 581 "parser.y" /* yacc.c:1646 */
3418  { (yyval.attr) = make_attr(ATTR_OLEAUTOMATION); }
3419 #line 3420 "parser.tab.c" /* yacc.c:1646 */
3420  break;
3421 
3422  case 140:
3423 #line 582 "parser.y" /* yacc.c:1646 */
3424  { (yyval.attr) = make_attrp(ATTR_OPTIMIZE, (yyvsp[-1].str)); }
3425 #line 3426 "parser.tab.c" /* yacc.c:1646 */
3426  break;
3427 
3428  case 141:
3429 #line 583 "parser.y" /* yacc.c:1646 */
3430  { (yyval.attr) = make_attr(ATTR_OPTIONAL); }
3431 #line 3432 "parser.tab.c" /* yacc.c:1646 */
3432  break;
3433 
3434  case 142:
3435 #line 584 "parser.y" /* yacc.c:1646 */
3436  { (yyval.attr) = make_attr(ATTR_OUT); }
3437 #line 3438 "parser.tab.c" /* yacc.c:1646 */
3438  break;
3439 
3440  case 143:
3441 #line 585 "parser.y" /* yacc.c:1646 */
3442  { (yyval.attr) = make_attr(ATTR_PARTIALIGNORE); }
3443 #line 3444 "parser.tab.c" /* yacc.c:1646 */
3444  break;
3445 
3446  case 144:
3447 #line 586 "parser.y" /* yacc.c:1646 */
3448  { (yyval.attr) = make_attrv(ATTR_POINTERDEFAULT, (yyvsp[-1].num)); }
3449 #line 3450 "parser.tab.c" /* yacc.c:1646 */
3450  break;
3451 
3452  case 145:
3453 #line 587 "parser.y" /* yacc.c:1646 */
3454  { (yyval.attr) = make_attrp(ATTR_PROGID, (yyvsp[-1].str)); }
3455 #line 3456 "parser.tab.c" /* yacc.c:1646 */
3456  break;
3457 
3458  case 146:
3459 #line 588 "parser.y" /* yacc.c:1646 */
3460  { (yyval.attr) = make_attr(ATTR_PROPGET); }
3461 #line 3462 "parser.tab.c" /* yacc.c:1646 */
3462  break;
3463 
3464  case 147:
3465 #line 589 "parser.y" /* yacc.c:1646 */
3466  { (yyval.attr) = make_attr(ATTR_PROPPUT); }
3467 #line 3468 "parser.tab.c" /* yacc.c:1646 */
3468  break;
3469 
3470  case 148:
3471 #line 590 "parser.y" /* yacc.c:1646 */
3472  { (yyval.attr) = make_attr(ATTR_PROPPUTREF); }
3473 #line 3474 "parser.tab.c" /* yacc.c:1646 */
3474  break;
3475 
3476  case 149:
3477 #line 591 "parser.y" /* yacc.c:1646 */
3478  { (yyval.attr) = make_attr(ATTR_PROXY); }
3479 #line 3480 "parser.tab.c" /* yacc.c:1646 */
3480  break;
3481 
3482  case 150:
3483 #line 592 "parser.y" /* yacc.c:1646 */
3484  { (yyval.attr) = make_attr(ATTR_PUBLIC); }
3485 #line 3486 "parser.tab.c" /* yacc.c:1646 */
3486  break;
3487 
3488  case 151:
3489 #line 594 "parser.y" /* yacc.c:1646 */
3490  { expr_list_t *list = append_expr( NULL, (yyvsp[-3].expr) );
3491  list = append_expr( list, (yyvsp[-1].expr) );
3492  (yyval.attr) = make_attrp(ATTR_RANGE, list); }
3493 #line 3494 "parser.tab.c" /* yacc.c:1646 */
3494  break;
3495 
3496  case 152:
3497 #line 597 "parser.y" /* yacc.c:1646 */
3498  { (yyval.attr) = make_attr(ATTR_READONLY); }
3499 #line 3500 "parser.tab.c" /* yacc.c:1646 */
3500  break;
3501 
3502  case 153:
3503 #line 598 "parser.y" /* yacc.c:1646 */
3504  { (yyval.attr) = make_attrp(ATTR_REPRESENTAS, (yyvsp[-1].type)); }
3505 #line 3506 "parser.tab.c" /* yacc.c:1646 */
3506  break;
3507 
3508  case 154:
3509 #line 599 "parser.y" /* yacc.c:1646 */
3510  { (yyval.attr) = make_attr(ATTR_REQUESTEDIT); }
3511 #line 3512 "parser.tab.c" /* yacc.c:1646 */
3512  break;
3513 
3514  case 155:
3515 #line 600 "parser.y" /* yacc.c:1646 */
3516  { (yyval.attr) = make_attr(ATTR_RESTRICTED); }
3517 #line 3518 "parser.tab.c" /* yacc.c:1646 */
3518  break;
3519 
3520  case 156:
3521 #line 601 "parser.y" /* yacc.c:1646 */
3522  { (yyval.attr) = make_attr(ATTR_RETVAL); }
3523 #line 3524 "parser.tab.c" /* yacc.c:1646 */
3524  break;
3525 
3526  case 157:
3527 #line 602 "parser.y" /* yacc.c:1646 */
3528  { (yyval.attr) = make_attrp(ATTR_SIZEIS, (yyvsp[-1].expr_list)); }
3529 #line 3530 "parser.tab.c" /* yacc.c:1646 */
3530  break;
3531 
3532  case 158:
3533 #line 603 "parser.y" /* yacc.c:1646 */
3534  { (yyval.attr) = make_attr(ATTR_SOURCE); }
3535 #line 3536 "parser.tab.c" /* yacc.c:1646 */
3536  break;
3537 
3538  case 159:
3539 #line 604 "parser.y" /* yacc.c:1646 */
3540  { (yyval.attr) = make_attr(ATTR_STRICTCONTEXTHANDLE); }
3541 #line 3542 "parser.tab.c" /* yacc.c:1646 */
3542  break;
3543 
3544  case 160:
3545 #line 605 "parser.y" /* yacc.c:1646 */
3546  { (yyval.attr) = make_attr(ATTR_STRING); }
3547 #line 3548 "parser.tab.c" /* yacc.c:1646 */
3548  break;
3549 
3550  case 161:
3551 #line 606 "parser.y" /* yacc.c:1646 */
3552  { (yyval.attr) = make_attrp(ATTR_SWITCHIS, (yyvsp[-1].expr)); }
3553 #line 3554 "parser.tab.c" /* yacc.c:1646 */
3554  break;
3555 
3556  case 162:
3557 #line 607 "parser.y" /* yacc.c:1646 */
3558  { (yyval.attr) = make_attrp(ATTR_SWITCHTYPE, (yyvsp[-1].type)); }
3559 #line 3560 "parser.tab.c" /* yacc.c:1646 */
3560  break;
3561 
3562  case 163:
3563 #line 608 "parser.y" /* yacc.c:1646 */
3564  { (yyval.attr) = make_attrp(ATTR_TRANSMITAS, (yyvsp[-1].type)); }
3565 #line 3566 "parser.tab.c" /* yacc.c:1646 */
3566  break;
3567 
3568  case 164:
3569 #line 609 "parser.y" /* yacc.c:1646 */
3570  { (yyval.attr) = make_attrv(ATTR_THREADING, (yyvsp[-1].num)); }
3571 #line 3572 "parser.tab.c" /* yacc.c:1646 */
3572  break;
3573 
3574  case 165:
3575 #line 610 "parser.y" /* yacc.c:1646 */
3576  { (yyval.attr) = make_attr(ATTR_UIDEFAULT); }
3577 #line 3578 "parser.tab.c" /* yacc.c:1646 */
3578  break;
3579 
3580  case 166:
3581 #line 611 "parser.y" /* yacc.c:1646 */
3582  { (yyval.attr) = make_attr(ATTR_USESGETLASTERROR); }
3583 #line 3584 "parser.tab.c" /* yacc.c:1646 */
3584  break;
3585 
3586  case 167:
3587 #line 612 "parser.y" /* yacc.c:1646 */
3588  { (yyval.attr) = make_attrp(ATTR_USERMARSHAL, (yyvsp[-1].type)); }
3589 #line 3590 "parser.tab.c" /* yacc.c:1646 */
3590  break;
3591 
3592  case 168:
3593 #line 613 "parser.y" /* yacc.c:1646 */
3594  { (yyval.attr) = make_attrp(ATTR_UUID, (yyvsp[-1].uuid)); }
3595 #line 3596 "parser.tab.c" /* yacc.c:1646 */
3596  break;
3597 
3598  case 169:
3599 #line 614 "parser.y" /* yacc.c:1646 */
3600  { (yyval.attr) = make_attrp(ATTR_ASYNCUUID, (yyvsp[-1].uuid)); }
3601 #line 3602 "parser.tab.c" /* yacc.c:1646 */
3602  break;
3603 
3604  case 170:
3605 #line 615 "parser.y" /* yacc.c:1646 */
3606  { (yyval.attr) = make_attr(ATTR_V1ENUM); }
3607 #line 3608 "parser.tab.c" /* yacc.c:1646 */
3608  break;
3609 
3610  case 171:
3611 #line 616 "parser.y" /* yacc.c:1646 */
3612  { (yyval.attr) = make_attr(ATTR_VARARG); }
3613 #line 3614 "parser.tab.c" /* yacc.c:1646 */
3614  break;
3615 
3616  case 172:
3617 #line 617 "parser.y" /* yacc.c:1646 */
3618  { (yyval.attr) = make_attrv(ATTR_VERSION, (yyvsp[-1].num)); }
3619 #line 3620 "parser.tab.c" /* yacc.c:1646 */
3620  break;
3621 
3622  case 173:
3623 #line 618 "parser.y" /* yacc.c:1646 */
3624  { (yyval.attr) = make_attrp(ATTR_VIPROGID, (yyvsp[-1].str)); }
3625 #line 3626 "parser.tab.c" /* yacc.c:1646 */
3626  break;
3627 
3628  case 174:
3629 #line 619 "parser.y" /* yacc.c:1646 */
3630  { (yyval.attr) = make_attrp(ATTR_WIREMARSHAL, (yyvsp[-1].type)); }
3631 #line 3632 "parser.tab.c" /* yacc.c:1646 */
3632  break;
3633 
3634  case 175:
3635 #line 620 "parser.y" /* yacc.c:1646 */
3636  { (yyval.attr) = make_attrv(ATTR_POINTERTYPE, (yyvsp[0].num)); }
3637 #line 3638 "parser.tab.c" /* yacc.c:1646 */
3638  break;
3639 
3640  case 177:
3641 #line 625 "parser.y" /* yacc.c:1646 */
3642  { if (!is_valid_uuid((yyvsp[0].str)))
3643  error_loc("invalid UUID: %s\n", (yyvsp[0].str));
3644  (yyval.uuid) = parse_uuid((yyvsp[0].str)); }
3645 #line 3646 "parser.tab.c" /* yacc.c:1646 */
3646  break;
3647 
3648  case 178:
3649 #line 630 "parser.y" /* yacc.c:1646 */
3650  { (yyval.str) = xstrdup("__cdecl"); }
3651 #line 3652 "parser.tab.c" /* yacc.c:1646 */
3652  break;
3653 
3654  case 179:
3655 #line 631 "parser.y" /* yacc.c:1646 */
3656  { (yyval.str) = xstrdup("__fastcall"); }
3657 #line 3658 "parser.tab.c" /* yacc.c:1646 */
3658  break;
3659 
3660  case 180:
3661 #line 632 "parser.y" /* yacc.c:1646 */
3662  { (yyval.str) = xstrdup("__pascal"); }
3663 #line 3664 "parser.tab.c" /* yacc.c:1646 */
3664  break;
3665 
3666  case 181:
3667 #line 633 "parser.y" /* yacc.c:1646 */
3668  { (yyval.str) = xstrdup("__stdcall"); }
3669 #line 3670 "parser.tab.c" /* yacc.c:1646 */
3670  break;
3671 
3672  case 182:
3673 #line 636 "parser.y" /* yacc.c:1646 */
3674  { (yyval.var_list) = NULL; }
3675 #line 3676 "parser.tab.c" /* yacc.c:1646 */
3676  break;
3677 
3678  case 183:
3679 #line 637 "parser.y" /* yacc.c:1646 */
3680  { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); }
3681 #line 3682 "parser.tab.c" /* yacc.c:1646 */
3682  break;
3683 
3684  case 184:
3685 #line 640 "parser.y" /* yacc.c:1646 */
3686  { attr_t *a = make_attrp(ATTR_CASE, append_expr( NULL, (yyvsp[-2].expr) ));
3687  (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL);
3688  (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a );
3689  }
3690 #line 3691 "parser.tab.c" /* yacc.c:1646 */
3691  break;
3692 
3693  case 185:
3694 #line 644 "parser.y" /* yacc.c:1646 */
3696  (yyval.var) = (yyvsp[0].var); if (!(yyval.var)) (yyval.var) = make_var(NULL);
3697  (yyval.var)->attrs = append_attr( (yyval.var)->attrs, a );
3698  }
3699 #line 3700 "parser.tab.c" /* yacc.c:1646 */
3700  break;
3701 
3702  case 186:
3703 #line 650 "parser.y" /* yacc.c:1646 */
3704  { (yyval.var_list) = NULL; }
3705 #line 3706 "parser.tab.c" /* yacc.c:1646 */
3706  break;
3707 
3708  case 187:
3709 #line 651 "parser.y" /* yacc.c:1646 */
3710  { (yyval.var_list) = (yyvsp[-1].var_list); }
3711 #line 3712 "parser.tab.c" /* yacc.c:1646 */
3712  break;
3713 
3714  case 189:
3715 #line 655 "parser.y" /* yacc.c:1646 */
3716  { if (!(yyvsp[0].var)->eval)
3717  (yyvsp[0].var)->eval = make_exprl(EXPR_NUM, 0 /* default for first enum entry */);
3718  (yyval.var_list) = append_var( NULL, (yyvsp[0].var) );
3719  }
3720 #line 3721 "parser.tab.c" /* yacc.c:1646 */
3721  break;
3722 
3723  case 190:
3724 #line 659 "parser.y" /* yacc.c:1646 */
3725  { if (!(yyvsp[0].var)->eval)
3726  {
3727  var_t *last = LIST_ENTRY( list_tail((yyval.var_list)), var_t, entry );
3728  enum expr_type type = EXPR_NUM;
3729  if (last->eval->type == EXPR_HEXNUM) type = EXPR_HEXNUM;
3730  if (last->eval->cval + 1 < 0) type = EXPR_HEXNUM;
3731  (yyvsp[0].var)->eval = make_exprl(type, last->eval->cval + 1);
3732  }
3733  (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var) );
3734  }
3735 #line 3736 "parser.tab.c" /* yacc.c:1646 */
3736  break;
3737 
3738  case 191:
3739 #line 671 "parser.y" /* yacc.c:1646 */
3740  { (yyval.var) = reg_const((yyvsp[-2].var));
3741  (yyval.var)->eval = (yyvsp[0].expr);
3742  (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0);
3743  }
3744 #line 3745 "parser.tab.c" /* yacc.c:1646 */
3745  break;
3746 
3747  case 192:
3748 #line 675 "parser.y" /* yacc.c:1646 */
3749  { (yyval.var) = reg_const((yyvsp[0].var));
3750  (yyval.var)->type = type_new_int(TYPE_BASIC_INT, 0);
3751  }
3752 #line 3753 "parser.tab.c" /* yacc.c:1646 */
3753  break;
3754 
3755  case 193:
3756 #line 680 "parser.y" /* yacc.c:1646 */
3757  { (yyval.type) = type_new_enum((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); }
3758 #line 3759 "parser.tab.c" /* yacc.c:1646 */
3759  break;
3760 
3761  case 194:
3762 #line 683 "parser.y" /* yacc.c:1646 */
3763  { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); }
3764 #line 3765 "parser.tab.c" /* yacc.c:1646 */
3765  break;
3766 
3767  case 195:
3768 #line 684 "parser.y" /* yacc.c:1646 */
3769  { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); }
3770 #line 3771 "parser.tab.c" /* yacc.c:1646 */
3771  break;
3772 
3773  case 196:
3774 #line 687 "parser.y" /* yacc.c:1646 */
3775  { (yyval.expr) = make_expr(EXPR_VOID); }
3776 #line 3777 "parser.tab.c" /* yacc.c:1646 */
3777  break;
3778 
3779  case 198:
3780 #line 691 "parser.y" /* yacc.c:1646 */
3781  { (yyval.expr) = make_exprl(EXPR_NUM, (yyvsp[0].num)); }
3782 #line 3783 "parser.tab.c" /* yacc.c:1646 */
3783  break;
3784 
3785  case 199:
3786 #line 692 "parser.y" /* yacc.c:1646 */
3787  { (yyval.expr) = make_exprl(EXPR_HEXNUM, (yyvsp[0].num)); }
3788 #line 3789 "parser.tab.c" /* yacc.c:1646 */
3789  break;
3790 
3791  case 200:
3792 #line 693 "parser.y" /* yacc.c:1646 */
3793  { (yyval.expr) = make_exprd(EXPR_DOUBLE, (yyvsp[0].dbl)); }
3794 #line 3795 "parser.tab.c" /* yacc.c:1646 */
3795  break;
3796 
3797  case 201:
3798 #line 694 "parser.y" /* yacc.c:1646 */
3799  { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 0); }
3800 #line 3801 "parser.tab.c" /* yacc.c:1646 */
3801  break;
3802 
3803  case 202:
3804 #line 695 "parser.y" /* yacc.c:1646 */
3805  { (yyval.expr) = make_exprl(EXPR_NUM, 0); }
3806 #line 3807 "parser.tab.c" /* yacc.c:1646 */
3807  break;
3808 
3809  case 203:
3810 #line 696 "parser.y" /* yacc.c:1646 */
3811  { (yyval.expr) = make_exprl(EXPR_TRUEFALSE, 1); }
3812 #line 3813 "parser.tab.c" /* yacc.c:1646 */
3813  break;
3814 
3815  case 204:
3816 #line 697 "parser.y" /* yacc.c:1646 */
3817  { (yyval.expr) = make_exprs(EXPR_STRLIT, (yyvsp[0].str)); }
3818 #line 3819 "parser.tab.c" /* yacc.c:1646 */
3819  break;
3820 
3821  case 205:
3822 #line 698 "parser.y" /* yacc.c:1646 */
3823  { (yyval.expr) = make_exprs(EXPR_WSTRLIT, (yyvsp[0].str)); }
3824 #line 3825 "parser.tab.c" /* yacc.c:1646 */
3825  break;
3826 
3827  case 206:
3828 #line 699 "parser.y" /* yacc.c:1646 */
3829  { (yyval.expr) = make_exprs(EXPR_CHARCONST, (yyvsp[0].str)); }
3830 #line 3831 "parser.tab.c" /* yacc.c:1646 */
3831  break;
3832 
3833  case 207:
3834 #line 700 "parser.y" /* yacc.c:1646 */
3835  { (yyval.expr) = make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str)); }
3836 #line 3837 "parser.tab.c" /* yacc.c:1646 */
3837  break;
3838 
3839  case 208:
3840 #line 701 "parser.y" /* yacc.c:1646 */
3841  { (yyval.expr) = make_expr3(EXPR_COND, (yyvsp[-4].expr), (yyvsp[-2].expr), (yyvsp[0].expr)); }
3842 #line 3843 "parser.tab.c" /* yacc.c:1646 */
3843  break;
3844 
3845  case 209:
3846 #line 702 "parser.y" /* yacc.c:1646 */
3847  { (yyval.expr) = make_expr2(EXPR_LOGOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3848 #line 3849 "parser.tab.c" /* yacc.c:1646 */
3849  break;
3850 
3851  case 210:
3852 #line 703 "parser.y" /* yacc.c:1646 */
3853  { (yyval.expr) = make_expr2(EXPR_LOGAND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3854 #line 3855 "parser.tab.c" /* yacc.c:1646 */
3855  break;
3856 
3857  case 211:
3858 #line 704 "parser.y" /* yacc.c:1646 */
3859  { (yyval.expr) = make_expr2(EXPR_OR , (yyvsp[-2].expr), (yyvsp[0].expr)); }
3860 #line 3861 "parser.tab.c" /* yacc.c:1646 */
3861  break;
3862 
3863  case 212:
3864 #line 705 "parser.y" /* yacc.c:1646 */
3865  { (yyval.expr) = make_expr2(EXPR_XOR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3866 #line 3867 "parser.tab.c" /* yacc.c:1646 */
3867  break;
3868 
3869  case 213:
3870 #line 706 "parser.y" /* yacc.c:1646 */
3871  { (yyval.expr) = make_expr2(EXPR_AND, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3872 #line 3873 "parser.tab.c" /* yacc.c:1646 */
3873  break;
3874 
3875  case 214:
3876 #line 707 "parser.y" /* yacc.c:1646 */
3877  { (yyval.expr) = make_expr2(EXPR_EQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3878 #line 3879 "parser.tab.c" /* yacc.c:1646 */
3879  break;
3880 
3881  case 215:
3882 #line 708 "parser.y" /* yacc.c:1646 */
3883  { (yyval.expr) = make_expr2(EXPR_INEQUALITY, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3884 #line 3885 "parser.tab.c" /* yacc.c:1646 */
3885  break;
3886 
3887  case 216:
3888 #line 709 "parser.y" /* yacc.c:1646 */
3889  { (yyval.expr) = make_expr2(EXPR_GTR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3890 #line 3891 "parser.tab.c" /* yacc.c:1646 */
3891  break;
3892 
3893  case 217:
3894 #line 710 "parser.y" /* yacc.c:1646 */
3895  { (yyval.expr) = make_expr2(EXPR_LESS, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3896 #line 3897 "parser.tab.c" /* yacc.c:1646 */
3897  break;
3898 
3899  case 218:
3900 #line 711 "parser.y" /* yacc.c:1646 */
3901  { (yyval.expr) = make_expr2(EXPR_GTREQL, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3902 #line 3903 "parser.tab.c" /* yacc.c:1646 */
3903  break;
3904 
3905  case 219:
3906 #line 712 "parser.y" /* yacc.c:1646 */
3907  { (yyval.expr) = make_expr2(EXPR_LESSEQL, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3908 #line 3909 "parser.tab.c" /* yacc.c:1646 */
3909  break;
3910 
3911  case 220:
3912 #line 713 "parser.y" /* yacc.c:1646 */
3913  { (yyval.expr) = make_expr2(EXPR_SHL, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3914 #line 3915 "parser.tab.c" /* yacc.c:1646 */
3915  break;
3916 
3917  case 221:
3918 #line 714 "parser.y" /* yacc.c:1646 */
3919  { (yyval.expr) = make_expr2(EXPR_SHR, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3920 #line 3921 "parser.tab.c" /* yacc.c:1646 */
3921  break;
3922 
3923  case 222:
3924 #line 715 "parser.y" /* yacc.c:1646 */
3925  { (yyval.expr) = make_expr2(EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3926 #line 3927 "parser.tab.c" /* yacc.c:1646 */
3927  break;
3928 
3929  case 223:
3930 #line 716 "parser.y" /* yacc.c:1646 */
3931  { (yyval.expr) = make_expr2(EXPR_SUB, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3932 #line 3933 "parser.tab.c" /* yacc.c:1646 */
3933  break;
3934 
3935  case 224:
3936 #line 717 "parser.y" /* yacc.c:1646 */
3937  { (yyval.expr) = make_expr2(EXPR_MOD, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3938 #line 3939 "parser.tab.c" /* yacc.c:1646 */
3939  break;
3940 
3941  case 225:
3942 #line 718 "parser.y" /* yacc.c:1646 */
3943  { (yyval.expr) = make_expr2(EXPR_MUL, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3944 #line 3945 "parser.tab.c" /* yacc.c:1646 */
3945  break;
3946 
3947  case 226:
3948 #line 719 "parser.y" /* yacc.c:1646 */
3949  { (yyval.expr) = make_expr2(EXPR_DIV, (yyvsp[-2].expr), (yyvsp[0].expr)); }
3950 #line 3951 "parser.tab.c" /* yacc.c:1646 */
3951  break;
3952 
3953  case 227:
3954 #line 720 "parser.y" /* yacc.c:1646 */
3955  { (yyval.expr) = make_expr1(EXPR_LOGNOT, (yyvsp[0].expr)); }
3956 #line 3957 "parser.tab.c" /* yacc.c:1646 */
3957  break;
3958 
3959  case 228:
3960 #line 721 "parser.y" /* yacc.c:1646 */
3961  { (yyval.expr) = make_expr1(EXPR_NOT, (yyvsp[0].expr)); }
3962 #line 3963 "parser.tab.c" /* yacc.c:1646 */
3963  break;
3964 
3965  case 229:
3966 #line 722 "parser.y" /* yacc.c:1646 */
3967  { (yyval.expr) = make_expr1(EXPR_POS, (yyvsp[0].expr)); }
3968 #line 3969 "parser.tab.c" /* yacc.c:1646 */
3969  break;
3970 
3971  case 230:
3972 #line 723 "parser.y" /* yacc.c:1646 */
3973  { (yyval.expr) = make_expr1(EXPR_NEG, (yyvsp[0].expr)); }
3974 #line 3975 "parser.tab.c" /* yacc.c:1646 */
3975  break;
3976 
3977  case 231:
3978 #line 724 "parser.y" /* yacc.c:1646 */
3979  { (yyval.expr) = make_expr1(EXPR_ADDRESSOF, (yyvsp[0].expr)); }
3980 #line 3981 "parser.tab.c" /* yacc.c:1646 */
3981  break;
3982 
3983  case 232:
3984 #line 725 "parser.y" /* yacc.c:1646 */
3985  { (yyval.expr) = make_expr1(EXPR_PPTR, (yyvsp[0].expr)); }
3986 #line 3987 "parser.tab.c" /* yacc.c:1646 */
3987  break;
3988 
3989  case 233:
3990 #line 726 "parser.y" /* yacc.c:1646 */
3991  { (yyval.expr) = make_expr2(EXPR_MEMBER, make_expr1(EXPR_PPTR, (yyvsp[-2].expr)), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); }
3992 #line 3993 "parser.tab.c" /* yacc.c:1646 */
3993  break;
3994 
3995  case 234:
3996 #line 727 "parser.y" /* yacc.c:1646 */
3997  { (yyval.expr) = make_expr2(EXPR_MEMBER, (yyvsp[-2].expr), make_exprs(EXPR_IDENTIFIER, (yyvsp[0].str))); }
3998 #line 3999 "parser.tab.c" /* yacc.c:1646 */
3999  break;
4000 
4001  case 235:
4002 #line 729 "parser.y" /* yacc.c:1646 */
4003  { (yyval.expr) = make_exprt(EXPR_CAST, declare_var(NULL, (yyvsp[-3].declspec), (yyvsp[-2].declarator), 0), (yyvsp[0].expr)); free((yyvsp[-3].declspec)); free((yyvsp[-2].declarator)); }
4004 #line 4005 "parser.tab.c" /* yacc.c:1646 */
4005  break;
4006 
4007  case 236:
4008 #line 731 "parser.y" /* yacc.c:1646 */
4009  { (yyval.expr) = make_exprt(EXPR_SIZEOF, declare_var(NULL, (yyvsp[-2].declspec), (yyvsp[-1].declarator), 0), NULL); free((yyvsp[-2].declspec)); free((yyvsp[-1].declarator)); }
4010 #line 4011 "parser.tab.c" /* yacc.c:1646 */
4011  break;
4012 
4013  case 237:
4014 #line 732 "parser.y" /* yacc.c:1646 */
4015  { (yyval.expr) = make_expr2(EXPR_ARRAY, (yyvsp[-3].expr), (yyvsp[-1].expr)); }
4016 #line 4017 "parser.tab.c" /* yacc.c:1646 */
4017  break;
4018 
4019  case 238:
4020 #line 733 "parser.y" /* yacc.c:1646 */
4021  { (yyval.expr) = (yyvsp[-1].expr); }
4022 #line 4023 "parser.tab.c" /* yacc.c:1646 */
4023  break;
4024 
4025  case 239:
4026 #line 736 "parser.y" /* yacc.c:1646 */
4027  { (yyval.expr_list) = append_expr( NULL, (yyvsp[0].expr) ); }
4028 #line 4029 "parser.tab.c" /* yacc.c:1646 */
4029  break;
4030 
4031  case 240:
4032 #line 737 "parser.y" /* yacc.c:1646 */
4033  { (yyval.expr_list) = append_expr( (yyvsp[-2].expr_list), (yyvsp[0].expr) ); }
4034 #line 4035 "parser.tab.c" /* yacc.c:1646 */
4035  break;
4036 
4037  case 241:
4038 #line 740 "parser.y" /* yacc.c:1646 */
4039  { (yyval.expr) = (yyvsp[0].expr);
4040  if (!(yyval.expr)->is_const)
4041  error_loc("expression is not an integer constant\n");
4042  }
4043 #line 4044 "parser.tab.c" /* yacc.c:1646 */
4044  break;
4045 
4046  case 242:
4047 #line 746 "parser.y" /* yacc.c:1646 */
4048  { (yyval.expr) = (yyvsp[0].expr);
4049  if (!(yyval.expr)->is_const && (yyval.expr)->type != EXPR_STRLIT && (yyval.expr)->type != EXPR_WSTRLIT)
4050  error_loc("expression is not constant\n");
4051  }
4052 #line 4053 "parser.tab.c" /* yacc.c:1646 */
4053  break;
4054 
4055  case 243:
4056 #line 752 "parser.y" /* yacc.c:1646 */
4057  { (yyval.var_list) = NULL; }
4058 #line 4059 "parser.tab.c" /* yacc.c:1646 */
4059  break;
4060 
4061  case 244:
4062 #line 753 "parser.y" /* yacc.c:1646 */
4063  { (yyval.var_list) = append_var_list((yyvsp[-1].var_list), (yyvsp[0].var_list)); }
4064 #line 4065 "parser.tab.c" /* yacc.c:1646 */
4065  break;
4066 
4067  case 245:
4068 #line 757 "parser.y" /* yacc.c:1646 */
4069  { const char *first = LIST_ENTRY(list_head((yyvsp[-1].declarator_list)), declarator_t, entry)->var->name;
4070  check_field_attrs(first, (yyvsp[-3].attr_list));
4071  (yyval.var_list) = set_var_types((yyvsp[-3].attr_list), (yyvsp[-2].declspec), (yyvsp[-1].declarator_list));
4072  }
4073 #line 4074 "parser.tab.c" /* yacc.c:1646 */
4074  break;
4075 
4076  case 246:
4077 #line 761 "parser.y" /* yacc.c:1646 */
4078  { var_t *v = make_var(NULL);
4079  v->type = (yyvsp[-1].type); v->attrs = (yyvsp[-2].attr_list);
4080  (yyval.var_list) = append_var(NULL, v);
4081  }
4082 #line 4083 "parser.tab.c" /* yacc.c:1646 */
4083  break;
4084 
4085  case 247:
4086 #line 768 "parser.y" /* yacc.c:1646 */
4087  { (yyval.var) = (yyvsp[-1].var); }
4088 #line 4089 "parser.tab.c" /* yacc.c:1646 */
4089  break;
4090 
4091  case 248:
4092 #line 769 "parser.y" /* yacc.c:1646 */
4093  { (yyval.var) = make_var(NULL); (yyval.var)->attrs = (yyvsp[-1].attr_list); }
4094 #line 4095 "parser.tab.c" /* yacc.c:1646 */
4095  break;
4096 
4097  case 249:
4098 #line 772 "parser.y" /* yacc.c:1646 */
4099  { (yyval.var_list) = NULL; }
4100 #line 4101 "parser.tab.c" /* yacc.c:1646 */
4101  break;
4102 
4103  case 250:
4104 #line 773 "parser.y" /* yacc.c:1646 */
4105  { (yyval.var_list) = append_var( (yyvsp[-1].var_list), (yyvsp[0].var) ); }
4106 #line 4107 "parser.tab.c" /* yacc.c:1646 */
4107  break;
4108 
4109  case 251:
4110 #line 777 "parser.y" /* yacc.c:1646 */
4111  { (yyval.var) = (yyvsp[-1].var); }
4112 #line 4113 "parser.tab.c" /* yacc.c:1646 */
4113  break;
4114 
4115  case 252:
4116 #line 778 "parser.y" /* yacc.c:1646 */
4117  { (yyval.var) = NULL; }
4118 #line 4119 "parser.tab.c" /* yacc.c:1646 */
4119  break;
4120 
4121  case 253:
4122 #line 781 "parser.y" /* yacc.c:1646 */
4123  { (yyval.var) = declare_var(check_field_attrs((yyvsp[0].declarator)->var->name, (yyvsp[-2].attr_list)),
4124  (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE);
4125  free((yyvsp[0].declarator));
4126  }
4127 #line 4128 "parser.tab.c" /* yacc.c:1646 */
4128  break;
4129 
4130  case 254:
4131 #line 785 "parser.y" /* yacc.c:1646 */
4132  { var_t *v = make_var(NULL);
4133  v->type = (yyvsp[0].type); v->attrs = (yyvsp[-1].attr_list);
4134  (yyval.var) = v;
4135  }
4136 #line 4137 "parser.tab.c" /* yacc.c:1646 */
4137  break;
4138 
4139  case 255:
4140 #line 791 "parser.y" /* yacc.c:1646 */
4141  { (yyval.var) = (yyvsp[0].var);
4142  if (type_get_type((yyval.var)->type) != TYPE_FUNCTION)
4143  error_loc("only methods may be declared inside the methods section of a dispinterface\n");
4144  check_function_attrs((yyval.var)->name, (yyval.var)->attrs);
4145  }
4146 #line 4147 "parser.tab.c" /* yacc.c:1646 */
4147  break;
4148 
4149  case 256:
4150 #line 800 "parser.y" /* yacc.c:1646 */
4151  { (yyval.var) = declare_var((yyvsp[-2].attr_list), (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE);
4152  free((yyvsp[0].declarator));
4153  }
4154 #line 4155 "parser.tab.c" /* yacc.c:1646 */
4155  break;
4156 
4157  case 257:
4158 #line 803 "parser.y" /* yacc.c:1646 */
4159  { (yyval.var) = declare_var(NULL, (yyvsp[-1].declspec), (yyvsp[0].declarator), FALSE);
4160  free((yyvsp[0].declarator));
4161  }
4162 #line 4163 "parser.tab.c" /* yacc.c:1646 */
4163  break;
4164 
4165  case 258:
4166 #line 808 "parser.y" /* yacc.c:1646 */
4167  { (yyval.var) = NULL; }
4168 #line 4169 "parser.tab.c" /* yacc.c:1646 */
4169  break;
4170 
4171  case 260:
4172 #line 812 "parser.y" /* yacc.c:1646 */
4173  { (yyval.str) = NULL; }
4174 #line 4175 "parser.tab.c" /* yacc.c:1646 */
4175  break;
4176 
4177  case 261:
4178 #line 813 "parser.y" /* yacc.c:1646 */
4179  { (yyval.str) = (yyvsp[0].str); }
4180 #line 4181 "parser.tab.c" /* yacc.c:1646 */
4181  break;
4182 
4183  case 262:
4184 #line 814 "parser.y" /* yacc.c:1646 */
4185  { (yyval.str) = (yyvsp[0].str); }
4186 #line 4187 "parser.tab.c" /* yacc.c:1646 */
4187  break;
4188 
4189  case 263:
4190 #line 817 "parser.y" /* yacc.c:1646 */
4191  { (yyval.var) = make_var((yyvsp[0].str)); }
4192 #line 4193 "parser.tab.c" /* yacc.c:1646 */
4193  break;
4194 
4195  case 264:
4196 #line 819 "parser.y" /* yacc.c:1646 */
4197  { (yyval.var) = make_var((yyvsp[0].str)); }
4198 #line 4199 "parser.tab.c" /* yacc.c:1646 */
4199  break;
4200 
4201  case 265:
4202 #line 822 "parser.y" /* yacc.c:1646 */
4203  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4204 #line 4205 "parser.tab.c" /* yacc.c:1646 */
4205  break;
4206 
4207  case 266:
4208 #line 823 "parser.y" /* yacc.c:1646 */
4209  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4210 #line 4211 "parser.tab.c" /* yacc.c:1646 */
4211  break;
4212 
4213  case 268:
4214 #line 825 "parser.y" /* yacc.c:1646 */
4215  { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), -1); }
4216 #line 4217 "parser.tab.c" /* yacc.c:1646 */
4217  break;
4218 
4219  case 269:
4220 #line 826 "parser.y" /* yacc.c:1646 */
4221  { (yyval.type) = type_new_int(type_basic_get_type((yyvsp[0].type)), 1); }
4222 #line 4223 "parser.tab.c" /* yacc.c:1646 */
4223  break;
4224 
4225  case 270:
4226 #line 827 "parser.y" /* yacc.c:1646 */
4227  { (yyval.type) = type_new_int(TYPE_BASIC_INT, 1); }
4228 #line 4229 "parser.tab.c" /* yacc.c:1646 */
4229  break;
4230 
4231  case 271:
4232 #line 828 "parser.y" /* yacc.c:1646 */
4233  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4234 #line 4235 "parser.tab.c" /* yacc.c:1646 */
4235  break;
4236 
4237  case 272:
4238 #line 829 "parser.y" /* yacc.c:1646 */
4239  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4240 #line 4241 "parser.tab.c" /* yacc.c:1646 */
4241  break;
4242 
4243  case 273:
4244 #line 830 "parser.y" /* yacc.c:1646 */
4245  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4246 #line 4247 "parser.tab.c" /* yacc.c:1646 */
4247  break;
4248 
4249  case 274:
4250 #line 831 "parser.y" /* yacc.c:1646 */
4251  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4252 #line 4253 "parser.tab.c" /* yacc.c:1646 */
4253  break;
4254 
4255  case 275:
4256 #line 832 "parser.y" /* yacc.c:1646 */
4257  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4258 #line 4259 "parser.tab.c" /* yacc.c:1646 */
4259  break;
4260 
4261  case 278:
4262 #line 839 "parser.y" /* yacc.c:1646 */
4263  { (yyval.type) = type_new_int(TYPE_BASIC_INT, 0); }
4264 #line 4265 "parser.tab.c" /* yacc.c:1646 */
4265  break;
4266 
4267  case 279:
4268 #line 840 "parser.y" /* yacc.c:1646 */
4269  { (yyval.type) = type_new_int(TYPE_BASIC_INT16, 0); }
4270 #line 4271 "parser.tab.c" /* yacc.c:1646 */
4271  break;
4272 
4273  case 280:
4274 #line 841 "parser.y" /* yacc.c:1646 */
4275  { (yyval.type) = type_new_int(TYPE_BASIC_INT8, 0); }
4276 #line 4277 "parser.tab.c" /* yacc.c:1646 */
4277  break;
4278 
4279  case 281:
4280 #line 842 "parser.y" /* yacc.c:1646 */
4281  { (yyval.type) = type_new_int(TYPE_BASIC_LONG, 0); }
4282 #line 4283 "parser.tab.c" /* yacc.c:1646 */
4283  break;
4284 
4285  case 282:
4286 #line 843 "parser.y" /* yacc.c:1646 */
4287  { (yyval.type) = type_new_int(TYPE_BASIC_HYPER, 0); }
4288 #line 4289 "parser.tab.c" /* yacc.c:1646 */
4289  break;
4290 
4291  case 283:
4292 #line 844 "parser.y" /* yacc.c:1646 */
4293  { (yyval.type) = type_new_int(TYPE_BASIC_INT64, 0); }
4294 #line 4295 "parser.tab.c" /* yacc.c:1646 */
4295  break;
4296 
4297  case 284:
4298 #line 845 "parser.y" /* yacc.c:1646 */
4299  { (yyval.type) = type_new_int(TYPE_BASIC_CHAR, 0); }
4300 #line 4301 "parser.tab.c" /* yacc.c:1646 */
4301  break;
4302 
4303  case 285:
4304 #line 846 "parser.y" /* yacc.c:1646 */
4305  { (yyval.type) = type_new_int(TYPE_BASIC_INT32, 0); }
4306 #line 4307 "parser.tab.c" /* yacc.c:1646 */
4307  break;
4308 
4309  case 286:
4310 #line 847 "parser.y" /* yacc.c:1646 */
4311  { (yyval.type) = type_new_int(TYPE_BASIC_INT3264, 0); }
4312 #line 4313 "parser.tab.c" /* yacc.c:1646 */
4313  break;
4314 
4315  case 287:
4316 #line 850 "parser.y" /* yacc.c:1646 */
4317  { (yyval.type) = type_new_coclass((yyvsp[0].str)); }
4318 #line 4319 "parser.tab.c" /* yacc.c:1646 */
4319  break;
4320 
4321  case 288:
4322 #line 851 "parser.y" /* yacc.c:1646 */
4323  { (yyval.type) = find_type((yyvsp[0].str), NULL, 0);
4325  error_loc("%s was not declared a coclass at %s:%d\n",
4326  (yyvsp[0].str), (yyval.type)->loc_info.input_name,
4327  (yyval.type)->loc_info.line_number);
4328  }
4329 #line 4330 "parser.tab.c" /* yacc.c:1646 */
4330  break;
4331 
4332  case 289:
4333 #line 859 "parser.y" /* yacc.c:1646 */
4334  { (yyval.type) = (yyvsp[0].type);
4335  check_def((yyval.type));
4336  (yyval.type)->attrs = check_coclass_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list));
4337  }
4338 #line 4339 "parser.tab.c" /* yacc.c:1646 */
4339  break;
4340 
4341  case 290:
4342 #line 866 "parser.y" /* yacc.c:1646 */
4343  { (yyval.type) = type_coclass_define((yyvsp[-4].type), (yyvsp[-2].ifref_list)); }
4344 #line 4345 "parser.tab.c" /* yacc.c:1646 */
4345  break;
4346 
4347  case 291:
4348 #line 869 "parser.y" /* yacc.c:1646 */
4349  { (yyval.str) = (yyvsp[0].str); }
4350 #line 4351 "parser.tab.c" /* yacc.c:1646 */
4351  break;
4352 
4353  case 292:
4354 #line 872 "parser.y" /* yacc.c:1646 */
4355  { (yyval.ifref_list) = NULL; }
4356 #line 4357 "parser.tab.c" /* yacc.c:1646 */
4357  break;
4358 
4359  case 293:
4360 #line 873 "parser.y" /* yacc.c:1646 */
4361  { (yyval.ifref_list) = append_ifref( (yyvsp[-1].ifref_list), (yyvsp[0].ifref) ); }
4362 #line 4363 "parser.tab.c" /* yacc.c:1646 */
4363  break;
4364 
4365  case 294:
4366 #line 877 "parser.y" /* yacc.c:1646 */
4367  { (yyval.ifref) = make_ifref((yyvsp[0].type)); (yyval.ifref)->attrs = (yyvsp[-1].attr_list); }
4368 #line 4369 "parser.tab.c" /* yacc.c:1646 */
4369  break;
4370 
4371  case 295:
4372 #line 880 "parser.y" /* yacc.c:1646 */
4373  { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); }
4374 #line 4375 "parser.tab.c" /* yacc.c:1646 */
4375  break;
4376 
4377  case 296:
4378 #line 881 "parser.y" /* yacc.c:1646 */
4379  { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); }
4380 #line 4381 "parser.tab.c" /* yacc.c:1646 */
4381  break;
4382 
4383  case 297:
4384 #line 884 "parser.y" /* yacc.c:1646 */
4385  { attr_t *attrs;
4386  (yyval.type) = (yyvsp[0].type);
4387  check_def((yyval.type));
4388  attrs = make_attr(ATTR_DISPINTERFACE);
4389  (yyval.type)->attrs = append_attr( check_dispiface_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list)), attrs );
4390  (yyval.type)->defined = TRUE;
4391  }
4392 #line 4393 "parser.tab.c" /* yacc.c:1646 */
4393  break;
4394 
4395  case 298:
4396 #line 893 "parser.y" /* yacc.c:1646 */
4397  { (yyval.var_list) = NULL; }
4398 #line 4399 "parser.tab.c" /* yacc.c:1646 */
4399  break;
4400 
4401  case 299:
4402 #line 894 "parser.y" /* yacc.c:1646 */
4403  { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); }
4404 #line 4405 "parser.tab.c" /* yacc.c:1646 */
4405  break;
4406 
4407  case 300:
4408 #line 897 "parser.y" /* yacc.c:1646 */
4409  { (yyval.var_list) = NULL; }
4410 #line 4411 "parser.tab.c" /* yacc.c:1646 */
4411  break;
4412 
4413  case 301:
4414 #line 898 "parser.y" /* yacc.c:1646 */
4415  { (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[-1].var) ); }
4416 #line 4417 "parser.tab.c" /* yacc.c:1646 */
4417  break;
4418 
4419  case 302:
4420 #line 904 "parser.y" /* yacc.c:1646 */
4421  { (yyval.type) = (yyvsp[-4].type);
4422  type_dispinterface_define((yyval.type), (yyvsp[-2].var_list), (yyvsp[-1].var_list));
4423  }
4424 #line 4425 "parser.tab.c" /* yacc.c:1646 */
4425  break;
4426 
4427  case 303:
4428 #line 908 "parser.y" /* yacc.c:1646 */
4429  { (yyval.type) = (yyvsp[-4].type);
4430  type_dispinterface_define_from_iface((yyval.type), (yyvsp[-2].type));
4431  }
4432 #line 4433 "parser.tab.c" /* yacc.c:1646 */
4433  break;
4434 
4435  case 304:
4436 #line 913 "parser.y" /* yacc.c:1646 */
4437  { (yyval.type) = NULL; }
4438 #line 4439 "parser.tab.c" /* yacc.c:1646 */
4439  break;
4440 
4441  case 305:
4442 #line 914 "parser.y" /* yacc.c:1646 */
4443  { (yyval.type) = find_type_or_error2((yyvsp[0].str), 0); }
4444 #line 4445 "parser.tab.c" /* yacc.c:1646 */
4445  break;
4446 
4447  case 306:
4448 #line 917 "parser.y" /* yacc.c:1646 */
4449  { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); }
4450 #line 4451 "parser.tab.c" /* yacc.c:1646 */
4451  break;
4452 
4453  case 307:
4454 #line 918 "parser.y" /* yacc.c:1646 */
4455  { (yyval.type) = get_type(TYPE_INTERFACE, (yyvsp[0].str), current_namespace, 0); }
4456 #line 4457 "parser.tab.c" /* yacc.c:1646 */
4457  break;
4458 
4459  case 308:
4460 #line 921 "parser.y" /* yacc.c:1646 */
4461  { (yyval.ifinfo).interface = (yyvsp[0].type);
4462  (yyval.ifinfo).old_pointer_default = pointer_default;
4463  if (is_attr((yyvsp[-1].attr_list), ATTR_POINTERDEFAULT))
4464  pointer_default = get_attrv((yyvsp[-1].attr_list), ATTR_POINTERDEFAULT);
4465  check_def((yyvsp[0].type));
4466  (yyvsp[0].type)->attrs = check_iface_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list));
4467  (yyvsp[0].type)->defined = TRUE;
4468  }
4469 #line 4470 "parser.tab.c" /* yacc.c:1646 */
4470  break;
4471 
4472  case 309:
4473 #line 932 "parser.y" /* yacc.c:1646 */
4474  { (yyval.type) = (yyvsp[-5].ifinfo).interface;
4475  if((yyval.type) == (yyvsp[-4].type))
4476  error_loc("Interface can't inherit from itself\n");
4477  type_interface_define((yyval.type), (yyvsp[-4].type), (yyvsp[-2].stmt_list));
4478  check_async_uuid((yyval.type));
4479  pointer_default = (yyvsp[-5].ifinfo).old_pointer_default;
4480  }
4481 #line 4482 "parser.tab.c" /* yacc.c:1646 */
4482  break;
4483 
4484  case 310:
4485 #line 943 "parser.y" /* yacc.c:1646 */
4486  { (yyval.type) = (yyvsp[-7].ifinfo).interface;
4487  type_interface_define((yyval.type), find_type_or_error2((yyvsp[-5].str), 0), (yyvsp[-2].stmt_list));
4488  pointer_default = (yyvsp[-7].ifinfo).old_pointer_default;
4489  }
4490 #line 4491 "parser.tab.c" /* yacc.c:1646 */
4491  break;
4492 
4493  case 311:
4494 #line 947 "parser.y" /* yacc.c:1646 */
4495  { (yyval.type) = (yyvsp[-1].type); }
4496 #line 4497 "parser.tab.c" /* yacc.c:1646 */
4497  break;
4498 
4499  case 312:
4500 #line 951 "parser.y" /* yacc.c:1646 */
4501  { (yyval.type) = (yyvsp[-1].type); }
4502 #line 4503 "parser.tab.c" /* yacc.c:1646 */
4503  break;
4504 
4505  case 313:
4506 #line 952 "parser.y" /* yacc.c:1646 */
4507  { (yyval.type) = (yyvsp[-1].type); }
4508 #line 4509 "parser.tab.c" /* yacc.c:1646 */
4509  break;
4510 
4511  case 314:
4512 #line 955 "parser.y" /* yacc.c:1646 */
4513  { (yyval.type) = type_new_module((yyvsp[0].str)); }
4514 #line 4515 "parser.tab.c" /* yacc.c:1646 */
4515  break;
4516 
4517  case 315:
4518 #line 956 "parser.y" /* yacc.c:1646 */
4519  { (yyval.type) = type_new_module((yyvsp[0].str)); }
4520 #line 4521 "parser.tab.c" /* yacc.c:1646 */
4521  break;
4522 
4523  case 316:
4524 #line 959 "parser.y" /* yacc.c:1646 */
4525  { (yyval.type) = (yyvsp[0].type);
4526  (yyval.type)->attrs = check_module_attrs((yyvsp[0].type)->name, (yyvsp[-1].attr_list));
4527  }
4528 #line 4529 "parser.tab.c" /* yacc.c:1646 */
4529  break;
4530 
4531  case 317:
4532 #line 965 "parser.y" /* yacc.c:1646 */
4533  { (yyval.type) = (yyvsp[-4].type);
4534  type_module_define((yyval.type), (yyvsp[-2].stmt_list));
4535  }
4536 #line 4537 "parser.tab.c" /* yacc.c:1646 */
4537  break;
4538 
4539  case 318:
4540 #line 971 "parser.y" /* yacc.c:1646 */
4541  { (yyval.stgclass) = STG_EXTERN; }
4542 #line 4543 "parser.tab.c" /* yacc.c:1646 */
4543  break;
4544 
4545  case 319:
4546 #line 972 "parser.y" /* yacc.c:1646 */
4547  { (yyval.stgclass) = STG_STATIC; }
4548 #line 4549 "parser.tab.c" /* yacc.c:1646 */
4549  break;
4550 
4551  case 320:
4552 #line 973 "parser.y" /* yacc.c:1646 */
4553  { (yyval.stgclass) = STG_REGISTER; }
4554 #line 4555 "parser.tab.c" /* yacc.c:1646 */
4555  break;
4556 
4557  case 321:
4558 #line 977 "parser.y" /* yacc.c:1646 */
4559  { (yyval.attr) = make_attr(ATTR_INLINE); }
4560 #line 4561 "parser.tab.c" /* yacc.c:1646 */
4561  break;
4562 
4563  case 322:
4564 #line 981 "parser.y" /* yacc.c:1646 */
4565  { (yyval.attr) = make_attr(ATTR_CONST); }
4566 #line 4567 "parser.tab.c" /* yacc.c:1646 */
4567  break;
4568 
4569  case 323:
4570 #line 984 "parser.y" /* yacc.c:1646 */
4571  { (yyval.attr_list) = NULL; }
4572 #line 4573 "parser.tab.c" /* yacc.c:1646 */
4573  break;
4574 
4575  case 324:
4576 #line 985 "parser.y" /* yacc.c:1646 */
4577  { (yyval.attr_list) = append_attr((yyvsp[-1].attr_list), (yyvsp[0].attr)); }
4578 #line 4579 "parser.tab.c" /* yacc.c:1646 */
4579  break;
4580 
4581  case 325:
4582 #line 988 "parser.y" /* yacc.c:1646 */
4583  { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[0].declspec), NULL, NULL, STG_NONE); }
4584 #line 4585 "parser.tab.c" /* yacc.c:1646 */
4585  break;
4586 
4587  case 326:
4588 #line 990 "parser.y" /* yacc.c:1646 */
4589  { (yyval.declspec) = make_decl_spec((yyvsp[-1].type), (yyvsp[-2].declspec), (yyvsp[0].declspec), NULL, STG_NONE); }
4590 #line 4591 "parser.tab.c" /* yacc.c:1646 */
4591  break;
4592 
4593  case 327:
4594 #line 993 "parser.y" /* yacc.c:1646 */
4595  { (yyval.declspec) = NULL; }
4596 #line 4597 "parser.tab.c" /* yacc.c:1646 */
4597  break;
4598 
4599  case 329:
4600 #line 998 "parser.y" /* yacc.c:1646 */
4601  { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); }
4602 #line 4603 "parser.tab.c" /* yacc.c:1646 */
4603  break;
4604 
4605  case 330:
4606 #line 999 "parser.y" /* yacc.c:1646 */
4607  { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, (yyvsp[-1].attr), STG_NONE); }
4608 #line 4609 "parser.tab.c" /* yacc.c:1646 */
4609  break;
4610 
4611  case 331:
4612 #line 1000 "parser.y" /* yacc.c:1646 */
4613  { (yyval.declspec) = make_decl_spec(NULL, (yyvsp[0].declspec), NULL, NULL, (yyvsp[-1].stgclass)); }
4614 #line 4615 "parser.tab.c" /* yacc.c:1646 */
4615  break;
4616 
4617  case 332:
4618 #line 1005 "parser.y" /* yacc.c:1646 */
4619  { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); }
4620 #line 4621 "parser.tab.c" /* yacc.c:1646 */
4621  break;
4622 
4623  case 333:
4624 #line 1006 "parser.y" /* yacc.c:1646 */
4625  { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str)));
4626  else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); }
4627 #line 4628 "parser.tab.c" /* yacc.c:1646 */
4628  break;
4629 
4630  case 335:
4631 #line 1012 "parser.y" /* yacc.c:1646 */
4632  { (yyval.declarator) = make_declarator((yyvsp[0].var)); }
4633 #line 4634 "parser.tab.c" /* yacc.c:1646 */
4634  break;
4635 
4636  case 336:
4637 #line 1013 "parser.y" /* yacc.c:1646 */
4638  { (yyval.declarator) = (yyvsp[-1].declarator); }
4639 #line 4640 "parser.tab.c" /* yacc.c:1646 */
4640  break;
4641 
4642  case 337:
4643 #line 1014 "parser.y" /* yacc.c:1646 */
4644  { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); }
4645 #line 4646 "parser.tab.c" /* yacc.c:1646 */
4646  break;
4647 
4648  case 338:
4649 #line 1015 "parser.y" /* yacc.c:1646 */
4650  { (yyval.declarator) = (yyvsp[-3].declarator);
4651  (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list)));
4652  (yyval.declarator)->type = NULL;
4653  }
4654 #line 4655 "parser.tab.c" /* yacc.c:1646 */
4655  break;
4656 
4657  case 339:
4658 #line 1024 "parser.y" /* yacc.c:1646 */
4659  { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); }
4660 #line 4661 "parser.tab.c" /* yacc.c:1646 */
4661  break;
4662 
4663  case 340:
4664 #line 1025 "parser.y" /* yacc.c:1646 */
4665  { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str)));
4666  else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); }
4667 #line 4668 "parser.tab.c" /* yacc.c:1646 */
4668  break;
4669 
4670  case 342:
4671 #line 1033 "parser.y" /* yacc.c:1646 */
4672  { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); }
4673 #line 4674 "parser.tab.c" /* yacc.c:1646 */
4674  break;
4675 
4676  case 343:
4677 #line 1034 "parser.y" /* yacc.c:1646 */
4678  { (yyval.declarator) = (yyvsp[0].declarator); if ((yyval.declarator)->func_type) (yyval.declarator)->func_type->attrs = append_attr((yyval.declarator)->func_type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str)));
4679  else if ((yyval.declarator)->type) (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); }
4680 #line 4681 "parser.tab.c" /* yacc.c:1646 */
4681  break;
4682 
4683  case 344:
4684 #line 1039 "parser.y" /* yacc.c:1646 */
4685  { (yyval.declarator) = make_declarator(NULL); }
4686 #line 4687 "parser.tab.c" /* yacc.c:1646 */
4687  break;
4688 
4689  case 346:
4690 #line 1045 "parser.y" /* yacc.c:1646 */
4691  { (yyval.declarator) = (yyvsp[-1].declarator); }
4692 #line 4693 "parser.tab.c" /* yacc.c:1646 */
4693  break;
4694 
4695  case 347:
4696 #line 1046 "parser.y" /* yacc.c:1646 */
4697  { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); }
4698 #line 4699 "parser.tab.c" /* yacc.c:1646 */
4699  break;
4700 
4701  case 348:
4702 #line 1047 "parser.y" /* yacc.c:1646 */
4703  { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); }
4704 #line 4705 "parser.tab.c" /* yacc.c:1646 */
4705  break;
4706 
4707  case 349:
4708 #line 1049 "parser.y" /* yacc.c:1646 */
4709  { (yyval.declarator) = make_declarator(NULL);
4710  (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list)));
4711  (yyval.declarator)->type = NULL;
4712  }
4713 #line 4714 "parser.tab.c" /* yacc.c:1646 */
4714  break;
4715 
4716  case 350:
4717 #line 1054 "parser.y" /* yacc.c:1646 */
4718  { (yyval.declarator) = (yyvsp[-3].declarator);
4719  (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list)));
4720  (yyval.declarator)->type = NULL;
4721  }
4722 #line 4723 "parser.tab.c" /* yacc.c:1646 */
4723  break;
4724 
4725  case 351:
4726 #line 1063 "parser.y" /* yacc.c:1646 */
4727  { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); }
4728 #line 4729 "parser.tab.c" /* yacc.c:1646 */
4729  break;
4730 
4731  case 352:
4732 #line 1064 "parser.y" /* yacc.c:1646 */
4733  { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); }
4734 #line 4735 "parser.tab.c" /* yacc.c:1646 */
4735  break;
4736 
4737  case 354:
4738 #line 1071 "parser.y" /* yacc.c:1646 */
4739  { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type = append_chain_type((yyval.declarator)->type, type_new_pointer(pointer_default, NULL, (yyvsp[-1].attr_list))); }
4740 #line 4741 "parser.tab.c" /* yacc.c:1646 */
4741  break;
4742 
4743  case 355:
4744 #line 1072 "parser.y" /* yacc.c:1646 */
4745  { (yyval.declarator) = (yyvsp[0].declarator); (yyval.declarator)->type->attrs = append_attr((yyval.declarator)->type->attrs, make_attrp(ATTR_CALLCONV, (yyvsp[-1].str))); }
4746 #line 4747 "parser.tab.c" /* yacc.c:1646 */
4747  break;
4748 
4749  case 356:
4750 #line 1076 "parser.y" /* yacc.c:1646 */
4751  { (yyval.declarator) = make_declarator(NULL); }
4752 #line 4753 "parser.tab.c" /* yacc.c:1646 */
4753  break;
4754 
4755  case 358:
4756 #line 1084 "parser.y" /* yacc.c:1646 */
4757  { (yyval.declarator) = make_declarator((yyvsp[0].var)); }
4758 #line 4759 "parser.tab.c" /* yacc.c:1646 */
4759  break;
4760 
4761  case 359:
4762 #line 1085 "parser.y" /* yacc.c:1646 */
4763  { (yyval.declarator) = (yyvsp[-1].declarator); }
4764 #line 4765 "parser.tab.c" /* yacc.c:1646 */
4765  break;
4766 
4767  case 360:
4768 #line 1086 "parser.y" /* yacc.c:1646 */
4769  { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); }
4770 #line 4771 "parser.tab.c" /* yacc.c:1646 */
4771  break;
4772 
4773  case 361:
4774 #line 1087 "parser.y" /* yacc.c:1646 */
4775  { (yyval.declarator) = make_declarator(NULL); (yyval.declarator)->type = append_array((yyval.declarator)->type, (yyvsp[0].expr)); }
4776 #line 4777 "parser.tab.c" /* yacc.c:1646 */
4777  break;
4778 
4779  case 362:
4780 #line 1089 "parser.y" /* yacc.c:1646 */
4781  { (yyval.declarator) = make_declarator(NULL);
4782  (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list)));
4783  (yyval.declarator)->type = NULL;
4784  }
4785 #line 4786 "parser.tab.c" /* yacc.c:1646 */
4786  break;
4787 
4788  case 363:
4789 #line 1094 "parser.y" /* yacc.c:1646 */
4790  { (yyval.declarator) = (yyvsp[-3].declarator);
4791  (yyval.declarator)->func_type = append_chain_type((yyval.declarator)->type, type_new_function((yyvsp[-1].var_list)));
4792  (yyval.declarator)->type = NULL;
4793  }
4794 #line 4795 "parser.tab.c" /* yacc.c:1646 */
4795  break;
4796 
4797  case 364:
4798 #line 1101 "parser.y" /* yacc.c:1646 */
4799  { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); }
4800 #line 4801 "parser.tab.c" /* yacc.c:1646 */
4801  break;
4802 
4803  case 365:
4804 #line 1102 "parser.y" /* yacc.c:1646 */
4805  { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); }
4806 #line 4807 "parser.tab.c" /* yacc.c:1646 */
4807  break;
4808 
4809  case 366:
4810 #line 1105 "parser.y" /* yacc.c:1646 */
4811  { (yyval.expr) = NULL; }
4812 #line 4813 "parser.tab.c" /* yacc.c:1646 */
4813  break;
4814 
4815  case 367:
4816 #line 1106 "parser.y" /* yacc.c:1646 */
4817  { (yyval.expr) = (yyvsp[0].expr); }
4818 #line 4819 "parser.tab.c" /* yacc.c:1646 */
4819  break;
4820 
4821  case 368:
4822 #line 1109 "parser.y" /* yacc.c:1646 */
4823  { (yyval.declarator) = (yyvsp[-1].declarator); (yyval.declarator)->bits = (yyvsp[0].expr);
4824  if (!(yyval.declarator)->bits && !(yyval.declarator)->var->name)
4825  error_loc("unnamed fields are not allowed\n");
4826  }
4827 #line 4828 "parser.tab.c" /* yacc.c:1646 */
4828  break;
4829 
4830  case 369:
4831 #line 1116 "parser.y" /* yacc.c:1646 */
4832  { (yyval.declarator_list) = append_declarator( NULL, (yyvsp[0].declarator) ); }
4833 #line 4834 "parser.tab.c" /* yacc.c:1646 */
4834  break;
4835 
4836  case 370:
4837 #line 1118 "parser.y" /* yacc.c:1646 */
4838  { (yyval.declarator_list) = append_declarator( (yyvsp[-2].declarator_list), (yyvsp[0].declarator) ); }
4839 #line 4840 "parser.tab.c" /* yacc.c:1646 */
4840  break;
4841 
4842  case 371:
4843 #line 1122 "parser.y" /* yacc.c:1646 */
4844  { (yyval.declarator) = (yyvsp[0].declarator); }
4845 #line 4846 "parser.tab.c" /* yacc.c:1646 */
4846  break;
4847 
4848  case 372:
4849 #line 1123 "parser.y" /* yacc.c:1646 */
4850  { (yyval.declarator) = (yyvsp[-2].declarator); (yyvsp[-2].declarator)->var->eval = (yyvsp[0].expr); }
4851 #line 4852 "parser.tab.c" /* yacc.c:1646 */
4852  break;
4853 
4854  case 373:
4855 #line 1127 "parser.y" /* yacc.c:1646 */
4856  { (yyval.num) = THREADING_APARTMENT; }
4857 #line 4858 "parser.tab.c" /* yacc.c:1646 */
4858  break;
4859 
4860  case 374:
4861 #line 1128 "parser.y" /* yacc.c:1646 */
4862  { (yyval.num) = THREADING_NEUTRAL; }
4863 #line 4864 "parser.tab.c" /* yacc.c:1646 */
4864  break;
4865 
4866  case 375:
4867 #line 1129 "parser.y" /* yacc.c:1646 */
4868  { (yyval.num) = THREADING_SINGLE; }
4869 #line 4870 "parser.tab.c" /* yacc.c:1646 */
4870  break;
4871 
4872  case 376:
4873 #line 1130 "parser.y" /* yacc.c:1646 */
4874  { (yyval.num) = THREADING_FREE; }
4875 #line 4876 "parser.tab.c" /* yacc.c:1646 */
4876  break;
4877 
4878  case 377:
4879 #line 1131 "parser.y" /* yacc.c:1646 */
4880  { (yyval.num) = THREADING_BOTH; }
4881 #line 4882 "parser.tab.c" /* yacc.c:1646 */
4882  break;
4883 
4884  case 378:
4885 #line 1135 "parser.y" /* yacc.c:1646 */
4886  { (yyval.num) = FC_RP; }
4887 #line 4888 "parser.tab.c" /* yacc.c:1646 */
4888  break;
4889 
4890  case 379:
4891 #line 1136 "parser.y" /* yacc.c:1646 */
4892  { (yyval.num) = FC_UP; }
4893 #line 4894 "parser.tab.c" /* yacc.c:1646 */
4894  break;
4895 
4896  case 380:
4897 #line 1137 "parser.y" /* yacc.c:1646 */
4898  { (yyval.num) = FC_FP; }
4899 #line 4900 "parser.tab.c" /* yacc.c:1646 */
4900  break;
4901 
4902  case 381:
4903 #line 1140 "parser.y" /* yacc.c:1646 */
4904  { (yyval.type) = type_new_struct((yyvsp[-3].str), current_namespace, TRUE, (yyvsp[-1].var_list)); }
4905 #line 4906 "parser.tab.c" /* yacc.c:1646 */
4906  break;
4907 
4908  case 382:
4909 #line 1143 "parser.y" /* yacc.c:1646 */
4910  { (yyval.type) = type_new_void(); }
4911 #line 4912 "parser.tab.c" /* yacc.c:1646 */
4912  break;
4913 
4914  case 383:
4915 #line 1144 "parser.y" /* yacc.c:1646 */
4916  { (yyval.type) = find_type_or_error((yyvsp[0].str), 0); }
4917 #line 4918 "parser.tab.c" /* yacc.c:1646 */
4918  break;
4919 
4920  case 384:
4921 #line 1145 "parser.y" /* yacc.c:1646 */
4922  { (yyval.type) = (yyvsp[0].type); }
4923 #line 4924 "parser.tab.c" /* yacc.c:1646 */
4924  break;
4925 
4926  case 385:
4927 #line 1146 "parser.y" /* yacc.c:1646 */
4928  { (yyval.type) = (yyvsp[0].type); }
4929 #line 4930 "parser.tab.c" /* yacc.c:1646 */
4930  break;
4931 
4932  case 386:
4933 #line 1147 "parser.y" /* yacc.c:1646 */
4934  { (yyval.type) = type_new_enum((yyvsp[0].str), current_namespace, FALSE, NULL); }
4935 #line 4936 "parser.tab.c" /* yacc.c:1646 */
4936  break;
4937 
4938  case 387:
4939 #line 1148 "parser.y" /* yacc.c:1646 */
4940  { (yyval.type) = (yyvsp[0].type); }
4941 #line 4942 "parser.tab.c" /* yacc.c:1646 */
4942  break;
4943 
4944  case 388:
4945 #line 1149 "parser.y" /* yacc.c:1646 */
4946  { (yyval.type) = type_new_struct((yyvsp[0].str), current_namespace, FALSE, NULL); }
4947 #line 4948 "parser.tab.c" /* yacc.c:1646 */
4948  break;
4949 
4950  case 389:
4951 #line 1150 "parser.y" /* yacc.c:1646 */
4952  { (yyval.type) = (yyvsp[0].type); }
4953 #line 4954 "parser.tab.c" /* yacc.c:1646 */
4954  break;
4955 
4956  case 390:
4957 #line 1151 "parser.y" /* yacc.c:1646 */
4958  { (yyval.type) = type_new_nonencapsulated_union((yyvsp[0].str), FALSE, NULL); }
4959 #line 4960 "parser.tab.c" /* yacc.c:1646 */
4960  break;
4961 
4962  case 391:
4963 #line 1152 "parser.y" /* yacc.c:1646 */
4964  { (yyval.type) = make_safearray((yyvsp[-1].type)); }
4965 #line 4966 "parser.tab.c" /* yacc.c:1646 */
4966  break;
4967 
4968  case 392:
4969 #line 1156 "parser.y" /* yacc.c:1646 */
4970  { (yyvsp[-4].attr_list) = append_attribs((yyvsp[-4].attr_list), (yyvsp[-2].attr_list));
4971  reg_typedefs((yyvsp[-1].declspec), (yyvsp[0].declarator_list), check_typedef_attrs((yyvsp[-4].attr_list)));
4972  (yyval.statement) = make_statement_typedef((yyvsp[0].declarator_list));
4973  }
4974 #line 4975 "parser.tab.c" /* yacc.c:1646 */
4975  break;
4976 
4977  case 393:
4978 #line 1163 "parser.y" /* yacc.c:1646 */
4979  { (yyval.type) = type_new_nonencapsulated_union((yyvsp[-3].str), TRUE, (yyvsp[-1].var_list)); }
4980 #line 4981 "parser.tab.c" /* yacc.c:1646 */
4981  break;
4982 
4983  case 394:
4984 #line 1166 "parser.y" /* yacc.c:1646 */
4985  { (yyval.type) = type_new_encapsulated_union((yyvsp[-8].str), (yyvsp[-5].var), (yyvsp[-3].var), (yyvsp[-1].var_list)); }
4986 #line 4987 "parser.tab.c" /* yacc.c:1646 */
4987  break;
4988 
4989  case 395:
4990 #line 1170 "parser.y" /* yacc.c:1646 */
4991  { (yyval.num) = MAKEVERSION((yyvsp[0].num), 0); }
4992 #line 4993 "parser.tab.c" /* yacc.c:1646 */
4993  break;
4994 
4995  case 396:
4996 #line 1171 "parser.y" /* yacc.c:1646 */
4997  { (yyval.num) = MAKEVERSION((yyvsp[-2].num), (yyvsp[0].num)); }
4998 #line 4999 "parser.tab.c" /* yacc.c:1646 */
4999  break;
5000 
5001  case 397:
5002 #line 1172 "parser.y" /* yacc.c:1646 */
5003  { (yyval.num) = (yyvsp[0].num); }
5004 #line 5005 "parser.tab.c" /* yacc.c:1646 */
5005  break;
5006 
5007  case 402:
5008 #line 1185 "parser.y" /* yacc.c:1646 */
5009  { type_t *type = find_type_or_error((yyvsp[-1].str), 0);
5010  type->attrs = append_attr_list(type->attrs, (yyvsp[-2].attr_list));
5011  }
5012 #line 5013 "parser.tab.c" /* yacc.c:1646 */
5013  break;
5014 
5015  case 403:
5016 #line 1190 "parser.y" /* yacc.c:1646 */
5017  { type_t *iface = find_type_or_error2((yyvsp[-3].str), 0);
5018  if (type_get_type(iface) != TYPE_INTERFACE)
5019  error_loc("%s is not an interface\n", iface->name);
5020  iface->attrs = append_attr_list(iface->attrs, (yyvsp[-5].attr_list));
5021  }
5022