20b4648515b0310c3744203ae29bf60f4b248cec
[reactos.git] / reactos / tools / widl / parser.tab.c
1 /* A Bison parser, made by GNU Bison 2.1. */
2
3 /* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor,
19 Boston, MA 02110-1301, USA. */
20
21 /* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
25
26 /* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
28
29 /* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
35
36 /* Identify Bison output. */
37 #define YYBISON 1
38
39 /* Bison version. */
40 #define YYBISON_VERSION "2.1"
41
42 /* Skeleton name. */
43 #define YYSKELETON_NAME "yacc.c"
44
45 /* Pure parsers. */
46 #define YYPURE 0
47
48 /* Using locations. */
49 #define YYLSP_NEEDED 0
50
51 /* Substitute the variable and function names. */
52 #define yyparse parser_parse
53 #define yylex parser_lex
54 #define yyerror parser_error
55 #define yylval parser_lval
56 #define yychar parser_char
57 #define yydebug parser_debug
58 #define yynerrs parser_nerrs
59
60
61 /* Tokens. */
62 #ifndef YYTOKENTYPE
63 # define YYTOKENTYPE
64 /* Put the tokens into the symbol table, so that GDB and other debuggers
65 know about them. */
66 enum yytokentype {
67 aIDENTIFIER = 258,
68 aKNOWNTYPE = 259,
69 aNUM = 260,
70 aHEXNUM = 261,
71 aDOUBLE = 262,
72 aSTRING = 263,
73 aUUID = 264,
74 aEOF = 265,
75 SHL = 266,
76 SHR = 267,
77 tAGGREGATABLE = 268,
78 tALLOCATE = 269,
79 tAPPOBJECT = 270,
80 tASYNC = 271,
81 tASYNCUUID = 272,
82 tAUTOHANDLE = 273,
83 tBINDABLE = 274,
84 tBOOLEAN = 275,
85 tBROADCAST = 276,
86 tBYTE = 277,
87 tBYTECOUNT = 278,
88 tCALLAS = 279,
89 tCALLBACK = 280,
90 tCASE = 281,
91 tCDECL = 282,
92 tCHAR = 283,
93 tCOCLASS = 284,
94 tCODE = 285,
95 tCOMMSTATUS = 286,
96 tCONST = 287,
97 tCONTEXTHANDLE = 288,
98 tCONTEXTHANDLENOSERIALIZE = 289,
99 tCONTEXTHANDLESERIALIZE = 290,
100 tCONTROL = 291,
101 tCPPQUOTE = 292,
102 tDEFAULT = 293,
103 tDEFAULTCOLLELEM = 294,
104 tDEFAULTVALUE = 295,
105 tDEFAULTVTABLE = 296,
106 tDISPLAYBIND = 297,
107 tDISPINTERFACE = 298,
108 tDLLNAME = 299,
109 tDOUBLE = 300,
110 tDUAL = 301,
111 tENDPOINT = 302,
112 tENTRY = 303,
113 tENUM = 304,
114 tERRORSTATUST = 305,
115 tEXPLICITHANDLE = 306,
116 tEXTERN = 307,
117 tFALSE = 308,
118 tFASTCALL = 309,
119 tFLOAT = 310,
120 tHANDLE = 311,
121 tHANDLET = 312,
122 tHELPCONTEXT = 313,
123 tHELPFILE = 314,
124 tHELPSTRING = 315,
125 tHELPSTRINGCONTEXT = 316,
126 tHELPSTRINGDLL = 317,
127 tHIDDEN = 318,
128 tHYPER = 319,
129 tID = 320,
130 tIDEMPOTENT = 321,
131 tIIDIS = 322,
132 tIMMEDIATEBIND = 323,
133 tIMPLICITHANDLE = 324,
134 tIMPORT = 325,
135 tIMPORTLIB = 326,
136 tIN = 327,
137 tINLINE = 328,
138 tINPUTSYNC = 329,
139 tINT = 330,
140 tINT64 = 331,
141 tINTERFACE = 332,
142 tLCID = 333,
143 tLENGTHIS = 334,
144 tLIBRARY = 335,
145 tLOCAL = 336,
146 tLONG = 337,
147 tMETHODS = 338,
148 tMODULE = 339,
149 tNONBROWSABLE = 340,
150 tNONCREATABLE = 341,
151 tNONEXTENSIBLE = 342,
152 tOBJECT = 343,
153 tODL = 344,
154 tOLEAUTOMATION = 345,
155 tOPTIONAL = 346,
156 tOUT = 347,
157 tPASCAL = 348,
158 tPOINTERDEFAULT = 349,
159 tPROPERTIES = 350,
160 tPROPGET = 351,
161 tPROPPUT = 352,
162 tPROPPUTREF = 353,
163 tPTR = 354,
164 tPUBLIC = 355,
165 tRANGE = 356,
166 tREADONLY = 357,
167 tREF = 358,
168 tREQUESTEDIT = 359,
169 tRESTRICTED = 360,
170 tRETVAL = 361,
171 tSAFEARRAY = 362,
172 tSHORT = 363,
173 tSIGNED = 364,
174 tSINGLE = 365,
175 tSIZEIS = 366,
176 tSIZEOF = 367,
177 tSMALL = 368,
178 tSOURCE = 369,
179 tSTDCALL = 370,
180 tSTRICTCONTEXTHANDLE = 371,
181 tSTRING = 372,
182 tSTRUCT = 373,
183 tSWITCH = 374,
184 tSWITCHIS = 375,
185 tSWITCHTYPE = 376,
186 tTRANSMITAS = 377,
187 tTRUE = 378,
188 tTYPEDEF = 379,
189 tUNION = 380,
190 tUNIQUE = 381,
191 tUNSIGNED = 382,
192 tUUID = 383,
193 tV1ENUM = 384,
194 tVARARG = 385,
195 tVERSION = 386,
196 tVOID = 387,
197 tWCHAR = 388,
198 tWIREMARSHAL = 389,
199 CAST = 390,
200 PPTR = 391,
201 NEG = 392,
202 ADDRESSOF = 393
203 };
204 #endif
205 /* Tokens. */
206 #define aIDENTIFIER 258
207 #define aKNOWNTYPE 259
208 #define aNUM 260
209 #define aHEXNUM 261
210 #define aDOUBLE 262
211 #define aSTRING 263
212 #define aUUID 264
213 #define aEOF 265
214 #define SHL 266
215 #define SHR 267
216 #define tAGGREGATABLE 268
217 #define tALLOCATE 269
218 #define tAPPOBJECT 270
219 #define tASYNC 271
220 #define tASYNCUUID 272
221 #define tAUTOHANDLE 273
222 #define tBINDABLE 274
223 #define tBOOLEAN 275
224 #define tBROADCAST 276
225 #define tBYTE 277
226 #define tBYTECOUNT 278
227 #define tCALLAS 279
228 #define tCALLBACK 280
229 #define tCASE 281
230 #define tCDECL 282
231 #define tCHAR 283
232 #define tCOCLASS 284
233 #define tCODE 285
234 #define tCOMMSTATUS 286
235 #define tCONST 287
236 #define tCONTEXTHANDLE 288
237 #define tCONTEXTHANDLENOSERIALIZE 289
238 #define tCONTEXTHANDLESERIALIZE 290
239 #define tCONTROL 291
240 #define tCPPQUOTE 292
241 #define tDEFAULT 293
242 #define tDEFAULTCOLLELEM 294
243 #define tDEFAULTVALUE 295
244 #define tDEFAULTVTABLE 296
245 #define tDISPLAYBIND 297
246 #define tDISPINTERFACE 298
247 #define tDLLNAME 299
248 #define tDOUBLE 300
249 #define tDUAL 301
250 #define tENDPOINT 302
251 #define tENTRY 303
252 #define tENUM 304
253 #define tERRORSTATUST 305
254 #define tEXPLICITHANDLE 306
255 #define tEXTERN 307
256 #define tFALSE 308
257 #define tFASTCALL 309
258 #define tFLOAT 310
259 #define tHANDLE 311
260 #define tHANDLET 312
261 #define tHELPCONTEXT 313
262 #define tHELPFILE 314
263 #define tHELPSTRING 315
264 #define tHELPSTRINGCONTEXT 316
265 #define tHELPSTRINGDLL 317
266 #define tHIDDEN 318
267 #define tHYPER 319
268 #define tID 320
269 #define tIDEMPOTENT 321
270 #define tIIDIS 322
271 #define tIMMEDIATEBIND 323
272 #define tIMPLICITHANDLE 324
273 #define tIMPORT 325
274 #define tIMPORTLIB 326
275 #define tIN 327
276 #define tINLINE 328
277 #define tINPUTSYNC 329
278 #define tINT 330
279 #define tINT64 331
280 #define tINTERFACE 332
281 #define tLCID 333
282 #define tLENGTHIS 334
283 #define tLIBRARY 335
284 #define tLOCAL 336
285 #define tLONG 337
286 #define tMETHODS 338
287 #define tMODULE 339
288 #define tNONBROWSABLE 340
289 #define tNONCREATABLE 341
290 #define tNONEXTENSIBLE 342
291 #define tOBJECT 343
292 #define tODL 344
293 #define tOLEAUTOMATION 345
294 #define tOPTIONAL 346
295 #define tOUT 347
296 #define tPASCAL 348
297 #define tPOINTERDEFAULT 349
298 #define tPROPERTIES 350
299 #define tPROPGET 351
300 #define tPROPPUT 352
301 #define tPROPPUTREF 353
302 #define tPTR 354
303 #define tPUBLIC 355
304 #define tRANGE 356
305 #define tREADONLY 357
306 #define tREF 358
307 #define tREQUESTEDIT 359
308 #define tRESTRICTED 360
309 #define tRETVAL 361
310 #define tSAFEARRAY 362
311 #define tSHORT 363
312 #define tSIGNED 364
313 #define tSINGLE 365
314 #define tSIZEIS 366
315 #define tSIZEOF 367
316 #define tSMALL 368
317 #define tSOURCE 369
318 #define tSTDCALL 370
319 #define tSTRICTCONTEXTHANDLE 371
320 #define tSTRING 372
321 #define tSTRUCT 373
322 #define tSWITCH 374
323 #define tSWITCHIS 375
324 #define tSWITCHTYPE 376
325 #define tTRANSMITAS 377
326 #define tTRUE 378
327 #define tTYPEDEF 379
328 #define tUNION 380
329 #define tUNIQUE 381
330 #define tUNSIGNED 382
331 #define tUUID 383
332 #define tV1ENUM 384
333 #define tVARARG 385
334 #define tVERSION 386
335 #define tVOID 387
336 #define tWCHAR 388
337 #define tWIREMARSHAL 389
338 #define CAST 390
339 #define PPTR 391
340 #define NEG 392
341 #define ADDRESSOF 393
342
343
344
345
346 /* Copy the first part of user declarations. */
347 #line 1 "parser.y"
348
349 /*
350 * IDL Compiler
351 *
352 * Copyright 2002 Ove Kaaven
353 *
354 * This library is free software; you can redistribute it and/or
355 * modify it under the terms of the GNU Lesser General Public
356 * License as published by the Free Software Foundation; either
357 * version 2.1 of the License, or (at your option) any later version.
358 *
359 * This library is distributed in the hope that it will be useful,
360 * but WITHOUT ANY WARRANTY; without even the implied warranty of
361 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
362 * Lesser General Public License for more details.
363 *
364 * You should have received a copy of the GNU Lesser General Public
365 * License along with this library; if not, write to the Free Software
366 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
367 */
368
369 #include "config.h"
370
371 #include <stdio.h>
372 #include <stdlib.h>
373 #include <stdarg.h>
374 #include <assert.h>
375 #include <ctype.h>
376 #include <string.h>
377 #ifdef HAVE_ALLOCA_H
378 #include <alloca.h>
379 #endif
380
381 #include "widl.h"
382 #include "utils.h"
383 #include "parser.h"
384 #include "header.h"
385 #include "typelib.h"
386 #include "typegen.h"
387
388 #if defined(YYBYACC)
389 /* Berkeley yacc (byacc) doesn't seem to know about these */
390 /* Some *BSD supplied versions do define these though */
391 # ifndef YYEMPTY
392 # define YYEMPTY (-1) /* Empty lookahead value of yychar */
393 # endif
394 # ifndef YYLEX
395 # define YYLEX yylex()
396 # endif
397
398 #elif defined(YYBISON)
399 /* Bison was used for original development */
400 /* #define YYEMPTY -2 */
401 /* #define YYLEX yylex() */
402
403 #else
404 /* No yacc we know yet */
405 # if !defined(YYEMPTY) || !defined(YYLEX)
406 # error Yacc version/type unknown. This version needs to be verified for settings of YYEMPTY and YYLEX.
407 # elif defined(__GNUC__) /* gcc defines the #warning directive */
408 # warning Yacc version/type unknown. It defines YYEMPTY and YYLEX, but is not tested
409 /* #else we just take a chance that it works... */
410 # endif
411 #endif
412
413 #define YYERROR_VERBOSE
414
415 unsigned char pointer_default = RPC_FC_UP;
416 static int is_object_interface = FALSE;
417 /* are we inside a library block? */
418 static int is_inside_library = FALSE;
419
420 typedef struct list typelist_t;
421 struct typenode {
422 type_t *type;
423 struct list entry;
424 };
425
426 typelist_t incomplete_types = LIST_INIT(incomplete_types);
427
428 static void add_incomplete(type_t *t);
429 static void fix_incomplete(void);
430
431 static str_list_t *append_str(str_list_t *list, char *str);
432 static attr_list_t *append_attr(attr_list_t *list, attr_t *attr);
433 static attr_t *make_attr(enum attr_type type);
434 static attr_t *make_attrv(enum attr_type type, unsigned long val);
435 static attr_t *make_attrp(enum attr_type type, void *val);
436 static expr_t *make_expr(enum expr_type type);
437 static expr_t *make_exprl(enum expr_type type, long val);
438 static expr_t *make_exprd(enum expr_type type, double val);
439 static expr_t *make_exprs(enum expr_type type, char *val);
440 static expr_t *make_exprt(enum expr_type type, type_t *tref, expr_t *expr);
441 static expr_t *make_expr1(enum expr_type type, expr_t *expr);
442 static expr_t *make_expr2(enum expr_type type, expr_t *exp1, expr_t *exp2);
443 static expr_t *make_expr3(enum expr_type type, expr_t *expr1, expr_t *expr2, expr_t *expr3);
444 static type_t *make_type(unsigned char type, type_t *ref);
445 static expr_list_t *append_expr(expr_list_t *list, expr_t *expr);
446 static array_dims_t *append_array(array_dims_t *list, expr_t *expr);
447 static void set_type(var_t *v, type_t *type, const pident_t *pident, array_dims_t *arr, int top);
448 static ifref_list_t *append_ifref(ifref_list_t *list, ifref_t *iface);
449 static ifref_t *make_ifref(type_t *iface);
450 static var_list_t *append_var(var_list_t *list, var_t *var);
451 static var_t *make_var(char *name);
452 static pident_list_t *append_pident(pident_list_t *list, pident_t *p);
453 static pident_t *make_pident(var_t *var);
454 static func_list_t *append_func(func_list_t *list, func_t *func);
455 static func_t *make_func(var_t *def, var_list_t *args);
456 static type_t *make_class(char *name);
457 static type_t *make_safearray(type_t *type);
458 static type_t *make_builtin(char *name);
459 static type_t *make_int(int sign);
460
461 static type_t *reg_type(type_t *type, const char *name, int t);
462 static type_t *reg_typedefs(type_t *type, var_list_t *names, attr_list_t *attrs);
463 static type_t *find_type(const char *name, int t);
464 static type_t *find_type2(char *name, int t);
465 static type_t *get_type(unsigned char type, char *name, int t);
466 static type_t *get_typev(unsigned char type, var_t *name, int t);
467 static int get_struct_type(var_list_t *fields);
468
469 static var_t *reg_const(var_t *var);
470 static var_t *find_const(char *name, int f);
471
472 static void write_libid(const char *name, const attr_list_t *attr);
473 static void write_clsid(type_t *cls);
474 static void write_diid(type_t *iface);
475 static void write_iid(type_t *iface);
476
477 static int compute_method_indexes(type_t *iface);
478 static char *gen_name(void);
479 static void process_typedefs(var_list_t *names);
480 static void check_arg(var_t *arg);
481 static void check_functions(const type_t *iface);
482 static void check_all_user_types(ifref_list_t *ifaces);
483 static const attr_list_t *check_iface_attrs(const char *name, const attr_list_t *attrs);
484 static attr_list_t *check_function_attrs(const char *name, attr_list_t *attrs);
485 static attr_list_t *check_typedef_attrs(attr_list_t *attrs);
486 static attr_list_t *check_field_attrs(const char *name, attr_list_t *attrs);
487 static const attr_list_t *check_library_attrs(const char *name, const attr_list_t *attrs);
488 static attr_list_t *check_dispiface_attrs(const char *name, attr_list_t *attrs);
489 static const attr_list_t *check_module_attrs(const char *name, const attr_list_t *attrs);
490 static const attr_list_t *check_coclass_attrs(const char *name, const attr_list_t *attrs);
491 const char *get_attr_display_name(enum attr_type type);
492
493 #define tsENUM 1
494 #define tsSTRUCT 2
495 #define tsUNION 3
496
497
498
499 /* Enabling traces. */
500 #ifndef YYDEBUG
501 # define YYDEBUG 0
502 #endif
503
504 /* Enabling verbose error messages. */
505 #ifdef YYERROR_VERBOSE
506 # undef YYERROR_VERBOSE
507 # define YYERROR_VERBOSE 1
508 #else
509 # define YYERROR_VERBOSE 0
510 #endif
511
512 /* Enabling the token table. */
513 #ifndef YYTOKEN_TABLE
514 # define YYTOKEN_TABLE 0
515 #endif
516
517 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
518 #line 151 "parser.y"
519 typedef union YYSTYPE {
520 attr_t *attr;
521 attr_list_t *attr_list;
522 str_list_t *str_list;
523 expr_t *expr;
524 expr_list_t *expr_list;
525 array_dims_t *array_dims;
526 type_t *type;
527 var_t *var;
528 var_list_t *var_list;
529 pident_t *pident;
530 pident_list_t *pident_list;
531 func_t *func;
532 func_list_t *func_list;
533 ifref_t *ifref;
534 ifref_list_t *ifref_list;
535 char *str;
536 UUID *uuid;
537 unsigned int num;
538 double dbl;
539 interface_info_t ifinfo;
540 } YYSTYPE;
541 /* Line 196 of yacc.c. */
542 #line 543 "parser.tab.c"
543 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
544 # define YYSTYPE_IS_DECLARED 1
545 # define YYSTYPE_IS_TRIVIAL 1
546 #endif
547
548
549
550 /* Copy the second part of user declarations. */
551
552
553 /* Line 219 of yacc.c. */
554 #line 555 "parser.tab.c"
555
556 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
557 # define YYSIZE_T __SIZE_TYPE__
558 #endif
559 #if ! defined (YYSIZE_T) && defined (size_t)
560 # define YYSIZE_T size_t
561 #endif
562 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
563 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
564 # define YYSIZE_T size_t
565 #endif
566 #if ! defined (YYSIZE_T)
567 # define YYSIZE_T unsigned int
568 #endif
569
570 #ifndef YY_
571 # if YYENABLE_NLS
572 # if ENABLE_NLS
573 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
574 # define YY_(msgid) dgettext ("bison-runtime", msgid)
575 # endif
576 # endif
577 # ifndef YY_
578 # define YY_(msgid) msgid
579 # endif
580 #endif
581
582 #if ! defined (yyoverflow) || YYERROR_VERBOSE
583
584 /* The parser invokes alloca or malloc; define the necessary symbols. */
585
586 # ifdef YYSTACK_USE_ALLOCA
587 # if YYSTACK_USE_ALLOCA
588 # ifdef __GNUC__
589 # define YYSTACK_ALLOC __builtin_alloca
590 # else
591 # define YYSTACK_ALLOC alloca
592 # if defined (__STDC__) || defined (__cplusplus)
593 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
594 # define YYINCLUDED_STDLIB_H
595 # endif
596 # endif
597 # endif
598 # endif
599
600 # ifdef YYSTACK_ALLOC
601 /* Pacify GCC's `empty if-body' warning. */
602 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
603 # ifndef YYSTACK_ALLOC_MAXIMUM
604 /* The OS might guarantee only one guard page at the bottom of the stack,
605 and a page size can be as small as 4096 bytes. So we cannot safely
606 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
607 to allow for a few compiler-allocated temporary stack slots. */
608 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
609 # endif
610 # else
611 # define YYSTACK_ALLOC YYMALLOC
612 # define YYSTACK_FREE YYFREE
613 # ifndef YYSTACK_ALLOC_MAXIMUM
614 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
615 # endif
616 # ifdef __cplusplus
617 extern "C" {
618 # endif
619 # ifndef YYMALLOC
620 # define YYMALLOC malloc
621 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
622 && (defined (__STDC__) || defined (__cplusplus)))
623 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
624 # endif
625 # endif
626 # ifndef YYFREE
627 # define YYFREE free
628 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
629 && (defined (__STDC__) || defined (__cplusplus)))
630 void free (void *); /* INFRINGES ON USER NAME SPACE */
631 # endif
632 # endif
633 # ifdef __cplusplus
634 }
635 # endif
636 # endif
637 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
638
639
640 #if (! defined (yyoverflow) \
641 && (! defined (__cplusplus) \
642 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
643
644 /* A type that is properly aligned for any stack member. */
645 union yyalloc
646 {
647 short int yyss;
648 YYSTYPE yyvs;
649 };
650
651 /* The size of the maximum gap between one aligned stack and the next. */
652 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
653
654 /* The size of an array large to enough to hold all stacks, each with
655 N elements. */
656 # define YYSTACK_BYTES(N) \
657 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
658 + YYSTACK_GAP_MAXIMUM)
659
660 /* Copy COUNT objects from FROM to TO. The source and destination do
661 not overlap. */
662 # ifndef YYCOPY
663 # if defined (__GNUC__) && 1 < __GNUC__
664 # define YYCOPY(To, From, Count) \
665 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
666 # else
667 # define YYCOPY(To, From, Count) \
668 do \
669 { \
670 YYSIZE_T yyi; \
671 for (yyi = 0; yyi < (Count); yyi++) \
672 (To)[yyi] = (From)[yyi]; \
673 } \
674 while (0)
675 # endif
676 # endif
677
678 /* Relocate STACK from its old location to the new one. The
679 local variables YYSIZE and YYSTACKSIZE give the old and new number of
680 elements in the stack, and YYPTR gives the new location of the
681 stack. Advance YYPTR to a properly aligned location for the next
682 stack. */
683 # define YYSTACK_RELOCATE(Stack) \
684 do \
685 { \
686 YYSIZE_T yynewbytes; \
687 YYCOPY (&yyptr->Stack, Stack, yysize); \
688 Stack = &yyptr->Stack; \
689 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
690 yyptr += yynewbytes / sizeof (*yyptr); \
691 } \
692 while (0)
693
694 #endif
695
696 #if defined (__STDC__) || defined (__cplusplus)
697 typedef signed char yysigned_char;
698 #else
699 typedef short int yysigned_char;
700 #endif
701
702 /* YYFINAL -- State number of the termination state. */
703 #define YYFINAL 3
704 /* YYLAST -- Last index in YYTABLE. */
705 #define YYLAST 1042
706
707 /* YYNTOKENS -- Number of terminals. */
708 #define YYNTOKENS 158
709 /* YYNNTS -- Number of nonterminals. */
710 #define YYNNTS 78
711 /* YYNRULES -- Number of rules. */
712 #define YYNRULES 278
713 /* YYNRULES -- Number of states. */
714 #define YYNSTATES 507
715
716 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
717 #define YYUNDEFTOK 2
718 #define YYMAXUTOK 393
719
720 #define YYTRANSLATE(YYX) \
721 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
722
723 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
724 static const unsigned char yytranslate[] =
725 {
726 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
727 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
728 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
729 2, 2, 2, 2, 2, 2, 2, 2, 139, 2,
730 150, 151, 142, 141, 135, 140, 157, 143, 2, 2,
731 2, 2, 2, 2, 2, 2, 2, 2, 137, 149,
732 2, 156, 2, 136, 2, 2, 2, 2, 2, 2,
733 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
734 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
735 2, 154, 2, 155, 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, 152, 138, 153, 144, 2, 2, 2,
739 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
740 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
741 2, 2, 2, 2, 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, 2, 2, 2, 2, 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, 2, 2, 2, 2, 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, 1, 2, 3, 4,
752 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
753 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
754 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
755 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
756 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
757 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
758 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
759 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
760 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
761 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
762 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
763 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
764 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
765 145, 146, 147, 148
766 };
767
768 #if YYDEBUG
769 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
770 YYRHS. */
771 static const unsigned short int yyprhs[] =
772 {
773 0, 0, 3, 5, 6, 9, 12, 16, 19, 22,
774 25, 28, 29, 32, 35, 39, 42, 45, 48, 51,
775 54, 55, 59, 62, 63, 65, 68, 70, 73, 76,
776 78, 81, 84, 87, 92, 96, 100, 106, 109, 113,
777 118, 119, 121, 123, 125, 129, 131, 136, 140, 141,
778 145, 149, 151, 155, 160, 161, 163, 167, 169, 173,
779 178, 180, 184, 185, 187, 189, 191, 193, 195, 197,
780 202, 207, 209, 211, 213, 215, 217, 219, 224, 229,
781 231, 233, 238, 240, 245, 250, 255, 257, 259, 264,
782 269, 274, 279, 284, 286, 291, 293, 298, 300, 306,
783 308, 310, 315, 317, 319, 321, 323, 325, 327, 329,
784 331, 333, 338, 340, 342, 344, 346, 353, 355, 357,
785 359, 361, 366, 368, 370, 372, 377, 382, 387, 392,
786 394, 396, 401, 406, 408, 410, 412, 414, 416, 418,
787 420, 421, 424, 429, 433, 439, 440, 443, 445, 447,
788 451, 455, 457, 463, 465, 469, 470, 472, 474, 476,
789 478, 480, 482, 484, 490, 494, 498, 502, 506, 510,
790 514, 518, 522, 525, 528, 531, 534, 539, 544, 548,
791 550, 554, 556, 561, 562, 565, 568, 572, 575, 577,
792 582, 586, 587, 589, 590, 592, 594, 596, 598, 600,
793 602, 604, 607, 610, 612, 614, 616, 618, 620, 622,
794 624, 625, 627, 629, 632, 634, 637, 640, 642, 644,
795 647, 650, 653, 659, 660, 663, 666, 669, 672, 675,
796 678, 682, 685, 689, 695, 701, 702, 705, 708, 711,
797 714, 721, 730, 733, 736, 739, 742, 745, 748, 754,
798 757, 760, 763, 765, 770, 772, 776, 778, 780, 784,
799 786, 788, 790, 796, 798, 800, 802, 805, 807, 810,
800 812, 815, 817, 820, 825, 830, 836, 847, 849
801 };
802
803 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
804 static const short int yyrhs[] =
805 {
806 159, 0, -1, 160, -1, -1, 160, 222, -1, 160,
807 221, -1, 160, 208, 149, -1, 160, 210, -1, 160,
808 225, -1, 160, 171, -1, 160, 164, -1, -1, 161,
809 222, -1, 161, 221, -1, 161, 208, 149, -1, 161,
810 210, -1, 161, 225, -1, 161, 164, -1, 161, 168,
811 -1, 161, 171, -1, -1, 162, 201, 149, -1, 162,
812 164, -1, -1, 149, -1, 187, 149, -1, 165, -1,
813 191, 149, -1, 197, 149, -1, 167, -1, 231, 149,
814 -1, 233, 149, -1, 234, 149, -1, 37, 150, 8,
815 151, -1, 70, 8, 149, -1, 166, 161, 10, -1,
816 71, 150, 8, 151, 163, -1, 80, 3, -1, 179,
817 169, 152, -1, 170, 161, 153, 163, -1, -1, 174,
818 -1, 132, -1, 175, -1, 174, 135, 175, -1, 173,
819 -1, 179, 232, 226, 176, -1, 232, 226, 176, -1,
820 -1, 154, 177, 155, -1, 154, 142, 155, -1, 193,
821 -1, 177, 135, 194, -1, 177, 155, 154, 194, -1,
822 -1, 179, -1, 154, 180, 155, -1, 182, -1, 180,
823 135, 182, -1, 180, 155, 154, 182, -1, 8, -1,
824 181, 135, 8, -1, -1, 13, -1, 15, -1, 16,
825 -1, 18, -1, 19, -1, 21, -1, 24, 150, 204,
826 151, -1, 26, 150, 195, 151, -1, 33, -1, 34,
827 -1, 35, -1, 36, -1, 38, -1, 39, -1, 40,
828 150, 196, 151, -1, 40, 150, 8, 151, -1, 41,
829 -1, 42, -1, 44, 150, 8, 151, -1, 46, -1,
830 47, 150, 181, 151, -1, 48, 150, 8, 151, -1,
831 48, 150, 196, 151, -1, 51, -1, 56, -1, 58,
832 150, 196, 151, -1, 59, 150, 8, 151, -1, 60,
833 150, 8, 151, -1, 61, 150, 196, 151, -1, 62,
834 150, 8, 151, -1, 63, -1, 65, 150, 196, 151,
835 -1, 66, -1, 67, 150, 194, 151, -1, 68, -1,
836 69, 150, 57, 3, 151, -1, 72, -1, 74, -1,
837 79, 150, 192, 151, -1, 81, -1, 85, -1, 86,
838 -1, 87, -1, 88, -1, 89, -1, 90, -1, 91,
839 -1, 92, -1, 94, 150, 230, 151, -1, 96, -1,
840 97, -1, 98, -1, 100, -1, 101, 150, 196, 135,
841 196, 151, -1, 102, -1, 104, -1, 105, -1, 106,
842 -1, 111, 150, 192, 151, -1, 114, -1, 116, -1,
843 117, -1, 120, 150, 194, 151, -1, 121, 150, 232,
844 151, -1, 122, 150, 232, 151, -1, 128, 150, 183,
845 151, -1, 129, -1, 130, -1, 131, 150, 235, 151,
846 -1, 134, 150, 232, 151, -1, 230, -1, 9, -1,
847 8, -1, 27, -1, 54, -1, 93, -1, 115, -1,
848 -1, 185, 186, -1, 26, 194, 137, 199, -1, 38,
849 137, 199, -1, 32, 232, 204, 156, 196, -1, -1,
850 189, 135, -1, 189, -1, 190, -1, 189, 135, 190,
851 -1, 204, 156, 196, -1, 204, -1, 49, 203, 152,
852 188, 153, -1, 193, -1, 192, 135, 193, -1, -1,
853 194, -1, 5, -1, 6, -1, 7, -1, 53, -1,
854 123, -1, 3, -1, 194, 136, 194, 137, 194, -1,
855 194, 138, 194, -1, 194, 139, 194, -1, 194, 141,
856 194, -1, 194, 140, 194, -1, 194, 142, 194, -1,
857 194, 143, 194, -1, 194, 11, 194, -1, 194, 12,
858 194, -1, 144, 194, -1, 140, 194, -1, 139, 194,
859 -1, 142, 194, -1, 150, 232, 151, 194, -1, 112,
860 150, 232, 151, -1, 150, 194, 151, -1, 196, -1,
861 195, 135, 196, -1, 194, -1, 52, 32, 232, 204,
862 -1, -1, 198, 199, -1, 200, 149, -1, 178, 234,
863 149, -1, 179, 149, -1, 149, -1, 178, 232, 226,
864 176, -1, 178, 232, 226, -1, -1, 204, -1, -1,
865 3, -1, 4, -1, 3, -1, 4, -1, 22, -1,
866 133, -1, 207, -1, 109, 207, -1, 127, 207, -1,
867 127, -1, 55, -1, 110, -1, 45, -1, 20, -1,
868 50, -1, 57, -1, -1, 75, -1, 75, -1, 108,
869 206, -1, 113, -1, 82, 206, -1, 64, 206, -1,
870 76, -1, 28, -1, 29, 3, -1, 29, 4, -1,
871 179, 208, -1, 209, 152, 211, 153, 163, -1, -1,
872 211, 212, -1, 178, 222, -1, 43, 3, -1, 43,
873 4, -1, 179, 213, -1, 95, 137, -1, 215, 200,
874 149, -1, 83, 137, -1, 216, 201, 149, -1, 214,
875 152, 215, 216, 153, -1, 214, 152, 219, 149, 153,
876 -1, -1, 137, 4, -1, 77, 3, -1, 77, 4,
877 -1, 179, 219, -1, 220, 218, 152, 162, 153, 163,
878 -1, 220, 137, 3, 152, 167, 162, 153, 163, -1,
879 217, 163, -1, 219, 149, -1, 213, 149, -1, 84,
880 3, -1, 84, 4, -1, 179, 223, -1, 224, 152,
881 162, 153, 163, -1, 142, 226, -1, 32, 226, -1,
882 184, 226, -1, 228, -1, 228, 150, 172, 151, -1,
883 204, -1, 150, 226, 151, -1, 227, -1, 226, -1,
884 229, 135, 226, -1, 103, -1, 126, -1, 99, -1,
885 118, 203, 152, 198, 153, -1, 132, -1, 4, -1,
886 205, -1, 32, 232, -1, 191, -1, 49, 3, -1,
887 231, -1, 118, 3, -1, 234, -1, 125, 3, -1,
888 107, 150, 232, 151, -1, 124, 178, 232, 229, -1,
889 125, 203, 152, 198, 153, -1, 125, 203, 119, 150,
890 200, 151, 202, 152, 185, 153, -1, 5, -1, 5,
891 157, 5, -1
892 };
893
894 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
895 static const unsigned short int yyrline[] =
896 {
897 0, 304, 304, 313, 314, 315, 316, 320, 325, 326,
898 327, 330, 331, 332, 333, 334, 338, 339, 340, 341,
899 344, 345, 346, 349, 350, 353, 354, 355, 360, 361,
900 362, 367, 368, 375, 377, 383, 387, 391, 393, 400,
901 404, 405, 408, 411, 412, 413, 417, 422, 428, 429,
902 430, 433, 434, 435, 438, 439, 443, 449, 450, 451,
903 454, 455, 458, 459, 460, 461, 462, 463, 464, 465,
904 466, 467, 468, 469, 470, 471, 472, 473, 474, 475,
905 476, 477, 478, 479, 480, 481, 482, 483, 484, 485,
906 486, 487, 488, 489, 490, 491, 492, 493, 494, 495,
907 496, 497, 498, 499, 500, 501, 502, 503, 504, 505,
908 506, 507, 508, 509, 510, 511, 512, 515, 516, 517,
909 518, 519, 520, 521, 522, 523, 524, 525, 526, 527,
910 528, 529, 530, 531, 535, 536, 541, 542, 543, 544,
911 547, 548, 551, 555, 561, 567, 568, 569, 572, 576,
912 585, 589, 594, 603, 604, 617, 618, 621, 622, 623,
913 624, 625, 626, 627, 628, 629, 630, 631, 632, 633,
914 634, 635, 636, 637, 638, 639, 640, 641, 642, 645,
915 646, 649, 655, 660, 661, 664, 665, 666, 667, 670,
916 678, 687, 688, 691, 692, 693, 696, 698, 701, 702,
917 703, 704, 705, 721, 722, 723, 724, 725, 726, 727,
918 730, 731, 734, 735, 736, 737, 738, 739, 740, 743,
919 744, 750, 759, 766, 767, 771, 774, 775, 778, 791,
920 792, 795, 796, 799, 808, 817, 818, 821, 822, 825,
921 837, 850, 862, 866, 867, 870, 871, 874, 879, 886,
922 887, 888, 892, 895, 902, 903, 904, 911, 912, 916,
923 917, 918, 921, 932, 933, 934, 935, 936, 937, 938,
924 939, 940, 941, 942, 945, 950, 955, 972, 973
925 };
926 #endif
927
928 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
929 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
930 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
931 static const char *const yytname[] =
932 {
933 "$end", "error", "$undefined", "aIDENTIFIER", "aKNOWNTYPE", "aNUM",
934 "aHEXNUM", "aDOUBLE", "aSTRING", "aUUID", "aEOF", "SHL", "SHR",
935 "tAGGREGATABLE", "tALLOCATE", "tAPPOBJECT", "tASYNC", "tASYNCUUID",
936 "tAUTOHANDLE", "tBINDABLE", "tBOOLEAN", "tBROADCAST", "tBYTE",
937 "tBYTECOUNT", "tCALLAS", "tCALLBACK", "tCASE", "tCDECL", "tCHAR",
938 "tCOCLASS", "tCODE", "tCOMMSTATUS", "tCONST", "tCONTEXTHANDLE",
939 "tCONTEXTHANDLENOSERIALIZE", "tCONTEXTHANDLESERIALIZE", "tCONTROL",
940 "tCPPQUOTE", "tDEFAULT", "tDEFAULTCOLLELEM", "tDEFAULTVALUE",
941 "tDEFAULTVTABLE", "tDISPLAYBIND", "tDISPINTERFACE", "tDLLNAME",
942 "tDOUBLE", "tDUAL", "tENDPOINT", "tENTRY", "tENUM", "tERRORSTATUST",
943 "tEXPLICITHANDLE", "tEXTERN", "tFALSE", "tFASTCALL", "tFLOAT", "tHANDLE",
944 "tHANDLET", "tHELPCONTEXT", "tHELPFILE", "tHELPSTRING",
945 "tHELPSTRINGCONTEXT", "tHELPSTRINGDLL", "tHIDDEN", "tHYPER", "tID",
946 "tIDEMPOTENT", "tIIDIS", "tIMMEDIATEBIND", "tIMPLICITHANDLE", "tIMPORT",
947 "tIMPORTLIB", "tIN", "tINLINE", "tINPUTSYNC", "tINT", "tINT64",
948 "tINTERFACE", "tLCID", "tLENGTHIS", "tLIBRARY", "tLOCAL", "tLONG",
949 "tMETHODS", "tMODULE", "tNONBROWSABLE", "tNONCREATABLE",
950 "tNONEXTENSIBLE", "tOBJECT", "tODL", "tOLEAUTOMATION", "tOPTIONAL",
951 "tOUT", "tPASCAL", "tPOINTERDEFAULT", "tPROPERTIES", "tPROPGET",
952 "tPROPPUT", "tPROPPUTREF", "tPTR", "tPUBLIC", "tRANGE", "tREADONLY",
953 "tREF", "tREQUESTEDIT", "tRESTRICTED", "tRETVAL", "tSAFEARRAY", "tSHORT",
954 "tSIGNED", "tSINGLE", "tSIZEIS", "tSIZEOF", "tSMALL", "tSOURCE",
955 "tSTDCALL", "tSTRICTCONTEXTHANDLE", "tSTRING", "tSTRUCT", "tSWITCH",
956 "tSWITCHIS", "tSWITCHTYPE", "tTRANSMITAS", "tTRUE", "tTYPEDEF", "tUNION",
957 "tUNIQUE", "tUNSIGNED", "tUUID", "tV1ENUM", "tVARARG", "tVERSION",
958 "tVOID", "tWCHAR", "tWIREMARSHAL", "','", "'?'", "':'", "'|'", "'&'",
959 "'-'", "'+'", "'*'", "'/'", "'~'", "CAST", "PPTR", "NEG", "ADDRESSOF",
960 "';'", "'('", "')'", "'{'", "'}'", "'['", "']'", "'='", "'.'", "$accept",
961 "input", "gbl_statements", "imp_statements", "int_statements",
962 "semicolon_opt", "statement", "cppquote", "import_start", "import",
963 "importlib", "libraryhdr", "library_start", "librarydef", "m_args",
964 "no_args", "args", "arg", "array", "array_list", "m_attributes",
965 "attributes", "attrib_list", "str_list", "attribute", "uuid_string",
966 "callconv", "cases", "case", "constdef", "enums", "enum_list", "enum",
967 "enumdef", "m_exprs", "m_expr", "expr", "expr_list_const", "expr_const",
968 "externdef", "fields", "field", "s_field", "funcdef", "m_ident",
969 "t_ident", "ident", "base_type", "m_int", "int_std", "coclass",
970 "coclasshdr", "coclassdef", "coclass_ints", "coclass_int",
971 "dispinterface", "dispinterfacehdr", "dispint_props", "dispint_meths",
972 "dispinterfacedef", "inherit", "interface", "interfacehdr",
973 "interfacedef", "interfacedec", "module", "modulehdr", "moduledef",
974 "pident", "func_ident", "direct_ident", "pident_list", "pointer_type",
975 "structdef", "type", "typedef", "uniondef", "version", 0
976 };
977 #endif
978
979 # ifdef YYPRINT
980 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
981 token YYLEX-NUM. */
982 static const unsigned short int yytoknum[] =
983 {
984 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
985 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
986 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
987 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
988 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
989 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
990 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
991 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
992 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
993 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
994 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
995 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
996 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
997 385, 386, 387, 388, 389, 44, 63, 58, 124, 38,
998 45, 43, 42, 47, 126, 390, 391, 392, 393, 59,
999 40, 41, 123, 125, 91, 93, 61, 46
1000 };
1001 # endif
1002
1003 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1004 static const unsigned char yyr1[] =
1005 {
1006 0, 158, 159, 160, 160, 160, 160, 160, 160, 160,
1007 160, 161, 161, 161, 161, 161, 161, 161, 161, 161,
1008 162, 162, 162, 163, 163, 164, 164, 164, 164, 164,
1009 164, 164, 164, 165, 166, 167, 168, 169, 170, 171,
1010 172, 172, 173, 174, 174, 174, 175, 175, 176, 176,
1011 176, 177, 177, 177, 178, 178, 179, 180, 180, 180,
1012 181, 181, 182, 182, 182, 182, 182, 182, 182, 182,
1013 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1014 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1015 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1016 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1017 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1018 182, 182, 182, 182, 182, 182, 182, 182, 182, 182,
1019 182, 182, 182, 182, 183, 183, 184, 184, 184, 184,
1020 185, 185, 186, 186, 187, 188, 188, 188, 189, 189,
1021 190, 190, 191, 192, 192, 193, 193, 194, 194, 194,
1022 194, 194, 194, 194, 194, 194, 194, 194, 194, 194,
1023 194, 194, 194, 194, 194, 194, 194, 194, 194, 195,
1024 195, 196, 197, 198, 198, 199, 199, 199, 199, 200,
1025 201, 202, 202, 203, 203, 203, 204, 204, 205, 205,
1026 205, 205, 205, 205, 205, 205, 205, 205, 205, 205,
1027 206, 206, 207, 207, 207, 207, 207, 207, 207, 208,
1028 208, 209, 210, 211, 211, 212, 213, 213, 214, 215,
1029 215, 216, 216, 217, 217, 218, 218, 219, 219, 220,
1030 221, 221, 221, 222, 222, 223, 223, 224, 225, 226,
1031 226, 226, 226, 227, 228, 228, 228, 229, 229, 230,
1032 230, 230, 231, 232, 232, 232, 232, 232, 232, 232,
1033 232, 232, 232, 232, 233, 234, 234, 235, 235
1034 };
1035
1036 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1037 static const unsigned char yyr2[] =
1038 {
1039 0, 2, 1, 0, 2, 2, 3, 2, 2, 2,
1040 2, 0, 2, 2, 3, 2, 2, 2, 2, 2,
1041 0, 3, 2, 0, 1, 2, 1, 2, 2, 1,
1042 2, 2, 2, 4, 3, 3, 5, 2, 3, 4,
1043 0, 1, 1, 1, 3, 1, 4, 3, 0, 3,
1044 3, 1, 3, 4, 0, 1, 3, 1, 3, 4,
1045 1, 3, 0, 1, 1, 1, 1, 1, 1, 4,
1046 4, 1, 1, 1, 1, 1, 1, 4, 4, 1,
1047 1, 4, 1, 4, 4, 4, 1, 1, 4, 4,
1048 4, 4, 4, 1, 4, 1, 4, 1, 5, 1,
1049 1, 4, 1, 1, 1, 1, 1, 1, 1, 1,
1050 1, 4, 1, 1, 1, 1, 6, 1, 1, 1,
1051 1, 4, 1, 1, 1, 4, 4, 4, 4, 1,
1052 1, 4, 4, 1, 1, 1, 1, 1, 1, 1,
1053 0, 2, 4, 3, 5, 0, 2, 1, 1, 3,
1054 3, 1, 5, 1, 3, 0, 1, 1, 1, 1,
1055 1, 1, 1, 5, 3, 3, 3, 3, 3, 3,
1056 3, 3, 2, 2, 2, 2, 4, 4, 3, 1,
1057 3, 1, 4, 0, 2, 2, 3, 2, 1, 4,
1058 3, 0, 1, 0, 1, 1, 1, 1, 1, 1,
1059 1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
1060 0, 1, 1, 2, 1, 2, 2, 1, 1, 2,
1061 2, 2, 5, 0, 2, 2, 2, 2, 2, 2,
1062 3, 2, 3, 5, 5, 0, 2, 2, 2, 2,
1063 6, 8, 2, 2, 2, 2, 2, 2, 5, 2,
1064 2, 2, 1, 4, 1, 3, 1, 1, 3, 1,
1065 1, 1, 5, 1, 1, 1, 2, 1, 2, 1,
1066 2, 1, 2, 4, 4, 5, 10, 1, 3
1067 };
1068
1069 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1070 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1071 means the default is an error. */
1072 static const unsigned short int yydefact[] =
1073 {
1074 3, 0, 2, 1, 0, 0, 0, 0, 193, 0,
1075 0, 0, 193, 54, 193, 62, 10, 26, 11, 29,
1076 11, 9, 0, 0, 0, 0, 0, 0, 7, 0,
1077 0, 23, 0, 235, 5, 4, 0, 8, 0, 0,
1078 0, 219, 220, 264, 207, 198, 218, 0, 206, 193,
1079 208, 204, 209, 210, 212, 217, 210, 0, 210, 0,
1080 205, 214, 193, 193, 203, 263, 199, 267, 265, 200,
1081 269, 0, 271, 0, 226, 227, 194, 195, 0, 0,
1082 0, 237, 238, 0, 0, 55, 0, 63, 64, 65,
1083 66, 67, 68, 0, 0, 71, 72, 73, 74, 75,
1084 76, 0, 79, 80, 0, 82, 0, 0, 86, 87,
1085 0, 0, 0, 0, 0, 93, 0, 95, 0, 97,
1086 0, 99, 100, 0, 102, 103, 104, 105, 106, 107,
1087 108, 109, 110, 0, 112, 113, 114, 261, 115, 0,
1088 117, 259, 118, 119, 120, 0, 122, 123, 124, 0,
1089 0, 0, 260, 0, 129, 130, 0, 0, 0, 57,
1090 133, 0, 0, 0, 0, 0, 221, 228, 239, 247,
1091 25, 27, 28, 6, 223, 244, 0, 24, 242, 243,
1092 0, 0, 20, 30, 31, 32, 266, 268, 211, 216,
1093 215, 0, 213, 201, 270, 272, 202, 196, 197, 0,
1094 0, 145, 0, 34, 183, 0, 0, 183, 0, 0,
1095 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1096 0, 0, 155, 0, 0, 155, 0, 0, 0, 0,
1097 0, 0, 62, 56, 35, 0, 17, 18, 19, 0,
1098 15, 13, 12, 16, 23, 37, 245, 246, 38, 54,
1099 0, 54, 0, 0, 236, 20, 54, 0, 0, 33,
1100 0, 147, 148, 151, 182, 54, 136, 0, 137, 138,
1101 139, 0, 0, 0, 254, 257, 256, 252, 274, 54,
1102 54, 0, 162, 157, 158, 159, 160, 0, 161, 0,
1103 0, 0, 0, 0, 181, 0, 179, 0, 0, 0,
1104 60, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1105 0, 0, 0, 153, 156, 0, 0, 0, 0, 0,
1106 0, 135, 134, 0, 277, 0, 0, 58, 62, 0,
1107 14, 39, 23, 0, 224, 229, 0, 0, 0, 54,
1108 0, 0, 54, 23, 22, 0, 0, 273, 144, 152,
1109 146, 0, 188, 262, 0, 55, 184, 0, 250, 249,
1110 0, 251, 40, 0, 0, 275, 69, 0, 174, 173,
1111 175, 172, 0, 0, 0, 0, 0, 0, 0, 0,
1112 0, 0, 0, 0, 70, 78, 77, 81, 0, 83,
1113 84, 85, 88, 89, 90, 91, 92, 94, 96, 0,
1114 155, 101, 111, 0, 121, 125, 126, 127, 128, 0,
1115 131, 132, 59, 0, 222, 225, 231, 0, 230, 233,
1116 0, 234, 20, 23, 248, 0, 21, 149, 150, 271,
1117 187, 185, 255, 263, 0, 45, 41, 43, 0, 0,
1118 258, 191, 0, 178, 0, 170, 171, 0, 164, 165,
1119 167, 166, 168, 169, 180, 61, 98, 154, 0, 278,
1120 23, 48, 232, 54, 240, 190, 186, 253, 0, 0,
1121 48, 0, 192, 177, 176, 0, 116, 36, 155, 189,
1122 23, 44, 48, 47, 140, 163, 0, 0, 51, 241,
1123 46, 0, 50, 0, 49, 0, 0, 276, 141, 52,
1124 0, 0, 54, 53, 54, 143, 142
1125 };
1126
1127 /* YYDEFGOTO[NTERM-NUM]. */
1128 static const short int yydefgoto[] =
1129 {
1130 -1, 1, 2, 161, 256, 178, 344, 17, 18, 19,
1131 237, 165, 20, 238, 434, 435, 436, 437, 479, 487,
1132 345, 85, 158, 301, 159, 323, 273, 491, 498, 23,
1133 260, 261, 262, 67, 312, 313, 294, 295, 296, 25,
1134 265, 356, 357, 346, 471, 78, 274, 68, 189, 69,
1135 239, 27, 240, 249, 334, 29, 30, 251, 339, 31,
1136 181, 32, 33, 241, 242, 169, 36, 243, 275, 276,
1137 277, 278, 160, 70, 417, 39, 72, 325
1138 };
1139
1140 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1141 STATE-NUM. */
1142 #define YYPACT_NINF -455
1143 static const short int yypact[] =
1144 {
1145 -455, 47, 733, -455, 135, 699, -87, 145, 151, 35,
1146 101, 153, 151, -53, 151, 908, -455, -455, -455, -455,
1147 -455, -455, 16, -42, -31, -27, -16, -25, -455, 9,
1148 12, 20, 41, 13, -455, -455, 43, -455, 50, 53,
1149 57, -455, -455, -455, -455, -455, -455, 699, -455, 190,
1150 -455, -455, -455, 71, -455, -455, 71, 2, 71, 15,
1151 -455, -455, 194, 201, 15, -455, -455, -455, -455, -455,
1152 -455, 226, -455, 203, -455, -455, -455, -455, 61, 699,
1153 60, -455, -455, 63, 699, -455, -110, -455, -455, -455,
1154 -455, -455, -455, 11, 70, -455, -455, -455, -455, -455,
1155 -455, 72, -455, -455, 76, -455, 88, 92, -455, -455,
1156 102, 106, 108, 109, 125, -455, 126, -455, 127, -455,
1157 130, -455, -455, 131, -455, -455, -455, -455, -455, -455,
1158 -455, -455, -455, 134, -455, -455, -455, -455, -455, 136,
1159 -455, -455, -455, -455, -455, 137, -455, -455, -455, 138,
1160 142, 143, -455, 144, -455, -455, 148, 149, -98, -455,
1161 -455, 362, 709, 258, 247, 114, -455, -455, -455, -455,
1162 -455, -455, -455, -455, -455, -455, -39, -455, -455, -455,
1163 251, 133, -455, -455, -455, -455, -455, 150, -455, -455,
1164 -455, 699, -455, -455, 150, -88, -455, -455, -455, 156,
1165 154, 226, 226, -455, -455, 99, 163, -455, 226, 68,
1166 303, 292, 293, 452, 68, 296, 306, 68, 307, 68,
1167 68, 259, 68, -48, 68, 68, 68, 699, 699, 31,
1168 312, 699, 908, 164, -455, 169, -455, -455, -455, 172,
1169 -455, -455, -455, -455, 20, -455, -455, -455, -455, 111,
1170 185, -55, 174, 175, -455, -455, 735, 177, 68, -455,
1171 173, 196, -455, 178, -455, -17, -455, 99, -455, -455,
1172 -455, 99, 99, 99, -455, -455, -455, 179, 198, -53,
1173 -9, 184, -455, -455, -455, -455, -455, 187, -455, 68,
1174 68, 68, 68, 491, 594, -86, -455, 189, 193, 202,
1175 -455, -83, 207, 210, 211, 212, 214, 215, 216, 217,
1176 531, 335, -82, -455, 594, 218, 206, -37, 545, 219,
1177 220, -455, -455, 222, 188, 224, 225, -455, 908, 339,
1178 -455, -455, 20, -7, -455, -455, 240, 699, 200, 116,
1179 199, 284, 746, 20, -455, 699, 229, -455, -455, -455,
1180 226, 68, -455, -455, 699, 230, -455, 231, -455, -455,
1181 235, -455, 275, 99, 236, -455, -455, 699, -455, -455,
1182 -455, -455, 559, 238, 68, 68, 68, 68, 68, 68,
1183 68, 68, 68, 68, -455, -455, -455, -455, 373, -455,
1184 -455, -455, -455, -455, -455, -455, -455, -455, -455, 239,
1185 68, -455, -455, 68, -455, -455, -455, -455, -455, 387,
1186 -455, -455, -455, 244, -455, -455, -455, 99, -455, -455,
1187 248, -455, -455, 20, -455, 99, -455, -455, -455, 249,
1188 -455, -455, -455, -22, 245, -455, 266, -455, 699, 99,
1189 -455, 226, 253, -455, 68, -455, -455, 440, 105, 93,
1190 0, 0, 261, 261, -455, -455, -455, -455, 255, -455,
1191 20, 256, -455, 786, -455, -455, -455, -455, 399, 99,
1192 256, 257, -455, -455, -455, 68, -455, -455, 515, -455,
1193 20, -455, 256, -455, -455, 594, 77, -94, -455, -455,
1194 -455, -6, -455, 68, 262, 68, 276, -455, -455, 594,
1195 68, 575, -77, 594, -77, -455, -455
1196 };
1197
1198 /* YYPGOTO[NTERM-NUM]. */
1199 static const short int yypgoto[] =
1200 {
1201 -455, -455, -455, 392, -240, -237, 23, -455, -455, 79,
1202 -455, -455, -455, 415, -455, -455, -455, -50, -358, -455,
1203 -12, -2, -455, -455, -209, -455, -455, -455, -455, -455,
1204 -455, -455, 73, 4, 197, -370, -204, -455, -200, -455,
1205 221, -454, -225, 85, -455, 48, -67, -455, 36, 56,
1206 44, -455, 423, -455, -455, 408, -455, -455, -455, -455,
1207 -455, 5, -455, 432, 3, -455, -455, 434, -238, -455,
1208 -455, -455, 223, 6, -3, -455, 1, -455
1209 };
1210
1211 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1212 positive, shift that token. If negative, reduce the rule which
1213 number is the opposite. If zero, do what YYDEFACT says.
1214 If YYTABLE_NINF, syntax error. */
1215 #define YYTABLE_NINF -195
1216 static const short int yytable[] =
1217 {
1218 22, 84, 71, 40, 199, 35, 24, 331, 38, 206,
1219 298, 374, 375, 303, 304, 342, 310, 307, 314, 309,
1220 495, 314, 318, 327, 316, 16, 338, 168, 336, 358,
1221 457, -194, 496, 359, 360, 361, 7, 232, 11, 321,
1222 322, 493, 207, 46, 186, 4, 26, 3, 505, 383,
1223 506, 137, 388, 400, 364, 141, 250, 233, 348, 7,
1224 83, 494, 86, 73, -194, 384, 166, 79, 389, 401,
1225 11, 282, 352, 283, 284, 285, 202, 15, 152, 53,
1226 282, 205, 283, 284, 285, 368, 369, 370, 371, 372,
1227 54, 55, 190, 11, 192, 414, 163, 56, 400, 15,
1228 164, 15, 197, 198, 374, 375, 424, 170, 488, 80,
1229 83, 86, 483, -42, 404, 193, 374, 375, 171, 412,
1230 196, 286, 172, 58, 490, 440, 266, 174, 61, -42,
1231 286, 267, 352, 173, 263, 264, 353, 15, 41, 42,
1232 352, 281, 381, 382, 365, 15, 188, 497, 74, 75,
1233 180, 428, 191, 268, 76, 77, 81, 82, 175, 22,
1234 22, 208, 40, 40, 176, 24, 24, 38, 38, 177,
1235 445, 446, 447, 448, 449, 450, 451, 452, 453, 461,
1236 287, 252, 463, 454, 236, 236, 464, 465, 257, 287,
1237 179, 288, 269, 187, 77, 182, 314, 194, 77, 183,
1238 288, 470, 184, 458, 195, 77, 185, 289, 290, 203,
1239 291, 200, 292, 201, 270, 204, 289, 290, 293, 291,
1240 209, 292, 210, 477, 319, 320, 211, 293, 326, 197,
1241 198, 482, 492, 379, 380, 381, 382, 333, 212, 337,
1242 474, 271, 213, 489, 378, 379, 380, 381, 382, 272,
1243 246, 247, 214, 354, 253, 254, 215, 40, 216, 217,
1244 24, 245, 38, 355, 332, 15, 248, 337, 354, 419,
1245 15, 485, 374, 375, 314, 218, 219, 220, 355, 43,
1246 221, 222, 370, 263, 223, 255, 224, 225, 226, 499,
1247 373, 501, 227, 228, 229, 44, 503, 45, 230, 231,
1248 299, 300, -194, 46, 305, 259, 282, 47, 283, 284,
1249 285, 297, 258, 279, 306, 308, 311, 324, 328, 329,
1250 48, 330, 335, 340, 49, 50, 349, 341, 347, 362,
1251 51, 350, 52, 363, 351, 366, 415, 367, 399, 53,
1252 385, 403, 425, 40, 386, 409, 24, 413, 38, 418,
1253 54, 55, 421, 387, 10, 429, 286, 56, 390, 439,
1254 438, 391, 392, 393, 442, 394, 395, 396, 397, 402,
1255 406, 407, 234, 408, 472, 410, 411, 416, 426, 430,
1256 431, 455, 57, 58, 59, 60, 432, 441, 61, 444,
1257 456, 4, 459, 62, 5, 460, 467, 462, 466, 6,
1258 63, 468, 64, 43, 473, 7, 476, 433, 66, 484,
1259 478, 8, 162, 502, 9, 287, 500, 21, 481, 44,
1260 422, 45, 317, 427, 420, 28, 288, 46, 280, 15,
1261 167, 47, 10, 235, 34, 469, 37, 0, 0, 11,
1262 0, 0, 289, 290, 48, 291, 315, 292, 49, 50,
1263 0, 374, 375, 293, 51, 282, 52, 283, 284, 285,
1264 302, 0, 0, 53, 40, 439, 438, 24, 0, 38,
1265 0, 0, 0, 0, 54, 55, 0, 0, 0, 0,
1266 12, 56, 0, 0, 0, 0, 13, 14, 0, 0,
1267 354, 0, 354, 0, 282, 43, 283, 284, 285, 0,
1268 355, 0, 355, 0, 0, 286, 57, 58, 59, 60,
1269 0, 44, 61, 45, 0, 0, 15, 62, 282, 46,
1270 283, 284, 285, 47, 63, 0, 64, 0, 0, 0,
1271 0, 65, 66, 0, 0, 0, 48, 0, 0, 0,
1272 49, 50, 374, 375, 286, 0, 51, 0, 52, 0,
1273 0, 0, 0, 15, 0, 53, 374, 375, 0, 0,
1274 0, 0, 0, 0, 287, 0, 54, 55, 286, 0,
1275 374, 375, 0, 56, 0, 288, 376, 475, 377, 378,
1276 379, 380, 381, 382, 0, 0, 374, 375, 0, 0,
1277 0, 289, 290, 0, 291, 0, 292, 0, 57, 58,
1278 59, 60, 293, 287, 61, 374, 375, 0, 0, 62,
1279 0, 0, 0, 0, 288, 0, 63, 0, 64, 0,
1280 0, 0, 0, 65, 66, 0, 0, 287, 0, 0,
1281 289, 290, 0, 291, 0, 292, 0, 0, 288, 0,
1282 0, 293, 0, 0, 0, 0, 0, 0, 0, 0,
1283 0, 0, 0, 0, 289, 290, 0, 486, 0, 292,
1284 0, 0, 0, 0, 0, 293, 0, 376, 0, 377,
1285 378, 379, 380, 381, 382, 0, 0, 0, 0, 0,
1286 0, 376, 398, 377, 378, 379, 380, 381, 382, 0,
1287 0, 0, 0, 0, 0, 376, 405, 377, 378, 379,
1288 380, 381, 382, 43, 0, 0, 0, 0, 0, 0,
1289 443, 376, 504, 377, 378, 379, 380, 381, 382, 44,
1290 0, 45, 0, 0, 0, 0, 0, 46, 0, 0,
1291 376, 47, 377, 378, 379, 380, 381, 382, 4, 0,
1292 0, 5, 0, 0, 48, 0, 6, 0, 49, 50,
1293 0, 0, 7, 0, 51, 0, 52, 0, 8, 0,
1294 0, 9, 4, 53, 0, 5, 0, 5, 0, 0,
1295 6, 0, 6, 0, 54, 55, 7, 0, 5, 10,
1296 235, 56, 8, 6, 8, 9, 11, 9, 0, 0,
1297 0, 0, 0, 0, 0, 8, 0, 0, 9, 0,
1298 0, 0, 0, 10, 0, 10, 57, 58, 59, 60,
1299 11, 0, 61, 0, 0, 0, 10, 62, 5, 0,
1300 0, 0, 0, 6, 63, 0, 64, 12, 0, 0,
1301 0, 65, 66, 13, 14, 8, 0, 0, 9, 0,
1302 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1303 0, 12, 0, 12, 0, 0, 10, 13, 14, 13,
1304 14, 0, 244, 15, 12, 0, 0, 0, 0, 0,
1305 13, 14, 0, 0, 0, 0, 0, 0, 0, 0,
1306 0, 0, 0, 0, 0, 0, 0, 15, 343, 15,
1307 0, 0, 0, 0, 0, 0, 0, 0, 0, 423,
1308 15, 0, 0, 0, 12, 0, 0, 0, 0, 0,
1309 13, 14, 0, 0, 0, 0, 0, 0, 0, 0,
1310 0, 87, 0, 88, 89, 0, 90, 91, 0, 92,
1311 0, 0, 93, 0, 94, 0, 0, 0, 0, 480,
1312 15, 95, 96, 97, 98, 0, 99, 100, 101, 102,
1313 103, 0, 104, 0, 105, 106, 107, 0, 0, 108,
1314 0, 0, 0, 0, 109, 0, 110, 111, 112, 113,
1315 114, 115, 0, 116, 117, 118, 119, 120, 0, 0,
1316 121, 0, 122, 0, 0, 0, 0, 123, 0, 124,
1317 0, 0, 0, 125, 126, 127, 128, 129, 130, 131,
1318 132, 0, 133, 0, 134, 135, 136, 137, 138, 139,
1319 140, 141, 142, 143, 144, 0, 0, 0, 0, 145,
1320 0, 0, 146, 0, 147, 148, 0, 0, 149, 150,
1321 151, 0, 0, 0, 152, 0, 153, 154, 155, 156,
1322 0, 0, 157
1323 };
1324
1325 static const short int yycheck[] =
1326 {
1327 2, 13, 5, 2, 71, 2, 2, 244, 2, 119,
1328 210, 11, 12, 213, 214, 255, 220, 217, 222, 219,
1329 26, 225, 226, 232, 224, 2, 251, 22, 83, 267,
1330 400, 119, 38, 271, 272, 273, 43, 135, 77, 8,
1331 9, 135, 152, 28, 47, 29, 2, 0, 502, 135,
1332 504, 99, 135, 135, 279, 103, 95, 155, 258, 43,
1333 12, 155, 14, 150, 152, 151, 22, 32, 151, 151,
1334 77, 3, 149, 5, 6, 7, 79, 154, 126, 64,
1335 3, 84, 5, 6, 7, 289, 290, 291, 292, 293,
1336 75, 76, 56, 77, 58, 332, 80, 82, 135, 154,
1337 84, 154, 3, 4, 11, 12, 343, 149, 478, 8,
1338 62, 63, 470, 135, 151, 59, 11, 12, 149, 328,
1339 64, 53, 149, 108, 482, 363, 27, 152, 113, 151,
1340 53, 32, 149, 149, 201, 202, 153, 154, 3, 4,
1341 149, 208, 142, 143, 153, 154, 75, 153, 3, 4,
1342 137, 351, 150, 54, 3, 4, 3, 4, 149, 161,
1343 162, 150, 161, 162, 152, 161, 162, 161, 162, 149,
1344 374, 375, 376, 377, 378, 379, 380, 381, 382, 417,
1345 112, 176, 422, 383, 161, 162, 423, 425, 191, 112,
1346 149, 123, 93, 3, 4, 152, 400, 3, 4, 149,
1347 123, 439, 149, 403, 3, 4, 149, 139, 140, 149,
1348 142, 8, 144, 152, 115, 152, 139, 140, 150, 142,
1349 150, 144, 150, 460, 227, 228, 150, 150, 231, 3,
1350 4, 469, 155, 140, 141, 142, 143, 249, 150, 251,
1351 444, 142, 150, 480, 139, 140, 141, 142, 143, 150,
1352 3, 4, 150, 265, 3, 4, 150, 256, 150, 150,
1353 256, 3, 256, 265, 153, 154, 152, 279, 280, 153,
1354 154, 475, 11, 12, 478, 150, 150, 150, 280, 4,
1355 150, 150, 486, 350, 150, 152, 150, 150, 150, 493,
1356 293, 495, 150, 150, 150, 20, 500, 22, 150, 150,
1357 8, 8, 152, 28, 8, 151, 3, 32, 5, 6,
1358 7, 8, 156, 150, 8, 8, 57, 5, 154, 150,
1359 45, 149, 137, 149, 49, 50, 153, 152, 151, 150,
1360 55, 135, 57, 135, 156, 151, 333, 150, 3, 64,
1361 151, 135, 345, 342, 151, 157, 342, 8, 342, 149,
1362 75, 76, 153, 151, 70, 354, 53, 82, 151, 362,
1363 362, 151, 151, 151, 367, 151, 151, 151, 151, 151,
1364 151, 151, 10, 151, 441, 151, 151, 137, 149, 149,
1365 149, 8, 107, 108, 109, 110, 151, 151, 113, 151,
1366 151, 29, 5, 118, 32, 151, 151, 149, 149, 37,
1367 125, 135, 127, 4, 151, 43, 151, 132, 133, 152,
1368 154, 49, 20, 137, 52, 112, 154, 2, 468, 20,
1369 341, 22, 225, 350, 339, 2, 123, 28, 207, 154,
1370 22, 32, 70, 71, 2, 438, 2, -1, -1, 77,
1371 -1, -1, 139, 140, 45, 142, 223, 144, 49, 50,
1372 -1, 11, 12, 150, 55, 3, 57, 5, 6, 7,
1373 8, -1, -1, 64, 463, 468, 468, 463, -1, 463,
1374 -1, -1, -1, -1, 75, 76, -1, -1, -1, -1,
1375 118, 82, -1, -1, -1, -1, 124, 125, -1, -1,
1376 502, -1, 504, -1, 3, 4, 5, 6, 7, -1,
1377 502, -1, 504, -1, -1, 53, 107, 108, 109, 110,
1378 -1, 20, 113, 22, -1, -1, 154, 118, 3, 28,
1379 5, 6, 7, 32, 125, -1, 127, -1, -1, -1,
1380 -1, 132, 133, -1, -1, -1, 45, -1, -1, -1,
1381 49, 50, 11, 12, 53, -1, 55, -1, 57, -1,
1382 -1, -1, -1, 154, -1, 64, 11, 12, -1, -1,
1383 -1, -1, -1, -1, 112, -1, 75, 76, 53, -1,
1384 11, 12, -1, 82, -1, 123, 136, 137, 138, 139,
1385 140, 141, 142, 143, -1, -1, 11, 12, -1, -1,
1386 -1, 139, 140, -1, 142, -1, 144, -1, 107, 108,
1387 109, 110, 150, 112, 113, 11, 12, -1, -1, 118,
1388 -1, -1, -1, -1, 123, -1, 125, -1, 127, -1,
1389 -1, -1, -1, 132, 133, -1, -1, 112, -1, -1,
1390 139, 140, -1, 142, -1, 144, -1, -1, 123, -1,
1391 -1, 150, -1, -1, -1, -1, -1, -1, -1, -1,
1392 -1, -1, -1, -1, 139, 140, -1, 142, -1, 144,
1393 -1, -1, -1, -1, -1, 150, -1, 136, -1, 138,
1394 139, 140, 141, 142, 143, -1, -1, -1, -1, -1,
1395 -1, 136, 151, 138, 139, 140, 141, 142, 143, -1,
1396 -1, -1, -1, -1, -1, 136, 151, 138, 139, 140,
1397 141, 142, 143, 4, -1, -1, -1, -1, -1, -1,
1398 151, 136, 137, 138, 139, 140, 141, 142, 143, 20,
1399 -1, 22, -1, -1, -1, -1, -1, 28, -1, -1,
1400 136, 32, 138, 139, 140, 141, 142, 143, 29, -1,
1401 -1, 32, -1, -1, 45, -1, 37, -1, 49, 50,
1402 -1, -1, 43, -1, 55, -1, 57, -1, 49, -1,
1403 -1, 52, 29, 64, -1, 32, -1, 32, -1, -1,
1404 37, -1, 37, -1, 75, 76, 43, -1, 32, 70,
1405 71, 82, 49, 37, 49, 52, 77, 52, -1, -1,
1406 -1, -1, -1, -1, -1, 49, -1, -1, 52, -1,
1407 -1, -1, -1, 70, -1, 70, 107, 108, 109, 110,
1408 77, -1, 113, -1, -1, -1, 70, 118, 32, -1,
1409 -1, -1, -1, 37, 125, -1, 127, 118, -1, -1,
1410 -1, 132, 133, 124, 125, 49, -1, -1, 52, -1,
1411 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1412 -1, 118, -1, 118, -1, -1, 70, 124, 125, 124,
1413 125, -1, 153, 154, 118, -1, -1, -1, -1, -1,
1414 124, 125, -1, -1, -1, -1, -1, -1, -1, -1,
1415 -1, -1, -1, -1, -1, -1, -1, 154, 153, 154,
1416 -1, -1, -1, -1, -1, -1, -1, -1, -1, 153,
1417 154, -1, -1, -1, 118, -1, -1, -1, -1, -1,
1418 124, 125, -1, -1, -1, -1, -1, -1, -1, -1,
1419 -1, 13, -1, 15, 16, -1, 18, 19, -1, 21,
1420 -1, -1, 24, -1, 26, -1, -1, -1, -1, 153,
1421 154, 33, 34, 35, 36, -1, 38, 39, 40, 41,
1422 42, -1, 44, -1, 46, 47, 48, -1, -1, 51,
1423 -1, -1, -1, -1, 56, -1, 58, 59, 60, 61,
1424 62, 63, -1, 65, 66, 67, 68, 69, -1, -1,
1425 72, -1, 74, -1, -1, -1, -1, 79, -1, 81,
1426 -1, -1, -1, 85, 86, 87, 88, 89, 90, 91,
1427 92, -1, 94, -1, 96, 97, 98, 99, 100, 101,
1428 102, 103, 104, 105, 106, -1, -1, -1, -1, 111,
1429 -1, -1, 114, -1, 116, 117, -1, -1, 120, 121,
1430 122, -1, -1, -1, 126, -1, 128, 129, 130, 131,
1431 -1, -1, 134
1432 };
1433
1434 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1435 symbol of state STATE-NUM. */
1436 static const unsigned char yystos[] =
1437 {
1438 0, 159, 160, 0, 29, 32, 37, 43, 49, 52,
1439 70, 77, 118, 124, 125, 154, 164, 165, 166, 167,
1440 170, 171, 179, 187, 191, 197, 208, 209, 210, 213,
1441 214, 217, 219, 220, 221, 222, 224, 225, 231, 233,
1442 234, 3, 4, 4, 20, 22, 28, 32, 45, 49,
1443 50, 55, 57, 64, 75, 76, 82, 107, 108, 109,
1444 110, 113, 118, 125, 127, 132, 133, 191, 205, 207,
1445 231, 232, 234, 150, 3, 4, 3, 4, 203, 32,
1446 8, 3, 4, 203, 178, 179, 203, 13, 15, 16,
1447 18, 19, 21, 24, 26, 33, 34, 35, 36, 38,
1448 39, 40, 41, 42, 44, 46, 47, 48, 51, 56,
1449 58, 59, 60, 61, 62, 63, 65, 66, 67, 68,
1450 69, 72, 74, 79, 81, 85, 86, 87, 88, 89,
1451 90, 91, 92, 94, 96, 97, 98, 99, 100, 101,
1452 102, 103, 104, 105, 106, 111, 114, 116, 117, 120,
1453 121, 122, 126, 128, 129, 130, 131, 134, 180, 182,
1454 230, 161, 161, 80, 84, 169, 208, 213, 219, 223,
1455 149, 149, 149, 149, 152, 149, 152, 149, 163, 149,
1456 137, 218, 152, 149, 149, 149, 232, 3, 75, 206,
1457 206, 150, 206, 207, 3, 3, 207, 3, 4, 204,
1458 8, 152, 232, 149, 152, 232, 119, 152, 150, 150,
1459 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
1460 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
1461 150, 150, 135, 155, 10, 71, 164, 168, 171, 208,
1462 210, 221, 222, 225, 153, 3, 3, 4, 152, 211,
1463 95, 215, 219, 3, 4, 152, 162, 232, 156, 151,
1464 188, 189, 190, 204, 204, 198, 27, 32, 54, 93,
1465 115, 142, 150, 184, 204, 226, 227, 228, 229, 150,
1466 198, 204, 3, 5, 6, 7, 53, 112, 123, 139,
1467 140, 142, 144, 150, 194, 195, 196, 8, 196, 8,
1468 8, 181, 8, 196, 196, 8, 8, 196, 8, 196,
1469 194, 57, 192, 193, 194, 230, 196, 192, 194, 232,
1470 232, 8, 9, 183, 5, 235, 232, 182, 154, 150,
1471 149, 163, 153, 178, 212, 137, 83, 178, 200, 216,
1472 149, 152, 162, 153, 164, 178, 201, 151, 196, 153,
1473 135, 156, 149, 153, 178, 179, 199, 200, 226, 226,
1474 226, 226, 150, 135, 200, 153, 151, 150, 194, 194,
1475 194, 194, 194, 232, 11, 12, 136, 138, 139, 140,
1476 141, 142, 143, 135, 151, 151, 151, 151, 135, 151,
1477 151, 151, 151, 151, 151, 151, 151, 151, 151, 3,
1478 135, 151, 151, 135, 151, 151, 151, 151, 151, 157,
1479 151, 151, 182, 8, 163, 222, 137, 232, 149, 153,
1480 201, 153, 167, 153, 163, 232, 149, 190, 196, 234,
1481 149, 149, 151, 132, 172, 173, 174, 175, 179, 232,
1482 226, 151, 232, 151, 151, 194, 194, 194, 194, 194,
1483 194, 194, 194, 194, 196, 8, 151, 193, 196, 5,
1484 151, 226, 149, 162, 163, 226, 149, 151, 135, 232,
1485 226, 202, 204, 151, 194, 137, 151, 163, 154, 176,
1486 153, 175, 226, 176, 152, 194, 142, 177, 193, 163,
1487 176, 185, 155, 135, 155, 26, 38, 153, 186, 194,
1488 154, 194, 137, 194, 137, 199, 199
1489 };
1490
1491 #define yyerrok (yyerrstatus = 0)
1492 #define yyclearin (yychar = YYEMPTY)
1493 #define YYEMPTY (-2)
1494 #define YYEOF 0
1495
1496 #define YYACCEPT goto yyacceptlab
1497 #define YYABORT goto yyabortlab
1498 #define YYERROR goto yyerrorlab
1499
1500
1501 /* Like YYERROR except do call yyerror. This remains here temporarily
1502 to ease the transition to the new meaning of YYERROR, for GCC.
1503 Once GCC version 2 has supplanted version 1, this can go. */
1504
1505 #define YYFAIL goto yyerrlab
1506
1507 #define YYRECOVERING() (!!yyerrstatus)
1508
1509 #define YYBACKUP(Token, Value) \
1510 do \
1511 if (yychar == YYEMPTY && yylen == 1) \
1512 { \
1513 yychar = (Token); \
1514 yylval = (Value); \
1515 yytoken = YYTRANSLATE (yychar); \
1516 YYPOPSTACK; \
1517 goto yybackup; \
1518 } \
1519 else \
1520 { \
1521 yyerror (YY_("syntax error: cannot back up")); \
1522 YYERROR; \
1523 } \
1524 while (0)
1525
1526
1527 #define YYTERROR 1
1528 #define YYERRCODE 256
1529
1530
1531 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1532 If N is 0, then set CURRENT to the empty location which ends
1533 the previous symbol: RHS[0] (always defined). */
1534
1535 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1536 #ifndef YYLLOC_DEFAULT
1537 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1538 do \
1539 if (N) \
1540 { \
1541 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1542 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1543 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1544 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1545 } \
1546 else \
1547 { \
1548 (Current).first_line = (Current).last_line = \
1549 YYRHSLOC (Rhs, 0).last_line; \
1550 (Current).first_column = (Current).last_column = \
1551 YYRHSLOC (Rhs, 0).last_column; \
1552 } \
1553 while (0)
1554 #endif
1555
1556
1557 /* YY_LOCATION_PRINT -- Print the location on the stream.
1558 This macro was not mandated originally: define only if we know
1559 we won't break user code: when these are the locations we know. */
1560
1561 #ifndef YY_LOCATION_PRINT
1562 # if YYLTYPE_IS_TRIVIAL
1563 # define YY_LOCATION_PRINT(File, Loc) \
1564 fprintf (File, "%d.%d-%d.%d", \
1565 (Loc).first_line, (Loc).first_column, \
1566 (Loc).last_line, (Loc).last_column)
1567 # else
1568 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1569 # endif
1570 #endif
1571
1572
1573 /* YYLEX -- calling `yylex' with the right arguments. */
1574
1575 #ifdef YYLEX_PARAM
1576 # define YYLEX yylex (YYLEX_PARAM)
1577 #else
1578 # define YYLEX yylex ()
1579 #endif
1580
1581 /* Enable debugging if requested. */
1582 #if YYDEBUG
1583
1584 # ifndef YYFPRINTF
1585 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1586 # define YYFPRINTF fprintf
1587 # endif
1588
1589 # define YYDPRINTF(Args) \
1590 do { \
1591 if (yydebug) \
1592 YYFPRINTF Args; \
1593 } while (0)
1594
1595 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1596 do { \
1597 if (yydebug) \
1598 { \
1599 YYFPRINTF (stderr, "%s ", Title); \
1600 yysymprint (stderr, \
1601 Type, Value); \
1602 YYFPRINTF (stderr, "\n"); \
1603 } \
1604 } while (0)
1605
1606 /*------------------------------------------------------------------.
1607 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1608 | TOP (included). |
1609 `------------------------------------------------------------------*/
1610
1611 #if defined (__STDC__) || defined (__cplusplus)
1612 static void
1613 yy_stack_print (short int *bottom, short int *top)
1614 #else
1615 static void
1616 yy_stack_print (bottom, top)
1617 short int *bottom;
1618 short int *top;
1619 #endif
1620 {
1621 YYFPRINTF (stderr, "Stack now");
1622 for (/* Nothing. */; bottom <= top; ++bottom)
1623 YYFPRINTF (stderr, " %d", *bottom);
1624 YYFPRINTF (stderr, "\n");
1625 }
1626
1627 # define YY_STACK_PRINT(Bottom, Top) \
1628 do { \
1629 if (yydebug) \
1630 yy_stack_print ((Bottom), (Top)); \
1631 } while (0)
1632
1633
1634 /*------------------------------------------------.
1635 | Report that the YYRULE is going to be reduced. |
1636 `------------------------------------------------*/
1637
1638 #if defined (__STDC__) || defined (__cplusplus)
1639 static void
1640 yy_reduce_print (int yyrule)
1641 #else
1642 static void
1643 yy_reduce_print (yyrule)
1644 int yyrule;
1645 #endif
1646 {
1647 int yyi;
1648 unsigned long int yylno = yyrline[yyrule];
1649 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
1650 yyrule - 1, yylno);
1651 /* Print the symbols being reduced, and their result. */
1652 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1653 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1654 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
1655 }
1656
1657 # define YY_REDUCE_PRINT(Rule) \
1658 do { \
1659 if (yydebug) \
1660 yy_reduce_print (Rule); \
1661 } while (0)
1662
1663 /* Nonzero means print parse trace. It is left uninitialized so that
1664 multiple parsers can coexist. */
1665 int yydebug;
1666 #else /* !YYDEBUG */
1667 # define YYDPRINTF(Args)
1668 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1669 # define YY_STACK_PRINT(Bottom, Top)
1670 # define YY_REDUCE_PRINT(Rule)
1671 #endif /* !YYDEBUG */
1672
1673
1674 /* YYINITDEPTH -- initial size of the parser's stacks. */
1675 #ifndef YYINITDEPTH
1676 # define YYINITDEPTH 200
1677 #endif
1678
1679 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1680 if the built-in stack extension method is used).
1681
1682 Do not make this value too large; the results are undefined if
1683 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1684 evaluated with infinite-precision integer arithmetic. */
1685
1686 #ifndef YYMAXDEPTH
1687 # define YYMAXDEPTH 10000
1688 #endif
1689
1690 \f
1691
1692 #if YYERROR_VERBOSE
1693
1694 # ifndef yystrlen
1695 # if defined (__GLIBC__) && defined (_STRING_H)
1696 # define yystrlen strlen
1697 # else
1698 /* Return the length of YYSTR. */
1699 static YYSIZE_T
1700 # if defined (__STDC__) || defined (__cplusplus)
1701 yystrlen (const char *yystr)
1702 # else
1703 yystrlen (yystr)
1704 const char *yystr;
1705 # endif
1706 {
1707 const char *yys = yystr;
1708
1709 while (*yys++ != '\0')
1710 continue;
1711
1712 return yys - yystr - 1;
1713 }
1714 # endif
1715 # endif
1716
1717 # ifndef yystpcpy
1718 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
1719 # define yystpcpy stpcpy
1720 # else
1721 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1722 YYDEST. */
1723 static char *
1724 # if defined (__STDC__) || defined (__cplusplus)
1725 yystpcpy (char *yydest, const char *yysrc)
1726 # else
1727 yystpcpy (yydest, yysrc)
1728 char *yydest;
1729 const char *yysrc;
1730 # endif
1731 {
1732 char *yyd = yydest;
1733 const char *yys = yysrc;
1734
1735 while ((*yyd++ = *yys++) != '\0')
1736 continue;
1737
1738 return yyd - 1;
1739 }
1740 # endif
1741 # endif
1742
1743 # ifndef yytnamerr
1744 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1745 quotes and backslashes, so that it's suitable for yyerror. The
1746 heuristic is that double-quoting is unnecessary unless the string
1747 contains an apostrophe, a comma, or backslash (other than
1748 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1749 null, do not copy; instead, return the length of what the result
1750 would have been. */
1751 static YYSIZE_T
1752 yytnamerr (char *yyres, const char *yystr)
1753 {
1754 if (*yystr == '"')
1755 {
1756 size_t yyn = 0;
1757 char const *yyp = yystr;
1758
1759 for (;;)
1760 switch (*++yyp)
1761 {
1762 case '\'':
1763 case ',':
1764 goto do_not_strip_quotes;
1765
1766 case '\\':
1767 if (*++yyp != '\\')
1768 goto do_not_strip_quotes;
1769 /* Fall through. */
1770 default:
1771 if (yyres)
1772 yyres[yyn] = *yyp;
1773 yyn++;
1774 break;
1775
1776 case '"':
1777 if (yyres)
1778 yyres[yyn] = '\0';
1779 return yyn;
1780 }
1781 do_not_strip_quotes: ;
1782 }
1783
1784 if (! yyres)
1785 return yystrlen (yystr);
1786
1787 return yystpcpy (yyres, yystr) - yyres;
1788 }
1789 # endif
1790
1791 #endif /* YYERROR_VERBOSE */
1792
1793 \f
1794
1795 #if YYDEBUG
1796 /*--------------------------------.
1797 | Print this symbol on YYOUTPUT. |
1798 `--------------------------------*/
1799
1800 #if defined (__STDC__) || defined (__cplusplus)
1801 static void
1802 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
1803 #else
1804 static void
1805 yysymprint (yyoutput, yytype, yyvaluep)
1806 FILE *yyoutput;
1807 int yytype;
1808 YYSTYPE *yyvaluep;
1809 #endif
1810 {
1811 /* Pacify ``unused variable'' warnings. */
1812 (void) yyvaluep;
1813
1814 if (yytype < YYNTOKENS)
1815 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1816 else
1817 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1818
1819
1820 # ifdef YYPRINT
1821 if (yytype < YYNTOKENS)
1822 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1823 # endif
1824 switch (yytype)
1825 {
1826 default:
1827 break;
1828 }
1829 YYFPRINTF (yyoutput, ")");
1830 }
1831
1832 #endif /* ! YYDEBUG */
1833 /*-----------------------------------------------.
1834 | Release the memory associated to this symbol. |
1835 `-----------------------------------------------*/
1836
1837 #if defined (__STDC__) || defined (__cplusplus)
1838 static void
1839 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1840 #else
1841 static void
1842 yydestruct (yymsg, yytype, yyvaluep)
1843 const char *yymsg;
1844 int yytype;
1845 YYSTYPE *yyvaluep;
1846 #endif
1847 {
1848 /* Pacify ``unused variable'' warnings. */
1849 (void) yyvaluep;
1850
1851 if (!yymsg)
1852 yymsg = "Deleting";
1853 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1854
1855 switch (yytype)
1856 {
1857
1858 default:
1859 break;
1860 }
1861 }
1862 \f
1863
1864 /* Prevent warnings from -Wmissing-prototypes. */
1865
1866 #ifdef YYPARSE_PARAM
1867 # if defined (__STDC__) || defined (__cplusplus)
1868 int yyparse (void *YYPARSE_PARAM);
1869 # else
1870 int yyparse ();
1871 # endif
1872 #else /* ! YYPARSE_PARAM */
1873 #if defined (__STDC__) || defined (__cplusplus)
1874 int yyparse (void);
1875 #else
1876 int yyparse ();
1877 #endif
1878 #endif /* ! YYPARSE_PARAM */
1879
1880
1881
1882 /* The look-ahead symbol. */
1883 int yychar;
1884
1885 /* The semantic value of the look-ahead symbol. */
1886 YYSTYPE yylval;
1887
1888 /* Number of syntax errors so far. */
1889 int yynerrs;
1890
1891
1892
1893 /*----------.
1894 | yyparse. |
1895 `----------*/
1896
1897 #ifdef YYPARSE_PARAM
1898 # if defined (__STDC__) || defined (__cplusplus)
1899 int yyparse (void *YYPARSE_PARAM)
1900 # else
1901 int yyparse (YYPARSE_PARAM)
1902 void *YYPARSE_PARAM;
1903 # endif
1904 #else /* ! YYPARSE_PARAM */
1905 #if defined (__STDC__) || defined (__cplusplus)
1906 int
1907 yyparse (void)
1908 #else
1909 int
1910 yyparse ()
1911 ;
1912 #endif
1913 #endif
1914 {
1915
1916 int yystate;
1917 int yyn;
1918 int yyresult;
1919 /* Number of tokens to shift before error messages enabled. */
1920 int yyerrstatus;
1921 /* Look-ahead token as an internal (translated) token number. */
1922 int yytoken = 0;
1923
1924 /* Three stacks and their tools:
1925 `yyss': related to states,
1926 `yyvs': related to semantic values,
1927 `yyls': related to locations.
1928
1929 Refer to the stacks thru separate pointers, to allow yyoverflow
1930 to reallocate them elsewhere. */
1931
1932 /* The state stack. */
1933 short int yyssa[YYINITDEPTH];
1934 short int *yyss = yyssa;
1935 short int *yyssp;
1936
1937 /* The semantic value stack. */
1938 YYSTYPE yyvsa[YYINITDEPTH];
1939 YYSTYPE *yyvs = yyvsa;
1940 YYSTYPE *yyvsp;
1941
1942
1943
1944 #define YYPOPSTACK (yyvsp--, yyssp--)
1945
1946 YYSIZE_T yystacksize = YYINITDEPTH;
1947
1948 /* The variables used to return semantic value and location from the
1949 action routines. */
1950 YYSTYPE yyval;
1951
1952
1953 /* When reducing, the number of symbols on the RHS of the reduced
1954 rule. */
1955 int yylen;
1956
1957 YYDPRINTF ((stderr, "Starting parse\n"));
1958
1959 yystate = 0;
1960 yyerrstatus = 0;
1961 yynerrs = 0;
1962 yychar = YYEMPTY; /* Cause a token to be read. */
1963
1964 /* Initialize stack pointers.
1965 Waste one element of value and location stack
1966 so that they stay on the same level as the state stack.
1967 The wasted elements are never initialized. */
1968
1969 yyssp = yyss;
1970 yyvsp = yyvs;
1971
1972 goto yysetstate;
1973
1974 /*------------------------------------------------------------.
1975 | yynewstate -- Push a new state, which is found in yystate. |
1976 `------------------------------------------------------------*/
1977 yynewstate:
1978 /* In all cases, when you get here, the value and location stacks
1979 have just been pushed. so pushing a state here evens the stacks.
1980 */
1981 yyssp++;
1982
1983 yysetstate:
1984 *yyssp = yystate;
1985
1986 if (yyss + yystacksize - 1 <= yyssp)
1987 {
1988 /* Get the current used size of the three stacks, in elements. */
1989 YYSIZE_T yysize = yyssp - yyss + 1;
1990
1991 #ifdef yyoverflow
1992 {
1993 /* Give user a chance to reallocate the stack. Use copies of
1994 these so that the &'s don't force the real ones into
1995 memory. */
1996 YYSTYPE *yyvs1 = yyvs;
1997 short int *yyss1 = yyss;
1998
1999
2000 /* Each stack pointer address is followed by the size of the
2001 data in use in that stack, in bytes. This used to be a
2002 conditional around just the two extra args, but that might
2003 be undefined if yyoverflow is a macro. */
2004 yyoverflow (YY_("memory exhausted"),
2005 &yyss1, yysize * sizeof (*yyssp),
2006 &yyvs1, yysize * sizeof (*yyvsp),
2007
2008 &yystacksize);
2009
2010 yyss = yyss1;
2011 yyvs = yyvs1;
2012 }
2013 #else /* no yyoverflow */
2014 # ifndef YYSTACK_RELOCATE
2015 goto yyexhaustedlab;
2016 # else
2017 /* Extend the stack our own way. */
2018 if (YYMAXDEPTH <= yystacksize)
2019 goto yyexhaustedlab;
2020 yystacksize *= 2;
2021 if (YYMAXDEPTH < yystacksize)
2022 yystacksize = YYMAXDEPTH;
2023
2024 {
2025 short int *yyss1 = yyss;
2026 union yyalloc *yyptr =
2027 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2028 if (! yyptr)
2029 goto yyexhaustedlab;
2030 YYSTACK_RELOCATE (yyss);
2031 YYSTACK_RELOCATE (yyvs);
2032
2033 # undef YYSTACK_RELOCATE
2034 if (yyss1 != yyssa)
2035 YYSTACK_FREE (yyss1);
2036 }
2037 # endif
2038 #endif /* no yyoverflow */
2039
2040 yyssp = yyss + yysize - 1;
2041 yyvsp = yyvs + yysize - 1;
2042
2043
2044 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2045 (unsigned long int) yystacksize));
2046
2047 if (yyss + yystacksize - 1 <= yyssp)
2048 YYABORT;
2049 }
2050
2051 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2052
2053 goto yybackup;
2054
2055 /*-----------.
2056 | yybackup. |
2057 `-----------*/
2058 yybackup:
2059
2060 /* Do appropriate processing given the current state. */
2061 /* Read a look-ahead token if we need one and don't already have one. */
2062 /* yyresume: */
2063
2064 /* First try to decide what to do without reference to look-ahead token. */
2065
2066 yyn = yypact[yystate];
2067 if (yyn == YYPACT_NINF)
2068 goto yydefault;
2069
2070 /* Not known => get a look-ahead token if don't already have one. */
2071
2072 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2073 if (yychar == YYEMPTY)
2074 {
2075 YYDPRINTF ((stderr, "Reading a token: "));
2076 yychar = YYLEX;
2077 }
2078
2079 if (yychar <= YYEOF)
2080 {
2081 yychar = yytoken = YYEOF;
2082 YYDPRINTF ((stderr, "Now at end of input.\n"));
2083 }
2084 else
2085 {
2086 yytoken = YYTRANSLATE (yychar);
2087 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2088 }
2089
2090 /* If the proper action on seeing token YYTOKEN is to reduce or to
2091 detect an error, take that action. */
2092 yyn += yytoken;
2093 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2094 goto yydefault;
2095 yyn = yytable[yyn];
2096 if (yyn <= 0)
2097 {
2098 if (yyn == 0 || yyn == YYTABLE_NINF)
2099 goto yyerrlab;
2100 yyn = -yyn;
2101 goto yyreduce;
2102 }
2103
2104 if (yyn == YYFINAL)
2105 YYACCEPT;
2106
2107 /* Shift the look-ahead token. */
2108 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2109
2110 /* Discard the token being shifted unless it is eof. */
2111 if (yychar != YYEOF)
2112 yychar = YYEMPTY;
2113
2114 *++yyvsp = yylval;
2115
2116
2117 /* Count tokens shifted since error; after three, turn off error
2118 status. */
2119 if (yyerrstatus)
2120 yyerrstatus--;
2121
2122 yystate = yyn;
2123 goto yynewstate;
2124
2125
2126 /*-----------------------------------------------------------.
2127 | yydefault -- do the default action for the current state. |
2128 `-----------------------------------------------------------*/
2129 yydefault:
2130 yyn = yydefact[yystate];
2131 if (yyn == 0)
2132 goto yyerrlab;
2133 goto yyreduce;
2134
2135
2136 /*-----------------------------.
2137 | yyreduce -- Do a reduction. |
2138 `-----------------------------*/
2139 yyreduce:
2140 /* yyn is the number of a rule to reduce with. */
2141 yylen = yyr2[yyn];
2142
2143 /* If YYLEN is nonzero, implement the default value of the action:
2144 `$$ = $1'.
2145
2146 Otherwise, the following line sets YYVAL to garbage.
2147 This behavior is undocumented and Bison
2148 users should not rely upon it. Assigning to YYVAL
2149 unconditionally makes the parser a bit smaller, and it avoids a
2150 GCC warning that YYVAL may be used uninitialized. */
2151 yyval = yyvsp[1-yylen];
2152
2153
2154 YY_REDUCE_PRINT (yyn);
2155 switch (yyn)
2156 {
2157 case 2:
2158 #line 304 "parser.y"
2159 { fix_incomplete();
2160 check_all_user_types((yyvsp[0].ifref_list));
2161 write_proxies((yyvsp[0].ifref_list));
2162 write_client((yyvsp[0].ifref_list));
2163 write_server((yyvsp[0].ifref_list));
2164 write_dlldata((yyvsp[0].ifref_list));
2165 ;}
2166 break;
2167
2168 case 3:
2169 #line 313 "parser.y"
2170 { (yyval.ifref_list) = NULL; ;}
2171 break;
2172
2173 case 4:
2174 #line 314 "parser.y"
2175 { (yyval.ifref_list) = (yyvsp[-1].ifref_list); ;}
2176 break;
2177
2178 case 5:
2179 #line 315 "parser.y"
2180 { (yyval.ifref_list) = append_ifref( (yyvsp[-1].ifref_list), make_ifref((yyvsp[0].type)) ); ;}
2181 break;
2182
2183 case 6:
2184 #line 316 "parser.y"
2185 { (yyval.ifref_list) = (yyvsp[-2].ifref_list);
2186 reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, 0);
2187 if (!parse_only && do_header) write_coclass_forward((yyvsp[-1].type));
2188 ;}
2189 break;
2190
2191 case 7:
2192 #line 320 "parser.y"
2193 { (yyval.ifref_list) = (yyvsp[-1].ifref_list);
2194 add_typelib_entry((yyvsp[0].type));
2195 reg_type((yyvsp[0].type), (yyvsp[0].type)->name, 0);
2196 if (!parse_only && do_header) write_coclass_forward((yyvsp[0].type));
2197 ;}
2198 break;
2199
2200 case 8:
2201 #line 325 "parser.y"
2202 { (yyval.ifref_list) = (yyvsp[-1].ifref_list); add_typelib_entry((yyvsp[0].type)); ;}
2203 break;
2204
2205 case 9:
2206 #line 326 "parser.y"
2207 { (yyval.ifref_list) = (yyvsp[-1].ifref_list); ;}
2208 break;
2209
2210 case 10:
2211 #line 327 "parser.y"
2212 { (yyval.ifref_list) = (yyvsp[-1].ifref_list); ;}
2213 break;
2214
2215 case 11:
2216 #line 330 "parser.y"
2217 {;}
2218 break;
2219
2220 case 12:
2221 #line 331 "parser.y"
2222 { if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
2223 break;
2224
2225 case 13:
2226 #line 332 "parser.y"
2227 { if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
2228 break;
2229
2230 case 14:
2231 #line 333 "parser.y"
2232 { reg_type((yyvsp[-1].type), (yyvsp[-1].type)->name, 0); if (!parse_only && do_header) write_coclass_forward((yyvsp[-1].type)); ;}
2233 break;
2234
2235 case 15:
2236 #line 334 "parser.y"
2237 { if (!parse_only) add_typelib_entry((yyvsp[0].type));
2238 reg_type((yyvsp[0].type), (yyvsp[0].type)->name, 0);
2239 if (!parse_only && do_header) write_coclass_forward((yyvsp[0].type));
2240 ;}
2241 break;
2242
2243 case 16:
2244 #line 338 "parser.y"
2245 { if (!parse_only) add_typelib_entry((yyvsp[0].type)); ;}
2246 break;
2247
2248 case 17:
2249 #line 339 "parser.y"
2250 {;}
2251 break;
2252
2253 case 18:
2254 #line 340 "parser.y"
2255 {;}
2256 break;
2257
2258 case 19:
2259 #line 341 "parser.y"
2260 {;}
2261 break;
2262
2263 case 20:
2264 #line 344 "parser.y"
2265 { (yyval.func_list) = NULL; ;}
2266 break;
2267
2268 case 21:
2269 #line 345 "parser.y"
2270 { (yyval.func_list) = append_func( (yyvsp[-2].func_list), (yyvsp[-1].func) ); ;}
2271 break;
2272
2273 case 22:
2274 #line 346 "parser.y"
2275 { (yyval.func_list) = (yyvsp[-1].func_list); ;}
2276 break;
2277
2278 case 25:
2279 #line 353 "parser.y"
2280 { if (!parse_only && do_header) { write_constdef((yyvsp[-1].var)); } ;}
2281 break;
2282
2283 case 26:
2284 #line 354 "parser.y"
2285 {;}
2286 break;
2287
2288 case 27:
2289 #line 355 "parser.y"
2290 { if (!parse_only && do_header) {
2291 write_type_def_or_decl(header, (yyvsp[-1].type), FALSE, NULL);
2292 fprintf(header, ";\n\n");
2293 }
2294 ;}
2295 break;
2296
2297 case 28:
2298 #line 360 "parser.y"
2299 { if (!parse_only && do_header) { write_externdef((yyvsp[-1].var)); } ;}
2300 break;
2301
2302 case 29:
2303 #line 361 "parser.y"
2304 {;}
2305 break;
2306
2307 case 30:
2308 #line 362 "parser.y"
2309 { if (!parse_only && do_header) {
2310 write_type_def_or_decl(header, (yyvsp[-1].type), FALSE, NULL);
2311 fprintf(header, ";\n\n");
2312 }
2313 ;}
2314 break;
2315
2316 case 31:
2317 #line 367 "parser.y"
2318 {;}
2319 break;
2320
2321 case 32:
2322 #line 368 "parser.y"
2323 { if (!parse_only && do_header) {
2324 write_type_def_or_decl(header, (yyvsp[-1].type), FALSE, NULL);
2325 fprintf(header, ";\n\n");
2326 }
2327 ;}
2328 break;
2329
2330 case 33:
2331 #line 375 "parser.y"
2332 { if (!parse_only && do_header) fprintf(header, "%s\n", (yyvsp[-1].str)); ;}
2333 break;
2334
2335 case 34:
2336 #line 377 "parser.y"
2337 { assert(yychar == YYEMPTY);
2338 (yyval.num) = do_import((yyvsp[-1].str));
2339 if (!(yyval.num)) yychar = aEOF;
2340 ;}
2341 break;
2342
2343 case 35:
2344 #line 384 "parser.y"
2345 { if ((yyvsp[-2].num)) pop_import(); ;}
2346 break;
2347
2348 case 36:
2349 #line 388 "parser.y"
2350 { if(!parse_only) add_importlib((yyvsp[-2].str)); ;}
2351 break;
2352
2353 case 37:
2354 #line 391 "parser.y"
2355 { (yyval.str) = (yyvsp[0].str); ;}
2356 break;
2357
2358 case 38:
2359 #line 393 "parser.y"
2360 { check_library_attrs((yyvsp[-1].str), (yyvsp[-2].attr_list));
2361 if (!parse_only) start_typelib((yyvsp[-1].str), (yyvsp[-2].attr_list));
2362 if (!parse_only && do_header) write_library((yyvsp[-1].str), (yyvsp[-2].attr_list));
2363 if (!parse_only && do_idfile) write_libid((yyvsp[-1].str), (yyvsp[-2].attr_list));
2364 is_inside_library = TRUE;
2365 ;}
2366 break;
2367
2368 case 39:
2369 #line 401 "parser.y"
2370 { if (!parse_only) end_typelib(); is_inside_library = FALSE; ;}
2371 break;
2372
2373 case 40:
2374 #line 404 "parser.y"
2375 { (yyval.var_list) = NULL; ;}
2376 break;
2377
2378 case 42:
2379 #line 408 "parser.y"
2380 { (yyval.var_list) = NULL; ;}
2381 break;
2382
2383 case 43:
2384 #line 411 "parser.y"
2385 { check_arg((yyvsp[0].var)); (yyval.var_list) = append_var( NULL, (yyvsp[0].var) ); ;}
2386 break;
2387
2388 case 44:
2389 #line 412 "parser.y"
2390 { check_arg((yyvsp[0].var)); (yyval.var_list) = append_var( (yyvsp[-2].var_list), (yyvsp[0].var)); ;}
2391 break;
2392
2393 case 46:
2394 #line 417 "parser.y"
2395 { (yyval.var) = (yyvsp[-1].pident)->var;
2396 (yyval.var)->attrs = (yyvsp[-3].attr_list);
2397 set_type((yyval.var), (yyvsp[-2].type), (yyvsp[-1].pident), (yyvsp[0].array_dims), TRUE);
2398 free((yyvsp[-1].pident));
2399 ;}
2400 break;
2401
2402 case 47:
2403 #line 422 "parser.y"
2404 { (yyval.var) = (yyvsp[-1].pident)->var;
2405 set_type((yyval.var), (yyvsp[-2].type), (yyvsp[-1].pident), (yyvsp[0].array_dims), TRUE);
2406 free((yyvsp[-1].pident));
2407 ;}
2408 break;
2409
2410 case 48:
2411 #line 428 "parser.y"
2412 { (yyval.array_dims) = NULL; ;}
2413 break;
2414
2415 case 49:
2416 #line 429 "parser.y"
2417 { (yyval.array_dims) = (yyvsp[-1].array_dims); ;}
2418 break;
2419
2420 case 50:
2421 #line 430 "parser.y"
2422 { (yyval.array_dims) = append_array( NULL, make_expr(EXPR_VOID) ); ;}
2423 break;
2424
2425 case 51:
2426 #line 433 "parser.y"
2427 { (yyval.array_dims) = append_array( NULL, (yyvsp[0].expr) ); ;}
2428 break;
2429
2430 case 52:
2431 #line 434 "parser.y"
2432 { (yyval.array_dims) = append_array( (yyvsp[-2].array_dims), (yyvsp[0].expr) ); ;}
2433 break;
2434
2435 case 53:
2436 #line 435 "parser.y"
2437 { (yyval.array_dims) = append_array( (yyvsp[-3].array_dims), (yyvsp[0].expr) ); ;}
2438 break;
2439
2440 case 54:
2441 #line 438 "parser.y"
2442 { (yyval.attr_list) = NULL; ;}
2443 break;
2444
2445 case 56:
2446 #line 443 "parser.y"
2447 { (yyval.attr_list) = (yyvsp[-1].attr_list);
2448 if (!(yyval.attr_list))
2449 error_loc("empty attribute lists unsupported\n");
2450 ;}
2451 break;
2452
2453 case 57:
2454 #line 449 "parser.y"
2455 { (yyval.attr_list) = append_attr( NULL, (yyvsp[0].attr) ); ;}
2456 break;
2457
2458 case 58:
2459 #line 450 "parser.y"
2460 { (yyval.attr_list) = append_attr( (yyvsp[-2].attr_list), (yyvsp[0].attr) ); ;}
2461 break;
2462
2463 case 59:
2464 #line 451 "parser.y"
2465 { (yyval.attr_list) = append_attr( (yyvsp[-3].attr_list), (yyvsp[0].attr) ); ;}
2466 break;
2467
2468 case 60:
2469 #line 454 "parser.y"
2470 { (yyval.str_list) = append_str( NULL, (yyvsp[0].str) ); ;}
2471 break;
2472
2473 case 61:
2474 #line 455 "parser.y"
2475 { (yyval.str_list) = append_str( (yyvsp[-2].str_list), (yyvsp[0].str) ); ;}
2476 break;
2477
2478 case 62:
2479 #line 458 "parser.y"
2480 { (yyval.attr) = NULL; ;}
2481 break;
2482
2483 case 63:
2484 #line 459 "parser.y"
2485 { (yyval.attr) = make_attr(ATTR_AGGREGATABLE); ;}
2486 break;
2487
2488 case 64:
2489 #line 460 "parser.y"
2490 { (yyval.attr) = make_attr(ATTR_APPOBJECT); ;}
2491 break;
2492
2493 case 65:
2494 #line 461 "parser.y"
2495 { (yyval.attr) = make_attr(ATTR_ASYNC); ;}
2496 break;
2497
2498 case 66:
2499 #line 462 "parser.y"
2500 { (yyval.attr) = make_attr(ATTR_AUTO_HANDLE); ;}
2501 break;
2502
2503 case 67:
2504 #line 463 "parser.y"
2505 { (yyval.attr) = make_attr(ATTR_BINDABLE); ;}
2506 break;
2507
2508 case 68:
2509 #line 464 "parser.y"
2510 { (yyval.attr) = make_attr(ATTR_BROADCAST); ;}
2511 break;
2512
2513 case 69:
2514 #line 465 "parser.y"
2515 { (yyval.attr) = make_attrp(ATTR_CALLAS, (yyvsp[-1].var)); ;}
2516 break;
2517
2518 case 70:
2519 #line 466 "parser.y"
2520 { (yyval.attr) = make_attrp(ATTR_CASE, (yyvsp[-1].expr_list)); ;}
2521 break;
2522
2523 case 71:
2524 #line 467 "parser.y"
2525 { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); ;}
2526 break;
2527
2528 case 72:
2529 #line 468 "parser.y"
2530 { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_DONT_SERIALIZE */ ;}
2531 break;
2532
2533 case 73:
2534 #line 469 "parser.y"
2535 { (yyval.attr) = make_attrv(ATTR_CONTEXTHANDLE, 0); /* RPC_CONTEXT_HANDLE_SERIALIZE */ ;}
2536 break;
2537
2538 case 74:
2539 #line 470 "parser.y"
2540 { (yyval.attr) = make_attr(ATTR_CONTROL); ;}
2541 break;
2542
2543 case 75:
2544 #line 471 "parser.y"
2545 { (yyval.attr) = make_attr(ATTR_DEFAULT); ;}
2546 break;
2547
2548 case 76:
2549 #line 472 "parser.y"
2550 { (yyval.attr) = make_attr(ATTR_DEFAULTCOLLELEM); ;}
2551 break;
2552
2553 case 77:
2554 #line 473 "parser.y"
2555 { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE_EXPR, (yyvsp[-1].expr)); ;}
2556 break;
2557
2558 case 78:
2559 #line 474 "parser.y"
2560 { (yyval.attr) = make_attrp(ATTR_DEFAULTVALUE_STRING, (yyvsp[-1].str)); ;}
2561 break;
2562
2563 case 79:
2564 #line 475 "parser.y"
2565 { (yyval.attr) = make_attr(ATTR_DEFAULTVTABLE); ;}
2566 break;
2567
2568 case 80:
2569 #line 476 "parser.y"
2570 { (yyval.attr) = make_attr(ATTR_DISPLAYBIND); ;}
2571 break;
2572
2573 case 81:
2574 #line 477 "parser.y"
2575 { (yyval.attr) = make_attrp(ATTR_DLLNAME, (yyvsp[-1].str)); ;}
2576 break;
2577
2578 case 82:
2579 #line 478 "parser.y"
2580 { (yyval.attr) = make_attr(ATTR_DUAL); ;}
2581 break;
2582
2583 case 83:
2584 #line 479 "parser.y"
2585 { (yyval.attr) = make_attrp(ATTR_ENDPOINT, (yyvsp[-1].str_list)); ;}
2586 break;
2587
2588 case 84:
2589 #line 480 "parser.y"
2590 { (yyval.attr) = make_attrp(ATTR_ENTRY_STRING, (yyvsp[-1].str)); ;}
2591 break;
2592
2593 case 85:
2594 #line 481 "parser.y"
2595 { (yyval.attr) = make_attrp(ATTR_ENTRY_ORDINAL, (yyvsp[-1].expr)); ;}
2596 break;
2597
2598 case 86:
2599 #line 482 "parser.y"
2600 { (yyval.attr) = make_attr(ATTR_EXPLICIT_HANDLE); ;}
2601 break;
2602
2603 case 87:
2604 #line 483 "parser.y"
2605 { (yyval.attr) = make_attr(ATTR_HANDLE); ;}
2606 break;
2607
2608 case 88:
2609 #line 484 "parser.y"
2610 { (yyval.attr) = make_attrp(ATTR_HELPCONTEXT, (yyvsp[-1].expr)); ;}
2611 break;
2612
2613 case 89:
2614 #line 485 "parser.y"
2615 { (yyval.attr) = make_attrp(ATTR_HELPFILE, (yyvsp[-