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