Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / prebuilts / go / linux-x86 / 7bb052a61962320641242e4290ffb5087e6094cb / . / src / cmd / cc / y.tab.c
blob: 94932efe58e23ee3216a93ac1e427488c0a8a782 [file] [log] [blame]
Colin Cross7bb052a2015-02-03 12:59:37 -0800[diff] [blame^]1/* A Bison parser, made by GNU Bison 2.3. */
2
3/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 Free Software Foundation, Inc.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
22
23/* As a special exception, you may create a larger work that contains
24 part or all of the Bison parser skeleton and distribute that work
25 under terms of your choice, so long as that work isn't itself a
26 parser generator using the skeleton or a modified version thereof
27 as a parser skeleton. Alternatively, if you modify or redistribute
28 the parser skeleton itself, you may (at your option) remove this
29 special exception, which will cause the skeleton and the resulting
30 Bison output files to be licensed under the GNU General Public
31 License without this special exception.
32
33 This special exception was added by the Free Software Foundation in
34 version 2.2 of Bison. */
35
36/* C LALR(1) parser skeleton written by Richard Stallman, by
37 simplifying the original so-called "semantic" parser. */
38
39/* All symbols defined below should begin with yy or YY, to avoid
40 infringing on user name space. This should be done even for local
41 variables, as they might otherwise be expanded by user macros.
42 There are some unavoidable exceptions within include files to
43 define necessary library symbols; they are noted "INFRINGES ON
44 USER NAME SPACE" below. */
45
46/* Identify Bison output. */
47#define YYBISON 1
48
49/* Bison version. */
50#define YYBISON_VERSION "2.3"
51
52/* Skeleton name. */
53#define YYSKELETON_NAME "yacc.c"
54
55/* Pure parsers. */
56#define YYPURE 0
57
58/* Using locations. */
59#define YYLSP_NEEDED 0
60
61
62
63/* Tokens. */
64#ifndef YYTOKENTYPE
65# define YYTOKENTYPE
66 /* Put the tokens into the symbol table, so that GDB and other debuggers
67 know about them. */
68 enum yytokentype {
69 LORE = 258,
70 LXORE = 259,
71 LANDE = 260,
72 LLSHE = 261,
73 LRSHE = 262,
74 LMDE = 263,
75 LDVE = 264,
76 LMLE = 265,
77 LME = 266,
78 LPE = 267,
79 LOROR = 268,
80 LANDAND = 269,
81 LNE = 270,
82 LEQ = 271,
83 LGE = 272,
84 LLE = 273,
85 LRSH = 274,
86 LLSH = 275,
87 LMG = 276,
88 LPP = 277,
89 LMM = 278,
90 LNAME = 279,
91 LTYPE = 280,
92 LFCONST = 281,
93 LDCONST = 282,
94 LCONST = 283,
95 LLCONST = 284,
96 LUCONST = 285,
97 LULCONST = 286,
98 LVLCONST = 287,
99 LUVLCONST = 288,
100 LSTRING = 289,
101 LLSTRING = 290,
102 LAUTO = 291,
103 LBREAK = 292,
104 LCASE = 293,
105 LCHAR = 294,
106 LCONTINUE = 295,
107 LDEFAULT = 296,
108 LDO = 297,
109 LDOUBLE = 298,
110 LELSE = 299,
111 LEXTERN = 300,
112 LFLOAT = 301,
113 LFOR = 302,
114 LGOTO = 303,
115 LIF = 304,
116 LINT = 305,
117 LLONG = 306,
118 LPREFETCH = 307,
119 LREGISTER = 308,
120 LRETURN = 309,
121 LSHORT = 310,
122 LSIZEOF = 311,
123 LUSED = 312,
124 LSTATIC = 313,
125 LSTRUCT = 314,
126 LSWITCH = 315,
127 LTYPEDEF = 316,
128 LTYPESTR = 317,
129 LUNION = 318,
130 LUNSIGNED = 319,
131 LWHILE = 320,
132 LVOID = 321,
133 LENUM = 322,
134 LSIGNED = 323,
135 LCONSTNT = 324,
136 LVOLATILE = 325,
137 LSET = 326,
138 LSIGNOF = 327,
139 LRESTRICT = 328,
140 LINLINE = 329
141 };
142#endif
143/* Tokens. */
144#define LORE 258
145#define LXORE 259
146#define LANDE 260
147#define LLSHE 261
148#define LRSHE 262
149#define LMDE 263
150#define LDVE 264
151#define LMLE 265
152#define LME 266
153#define LPE 267
154#define LOROR 268
155#define LANDAND 269
156#define LNE 270
157#define LEQ 271
158#define LGE 272
159#define LLE 273
160#define LRSH 274
161#define LLSH 275
162#define LMG 276
163#define LPP 277
164#define LMM 278
165#define LNAME 279
166#define LTYPE 280
167#define LFCONST 281
168#define LDCONST 282
169#define LCONST 283
170#define LLCONST 284
171#define LUCONST 285
172#define LULCONST 286
173#define LVLCONST 287
174#define LUVLCONST 288
175#define LSTRING 289
176#define LLSTRING 290
177#define LAUTO 291
178#define LBREAK 292
179#define LCASE 293
180#define LCHAR 294
181#define LCONTINUE 295
182#define LDEFAULT 296
183#define LDO 297
184#define LDOUBLE 298
185#define LELSE 299
186#define LEXTERN 300
187#define LFLOAT 301
188#define LFOR 302
189#define LGOTO 303
190#define LIF 304
191#define LINT 305
192#define LLONG 306
193#define LPREFETCH 307
194#define LREGISTER 308
195#define LRETURN 309
196#define LSHORT 310
197#define LSIZEOF 311
198#define LUSED 312
199#define LSTATIC 313
200#define LSTRUCT 314
201#define LSWITCH 315
202#define LTYPEDEF 316
203#define LTYPESTR 317
204#define LUNION 318
205#define LUNSIGNED 319
206#define LWHILE 320
207#define LVOID 321
208#define LENUM 322
209#define LSIGNED 323
210#define LCONSTNT 324
211#define LVOLATILE 325
212#define LSET 326
213#define LSIGNOF 327
214#define LRESTRICT 328
215#define LINLINE 329
216
217
218
219
220/* Copy the first part of user declarations. */
221#line 31 "cc.y"
222
223#include <u.h>
224#include <stdio.h> /* if we don't, bison will, and cc.h re-#defines getc */
225#include "cc.h"
226
227
228/* Enabling traces. */
229#ifndef YYDEBUG
230# define YYDEBUG 0
231#endif
232
233/* Enabling verbose error messages. */
234#ifdef YYERROR_VERBOSE
235# undef YYERROR_VERBOSE
236# define YYERROR_VERBOSE 1
237#else
238# define YYERROR_VERBOSE 0
239#endif
240
241/* Enabling the token table. */
242#ifndef YYTOKEN_TABLE
243# define YYTOKEN_TABLE 0
244#endif
245
246#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
247typedef union YYSTYPE
248#line 36 "cc.y"
249{
250 Node* node;
251 Sym* sym;
252 Type* type;
253 struct
254 {
255 Type* t;
256 uchar c;
257 } tycl;
258 struct
259 {
260 Type* t1;
261 Type* t2;
262 Type* t3;
263 uchar c;
264 } tyty;
265 struct
266 {
267 char* s;
268 int32 l;
269 } sval;
270 int32 lval;
271 double dval;
272 vlong vval;
273}
274/* Line 193 of yacc.c. */
275#line 276 "y.tab.c"
276 YYSTYPE;
277# define yystype YYSTYPE /* obsolescent; will be withdrawn */
278# define YYSTYPE_IS_DECLARED 1
279# define YYSTYPE_IS_TRIVIAL 1
280#endif
281
282
283
284/* Copy the second part of user declarations. */
285
286
287/* Line 216 of yacc.c. */
288#line 289 "y.tab.c"
289
290#ifdef short
291# undef short
292#endif
293
294#ifdef YYTYPE_UINT8
295typedef YYTYPE_UINT8 yytype_uint8;
296#else
297typedef unsigned char yytype_uint8;
298#endif
299
300#ifdef YYTYPE_INT8
301typedef YYTYPE_INT8 yytype_int8;
302#elif (defined __STDC__ || defined __C99__FUNC__ \
303 || defined __cplusplus || defined _MSC_VER)
304typedef signed char yytype_int8;
305#else
306typedef short int yytype_int8;
307#endif
308
309#ifdef YYTYPE_UINT16
310typedef YYTYPE_UINT16 yytype_uint16;
311#else
312typedef unsigned short int yytype_uint16;
313#endif
314
315#ifdef YYTYPE_INT16
316typedef YYTYPE_INT16 yytype_int16;
317#else
318typedef short int yytype_int16;
319#endif
320
321#ifndef YYSIZE_T
322# ifdef __SIZE_TYPE__
323# define YYSIZE_T __SIZE_TYPE__
324# elif defined size_t
325# define YYSIZE_T size_t
326# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
327 || defined __cplusplus || defined _MSC_VER)
328# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
329# define YYSIZE_T size_t
330# else
331# define YYSIZE_T unsigned int
332# endif
333#endif
334
335#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
336
337#ifndef YY_
338# if defined YYENABLE_NLS && YYENABLE_NLS
339# if ENABLE_NLS
340# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
341# define YY_(msgid) dgettext ("bison-runtime", msgid)
342# endif
343# endif
344# ifndef YY_
345# define YY_(msgid) msgid
346# endif
347#endif
348
349/* Suppress unused-variable warnings by "using" E. */
350#if ! defined lint || defined __GNUC__
351# define YYUSE(e) ((void) (e))
352#else
353# define YYUSE(e) /* empty */
354#endif
355
356/* Identity function, used to suppress warnings about constant conditions. */
357#ifndef lint
358# define YYID(n) (n)
359#else
360#if (defined __STDC__ || defined __C99__FUNC__ \
361 || defined __cplusplus || defined _MSC_VER)
362static int
363YYID (int i)
364#else
365static int
366YYID (i)
367 int i;
368#endif
369{
370 return i;
371}
372#endif
373
374#if ! defined yyoverflow || YYERROR_VERBOSE
375
376/* The parser invokes alloca or malloc; define the necessary symbols. */
377
378# ifdef YYSTACK_USE_ALLOCA
379# if YYSTACK_USE_ALLOCA
380# ifdef __GNUC__
381# define YYSTACK_ALLOC __builtin_alloca
382# elif defined __BUILTIN_VA_ARG_INCR
383# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
384# elif defined _AIX
385# define YYSTACK_ALLOC __alloca
386# elif defined _MSC_VER
387# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
388# define alloca _alloca
389# else
390# define YYSTACK_ALLOC alloca
391# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
392 || defined __cplusplus || defined _MSC_VER)
393# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
394# ifndef _STDLIB_H
395# define _STDLIB_H 1
396# endif
397# endif
398# endif
399# endif
400# endif
401
402# ifdef YYSTACK_ALLOC
403 /* Pacify GCC's `empty if-body' warning. */
404# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
405# ifndef YYSTACK_ALLOC_MAXIMUM
406 /* The OS might guarantee only one guard page at the bottom of the stack,
407 and a page size can be as small as 4096 bytes. So we cannot safely
408 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
409 to allow for a few compiler-allocated temporary stack slots. */
410# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
411# endif
412# else
413# define YYSTACK_ALLOC YYMALLOC
414# define YYSTACK_FREE YYFREE
415# ifndef YYSTACK_ALLOC_MAXIMUM
416# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
417# endif
418# if (defined __cplusplus && ! defined _STDLIB_H \
419 && ! ((defined YYMALLOC || defined malloc) \
420 && (defined YYFREE || defined free)))
421# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
422# ifndef _STDLIB_H
423# define _STDLIB_H 1
424# endif
425# endif
426# ifndef YYMALLOC
427# define YYMALLOC malloc
428# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
429 || defined __cplusplus || defined _MSC_VER)
430void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
431# endif
432# endif
433# ifndef YYFREE
434# define YYFREE free
435# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
436 || defined __cplusplus || defined _MSC_VER)
437void free (void *); /* INFRINGES ON USER NAME SPACE */
438# endif
439# endif
440# endif
441#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
442
443
444#if (! defined yyoverflow \
445 && (! defined __cplusplus \
446 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
447
448/* A type that is properly aligned for any stack member. */
449union yyalloc
450{
451 yytype_int16 yyss;
452 YYSTYPE yyvs;
453 };
454
455/* The size of the maximum gap between one aligned stack and the next. */
456# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
457
458/* The size of an array large to enough to hold all stacks, each with
459 N elements. */
460# define YYSTACK_BYTES(N) \
461 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
462 + YYSTACK_GAP_MAXIMUM)
463
464/* Copy COUNT objects from FROM to TO. The source and destination do
465 not overlap. */
466# ifndef YYCOPY
467# if defined __GNUC__ && 1 < __GNUC__
468# define YYCOPY(To, From, Count) \
469 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
470# else
471# define YYCOPY(To, From, Count) \
472 do \
473 { \
474 YYSIZE_T yyi; \
475 for (yyi = 0; yyi < (Count); yyi++) \
476 (To)[yyi] = (From)[yyi]; \
477 } \
478 while (YYID (0))
479# endif
480# endif
481
482/* Relocate STACK from its old location to the new one. The
483 local variables YYSIZE and YYSTACKSIZE give the old and new number of
484 elements in the stack, and YYPTR gives the new location of the
485 stack. Advance YYPTR to a properly aligned location for the next
486 stack. */
487# define YYSTACK_RELOCATE(Stack) \
488 do \
489 { \
490 YYSIZE_T yynewbytes; \
491 YYCOPY (&yyptr->Stack, Stack, yysize); \
492 Stack = &yyptr->Stack; \
493 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
494 yyptr += yynewbytes / sizeof (*yyptr); \
495 } \
496 while (YYID (0))
497
498#endif
499
500/* YYFINAL -- State number of the termination state. */
501#define YYFINAL 2
502/* YYLAST -- Last index in YYTABLE. */
503#define YYLAST 1188
504
505/* YYNTOKENS -- Number of terminals. */
506#define YYNTOKENS 99
507/* YYNNTS -- Number of nonterminals. */
508#define YYNNTS 75
509/* YYNRULES -- Number of rules. */
510#define YYNRULES 247
511/* YYNRULES -- Number of states. */
512#define YYNSTATES 417
513
514/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
515#define YYUNDEFTOK 2
516#define YYMAXUTOK 329
517
518#define YYTRANSLATE(YYX) \
519 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
520
521/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
522static const yytype_uint8 yytranslate[] =
523{
524 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
526 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
527 2, 2, 2, 97, 2, 2, 2, 35, 22, 2,
528 38, 93, 33, 31, 4, 32, 36, 34, 2, 2,
529 2, 2, 2, 2, 2, 2, 2, 2, 17, 3,
530 25, 5, 26, 16, 2, 2, 2, 2, 2, 2,
531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
533 2, 37, 2, 94, 21, 2, 2, 2, 2, 2,
534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
536 2, 2, 2, 95, 20, 96, 98, 2, 2, 2,
537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
540 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
543 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
544 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
545 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
546 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
549 2, 2, 2, 2, 2, 2, 1, 2, 6, 7,
550 8, 9, 10, 11, 12, 13, 14, 15, 18, 19,
551 23, 24, 27, 28, 29, 30, 39, 40, 41, 42,
552 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
553 53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
554 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
555 73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
556 83, 84, 85, 86, 87, 88, 89, 90, 91, 92
557};
558
559#if YYDEBUG
560/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
561 YYRHS. */
562static const yytype_uint16 yyprhs[] =
563{
564 0, 0, 3, 4, 7, 10, 14, 15, 16, 23,
565 25, 26, 31, 35, 37, 41, 43, 47, 52, 57,
566 60, 64, 66, 67, 72, 76, 77, 82, 84, 88,
567 89, 94, 95, 101, 102, 104, 106, 110, 112, 116,
568 119, 120, 122, 125, 129, 131, 133, 138, 143, 146,
569 150, 154, 156, 160, 164, 167, 170, 173, 177, 179,
570 182, 184, 186, 189, 190, 192, 194, 197, 200, 204,
571 208, 212, 213, 216, 219, 221, 224, 228, 231, 234,
572 237, 239, 242, 244, 247, 250, 251, 254, 260, 268,
573 269, 280, 286, 294, 298, 304, 307, 310, 314, 320,
574 326, 332, 333, 335, 336, 338, 340, 342, 346, 348,
575 352, 356, 360, 364, 368, 372, 376, 380, 384, 388,
576 392, 396, 400, 404, 408, 412, 416, 420, 426, 430,
577 434, 438, 442, 446, 450, 454, 458, 462, 466, 470,
578 472, 478, 486, 488, 491, 494, 497, 500, 503, 506,
579 509, 512, 515, 518, 522, 528, 534, 539, 544, 548,
580 552, 555, 558, 560, 562, 564, 566, 568, 570, 572,
581 574, 576, 578, 580, 582, 585, 587, 590, 591, 593,
582 595, 599, 600, 605, 606, 608, 610, 612, 614, 617,
583 620, 624, 627, 631, 633, 635, 638, 639, 644, 647,
584 650, 651, 656, 659, 662, 663, 664, 672, 673, 679,
585 681, 683, 686, 687, 690, 692, 694, 696, 698, 701,
586 703, 705, 707, 711, 714, 718, 720, 722, 724, 726,
587 728, 730, 732, 734, 736, 738, 740, 742, 744, 746,
588 748, 750, 752, 754, 756, 758, 760, 762
589};
590
591/* YYRHS -- A `-1'-separated list of the rules' RHS. */
592static const yytype_int16 yyrhs[] =
593{
594 100, 0, -1, -1, 100, 101, -1, 152, 3, -1,
595 152, 104, 3, -1, -1, -1, 152, 106, 102, 111,
596 103, 129, -1, 106, -1, -1, 106, 105, 5, 123,
597 -1, 104, 4, 104, -1, 107, -1, 33, 163, 106,
598 -1, 172, -1, 38, 106, 93, -1, 107, 38, 127,
599 93, -1, 107, 37, 139, 94, -1, 155, 3, -1,
600 155, 109, 3, -1, 106, -1, -1, 106, 110, 5,
601 123, -1, 109, 4, 109, -1, -1, 111, 155, 112,
602 3, -1, 106, -1, 112, 4, 112, -1, -1, 154,
603 114, 116, 3, -1, -1, 113, 154, 115, 116, 3,
604 -1, -1, 117, -1, 118, -1, 117, 4, 117, -1,
605 106, -1, 172, 17, 140, -1, 17, 140, -1, -1,
606 120, -1, 33, 163, -1, 33, 163, 120, -1, 121,
607 -1, 122, -1, 121, 38, 127, 93, -1, 121, 37,
608 139, 94, -1, 38, 93, -1, 37, 139, 94, -1,
609 38, 120, 93, -1, 142, -1, 95, 126, 96, -1,
610 37, 140, 94, -1, 36, 173, -1, 124, 5, -1,
611 123, 4, -1, 125, 123, 4, -1, 124, -1, 125,
612 124, -1, 125, -1, 123, -1, 125, 123, -1, -1,
613 128, -1, 171, -1, 154, 119, -1, 154, 106, -1,
614 36, 36, 36, -1, 128, 4, 128, -1, 95, 130,
615 96, -1, -1, 130, 108, -1, 130, 133, -1, 132,
616 -1, 131, 132, -1, 56, 142, 17, -1, 59, 17,
617 -1, 42, 17, -1, 1, 3, -1, 135, -1, 131,
618 135, -1, 138, -1, 155, 109, -1, 138, 3, -1,
619 -1, 136, 129, -1, 67, 38, 141, 93, 133, -1,
620 67, 38, 141, 93, 133, 62, 133, -1, -1, 137,
621 65, 38, 134, 3, 138, 3, 138, 93, 133, -1,
622 83, 38, 141, 93, 133, -1, 60, 133, 83, 38,
623 141, 93, 3, -1, 72, 138, 3, -1, 78, 38,
624 141, 93, 133, -1, 55, 3, -1, 58, 3, -1,
625 66, 173, 3, -1, 75, 38, 148, 93, 3, -1,
626 70, 38, 148, 93, 3, -1, 89, 38, 148, 93,
627 3, -1, -1, 141, -1, -1, 140, -1, 142, -1,
628 142, -1, 141, 4, 141, -1, 143, -1, 142, 33,
629 142, -1, 142, 34, 142, -1, 142, 35, 142, -1,
630 142, 31, 142, -1, 142, 32, 142, -1, 142, 29,
631 142, -1, 142, 30, 142, -1, 142, 25, 142, -1,
632 142, 26, 142, -1, 142, 28, 142, -1, 142, 27,
633 142, -1, 142, 24, 142, -1, 142, 23, 142, -1,
634 142, 22, 142, -1, 142, 21, 142, -1, 142, 20,
635 142, -1, 142, 19, 142, -1, 142, 18, 142, -1,
636 142, 16, 141, 17, 142, -1, 142, 5, 142, -1,
637 142, 15, 142, -1, 142, 14, 142, -1, 142, 13,
638 142, -1, 142, 12, 142, -1, 142, 11, 142, -1,
639 142, 9, 142, -1, 142, 10, 142, -1, 142, 8,
640 142, -1, 142, 7, 142, -1, 142, 6, 142, -1,
641 144, -1, 38, 154, 119, 93, 143, -1, 38, 154,
642 119, 93, 95, 126, 96, -1, 145, -1, 33, 143,
643 -1, 22, 143, -1, 31, 143, -1, 32, 143, -1,
644 97, 143, -1, 98, 143, -1, 40, 143, -1, 41,
645 143, -1, 74, 144, -1, 90, 144, -1, 38, 141,
646 93, -1, 74, 38, 154, 119, 93, -1, 90, 38,
647 154, 119, 93, -1, 145, 38, 148, 93, -1, 145,
648 37, 141, 94, -1, 145, 39, 173, -1, 145, 36,
649 173, -1, 145, 40, -1, 145, 41, -1, 171, -1,
650 46, -1, 47, -1, 48, -1, 49, -1, 45, -1,
651 44, -1, 50, -1, 51, -1, 146, -1, 147, -1,
652 52, -1, 146, 52, -1, 53, -1, 147, 53, -1,
653 -1, 149, -1, 142, -1, 149, 4, 149, -1, -1,
654 95, 151, 113, 96, -1, -1, 155, -1, 156, -1,
655 168, -1, 165, -1, 156, 162, -1, 168, 162, -1,
656 165, 156, 163, -1, 165, 168, -1, 165, 168, 162,
657 -1, 153, -1, 153, -1, 77, 173, -1, -1, 77,
658 173, 157, 150, -1, 77, 150, -1, 81, 173, -1,
659 -1, 81, 173, 158, 150, -1, 81, 150, -1, 85,
660 173, -1, -1, -1, 85, 173, 159, 95, 160, 167,
661 96, -1, -1, 85, 95, 161, 167, 96, -1, 43,
662 -1, 164, -1, 162, 164, -1, -1, 163, 170, -1,
663 168, -1, 170, -1, 169, -1, 166, -1, 165, 166,
664 -1, 170, -1, 169, -1, 42, -1, 42, 5, 142,
665 -1, 167, 4, -1, 167, 4, 167, -1, 57, -1,
666 73, -1, 68, -1, 69, -1, 86, -1, 82, -1,
667 64, -1, 61, -1, 84, -1, 54, -1, 76, -1,
668 63, -1, 79, -1, 80, -1, 71, -1, 92, -1,
669 87, -1, 88, -1, 91, -1, 42, -1, 173, -1,
670 42, -1, 43, -1
671};
672
673/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
674static const yytype_uint16 yyrline[] =
675{
676 0, 101, 101, 102, 108, 112, 114, 128, 113, 143,
677 148, 147, 155, 158, 159, 166, 167, 171, 175, 184,
678 188, 194, 200, 199, 211, 224, 225, 228, 232, 239,
679 238, 244, 243, 250, 254, 257, 261, 264, 269, 273,
680 282, 285, 288, 293, 298, 301, 302, 306, 312, 316,
681 320, 326, 327, 333, 337, 342, 345, 346, 350, 351,
682 357, 358, 359, 365, 368, 375, 376, 381, 386, 390,
683 396, 406, 409, 413, 419, 420, 426, 430, 434, 440,
684 444, 445, 451, 452, 458, 459, 459, 470, 476, 484,
685 484, 495, 499, 503, 508, 522, 526, 530, 534, 538,
686 542, 548, 551, 554, 557, 560, 567, 568, 574, 575,
687 579, 583, 587, 591, 595, 599, 603, 607, 611, 615,
688 619, 623, 627, 631, 635, 639, 643, 647, 651, 655,
689 659, 663, 667, 671, 675, 679, 683, 687, 691, 697,
690 698, 705, 713, 714, 718, 722, 726, 730, 734, 738,
691 742, 746, 750, 756, 760, 766, 772, 780, 784, 789,
692 794, 798, 802, 803, 810, 817, 824, 831, 838, 845,
693 852, 859, 860, 863, 873, 891, 901, 919, 922, 925,
694 926, 933, 932, 955, 959, 962, 967, 972, 978, 986,
695 992, 998, 1004, 1012, 1020, 1027, 1033, 1032, 1044, 1053,
696 1059, 1058, 1070, 1078, 1087, 1091, 1086, 1108, 1107, 1116,
697 1122, 1123, 1129, 1132, 1138, 1139, 1140, 1143, 1144, 1150,
698 1151, 1154, 1158, 1162, 1163, 1166, 1167, 1168, 1169, 1170,
699 1171, 1172, 1173, 1174, 1177, 1178, 1179, 1180, 1181, 1182,
700 1183, 1186, 1187, 1188, 1191, 1206, 1218, 1219
701};
702#endif
703
704#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
705/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
706 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
707static const char *const yytname[] =
708{
709 "$end", "error", "$undefined", "';'", "','", "'='", "LORE", "LXORE",
710 "LANDE", "LLSHE", "LRSHE", "LMDE", "LDVE", "LMLE", "LME", "LPE", "'?'",
711 "':'", "LOROR", "LANDAND", "'|'", "'^'", "'&'", "LNE", "LEQ", "'<'",
712 "'>'", "LGE", "LLE", "LRSH", "LLSH", "'+'", "'-'", "'*'", "'/'", "'%'",
713 "'.'", "'['", "'('", "LMG", "LPP", "LMM", "LNAME", "LTYPE", "LFCONST",
714 "LDCONST", "LCONST", "LLCONST", "LUCONST", "LULCONST", "LVLCONST",
715 "LUVLCONST", "LSTRING", "LLSTRING", "LAUTO", "LBREAK", "LCASE", "LCHAR",
716 "LCONTINUE", "LDEFAULT", "LDO", "LDOUBLE", "LELSE", "LEXTERN", "LFLOAT",
717 "LFOR", "LGOTO", "LIF", "LINT", "LLONG", "LPREFETCH", "LREGISTER",
718 "LRETURN", "LSHORT", "LSIZEOF", "LUSED", "LSTATIC", "LSTRUCT", "LSWITCH",
719 "LTYPEDEF", "LTYPESTR", "LUNION", "LUNSIGNED", "LWHILE", "LVOID",
720 "LENUM", "LSIGNED", "LCONSTNT", "LVOLATILE", "LSET", "LSIGNOF",
721 "LRESTRICT", "LINLINE", "')'", "']'", "'{'", "'}'", "'!'", "'~'",
722 "$accept", "prog", "xdecl", "@1", "@2", "xdlist", "@3", "xdecor",
723 "xdecor2", "adecl", "adlist", "@4", "pdecl", "pdlist", "edecl", "@5",
724 "@6", "zedlist", "edlist", "edecor", "abdecor", "abdecor1", "abdecor2",
725 "abdecor3", "init", "qual", "qlist", "ilist", "zarglist", "arglist",
726 "block", "slist", "labels", "label", "stmnt", "forexpr", "ulstmnt", "@7",
727 "@8", "zcexpr", "zexpr", "lexpr", "cexpr", "expr", "xuexpr", "uexpr",
728 "pexpr", "string", "lstring", "zelist", "elist", "sbody", "@9",
729 "zctlist", "types", "tlist", "ctlist", "complex", "@10", "@11", "@12",
730 "@13", "@14", "gctnlist", "zgnlist", "gctname", "gcnlist", "gcname",
731 "enum", "tname", "cname", "gname", "name", "tag", "ltag", 0
732};
733#endif
734
735# ifdef YYPRINT
736/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
737 token YYLEX-NUM. */
738static const yytype_uint16 yytoknum[] =
739{
740 0, 256, 257, 59, 44, 61, 258, 259, 260, 261,
741 262, 263, 264, 265, 266, 267, 63, 58, 268, 269,
742 124, 94, 38, 270, 271, 60, 62, 272, 273, 274,
743 275, 43, 45, 42, 47, 37, 46, 91, 40, 276,
744 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
745 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
746 297, 298, 299, 300, 301, 302, 303, 304, 305, 306,
747 307, 308, 309, 310, 311, 312, 313, 314, 315, 316,
748 317, 318, 319, 320, 321, 322, 323, 324, 325, 326,
749 327, 328, 329, 41, 93, 123, 125, 33, 126
750};
751# endif
752
753/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
754static const yytype_uint8 yyr1[] =
755{
756 0, 99, 100, 100, 101, 101, 102, 103, 101, 104,
757 105, 104, 104, 106, 106, 107, 107, 107, 107, 108,
758 108, 109, 110, 109, 109, 111, 111, 112, 112, 114,
759 113, 115, 113, 116, 116, 117, 117, 118, 118, 118,
760 119, 119, 120, 120, 120, 121, 121, 121, 122, 122,
761 122, 123, 123, 124, 124, 124, 125, 125, 125, 125,
762 126, 126, 126, 127, 127, 128, 128, 128, 128, 128,
763 129, 130, 130, 130, 131, 131, 132, 132, 132, 133,
764 133, 133, 134, 134, 135, 136, 135, 135, 135, 137,
765 135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
766 135, 138, 138, 139, 139, 140, 141, 141, 142, 142,
767 142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
768 142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
769 142, 142, 142, 142, 142, 142, 142, 142, 142, 143,
770 143, 143, 144, 144, 144, 144, 144, 144, 144, 144,
771 144, 144, 144, 145, 145, 145, 145, 145, 145, 145,
772 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
773 145, 145, 145, 146, 146, 147, 147, 148, 148, 149,
774 149, 151, 150, 152, 152, 153, 153, 153, 153, 153,
775 153, 153, 153, 154, 155, 156, 157, 156, 156, 156,
776 158, 156, 156, 156, 159, 160, 156, 161, 156, 156,
777 162, 162, 163, 163, 164, 164, 164, 165, 165, 166,
778 166, 167, 167, 167, 167, 168, 168, 168, 168, 168,
779 168, 168, 168, 168, 169, 169, 169, 169, 169, 169,
780 169, 170, 170, 170, 171, 172, 173, 173
781};
782
783/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
784static const yytype_uint8 yyr2[] =
785{
786 0, 2, 0, 2, 2, 3, 0, 0, 6, 1,
787 0, 4, 3, 1, 3, 1, 3, 4, 4, 2,
788 3, 1, 0, 4, 3, 0, 4, 1, 3, 0,
789 4, 0, 5, 0, 1, 1, 3, 1, 3, 2,
790 0, 1, 2, 3, 1, 1, 4, 4, 2, 3,
791 3, 1, 3, 3, 2, 2, 2, 3, 1, 2,
792 1, 1, 2, 0, 1, 1, 2, 2, 3, 3,
793 3, 0, 2, 2, 1, 2, 3, 2, 2, 2,
794 1, 2, 1, 2, 2, 0, 2, 5, 7, 0,
795 10, 5, 7, 3, 5, 2, 2, 3, 5, 5,
796 5, 0, 1, 0, 1, 1, 1, 3, 1, 3,
797 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
798 3, 3, 3, 3, 3, 3, 3, 5, 3, 3,
799 3, 3, 3, 3, 3, 3, 3, 3, 3, 1,
800 5, 7, 1, 2, 2, 2, 2, 2, 2, 2,
801 2, 2, 2, 3, 5, 5, 4, 4, 3, 3,
802 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
803 1, 1, 1, 1, 2, 1, 2, 0, 1, 1,
804 3, 0, 4, 0, 1, 1, 1, 1, 2, 2,
805 3, 2, 3, 1, 1, 2, 0, 4, 2, 2,
806 0, 4, 2, 2, 0, 0, 7, 0, 5, 1,
807 1, 2, 0, 2, 1, 1, 1, 1, 2, 1,
808 1, 1, 3, 2, 3, 1, 1, 1, 1, 1,
809 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
810 1, 1, 1, 1, 1, 1, 1, 1
811};
812
813/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
814 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
815 means the default is an error. */
816static const yytype_uint8 yydefact[] =
817{
818 2, 183, 1, 209, 234, 225, 232, 236, 231, 227,
819 228, 239, 226, 235, 0, 237, 238, 0, 230, 233,
820 0, 229, 241, 242, 243, 240, 3, 0, 194, 184,
821 185, 187, 217, 186, 220, 219, 246, 247, 181, 198,
822 195, 202, 199, 207, 203, 4, 212, 0, 0, 6,
823 13, 15, 245, 188, 210, 214, 216, 215, 212, 218,
824 191, 189, 0, 0, 0, 0, 0, 0, 0, 5,
825 0, 25, 0, 103, 63, 211, 190, 192, 0, 193,
826 29, 197, 201, 221, 0, 205, 14, 213, 16, 12,
827 9, 7, 0, 0, 0, 0, 0, 0, 0, 0,
828 244, 168, 167, 163, 164, 165, 166, 169, 170, 173,
829 175, 0, 0, 0, 0, 0, 104, 105, 108, 139,
830 142, 171, 172, 162, 0, 0, 64, 40, 65, 182,
831 31, 33, 0, 223, 208, 0, 0, 0, 0, 11,
832 51, 144, 145, 146, 143, 0, 106, 40, 149, 150,
833 0, 151, 0, 152, 147, 148, 18, 0, 0, 0,
834 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
835 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
836 0, 0, 0, 0, 0, 0, 0, 0, 0, 177,
837 0, 160, 161, 174, 176, 0, 17, 0, 212, 103,
838 0, 67, 66, 41, 44, 45, 33, 0, 37, 0,
839 34, 35, 15, 222, 224, 0, 71, 8, 27, 0,
840 0, 0, 61, 58, 60, 0, 0, 153, 212, 0,
841 0, 40, 40, 128, 138, 137, 136, 134, 135, 133,
842 132, 131, 130, 129, 0, 126, 125, 124, 123, 122,
843 121, 120, 116, 117, 119, 118, 114, 115, 112, 113,
844 109, 110, 111, 159, 0, 179, 0, 178, 158, 68,
845 69, 42, 0, 48, 0, 103, 63, 0, 39, 30,
846 0, 0, 206, 0, 26, 0, 54, 0, 56, 55,
847 62, 59, 52, 107, 42, 0, 0, 0, 0, 157,
848 156, 0, 43, 49, 50, 0, 0, 32, 36, 38,
849 0, 244, 0, 0, 0, 0, 0, 0, 0, 0,
850 101, 0, 0, 0, 0, 70, 72, 85, 74, 73,
851 80, 0, 0, 0, 102, 0, 28, 53, 57, 0,
852 140, 154, 155, 127, 180, 47, 46, 79, 78, 95,
853 0, 96, 77, 0, 0, 0, 177, 0, 177, 0,
854 0, 177, 75, 81, 86, 0, 84, 19, 21, 0,
855 0, 76, 0, 97, 0, 0, 93, 0, 0, 0,
856 0, 101, 0, 20, 0, 141, 0, 0, 0, 0,
857 0, 0, 0, 0, 82, 0, 0, 24, 0, 87,
858 99, 98, 94, 91, 100, 101, 83, 23, 0, 0,
859 0, 92, 88, 101, 0, 0, 90
860};
861
862/* YYDEFGOTO[NTERM-NUM]. */
863static const yytype_int16 yydefgoto[] =
864{
865 -1, 1, 26, 71, 136, 48, 72, 208, 50, 326,
866 369, 382, 91, 219, 78, 131, 206, 209, 210, 211,
867 202, 203, 204, 205, 222, 223, 224, 225, 125, 126,
868 217, 283, 327, 328, 329, 393, 330, 331, 332, 333,
869 115, 116, 334, 146, 118, 119, 120, 121, 122, 266,
870 267, 39, 62, 27, 79, 127, 29, 30, 63, 64,
871 66, 135, 65, 53, 67, 54, 31, 32, 84, 33,
872 34, 35, 123, 51, 52
873};
874
875/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
876 STATE-NUM. */
877#define YYPACT_NINF -331
878static const yytype_int16 yypact[] =
879{
880 -331, 548, -331, -331, -331, -331, -331, -331, -331, -331,
881 -331, -331, -331, -331, -3, -331, -331, -3, -331, -331,
882 149, -331, -331, -331, -331, -331, -331, 264, -331, -331,
883 965, 929, -331, 965, -331, -331, -331, -331, -331, -331,
884 -75, -331, -72, -331, -60, -331, -331, 307, 60, 270,
885 156, -331, -331, 965, -331, -331, -331, -331, -331, -331,
886 965, 965, 929, -44, -44, 29, -15, 199, -10, -331,
887 307, -331, 83, 756, 849, -331, 140, 965, 889, -331,
888 -331, -331, -331, 86, 12, -331, -331, -331, -331, -331,
889 90, 929, 686, 756, 756, 756, 756, 615, 756, 756,
890 -331, -331, -331, -331, -331, -331, -331, -331, -331, -331,
891 -331, 791, 826, 756, 756, 9, -331, 1084, -331, -331,
892 708, 54, 57, -331, 110, 56, 152, 310, -331, -331,
893 -331, 279, 756, 29, -331, 29, 63, 307, 165, -331,
894 1084, -331, -331, -331, -331, 30, 1084, 44, -331, -331,
895 615, -331, 615, -331, -331, -331, -331, 756, 756, 756,
896 756, 756, 756, 756, 756, 756, 756, 756, 756, 756,
897 756, 756, 756, 756, 756, 756, 756, 756, 756, 756,
898 756, 756, 756, 756, 756, 756, 756, 157, 756, 756,
899 157, -331, -331, -331, -331, 115, -331, 849, -331, 756,
900 128, -331, -331, -331, 182, -331, 279, 756, -331, 164,
901 200, -331, 208, 1084, -331, 13, -331, -331, -331, 262,
902 157, 756, 225, 228, 165, 73, 756, -331, -331, -7,
903 150, 44, 44, 1084, 1084, 1084, 1084, 1084, 1084, 1084,
904 1084, 1084, 1084, 1084, 28, 304, 1100, 1115, 1129, 1142,
905 1153, 1153, 433, 433, 433, 433, 333, 333, 265, 265,
906 -331, -331, -331, -331, 8, 1084, 153, 236, -331, -331,
907 -331, 147, 158, -331, 161, 756, 849, 247, -331, -331,
908 279, 756, -331, 341, -331, 307, -331, 175, -331, -331,
909 254, 228, -331, -331, 135, 721, 188, 190, 756, -331,
910 -331, 756, -331, -331, -331, 191, 211, -331, -331, -331,
911 298, 301, 338, 756, 343, 339, 439, 157, 319, 321,
912 756, 322, 323, 324, 332, -331, -331, 509, -331, -331,
913 -331, 63, 306, 372, 373, 277, -331, -331, -331, 165,
914 -331, -331, -331, 425, -331, -331, -331, -331, -331, -331,
915 1053, -331, -331, 293, 375, 756, 756, 400, 756, 756,
916 756, 756, -331, -331, -331, 396, -331, -331, 430, 285,
917 377, -331, 431, -331, 55, 381, -331, 382, 62, 64,
918 383, 615, 473, -331, 307, -331, 756, 439, 479, 490,
919 439, 439, 493, 497, -331, 307, 686, -331, 66, 440,
920 -331, -331, -331, -331, -331, 756, 499, -331, 498, 439,
921 504, -331, -331, 756, 415, 439, -331
922};
923
924/* YYPGOTO[NTERM-NUM]. */
925static const yytype_int16 yypgoto[] =
926{
927 -331, -331, -331, -331, -331, 445, -331, -26, -331, -331,
928 -330, -331, -331, 233, -331, -331, -331, 313, 230, -331,
929 -132, -187, -331, -331, -82, 292, -331, 181, 245, 326,
930 193, -331, -331, 198, -227, -331, 203, -331, -331, -309,
931 -181, -183, -83, -45, -38, 243, -331, -331, -331, -175,
932 226, 10, -331, -331, -1, 0, -88, 495, -331, -331,
933 -331, -331, -331, -14, -51, -28, -331, 501, -85, 218,
934 231, -24, -52, -127, -12
935};
936
937/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
938 positive, shift that token. If negative, reduce the rule which
939 number is the opposite. If zero, do what YYDEFACT says.
940 If YYTABLE_NINF, syntax error. */
941#define YYTABLE_NINF -205
942static const yytype_int16 yytable[] =
943{
944 28, 49, 40, 137, 212, 42, 57, 76, 44, 57,
945 139, 357, 226, 274, 145, 230, 133, 133, 272, 61,
946 -196, 68, 128, -200, 278, 75, 228, 41, 117, 57,
947 199, 229, 226, 75, 226, -204, 57, 57, 287, 36,
948 37, 86, 274, 87, 90, 298, 77, 140, 214, 75,
949 215, 38, 87, 57, 397, 141, 142, 143, 144, 226,
950 148, 149, 80, 69, 70, 406, 226, 145, 226, 145,
951 226, 83, 394, 81, 82, 154, 155, 228, 130, 212,
952 85, 199, 229, 88, 302, 244, 273, 213, 92, 353,
953 28, 132, 38, 140, 305, -10, 410, 147, 309, 296,
954 297, 201, 299, 156, 414, 264, 193, 302, 134, 282,
955 194, 218, 233, 234, 235, 236, 237, 238, 239, 240,
956 241, 242, 243, 227, 245, 246, 247, 248, 249, 250,
957 251, 252, 253, 254, 255, 256, 257, 258, 259, 260,
958 261, 262, 290, 293, 265, 128, 195, 271, 387, 196,
959 231, 269, 232, 212, 117, 390, 197, 391, 216, 408,
960 399, 198, 117, 402, 403, 199, 200, 279, 228, 292,
961 36, 37, 199, 229, 68, 263, 117, 294, 268, 140,
962 198, 375, 412, 377, 199, 200, 380, 93, 416, 36,
963 37, 36, 37, 73, 74, 335, 94, 95, 96, 36,
964 37, 220, 221, 97, 280, 98, 99, 100, 286, 101,
965 102, 103, 104, 105, 106, 107, 108, 109, 110, 275,
966 276, 273, 22, 23, 128, 281, 24, 22, 23, 288,
967 117, 24, 46, 289, 22, 23, 117, 47, 24, 111,
968 301, 36, 37, 295, 43, 86, 300, 87, 55, 60,
969 307, 55, 303, 343, 304, 112, 265, 340, 338, 218,
970 138, 56, 113, 114, 56, 284, 285, 45, 350, 337,
971 87, 55, 374, -9, -9, -10, 378, 379, 55, 55,
972 367, 341, 28, 342, 56, 345, 22, 23, 383, 384,
973 24, 56, 56, 395, 140, 55, 207, 46, 184, 185,
974 186, 347, 47, 398, 346, 354, 36, 37, 56, 368,
975 46, 265, 46, 265, 407, 47, 265, 47, 348, 36,
976 37, 36, 37, 170, 171, 172, 173, 174, 175, 176,
977 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
978 46, 349, 310, 198, -101, 47, 351, 199, 200, 36,
979 37, 140, 36, 37, 151, 153, 352, 355, 368, 356,
980 358, 359, 360, 93, 182, 183, 184, 185, 186, 368,
981 361, 365, 94, 95, 96, 366, 372, 226, 373, 97,
982 28, 98, 99, 311, 3, 101, 102, 103, 104, 105,
983 106, 107, 108, 109, 110, 4, 312, 313, 5, 314,
984 315, 316, 6, 376, 7, 8, -89, 317, 318, 9,
985 10, 319, 11, 320, 12, 111, 321, 13, 14, 322,
986 15, 16, 17, 18, 323, 19, 20, 21, 22, 23,
987 324, 112, 24, 25, 381, -22, -85, 325, 113, 114,
988 310, 168, -101, 169, 170, 171, 172, 173, 174, 175,
989 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
990 186, 93, 180, 181, 182, 183, 184, 185, 186, 386,
991 94, 95, 96, 385, 388, 389, 392, 97, 396, 98,
992 99, 311, 400, 101, 102, 103, 104, 105, 106, 107,
993 108, 109, 110, 401, 312, 313, 404, 314, 315, 316,
994 405, 411, 409, 384, -89, 317, 318, 413, 415, 319,
995 308, 320, -101, 111, 321, 89, 291, 322, 336, 277,
996 370, 306, 323, 270, 364, 362, 58, 344, 324, 112,
997 363, 93, 59, 0, -85, 0, 113, 114, 0, 0,
998 94, 95, 96, 0, 0, 0, 0, 97, 2, 98,
999 99, 311, 0, 101, 102, 103, 104, 105, 106, 107,
1000 108, 109, 110, 0, 312, 313, 0, 314, 315, 316,
1001 0, 0, 0, 0, -89, 317, 318, 0, 0, 319,
1002 0, 320, 0, 111, 321, 0, 0, 322, 0, 0,
1003 0, 3, 323, 0, 0, 0, 0, 0, 324, 112,
1004 0, 0, 4, 0, 0, 5, 113, 114, 0, 6,
1005 0, 7, 8, 0, 0, 0, 9, 10, 0, 11,
1006 0, 12, 0, 0, 13, 14, 0, 15, 16, 17,
1007 18, 0, 19, 20, 21, 22, 23, 93, 0, 24,
1008 25, 0, 0, 0, 0, 0, 94, 95, 96, 0,
1009 0, 0, 0, 97, 0, 98, 99, 100, 3, 101,
1010 102, 103, 104, 105, 106, 107, 108, 109, 110, 4,
1011 0, 0, 5, 0, 0, 0, 6, 0, 7, 8,
1012 0, 0, 0, 9, 10, 0, 11, 0, 12, 111,
1013 0, 13, 14, 0, 15, 16, 17, 18, 0, 19,
1014 20, 21, 22, 23, 0, 112, 24, 25, 93, 0,
1015 0, 0, 113, 114, 0, 0, 0, 94, 95, 96,
1016 0, 0, 0, 0, 97, 0, 98, 99, 100, 0,
1017 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
1018 0, 0, 0, 93, 187, 188, 189, 190, 191, 192,
1019 0, 0, 94, 95, 96, 0, 0, 0, 0, 97,
1020 111, 98, 99, 100, 0, 101, 102, 103, 104, 105,
1021 106, 107, 108, 109, 110, 0, 112, 0, 93, 0,
1022 0, 138, 0, 113, 114, 0, 0, 94, 95, 96,
1023 0, 0, 0, 0, 97, 111, 98, 99, 100, 0,
1024 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
1025 0, 112, 0, 93, 0, 0, 339, 0, 113, 114,
1026 0, 0, 94, 95, 96, 0, 0, 0, 0, 150,
1027 111, 98, 99, 100, 0, 101, 102, 103, 104, 105,
1028 106, 107, 108, 109, 110, 0, 112, 0, 93, 0,
1029 0, 0, 0, 113, 114, 0, 0, 94, 95, 96,
1030 0, 0, 0, 0, 152, 111, 98, 99, 100, 0,
1031 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
1032 0, 112, 0, 0, 0, 124, 0, 0, 113, 114,
1033 0, 100, 3, 0, 0, 0, 0, 0, 0, 0,
1034 111, 0, 0, 4, 0, 0, 5, 0, 0, 0,
1035 6, 0, 7, 8, 0, 0, 112, 9, 10, 0,
1036 11, 0, 12, 113, 114, 13, 14, 0, 15, 16,
1037 17, 18, 3, 19, 20, 21, 22, 23, 0, 0,
1038 24, 25, 0, 4, 0, 0, 5, 0, 0, 0,
1039 6, 0, 7, 8, 0, 0, 0, 9, 10, 0,
1040 11, 0, 12, 0, 0, 13, 14, 0, 15, 16,
1041 17, 18, 3, 19, 20, 21, 22, 23, 0, 0,
1042 24, 25, 0, 4, 0, 129, 5, 0, 0, 0,
1043 6, 0, 7, 8, 0, 0, 0, 9, 10, 0,
1044 11, 0, 12, 0, 0, 13, 14, 0, 15, 16,
1045 17, 18, 0, 19, 20, 21, 22, 23, 0, 4,
1046 24, 25, 5, 0, 0, 0, 6, 0, 7, 8,
1047 0, 0, 0, 9, 10, 0, 11, 0, 12, 0,
1048 0, 13, 0, 0, 15, 16, 0, 18, 0, 19,
1049 0, 21, 22, 23, 0, 0, 24, 25, 157, 158,
1050 159, 160, 161, 162, 163, 164, 165, 166, 167, 168,
1051 371, 169, 170, 171, 172, 173, 174, 175, 176, 177,
1052 178, 179, 180, 181, 182, 183, 184, 185, 186, 157,
1053 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
1054 168, 0, 169, 170, 171, 172, 173, 174, 175, 176,
1055 177, 178, 179, 180, 181, 182, 183, 184, 185, 186,
1056 171, 172, 173, 174, 175, 176, 177, 178, 179, 180,
1057 181, 182, 183, 184, 185, 186, 172, 173, 174, 175,
1058 176, 177, 178, 179, 180, 181, 182, 183, 184, 185,
1059 186, 173, 174, 175, 176, 177, 178, 179, 180, 181,
1060 182, 183, 184, 185, 186, 174, 175, 176, 177, 178,
1061 179, 180, 181, 182, 183, 184, 185, 186, 176, 177,
1062 178, 179, 180, 181, 182, 183, 184, 185, 186
1063};
1064
1065static const yytype_int16 yycheck[] =
1066{
1067 1, 27, 14, 91, 131, 17, 30, 58, 20, 33,
1068 92, 320, 4, 200, 97, 147, 4, 4, 199, 33,
1069 95, 47, 74, 95, 207, 53, 33, 17, 73, 53,
1070 37, 38, 4, 61, 4, 95, 60, 61, 221, 42,
1071 43, 67, 229, 67, 70, 17, 60, 92, 133, 77,
1072 135, 95, 76, 77, 384, 93, 94, 95, 96, 4,
1073 98, 99, 62, 3, 4, 395, 4, 150, 4, 152,
1074 4, 42, 381, 63, 64, 113, 114, 33, 78, 206,
1075 95, 37, 38, 93, 271, 168, 93, 132, 5, 316,
1076 91, 5, 95, 138, 275, 5, 405, 97, 281, 231,
1077 232, 127, 94, 94, 413, 188, 52, 294, 96, 96,
1078 53, 137, 157, 158, 159, 160, 161, 162, 163, 164,
1079 165, 166, 167, 93, 169, 170, 171, 172, 173, 174,
1080 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
1081 185, 186, 224, 226, 189, 197, 36, 198, 93, 93,
1082 150, 36, 152, 280, 199, 93, 4, 93, 95, 93,
1083 387, 33, 207, 390, 391, 37, 38, 3, 33, 96,
1084 42, 43, 37, 38, 200, 187, 221, 228, 190, 224,
1085 33, 356, 409, 358, 37, 38, 361, 22, 415, 42,
1086 43, 42, 43, 37, 38, 283, 31, 32, 33, 42,
1087 43, 36, 37, 38, 4, 40, 41, 42, 220, 44,
1088 45, 46, 47, 48, 49, 50, 51, 52, 53, 37,
1089 38, 93, 87, 88, 276, 17, 91, 87, 88, 4,
1090 275, 91, 33, 5, 87, 88, 281, 38, 91, 74,
1091 4, 42, 43, 93, 95, 271, 93, 271, 30, 31,
1092 3, 33, 94, 298, 93, 90, 301, 295, 4, 285,
1093 95, 30, 97, 98, 33, 3, 4, 3, 313, 94,
1094 294, 53, 355, 3, 4, 5, 359, 360, 60, 61,
1095 3, 93, 283, 93, 53, 94, 87, 88, 3, 4,
1096 91, 60, 61, 381, 339, 77, 17, 33, 33, 34,
1097 35, 3, 38, 386, 93, 317, 42, 43, 77, 335,
1098 33, 356, 33, 358, 396, 38, 361, 38, 17, 42,
1099 43, 42, 43, 19, 20, 21, 22, 23, 24, 25,
1100 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1101 33, 3, 1, 33, 3, 38, 3, 37, 38, 42,
1102 43, 396, 42, 43, 111, 112, 17, 38, 384, 38,
1103 38, 38, 38, 22, 31, 32, 33, 34, 35, 395,
1104 38, 65, 31, 32, 33, 3, 83, 4, 3, 38,
1105 381, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1106 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1107 59, 60, 61, 3, 63, 64, 65, 66, 67, 68,
1108 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
1109 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
1110 89, 90, 91, 92, 38, 5, 95, 96, 97, 98,
1111 1, 16, 3, 18, 19, 20, 21, 22, 23, 24,
1112 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1113 35, 22, 29, 30, 31, 32, 33, 34, 35, 38,
1114 31, 32, 33, 96, 93, 93, 93, 38, 5, 40,
1115 41, 42, 3, 44, 45, 46, 47, 48, 49, 50,
1116 51, 52, 53, 3, 55, 56, 3, 58, 59, 60,
1117 3, 3, 62, 4, 65, 66, 67, 3, 93, 70,
1118 280, 72, 3, 74, 75, 70, 224, 78, 285, 206,
1119 339, 276, 83, 197, 331, 327, 31, 301, 89, 90,
1120 327, 22, 31, -1, 95, -1, 97, 98, -1, -1,
1121 31, 32, 33, -1, -1, -1, -1, 38, 0, 40,
1122 41, 42, -1, 44, 45, 46, 47, 48, 49, 50,
1123 51, 52, 53, -1, 55, 56, -1, 58, 59, 60,
1124 -1, -1, -1, -1, 65, 66, 67, -1, -1, 70,
1125 -1, 72, -1, 74, 75, -1, -1, 78, -1, -1,
1126 -1, 43, 83, -1, -1, -1, -1, -1, 89, 90,
1127 -1, -1, 54, -1, -1, 57, 97, 98, -1, 61,
1128 -1, 63, 64, -1, -1, -1, 68, 69, -1, 71,
1129 -1, 73, -1, -1, 76, 77, -1, 79, 80, 81,
1130 82, -1, 84, 85, 86, 87, 88, 22, -1, 91,
1131 92, -1, -1, -1, -1, -1, 31, 32, 33, -1,
1132 -1, -1, -1, 38, -1, 40, 41, 42, 43, 44,
1133 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1134 -1, -1, 57, -1, -1, -1, 61, -1, 63, 64,
1135 -1, -1, -1, 68, 69, -1, 71, -1, 73, 74,
1136 -1, 76, 77, -1, 79, 80, 81, 82, -1, 84,
1137 85, 86, 87, 88, -1, 90, 91, 92, 22, -1,
1138 -1, -1, 97, 98, -1, -1, -1, 31, 32, 33,
1139 -1, -1, -1, -1, 38, -1, 40, 41, 42, -1,
1140 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1141 -1, -1, -1, 22, 36, 37, 38, 39, 40, 41,
1142 -1, -1, 31, 32, 33, -1, -1, -1, -1, 38,
1143 74, 40, 41, 42, -1, 44, 45, 46, 47, 48,
1144 49, 50, 51, 52, 53, -1, 90, -1, 22, -1,
1145 -1, 95, -1, 97, 98, -1, -1, 31, 32, 33,
1146 -1, -1, -1, -1, 38, 74, 40, 41, 42, -1,
1147 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1148 -1, 90, -1, 22, -1, -1, 95, -1, 97, 98,
1149 -1, -1, 31, 32, 33, -1, -1, -1, -1, 38,
1150 74, 40, 41, 42, -1, 44, 45, 46, 47, 48,
1151 49, 50, 51, 52, 53, -1, 90, -1, 22, -1,
1152 -1, -1, -1, 97, 98, -1, -1, 31, 32, 33,
1153 -1, -1, -1, -1, 38, 74, 40, 41, 42, -1,
1154 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
1155 -1, 90, -1, -1, -1, 36, -1, -1, 97, 98,
1156 -1, 42, 43, -1, -1, -1, -1, -1, -1, -1,
1157 74, -1, -1, 54, -1, -1, 57, -1, -1, -1,
1158 61, -1, 63, 64, -1, -1, 90, 68, 69, -1,
1159 71, -1, 73, 97, 98, 76, 77, -1, 79, 80,
1160 81, 82, 43, 84, 85, 86, 87, 88, -1, -1,
1161 91, 92, -1, 54, -1, -1, 57, -1, -1, -1,
1162 61, -1, 63, 64, -1, -1, -1, 68, 69, -1,
1163 71, -1, 73, -1, -1, 76, 77, -1, 79, 80,
1164 81, 82, 43, 84, 85, 86, 87, 88, -1, -1,
1165 91, 92, -1, 54, -1, 96, 57, -1, -1, -1,
1166 61, -1, 63, 64, -1, -1, -1, 68, 69, -1,
1167 71, -1, 73, -1, -1, 76, 77, -1, 79, 80,
1168 81, 82, -1, 84, 85, 86, 87, 88, -1, 54,
1169 91, 92, 57, -1, -1, -1, 61, -1, 63, 64,
1170 -1, -1, -1, 68, 69, -1, 71, -1, 73, -1,
1171 -1, 76, -1, -1, 79, 80, -1, 82, -1, 84,
1172 -1, 86, 87, 88, -1, -1, 91, 92, 5, 6,
1173 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1174 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1175 27, 28, 29, 30, 31, 32, 33, 34, 35, 5,
1176 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
1177 16, -1, 18, 19, 20, 21, 22, 23, 24, 25,
1178 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1179 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
1180 30, 31, 32, 33, 34, 35, 21, 22, 23, 24,
1181 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1182 35, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1183 31, 32, 33, 34, 35, 23, 24, 25, 26, 27,
1184 28, 29, 30, 31, 32, 33, 34, 35, 25, 26,
1185 27, 28, 29, 30, 31, 32, 33, 34, 35
1186};
1187
1188/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1189 symbol of state STATE-NUM. */
1190static const yytype_uint8 yystos[] =
1191{
1192 0, 100, 0, 43, 54, 57, 61, 63, 64, 68,
1193 69, 71, 73, 76, 77, 79, 80, 81, 82, 84,
1194 85, 86, 87, 88, 91, 92, 101, 152, 153, 155,
1195 156, 165, 166, 168, 169, 170, 42, 43, 95, 150,
1196 173, 150, 173, 95, 173, 3, 33, 38, 104, 106,
1197 107, 172, 173, 162, 164, 168, 169, 170, 156, 166,
1198 168, 162, 151, 157, 158, 161, 159, 163, 106, 3,
1199 4, 102, 105, 37, 38, 164, 163, 162, 113, 153,
1200 154, 150, 150, 42, 167, 95, 106, 170, 93, 104,
1201 106, 111, 5, 22, 31, 32, 33, 38, 40, 41,
1202 42, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1203 53, 74, 90, 97, 98, 139, 140, 142, 143, 144,
1204 145, 146, 147, 171, 36, 127, 128, 154, 171, 96,
1205 154, 114, 5, 4, 96, 160, 103, 155, 95, 123,
1206 142, 143, 143, 143, 143, 141, 142, 154, 143, 143,
1207 38, 144, 38, 144, 143, 143, 94, 5, 6, 7,
1208 8, 9, 10, 11, 12, 13, 14, 15, 16, 18,
1209 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1210 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1211 39, 40, 41, 52, 53, 36, 93, 4, 33, 37,
1212 38, 106, 119, 120, 121, 122, 115, 17, 106, 116,
1213 117, 118, 172, 142, 167, 167, 95, 129, 106, 112,
1214 36, 37, 123, 124, 125, 126, 4, 93, 33, 38,
1215 119, 154, 154, 142, 142, 142, 142, 142, 142, 142,
1216 142, 142, 142, 142, 141, 142, 142, 142, 142, 142,
1217 142, 142, 142, 142, 142, 142, 142, 142, 142, 142,
1218 142, 142, 142, 173, 141, 142, 148, 149, 173, 36,
1219 128, 163, 139, 93, 120, 37, 38, 116, 140, 3,
1220 4, 17, 96, 130, 3, 4, 173, 140, 4, 5,
1221 123, 124, 96, 141, 163, 93, 119, 119, 17, 94,
1222 93, 4, 120, 94, 93, 139, 127, 3, 117, 140,
1223 1, 42, 55, 56, 58, 59, 60, 66, 67, 70,
1224 72, 75, 78, 83, 89, 96, 108, 131, 132, 133,
1225 135, 136, 137, 138, 141, 155, 112, 94, 4, 95,
1226 143, 93, 93, 142, 149, 94, 93, 3, 17, 3,
1227 142, 3, 17, 133, 173, 38, 38, 138, 38, 38,
1228 38, 38, 132, 135, 129, 65, 3, 3, 106, 109,
1229 126, 17, 83, 3, 141, 148, 3, 148, 141, 141,
1230 148, 38, 110, 3, 4, 96, 38, 93, 93, 93,
1231 93, 93, 93, 134, 138, 155, 5, 109, 141, 133,
1232 3, 3, 133, 133, 3, 3, 109, 123, 93, 62,
1233 138, 3, 133, 3, 138, 93, 133
1234};
1235
1236#define yyerrok (yyerrstatus = 0)
1237#define yyclearin (yychar = YYEMPTY)
1238#define YYEMPTY (-2)
1239#define YYEOF 0
1240
1241#define YYACCEPT goto yyacceptlab
1242#define YYABORT goto yyabortlab
1243#define YYERROR goto yyerrorlab
1244
1245
1246/* Like YYERROR except do call yyerror. This remains here temporarily
1247 to ease the transition to the new meaning of YYERROR, for GCC.
1248 Once GCC version 2 has supplanted version 1, this can go. */
1249
1250#define YYFAIL goto yyerrlab
1251
1252#define YYRECOVERING() (!!yyerrstatus)
1253
1254#define YYBACKUP(Token, Value) \
1255do \
1256 if (yychar == YYEMPTY && yylen == 1) \
1257 { \
1258 yychar = (Token); \
1259 yylval = (Value); \
1260 yytoken = YYTRANSLATE (yychar); \
1261 YYPOPSTACK (1); \
1262 goto yybackup; \
1263 } \
1264 else \
1265 { \
1266 yyerror (YY_("syntax error: cannot back up")); \
1267 YYERROR; \
1268 } \
1269while (YYID (0))
1270
1271
1272#define YYTERROR 1
1273#define YYERRCODE 256
1274
1275
1276/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1277 If N is 0, then set CURRENT to the empty location which ends
1278 the previous symbol: RHS[0] (always defined). */
1279
1280#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1281#ifndef YYLLOC_DEFAULT
1282# define YYLLOC_DEFAULT(Current, Rhs, N) \
1283 do \
1284 if (YYID (N)) \
1285 { \
1286 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1287 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1288 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1289 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1290 } \
1291 else \
1292 { \
1293 (Current).first_line = (Current).last_line = \
1294 YYRHSLOC (Rhs, 0).last_line; \
1295 (Current).first_column = (Current).last_column = \
1296 YYRHSLOC (Rhs, 0).last_column; \
1297 } \
1298 while (YYID (0))
1299#endif
1300
1301
1302/* YY_LOCATION_PRINT -- Print the location on the stream.
1303 This macro was not mandated originally: define only if we know
1304 we won't break user code: when these are the locations we know. */
1305
1306#ifndef YY_LOCATION_PRINT
1307# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1308# define YY_LOCATION_PRINT(File, Loc) \
1309 fprintf (File, "%d.%d-%d.%d", \
1310 (Loc).first_line, (Loc).first_column, \
1311 (Loc).last_line, (Loc).last_column)
1312# else
1313# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1314# endif
1315#endif
1316
1317
1318/* YYLEX -- calling `yylex' with the right arguments. */
1319
1320#ifdef YYLEX_PARAM
1321# define YYLEX yylex (YYLEX_PARAM)
1322#else
1323# define YYLEX yylex ()
1324#endif
1325
1326/* Enable debugging if requested. */
1327#if YYDEBUG
1328
1329# ifndef YYFPRINTF
1330# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1331# define YYFPRINTF fprintf
1332# endif
1333
1334# define YYDPRINTF(Args) \
1335do { \
1336 if (yydebug) \
1337 YYFPRINTF Args; \
1338} while (YYID (0))
1339
1340# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1341do { \
1342 if (yydebug) \
1343 { \
1344 YYFPRINTF (stderr, "%s ", Title); \
1345 yy_symbol_print (stderr, \
1346 Type, Value); \
1347 YYFPRINTF (stderr, "\n"); \
1348 } \
1349} while (YYID (0))
1350
1351
1352/*--------------------------------.
1353| Print this symbol on YYOUTPUT. |
1354`--------------------------------*/
1355
1356/*ARGSUSED*/
1357#if (defined __STDC__ || defined __C99__FUNC__ \
1358 || defined __cplusplus || defined _MSC_VER)
1359static void
1360yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1361#else
1362static void
1363yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1364 FILE *yyoutput;
1365 int yytype;
1366 YYSTYPE const * const yyvaluep;
1367#endif
1368{
1369 if (!yyvaluep)
1370 return;
1371# ifdef YYPRINT
1372 if (yytype < YYNTOKENS)
1373 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1374# else
1375 YYUSE (yyoutput);
1376# endif
1377 switch (yytype)
1378 {
1379 default:
1380 break;
1381 }
1382}
1383
1384
1385/*--------------------------------.
1386| Print this symbol on YYOUTPUT. |
1387`--------------------------------*/
1388
1389#if (defined __STDC__ || defined __C99__FUNC__ \
1390 || defined __cplusplus || defined _MSC_VER)
1391static void
1392yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1393#else
1394static void
1395yy_symbol_print (yyoutput, yytype, yyvaluep)
1396 FILE *yyoutput;
1397 int yytype;
1398 YYSTYPE const * const yyvaluep;
1399#endif
1400{
1401 if (yytype < YYNTOKENS)
1402 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1403 else
1404 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1405
1406 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1407 YYFPRINTF (yyoutput, ")");
1408}
1409
1410/*------------------------------------------------------------------.
1411| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1412| TOP (included). |
1413`------------------------------------------------------------------*/
1414
1415#if (defined __STDC__ || defined __C99__FUNC__ \
1416 || defined __cplusplus || defined _MSC_VER)
1417static void
1418yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1419#else
1420static void
1421yy_stack_print (bottom, top)
1422 yytype_int16 *bottom;
1423 yytype_int16 *top;
1424#endif
1425{
1426 YYFPRINTF (stderr, "Stack now");
1427 for (; bottom <= top; ++bottom)
1428 YYFPRINTF (stderr, " %d", *bottom);
1429 YYFPRINTF (stderr, "\n");
1430}
1431
1432# define YY_STACK_PRINT(Bottom, Top) \
1433do { \
1434 if (yydebug) \
1435 yy_stack_print ((Bottom), (Top)); \
1436} while (YYID (0))
1437
1438
1439/*------------------------------------------------.
1440| Report that the YYRULE is going to be reduced. |
1441`------------------------------------------------*/
1442
1443#if (defined __STDC__ || defined __C99__FUNC__ \
1444 || defined __cplusplus || defined _MSC_VER)
1445static void
1446yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1447#else
1448static void
1449yy_reduce_print (yyvsp, yyrule)
1450 YYSTYPE *yyvsp;
1451 int yyrule;
1452#endif
1453{
1454 int yynrhs = yyr2[yyrule];
1455 int yyi;
1456 unsigned long int yylno = yyrline[yyrule];
1457 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1458 yyrule - 1, yylno);
1459 /* The symbols being reduced. */
1460 for (yyi = 0; yyi < yynrhs; yyi++)
1461 {
1462 fprintf (stderr, " $%d = ", yyi + 1);
1463 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1464 &(yyvsp[(yyi + 1) - (yynrhs)])
1465 );
1466 fprintf (stderr, "\n");
1467 }
1468}
1469
1470# define YY_REDUCE_PRINT(Rule) \
1471do { \
1472 if (yydebug) \
1473 yy_reduce_print (yyvsp, Rule); \
1474} while (YYID (0))
1475
1476/* Nonzero means print parse trace. It is left uninitialized so that
1477 multiple parsers can coexist. */
1478int yydebug;
1479#else /* !YYDEBUG */
1480# define YYDPRINTF(Args)
1481# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1482# define YY_STACK_PRINT(Bottom, Top)
1483# define YY_REDUCE_PRINT(Rule)
1484#endif /* !YYDEBUG */
1485
1486
1487/* YYINITDEPTH -- initial size of the parser's stacks. */
1488#ifndef YYINITDEPTH
1489# define YYINITDEPTH 200
1490#endif
1491
1492/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1493 if the built-in stack extension method is used).
1494
1495 Do not make this value too large; the results are undefined if
1496 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1497 evaluated with infinite-precision integer arithmetic. */
1498
1499#ifndef YYMAXDEPTH
1500# define YYMAXDEPTH 10000
1501#endif
1502
1503
1504
1505#if YYERROR_VERBOSE
1506
1507# ifndef yystrlen
1508# if defined __GLIBC__ && defined _STRING_H
1509# define yystrlen strlen
1510# else
1511/* Return the length of YYSTR. */
1512#if (defined __STDC__ || defined __C99__FUNC__ \
1513 || defined __cplusplus || defined _MSC_VER)
1514static YYSIZE_T
1515yystrlen (const char *yystr)
1516#else
1517static YYSIZE_T
1518yystrlen (yystr)
1519 const char *yystr;
1520#endif
1521{
1522 YYSIZE_T yylen;
1523 for (yylen = 0; yystr[yylen]; yylen++)
1524 continue;
1525 return yylen;
1526}
1527# endif
1528# endif
1529
1530# ifndef yystpcpy
1531# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1532# define yystpcpy stpcpy
1533# else
1534/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1535 YYDEST. */
1536#if (defined __STDC__ || defined __C99__FUNC__ \
1537 || defined __cplusplus || defined _MSC_VER)
1538static char *
1539yystpcpy (char *yydest, const char *yysrc)
1540#else
1541static char *
1542yystpcpy (yydest, yysrc)
1543 char *yydest;
1544 const char *yysrc;
1545#endif
1546{
1547 char *yyd = yydest;
1548 const char *yys = yysrc;
1549
1550 while ((*yyd++ = *yys++) != '\0')
1551 continue;
1552
1553 return yyd - 1;
1554}
1555# endif
1556# endif
1557
1558# ifndef yytnamerr
1559/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1560 quotes and backslashes, so that it's suitable for yyerror. The
1561 heuristic is that double-quoting is unnecessary unless the string
1562 contains an apostrophe, a comma, or backslash (other than
1563 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1564 null, do not copy; instead, return the length of what the result
1565 would have been. */
1566static YYSIZE_T
1567yytnamerr (char *yyres, const char *yystr)
1568{
1569 if (*yystr == '"')
1570 {
1571 YYSIZE_T yyn = 0;
1572 char const *yyp = yystr;
1573
1574 for (;;)
1575 switch (*++yyp)
1576 {
1577 case '\'':
1578 case ',':
1579 goto do_not_strip_quotes;
1580
1581 case '\\':
1582 if (*++yyp != '\\')
1583 goto do_not_strip_quotes;
1584 /* Fall through. */
1585 default:
1586 if (yyres)
1587 yyres[yyn] = *yyp;
1588 yyn++;
1589 break;
1590
1591 case '"':
1592 if (yyres)
1593 yyres[yyn] = '\0';
1594 return yyn;
1595 }
1596 do_not_strip_quotes: ;
1597 }
1598
1599 if (! yyres)
1600 return yystrlen (yystr);
1601
1602 return yystpcpy (yyres, yystr) - yyres;
1603}
1604# endif
1605
1606/* Copy into YYRESULT an error message about the unexpected token
1607 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1608 including the terminating null byte. If YYRESULT is null, do not
1609 copy anything; just return the number of bytes that would be
1610 copied. As a special case, return 0 if an ordinary "syntax error"
1611 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1612 size calculation. */
1613static YYSIZE_T
1614yysyntax_error (char *yyresult, int yystate, int yychar)
1615{
1616 int yyn = yypact[yystate];
1617
1618 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1619 return 0;
1620 else
1621 {
1622 int yytype = YYTRANSLATE (yychar);
1623 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1624 YYSIZE_T yysize = yysize0;
1625 YYSIZE_T yysize1;
1626 int yysize_overflow = 0;
1627 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1628 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1629 int yyx;
1630
1631# if 0
1632 /* This is so xgettext sees the translatable formats that are
1633 constructed on the fly. */
1634 YY_("syntax error, unexpected %s");
1635 YY_("syntax error, unexpected %s, expecting %s");
1636 YY_("syntax error, unexpected %s, expecting %s or %s");
1637 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1638 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1639# endif
1640 char *yyfmt;
1641 char const *yyf;
1642 static char const yyunexpected[] = "syntax error, unexpected %s";
1643 static char const yyexpecting[] = ", expecting %s";
1644 static char const yyor[] = " or %s";
1645 char yyformat[sizeof yyunexpected
1646 + sizeof yyexpecting - 1
1647 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1648 * (sizeof yyor - 1))];
1649 char const *yyprefix = yyexpecting;
1650
1651 /* Start YYX at -YYN if negative to avoid negative indexes in
1652 YYCHECK. */
1653 int yyxbegin = yyn < 0 ? -yyn : 0;
1654
1655 /* Stay within bounds of both yycheck and yytname. */
1656 int yychecklim = YYLAST - yyn + 1;
1657 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1658 int yycount = 1;
1659
1660 yyarg[0] = yytname[yytype];
1661 yyfmt = yystpcpy (yyformat, yyunexpected);
1662
1663 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1664 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1665 {
1666 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1667 {
1668 yycount = 1;
1669 yysize = yysize0;
1670 yyformat[sizeof yyunexpected - 1] = '\0';
1671 break;
1672 }
1673 yyarg[yycount++] = yytname[yyx];
1674 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1675 yysize_overflow |= (yysize1 < yysize);
1676 yysize = yysize1;
1677 yyfmt = yystpcpy (yyfmt, yyprefix);
1678 yyprefix = yyor;
1679 }
1680
1681 yyf = YY_(yyformat);
1682 yysize1 = yysize + yystrlen (yyf);
1683 yysize_overflow |= (yysize1 < yysize);
1684 yysize = yysize1;
1685
1686 if (yysize_overflow)
1687 return YYSIZE_MAXIMUM;
1688
1689 if (yyresult)
1690 {
1691 /* Avoid sprintf, as that infringes on the user's name space.
1692 Don't have undefined behavior even if the translation
1693 produced a string with the wrong number of "%s"s. */
1694 char *yyp = yyresult;
1695 int yyi = 0;
1696 while ((*yyp = *yyf) != '\0')
1697 {
1698 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1699 {
1700 yyp += yytnamerr (yyp, yyarg[yyi++]);
1701 yyf += 2;
1702 }
1703 else
1704 {
1705 yyp++;
1706 yyf++;
1707 }
1708 }
1709 }
1710 return yysize;
1711 }
1712}
1713#endif /* YYERROR_VERBOSE */
1714
1715
1716/*-----------------------------------------------.
1717| Release the memory associated to this symbol. |
1718`-----------------------------------------------*/
1719
1720/*ARGSUSED*/
1721#if (defined __STDC__ || defined __C99__FUNC__ \
1722 || defined __cplusplus || defined _MSC_VER)
1723static void
1724yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1725#else
1726static void
1727yydestruct (yymsg, yytype, yyvaluep)
1728 const char *yymsg;
1729 int yytype;
1730 YYSTYPE *yyvaluep;
1731#endif
1732{
1733 YYUSE (yyvaluep);
1734
1735 if (!yymsg)
1736 yymsg = "Deleting";
1737 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1738
1739 switch (yytype)
1740 {
1741
1742 default:
1743 break;
1744 }
1745}
1746
1747
1748/* Prevent warnings from -Wmissing-prototypes. */
1749
1750#ifdef YYPARSE_PARAM
1751#if defined __STDC__ || defined __cplusplus
1752int yyparse (void *YYPARSE_PARAM);
1753#else
1754int yyparse ();
1755#endif
1756#else /* ! YYPARSE_PARAM */
1757#if defined __STDC__ || defined __cplusplus
1758int yyparse (void);
1759#else
1760int yyparse ();
1761#endif
1762#endif /* ! YYPARSE_PARAM */
1763
1764
1765
1766/* The look-ahead symbol. */
1767int yychar;
1768
1769/* The semantic value of the look-ahead symbol. */
1770YYSTYPE yylval;
1771
1772/* Number of syntax errors so far. */
1773int yynerrs;
1774
1775
1776
1777/*----------.
1778| yyparse. |
1779`----------*/
1780
1781#ifdef YYPARSE_PARAM
1782#if (defined __STDC__ || defined __C99__FUNC__ \
1783 || defined __cplusplus || defined _MSC_VER)
1784int
1785yyparse (void *YYPARSE_PARAM)
1786#else
1787int
1788yyparse (YYPARSE_PARAM)
1789 void *YYPARSE_PARAM;
1790#endif
1791#else /* ! YYPARSE_PARAM */
1792#if (defined __STDC__ || defined __C99__FUNC__ \
1793 || defined __cplusplus || defined _MSC_VER)
1794int
1795yyparse (void)
1796#else
1797int
1798yyparse ()
1799
1800#endif
1801#endif
1802{
1803
1804 int yystate;
1805 int yyn;
1806 int yyresult;
1807 /* Number of tokens to shift before error messages enabled. */
1808 int yyerrstatus;
1809 /* Look-ahead token as an internal (translated) token number. */
1810 int yytoken = 0;
1811#if YYERROR_VERBOSE
1812 /* Buffer for error messages, and its allocated size. */
1813 char yymsgbuf[128];
1814 char *yymsg = yymsgbuf;
1815 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1816#endif
1817
1818 /* Three stacks and their tools:
1819 `yyss': related to states,
1820 `yyvs': related to semantic values,
1821 `yyls': related to locations.
1822
1823 Refer to the stacks thru separate pointers, to allow yyoverflow
1824 to reallocate them elsewhere. */
1825
1826 /* The state stack. */
1827 yytype_int16 yyssa[YYINITDEPTH];
1828 yytype_int16 *yyss = yyssa;
1829 yytype_int16 *yyssp;
1830
1831 /* The semantic value stack. */
1832 YYSTYPE yyvsa[YYINITDEPTH];
1833 YYSTYPE *yyvs = yyvsa;
1834 YYSTYPE *yyvsp;
1835
1836
1837
1838#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1839
1840 YYSIZE_T yystacksize = YYINITDEPTH;
1841
1842 /* The variables used to return semantic value and location from the
1843 action routines. */
1844 YYSTYPE yyval;
1845
1846
1847 /* The number of symbols on the RHS of the reduced rule.
1848 Keep to zero when no symbol should be popped. */
1849 int yylen = 0;
1850
1851 YYDPRINTF ((stderr, "Starting parse\n"));
1852
1853 yystate = 0;
1854 yyerrstatus = 0;
1855 yynerrs = 0;
1856 yychar = YYEMPTY; /* Cause a token to be read. */
1857
1858 /* Initialize stack pointers.
1859 Waste one element of value and location stack
1860 so that they stay on the same level as the state stack.
1861 The wasted elements are never initialized. */
1862
1863 yyssp = yyss;
1864 yyvsp = yyvs;
1865
1866 goto yysetstate;
1867
1868/*------------------------------------------------------------.
1869| yynewstate -- Push a new state, which is found in yystate. |
1870`------------------------------------------------------------*/
1871 yynewstate:
1872 /* In all cases, when you get here, the value and location stacks
1873 have just been pushed. So pushing a state here evens the stacks. */
1874 yyssp++;
1875
1876 yysetstate:
1877 *yyssp = yystate;
1878
1879 if (yyss + yystacksize - 1 <= yyssp)
1880 {
1881 /* Get the current used size of the three stacks, in elements. */
1882 YYSIZE_T yysize = yyssp - yyss + 1;
1883
1884#ifdef yyoverflow
1885 {
1886 /* Give user a chance to reallocate the stack. Use copies of
1887 these so that the &'s don't force the real ones into
1888 memory. */
1889 YYSTYPE *yyvs1 = yyvs;
1890 yytype_int16 *yyss1 = yyss;
1891
1892
1893 /* Each stack pointer address is followed by the size of the
1894 data in use in that stack, in bytes. This used to be a
1895 conditional around just the two extra args, but that might
1896 be undefined if yyoverflow is a macro. */
1897 yyoverflow (YY_("memory exhausted"),
1898 &yyss1, yysize * sizeof (*yyssp),
1899 &yyvs1, yysize * sizeof (*yyvsp),
1900
1901 &yystacksize);
1902
1903 yyss = yyss1;
1904 yyvs = yyvs1;
1905 }
1906#else /* no yyoverflow */
1907# ifndef YYSTACK_RELOCATE
1908 goto yyexhaustedlab;
1909# else
1910 /* Extend the stack our own way. */
1911 if (YYMAXDEPTH <= yystacksize)
1912 goto yyexhaustedlab;
1913 yystacksize *= 2;
1914 if (YYMAXDEPTH < yystacksize)
1915 yystacksize = YYMAXDEPTH;
1916
1917 {
1918 yytype_int16 *yyss1 = yyss;
1919 union yyalloc *yyptr =
1920 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1921 if (! yyptr)
1922 goto yyexhaustedlab;
1923 YYSTACK_RELOCATE (yyss);
1924 YYSTACK_RELOCATE (yyvs);
1925
1926# undef YYSTACK_RELOCATE
1927 if (yyss1 != yyssa)
1928 YYSTACK_FREE (yyss1);
1929 }
1930# endif
1931#endif /* no yyoverflow */
1932
1933 yyssp = yyss + yysize - 1;
1934 yyvsp = yyvs + yysize - 1;
1935
1936
1937 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1938 (unsigned long int) yystacksize));
1939
1940 if (yyss + yystacksize - 1 <= yyssp)
1941 YYABORT;
1942 }
1943
1944 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1945
1946 goto yybackup;
1947
1948/*-----------.
1949| yybackup. |
1950`-----------*/
1951yybackup:
1952
1953 /* Do appropriate processing given the current state. Read a
1954 look-ahead token if we need one and don't already have one. */
1955
1956 /* First try to decide what to do without reference to look-ahead token. */
1957 yyn = yypact[yystate];
1958 if (yyn == YYPACT_NINF)
1959 goto yydefault;
1960
1961 /* Not known => get a look-ahead token if don't already have one. */
1962
1963 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1964 if (yychar == YYEMPTY)
1965 {
1966 YYDPRINTF ((stderr, "Reading a token: "));
1967 yychar = YYLEX;
1968 }
1969
1970 if (yychar <= YYEOF)
1971 {
1972 yychar = yytoken = YYEOF;
1973 YYDPRINTF ((stderr, "Now at end of input.\n"));
1974 }
1975 else
1976 {
1977 yytoken = YYTRANSLATE (yychar);
1978 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1979 }
1980
1981 /* If the proper action on seeing token YYTOKEN is to reduce or to
1982 detect an error, take that action. */
1983 yyn += yytoken;
1984 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1985 goto yydefault;
1986 yyn = yytable[yyn];
1987 if (yyn <= 0)
1988 {
1989 if (yyn == 0 || yyn == YYTABLE_NINF)
1990 goto yyerrlab;
1991 yyn = -yyn;
1992 goto yyreduce;
1993 }
1994
1995 if (yyn == YYFINAL)
1996 YYACCEPT;
1997
1998 /* Count tokens shifted since error; after three, turn off error
1999 status. */
2000 if (yyerrstatus)
2001 yyerrstatus--;
2002
2003 /* Shift the look-ahead token. */
2004 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2005
2006 /* Discard the shifted token unless it is eof. */
2007 if (yychar != YYEOF)
2008 yychar = YYEMPTY;
2009
2010 yystate = yyn;
2011 *++yyvsp = yylval;
2012
2013 goto yynewstate;
2014
2015
2016/*-----------------------------------------------------------.
2017| yydefault -- do the default action for the current state. |
2018`-----------------------------------------------------------*/
2019yydefault:
2020 yyn = yydefact[yystate];
2021 if (yyn == 0)
2022 goto yyerrlab;
2023 goto yyreduce;
2024
2025
2026/*-----------------------------.
2027| yyreduce -- Do a reduction. |
2028`-----------------------------*/
2029yyreduce:
2030 /* yyn is the number of a rule to reduce with. */
2031 yylen = yyr2[yyn];
2032
2033 /* If YYLEN is nonzero, implement the default value of the action:
2034 `$$ = $1'.
2035
2036 Otherwise, the following line sets YYVAL to garbage.
2037 This behavior is undocumented and Bison
2038 users should not rely upon it. Assigning to YYVAL
2039 unconditionally makes the parser a bit smaller, and it avoids a
2040 GCC warning that YYVAL may be used uninitialized. */
2041 yyval = yyvsp[1-yylen];
2042
2043
2044 YY_REDUCE_PRINT (yyn);
2045 switch (yyn)
2046 {
2047 case 4:
2048#line 109 "cc.y"
2049 {
2050 dodecl(xdecl, lastclass, lasttype, Z);
2051 }
2052 break;
2053
2054 case 6:
2055#line 114 "cc.y"
2056 {
2057 lastdcl = T;
2058 firstarg = S;
2059 dodecl(xdecl, lastclass, lasttype, (yyvsp[(2) - (2)].node));
2060 if(lastdcl == T || lastdcl->etype != TFUNC) {
2061 diag((yyvsp[(2) - (2)].node), "not a function");
2062 lastdcl = types[TFUNC];
2063 }
2064 thisfn = lastdcl;
2065 markdcl();
2066 firstdcl = dclstack;
2067 argmark((yyvsp[(2) - (2)].node), 0);
2068 }
2069 break;
2070
2071 case 7:
2072#line 128 "cc.y"
2073 {
2074 argmark((yyvsp[(2) - (4)].node), 1);
2075 }
2076 break;
2077
2078 case 8:
2079#line 132 "cc.y"
2080 {
2081 Node *n;
2082
2083 n = revertdcl();
2084 if(n)
2085 (yyvsp[(6) - (6)].node) = new(OLIST, n, (yyvsp[(6) - (6)].node));
2086 if(!debug['a'] && !debug['Z'])
2087 codgen((yyvsp[(6) - (6)].node), (yyvsp[(2) - (6)].node));
2088 }
2089 break;
2090
2091 case 9:
2092#line 144 "cc.y"
2093 {
2094 dodecl(xdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
2095 }
2096 break;
2097
2098 case 10:
2099#line 148 "cc.y"
2100 {
2101 (yyvsp[(1) - (1)].node) = dodecl(xdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
2102 }
2103 break;
2104
2105 case 11:
2106#line 152 "cc.y"
2107 {
2108 doinit((yyvsp[(1) - (4)].node)->sym, (yyvsp[(1) - (4)].node)->type, 0L, (yyvsp[(4) - (4)].node));
2109 }
2110 break;
2111
2112 case 14:
2113#line 160 "cc.y"
2114 {
2115 (yyval.node) = new(OIND, (yyvsp[(3) - (3)].node), Z);
2116 (yyval.node)->garb = simpleg((yyvsp[(2) - (3)].lval));
2117 }
2118 break;
2119
2120 case 16:
2121#line 168 "cc.y"
2122 {
2123 (yyval.node) = (yyvsp[(2) - (3)].node);
2124 }
2125 break;
2126
2127 case 17:
2128#line 172 "cc.y"
2129 {
2130 (yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
2131 }
2132 break;
2133
2134 case 18:
2135#line 176 "cc.y"
2136 {
2137 (yyval.node) = new(OARRAY, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
2138 }
2139 break;
2140
2141 case 19:
2142#line 185 "cc.y"
2143 {
2144 (yyval.node) = dodecl(adecl, lastclass, lasttype, Z);
2145 }
2146 break;
2147
2148 case 20:
2149#line 189 "cc.y"
2150 {
2151 (yyval.node) = (yyvsp[(2) - (3)].node);
2152 }
2153 break;
2154
2155 case 21:
2156#line 195 "cc.y"
2157 {
2158 dodecl(adecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
2159 (yyval.node) = Z;
2160 }
2161 break;
2162
2163 case 22:
2164#line 200 "cc.y"
2165 {
2166 (yyvsp[(1) - (1)].node) = dodecl(adecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
2167 }
2168 break;
2169
2170 case 23:
2171#line 204 "cc.y"
2172 {
2173 int32 w;
2174
2175 w = (yyvsp[(1) - (4)].node)->sym->type->width;
2176 (yyval.node) = doinit((yyvsp[(1) - (4)].node)->sym, (yyvsp[(1) - (4)].node)->type, 0L, (yyvsp[(4) - (4)].node));
2177 (yyval.node) = contig((yyvsp[(1) - (4)].node)->sym, (yyval.node), w);
2178 }
2179 break;
2180
2181 case 24:
2182#line 212 "cc.y"
2183 {
2184 (yyval.node) = (yyvsp[(1) - (3)].node);
2185 if((yyvsp[(3) - (3)].node) != Z) {
2186 (yyval.node) = (yyvsp[(3) - (3)].node);
2187 if((yyvsp[(1) - (3)].node) != Z)
2188 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2189 }
2190 }
2191 break;
2192
2193 case 27:
2194#line 229 "cc.y"
2195 {
2196 dodecl(pdecl, lastclass, lasttype, (yyvsp[(1) - (1)].node));
2197 }
2198 break;
2199
2200 case 29:
2201#line 239 "cc.y"
2202 {
2203 lasttype = (yyvsp[(1) - (1)].type);
2204 }
2205 break;
2206
2207 case 31:
2208#line 244 "cc.y"
2209 {
2210 lasttype = (yyvsp[(2) - (2)].type);
2211 }
2212 break;
2213
2214 case 33:
2215#line 250 "cc.y"
2216 {
2217 lastfield = 0;
2218 edecl(CXXX, lasttype, S);
2219 }
2220 break;
2221
2222 case 35:
2223#line 258 "cc.y"
2224 {
2225 dodecl(edecl, CXXX, lasttype, (yyvsp[(1) - (1)].node));
2226 }
2227 break;
2228
2229 case 37:
2230#line 265 "cc.y"
2231 {
2232 lastbit = 0;
2233 firstbit = 1;
2234 }
2235 break;
2236
2237 case 38:
2238#line 270 "cc.y"
2239 {
2240 (yyval.node) = new(OBIT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2241 }
2242 break;
2243
2244 case 39:
2245#line 274 "cc.y"
2246 {
2247 (yyval.node) = new(OBIT, Z, (yyvsp[(2) - (2)].node));
2248 }
2249 break;
2250
2251 case 40:
2252#line 282 "cc.y"
2253 {
2254 (yyval.node) = (Z);
2255 }
2256 break;
2257
2258 case 42:
2259#line 289 "cc.y"
2260 {
2261 (yyval.node) = new(OIND, (Z), Z);
2262 (yyval.node)->garb = simpleg((yyvsp[(2) - (2)].lval));
2263 }
2264 break;
2265
2266 case 43:
2267#line 294 "cc.y"
2268 {
2269 (yyval.node) = new(OIND, (yyvsp[(3) - (3)].node), Z);
2270 (yyval.node)->garb = simpleg((yyvsp[(2) - (3)].lval));
2271 }
2272 break;
2273
2274 case 46:
2275#line 303 "cc.y"
2276 {
2277 (yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
2278 }
2279 break;
2280
2281 case 47:
2282#line 307 "cc.y"
2283 {
2284 (yyval.node) = new(OARRAY, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node));
2285 }
2286 break;
2287
2288 case 48:
2289#line 313 "cc.y"
2290 {
2291 (yyval.node) = new(OFUNC, (Z), Z);
2292 }
2293 break;
2294
2295 case 49:
2296#line 317 "cc.y"
2297 {
2298 (yyval.node) = new(OARRAY, (Z), (yyvsp[(2) - (3)].node));
2299 }
2300 break;
2301
2302 case 50:
2303#line 321 "cc.y"
2304 {
2305 (yyval.node) = (yyvsp[(2) - (3)].node);
2306 }
2307 break;
2308
2309 case 52:
2310#line 328 "cc.y"
2311 {
2312 (yyval.node) = new(OINIT, invert((yyvsp[(2) - (3)].node)), Z);
2313 }
2314 break;
2315
2316 case 53:
2317#line 334 "cc.y"
2318 {
2319 (yyval.node) = new(OARRAY, (yyvsp[(2) - (3)].node), Z);
2320 }
2321 break;
2322
2323 case 54:
2324#line 338 "cc.y"
2325 {
2326 (yyval.node) = new(OELEM, Z, Z);
2327 (yyval.node)->sym = (yyvsp[(2) - (2)].sym);
2328 }
2329 break;
2330
2331 case 57:
2332#line 347 "cc.y"
2333 {
2334 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].node));
2335 }
2336 break;
2337
2338 case 59:
2339#line 352 "cc.y"
2340 {
2341 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
2342 }
2343 break;
2344
2345 case 62:
2346#line 360 "cc.y"
2347 {
2348 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
2349 }
2350 break;
2351
2352 case 63:
2353#line 365 "cc.y"
2354 {
2355 (yyval.node) = Z;
2356 }
2357 break;
2358
2359 case 64:
2360#line 369 "cc.y"
2361 {
2362 (yyval.node) = invert((yyvsp[(1) - (1)].node));
2363 }
2364 break;
2365
2366 case 66:
2367#line 377 "cc.y"
2368 {
2369 (yyval.node) = new(OPROTO, (yyvsp[(2) - (2)].node), Z);
2370 (yyval.node)->type = (yyvsp[(1) - (2)].type);
2371 }
2372 break;
2373
2374 case 67:
2375#line 382 "cc.y"
2376 {
2377 (yyval.node) = new(OPROTO, (yyvsp[(2) - (2)].node), Z);
2378 (yyval.node)->type = (yyvsp[(1) - (2)].type);
2379 }
2380 break;
2381
2382 case 68:
2383#line 387 "cc.y"
2384 {
2385 (yyval.node) = new(ODOTDOT, Z, Z);
2386 }
2387 break;
2388
2389 case 69:
2390#line 391 "cc.y"
2391 {
2392 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2393 }
2394 break;
2395
2396 case 70:
2397#line 397 "cc.y"
2398 {
2399 (yyval.node) = invert((yyvsp[(2) - (3)].node));
2400 // if($2 != Z)
2401 // $$ = new(OLIST, $2, $$);
2402 if((yyval.node) == Z)
2403 (yyval.node) = new(OLIST, Z, Z);
2404 }
2405 break;
2406
2407 case 71:
2408#line 406 "cc.y"
2409 {
2410 (yyval.node) = Z;
2411 }
2412 break;
2413
2414 case 72:
2415#line 410 "cc.y"
2416 {
2417 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
2418 }
2419 break;
2420
2421 case 73:
2422#line 414 "cc.y"
2423 {
2424 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
2425 }
2426 break;
2427
2428 case 75:
2429#line 421 "cc.y"
2430 {
2431 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
2432 }
2433 break;
2434
2435 case 76:
2436#line 427 "cc.y"
2437 {
2438 (yyval.node) = new(OCASE, (yyvsp[(2) - (3)].node), Z);
2439 }
2440 break;
2441
2442 case 77:
2443#line 431 "cc.y"
2444 {
2445 (yyval.node) = new(OCASE, Z, Z);
2446 }
2447 break;
2448
2449 case 78:
2450#line 435 "cc.y"
2451 {
2452 (yyval.node) = new(OLABEL, dcllabel((yyvsp[(1) - (2)].sym), 1), Z);
2453 }
2454 break;
2455
2456 case 79:
2457#line 441 "cc.y"
2458 {
2459 (yyval.node) = Z;
2460 }
2461 break;
2462
2463 case 81:
2464#line 446 "cc.y"
2465 {
2466 (yyval.node) = new(OLIST, (yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].node));
2467 }
2468 break;
2469
2470 case 83:
2471#line 453 "cc.y"
2472 {
2473 (yyval.node) = (yyvsp[(2) - (2)].node);
2474 }
2475 break;
2476
2477 case 85:
2478#line 459 "cc.y"
2479 {
2480 markdcl();
2481 }
2482 break;
2483
2484 case 86:
2485#line 463 "cc.y"
2486 {
2487 (yyval.node) = revertdcl();
2488 if((yyval.node))
2489 (yyval.node) = new(OLIST, (yyval.node), (yyvsp[(2) - (2)].node));
2490 else
2491 (yyval.node) = (yyvsp[(2) - (2)].node);
2492 }
2493 break;
2494
2495 case 87:
2496#line 471 "cc.y"
2497 {
2498 (yyval.node) = new(OIF, (yyvsp[(3) - (5)].node), new(OLIST, (yyvsp[(5) - (5)].node), Z));
2499 if((yyvsp[(5) - (5)].node) == Z)
2500 warn((yyvsp[(3) - (5)].node), "empty if body");
2501 }
2502 break;
2503
2504 case 88:
2505#line 477 "cc.y"
2506 {
2507 (yyval.node) = new(OIF, (yyvsp[(3) - (7)].node), new(OLIST, (yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].node)));
2508 if((yyvsp[(5) - (7)].node) == Z)
2509 warn((yyvsp[(3) - (7)].node), "empty if body");
2510 if((yyvsp[(7) - (7)].node) == Z)
2511 warn((yyvsp[(3) - (7)].node), "empty else body");
2512 }
2513 break;
2514
2515 case 89:
2516#line 484 "cc.y"
2517 { markdcl(); }
2518 break;
2519
2520 case 90:
2521#line 485 "cc.y"
2522 {
2523 (yyval.node) = revertdcl();
2524 if((yyval.node)){
2525 if((yyvsp[(4) - (10)].node))
2526 (yyvsp[(4) - (10)].node) = new(OLIST, (yyval.node), (yyvsp[(4) - (10)].node));
2527 else
2528 (yyvsp[(4) - (10)].node) = (yyval.node);
2529 }
2530 (yyval.node) = new(OFOR, new(OLIST, (yyvsp[(6) - (10)].node), new(OLIST, (yyvsp[(4) - (10)].node), (yyvsp[(8) - (10)].node))), (yyvsp[(10) - (10)].node));
2531 }
2532 break;
2533
2534 case 91:
2535#line 496 "cc.y"
2536 {
2537 (yyval.node) = new(OWHILE, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
2538 }
2539 break;
2540
2541 case 92:
2542#line 500 "cc.y"
2543 {
2544 (yyval.node) = new(ODWHILE, (yyvsp[(5) - (7)].node), (yyvsp[(2) - (7)].node));
2545 }
2546 break;
2547
2548 case 93:
2549#line 504 "cc.y"
2550 {
2551 (yyval.node) = new(ORETURN, (yyvsp[(2) - (3)].node), Z);
2552 (yyval.node)->type = thisfn->link;
2553 }
2554 break;
2555
2556 case 94:
2557#line 509 "cc.y"
2558 {
2559 (yyval.node) = new(OCONST, Z, Z);
2560 (yyval.node)->vconst = 0;
2561 (yyval.node)->type = types[TINT];
2562 (yyvsp[(3) - (5)].node) = new(OSUB, (yyval.node), (yyvsp[(3) - (5)].node));
2563
2564 (yyval.node) = new(OCONST, Z, Z);
2565 (yyval.node)->vconst = 0;
2566 (yyval.node)->type = types[TINT];
2567 (yyvsp[(3) - (5)].node) = new(OSUB, (yyval.node), (yyvsp[(3) - (5)].node));
2568
2569 (yyval.node) = new(OSWITCH, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node));
2570 }
2571 break;
2572
2573 case 95:
2574#line 523 "cc.y"
2575 {
2576 (yyval.node) = new(OBREAK, Z, Z);
2577 }
2578 break;
2579
2580 case 96:
2581#line 527 "cc.y"
2582 {
2583 (yyval.node) = new(OCONTINUE, Z, Z);
2584 }
2585 break;
2586
2587 case 97:
2588#line 531 "cc.y"
2589 {
2590 (yyval.node) = new(OGOTO, dcllabel((yyvsp[(2) - (3)].sym), 0), Z);
2591 }
2592 break;
2593
2594 case 98:
2595#line 535 "cc.y"
2596 {
2597 (yyval.node) = new(OUSED, (yyvsp[(3) - (5)].node), Z);
2598 }
2599 break;
2600
2601 case 99:
2602#line 539 "cc.y"
2603 {
2604 (yyval.node) = new(OPREFETCH, (yyvsp[(3) - (5)].node), Z);
2605 }
2606 break;
2607
2608 case 100:
2609#line 543 "cc.y"
2610 {
2611 (yyval.node) = new(OSET, (yyvsp[(3) - (5)].node), Z);
2612 }
2613 break;
2614
2615 case 101:
2616#line 548 "cc.y"
2617 {
2618 (yyval.node) = Z;
2619 }
2620 break;
2621
2622 case 103:
2623#line 554 "cc.y"
2624 {
2625 (yyval.node) = Z;
2626 }
2627 break;
2628
2629 case 105:
2630#line 561 "cc.y"
2631 {
2632 (yyval.node) = new(OCAST, (yyvsp[(1) - (1)].node), Z);
2633 (yyval.node)->type = types[TLONG];
2634 }
2635 break;
2636
2637 case 107:
2638#line 569 "cc.y"
2639 {
2640 (yyval.node) = new(OCOMMA, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2641 }
2642 break;
2643
2644 case 109:
2645#line 576 "cc.y"
2646 {
2647 (yyval.node) = new(OMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2648 }
2649 break;
2650
2651 case 110:
2652#line 580 "cc.y"
2653 {
2654 (yyval.node) = new(ODIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2655 }
2656 break;
2657
2658 case 111:
2659#line 584 "cc.y"
2660 {
2661 (yyval.node) = new(OMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2662 }
2663 break;
2664
2665 case 112:
2666#line 588 "cc.y"
2667 {
2668 (yyval.node) = new(OADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2669 }
2670 break;
2671
2672 case 113:
2673#line 592 "cc.y"
2674 {
2675 (yyval.node) = new(OSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2676 }
2677 break;
2678
2679 case 114:
2680#line 596 "cc.y"
2681 {
2682 (yyval.node) = new(OASHR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2683 }
2684 break;
2685
2686 case 115:
2687#line 600 "cc.y"
2688 {
2689 (yyval.node) = new(OASHL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2690 }
2691 break;
2692
2693 case 116:
2694#line 604 "cc.y"
2695 {
2696 (yyval.node) = new(OLT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2697 }
2698 break;
2699
2700 case 117:
2701#line 608 "cc.y"
2702 {
2703 (yyval.node) = new(OGT, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2704 }
2705 break;
2706
2707 case 118:
2708#line 612 "cc.y"
2709 {
2710 (yyval.node) = new(OLE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2711 }
2712 break;
2713
2714 case 119:
2715#line 616 "cc.y"
2716 {
2717 (yyval.node) = new(OGE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2718 }
2719 break;
2720
2721 case 120:
2722#line 620 "cc.y"
2723 {
2724 (yyval.node) = new(OEQ, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2725 }
2726 break;
2727
2728 case 121:
2729#line 624 "cc.y"
2730 {
2731 (yyval.node) = new(ONE, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2732 }
2733 break;
2734
2735 case 122:
2736#line 628 "cc.y"
2737 {
2738 (yyval.node) = new(OAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2739 }
2740 break;
2741
2742 case 123:
2743#line 632 "cc.y"
2744 {
2745 (yyval.node) = new(OXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2746 }
2747 break;
2748
2749 case 124:
2750#line 636 "cc.y"
2751 {
2752 (yyval.node) = new(OOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2753 }
2754 break;
2755
2756 case 125:
2757#line 640 "cc.y"
2758 {
2759 (yyval.node) = new(OANDAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2760 }
2761 break;
2762
2763 case 126:
2764#line 644 "cc.y"
2765 {
2766 (yyval.node) = new(OOROR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2767 }
2768 break;
2769
2770 case 127:
2771#line 648 "cc.y"
2772 {
2773 (yyval.node) = new(OCOND, (yyvsp[(1) - (5)].node), new(OLIST, (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)));
2774 }
2775 break;
2776
2777 case 128:
2778#line 652 "cc.y"
2779 {
2780 (yyval.node) = new(OAS, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2781 }
2782 break;
2783
2784 case 129:
2785#line 656 "cc.y"
2786 {
2787 (yyval.node) = new(OASADD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2788 }
2789 break;
2790
2791 case 130:
2792#line 660 "cc.y"
2793 {
2794 (yyval.node) = new(OASSUB, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2795 }
2796 break;
2797
2798 case 131:
2799#line 664 "cc.y"
2800 {
2801 (yyval.node) = new(OASMUL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2802 }
2803 break;
2804
2805 case 132:
2806#line 668 "cc.y"
2807 {
2808 (yyval.node) = new(OASDIV, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2809 }
2810 break;
2811
2812 case 133:
2813#line 672 "cc.y"
2814 {
2815 (yyval.node) = new(OASMOD, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2816 }
2817 break;
2818
2819 case 134:
2820#line 676 "cc.y"
2821 {
2822 (yyval.node) = new(OASASHL, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2823 }
2824 break;
2825
2826 case 135:
2827#line 680 "cc.y"
2828 {
2829 (yyval.node) = new(OASASHR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2830 }
2831 break;
2832
2833 case 136:
2834#line 684 "cc.y"
2835 {
2836 (yyval.node) = new(OASAND, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2837 }
2838 break;
2839
2840 case 137:
2841#line 688 "cc.y"
2842 {
2843 (yyval.node) = new(OASXOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2844 }
2845 break;
2846
2847 case 138:
2848#line 692 "cc.y"
2849 {
2850 (yyval.node) = new(OASOR, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
2851 }
2852 break;
2853
2854 case 140:
2855#line 699 "cc.y"
2856 {
2857 (yyval.node) = new(OCAST, (yyvsp[(5) - (5)].node), Z);
2858 dodecl(NODECL, CXXX, (yyvsp[(2) - (5)].type), (yyvsp[(3) - (5)].node));
2859 (yyval.node)->type = lastdcl;
2860 (yyval.node)->xcast = 1;
2861 }
2862 break;
2863
2864 case 141:
2865#line 706 "cc.y"
2866 {
2867 (yyval.node) = new(OSTRUCT, (yyvsp[(6) - (7)].node), Z);
2868 dodecl(NODECL, CXXX, (yyvsp[(2) - (7)].type), (yyvsp[(3) - (7)].node));
2869 (yyval.node)->type = lastdcl;
2870 }
2871 break;
2872
2873 case 143:
2874#line 715 "cc.y"
2875 {
2876 (yyval.node) = new(OIND, (yyvsp[(2) - (2)].node), Z);
2877 }
2878 break;
2879
2880 case 144:
2881#line 719 "cc.y"
2882 {
2883 (yyval.node) = new(OADDR, (yyvsp[(2) - (2)].node), Z);
2884 }
2885 break;
2886
2887 case 145:
2888#line 723 "cc.y"
2889 {
2890 (yyval.node) = new(OPOS, (yyvsp[(2) - (2)].node), Z);
2891 }
2892 break;
2893
2894 case 146:
2895#line 727 "cc.y"
2896 {
2897 (yyval.node) = new(ONEG, (yyvsp[(2) - (2)].node), Z);
2898 }
2899 break;
2900
2901 case 147:
2902#line 731 "cc.y"
2903 {
2904 (yyval.node) = new(ONOT, (yyvsp[(2) - (2)].node), Z);
2905 }
2906 break;
2907
2908 case 148:
2909#line 735 "cc.y"
2910 {
2911 (yyval.node) = new(OCOM, (yyvsp[(2) - (2)].node), Z);
2912 }
2913 break;
2914
2915 case 149:
2916#line 739 "cc.y"
2917 {
2918 (yyval.node) = new(OPREINC, (yyvsp[(2) - (2)].node), Z);
2919 }
2920 break;
2921
2922 case 150:
2923#line 743 "cc.y"
2924 {
2925 (yyval.node) = new(OPREDEC, (yyvsp[(2) - (2)].node), Z);
2926 }
2927 break;
2928
2929 case 151:
2930#line 747 "cc.y"
2931 {
2932 (yyval.node) = new(OSIZE, (yyvsp[(2) - (2)].node), Z);
2933 }
2934 break;
2935
2936 case 152:
2937#line 751 "cc.y"
2938 {
2939 (yyval.node) = new(OSIGN, (yyvsp[(2) - (2)].node), Z);
2940 }
2941 break;
2942
2943 case 153:
2944#line 757 "cc.y"
2945 {
2946 (yyval.node) = (yyvsp[(2) - (3)].node);
2947 }
2948 break;
2949
2950 case 154:
2951#line 761 "cc.y"
2952 {
2953 (yyval.node) = new(OSIZE, Z, Z);
2954 dodecl(NODECL, CXXX, (yyvsp[(3) - (5)].type), (yyvsp[(4) - (5)].node));
2955 (yyval.node)->type = lastdcl;
2956 }
2957 break;
2958
2959 case 155:
2960#line 767 "cc.y"
2961 {
2962 (yyval.node) = new(OSIGN, Z, Z);
2963 dodecl(NODECL, CXXX, (yyvsp[(3) - (5)].type), (yyvsp[(4) - (5)].node));
2964 (yyval.node)->type = lastdcl;
2965 }
2966 break;
2967
2968 case 156:
2969#line 773 "cc.y"
2970 {
2971 (yyval.node) = new(OFUNC, (yyvsp[(1) - (4)].node), Z);
2972 if((yyvsp[(1) - (4)].node)->op == ONAME)
2973 if((yyvsp[(1) - (4)].node)->type == T)
2974 dodecl(xdecl, CXXX, types[TINT], (yyval.node));
2975 (yyval.node)->right = invert((yyvsp[(3) - (4)].node));
2976 }
2977 break;
2978
2979 case 157:
2980#line 781 "cc.y"
2981 {
2982 (yyval.node) = new(OIND, new(OADD, (yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)), Z);
2983 }
2984 break;
2985
2986 case 158:
2987#line 785 "cc.y"
2988 {
2989 (yyval.node) = new(ODOT, new(OIND, (yyvsp[(1) - (3)].node), Z), Z);
2990 (yyval.node)->sym = (yyvsp[(3) - (3)].sym);
2991 }
2992 break;
2993
2994 case 159:
2995#line 790 "cc.y"
2996 {
2997 (yyval.node) = new(ODOT, (yyvsp[(1) - (3)].node), Z);
2998 (yyval.node)->sym = (yyvsp[(3) - (3)].sym);
2999 }
3000 break;
3001
3002 case 160:
3003#line 795 "cc.y"
3004 {
3005 (yyval.node) = new(OPOSTINC, (yyvsp[(1) - (2)].node), Z);
3006 }
3007 break;
3008
3009 case 161:
3010#line 799 "cc.y"
3011 {
3012 (yyval.node) = new(OPOSTDEC, (yyvsp[(1) - (2)].node), Z);
3013 }
3014 break;
3015
3016 case 163:
3017#line 804 "cc.y"
3018 {
3019 (yyval.node) = new(OCONST, Z, Z);
3020 (yyval.node)->type = types[TINT];
3021 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval);
3022 (yyval.node)->cstring = strdup(symb);
3023 }
3024 break;
3025
3026 case 164:
3027#line 811 "cc.y"
3028 {
3029 (yyval.node) = new(OCONST, Z, Z);
3030 (yyval.node)->type = types[TLONG];
3031 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval);
3032 (yyval.node)->cstring = strdup(symb);
3033 }
3034 break;
3035
3036 case 165:
3037#line 818 "cc.y"
3038 {
3039 (yyval.node) = new(OCONST, Z, Z);
3040 (yyval.node)->type = types[TUINT];
3041 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval);
3042 (yyval.node)->cstring = strdup(symb);
3043 }
3044 break;
3045
3046 case 166:
3047#line 825 "cc.y"
3048 {
3049 (yyval.node) = new(OCONST, Z, Z);
3050 (yyval.node)->type = types[TULONG];
3051 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval);
3052 (yyval.node)->cstring = strdup(symb);
3053 }
3054 break;
3055
3056 case 167:
3057#line 832 "cc.y"
3058 {
3059 (yyval.node) = new(OCONST, Z, Z);
3060 (yyval.node)->type = types[TDOUBLE];
3061 (yyval.node)->fconst = (yyvsp[(1) - (1)].dval);
3062 (yyval.node)->cstring = strdup(symb);
3063 }
3064 break;
3065
3066 case 168:
3067#line 839 "cc.y"
3068 {
3069 (yyval.node) = new(OCONST, Z, Z);
3070 (yyval.node)->type = types[TFLOAT];
3071 (yyval.node)->fconst = (yyvsp[(1) - (1)].dval);
3072 (yyval.node)->cstring = strdup(symb);
3073 }
3074 break;
3075
3076 case 169:
3077#line 846 "cc.y"
3078 {
3079 (yyval.node) = new(OCONST, Z, Z);
3080 (yyval.node)->type = types[TVLONG];
3081 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval);
3082 (yyval.node)->cstring = strdup(symb);
3083 }
3084 break;
3085
3086 case 170:
3087#line 853 "cc.y"
3088 {
3089 (yyval.node) = new(OCONST, Z, Z);
3090 (yyval.node)->type = types[TUVLONG];
3091 (yyval.node)->vconst = (yyvsp[(1) - (1)].vval);
3092 (yyval.node)->cstring = strdup(symb);
3093 }
3094 break;
3095
3096 case 173:
3097#line 864 "cc.y"
3098 {
3099 (yyval.node) = new(OSTRING, Z, Z);
3100 (yyval.node)->type = typ(TARRAY, types[TCHAR]);
3101 (yyval.node)->type->width = (yyvsp[(1) - (1)].sval).l + 1;
3102 (yyval.node)->cstring = (yyvsp[(1) - (1)].sval).s;
3103 (yyval.node)->sym = symstring;
3104 (yyval.node)->etype = TARRAY;
3105 (yyval.node)->class = CSTATIC;
3106 }
3107 break;
3108
3109 case 174:
3110#line 874 "cc.y"
3111 {
3112 char *s;
3113 int n;
3114
3115 n = (yyvsp[(1) - (2)].node)->type->width - 1;
3116 s = alloc(n+(yyvsp[(2) - (2)].sval).l+MAXALIGN);
3117
3118 memcpy(s, (yyvsp[(1) - (2)].node)->cstring, n);
3119 memcpy(s+n, (yyvsp[(2) - (2)].sval).s, (yyvsp[(2) - (2)].sval).l);
3120 s[n+(yyvsp[(2) - (2)].sval).l] = 0;
3121
3122 (yyval.node) = (yyvsp[(1) - (2)].node);
3123 (yyval.node)->type->width += (yyvsp[(2) - (2)].sval).l;
3124 (yyval.node)->cstring = s;
3125 }
3126 break;
3127
3128 case 175:
3129#line 892 "cc.y"
3130 {
3131 (yyval.node) = new(OLSTRING, Z, Z);
3132 (yyval.node)->type = typ(TARRAY, types[TRUNE]);
3133 (yyval.node)->type->width = (yyvsp[(1) - (1)].sval).l + sizeof(TRune);
3134 (yyval.node)->rstring = (TRune*)(yyvsp[(1) - (1)].sval).s;
3135 (yyval.node)->sym = symstring;
3136 (yyval.node)->etype = TARRAY;
3137 (yyval.node)->class = CSTATIC;
3138 }
3139 break;
3140
3141 case 176:
3142#line 902 "cc.y"
3143 {
3144 char *s;
3145 int n;
3146
3147 n = (yyvsp[(1) - (2)].node)->type->width - sizeof(TRune);
3148 s = alloc(n+(yyvsp[(2) - (2)].sval).l+MAXALIGN);
3149
3150 memcpy(s, (yyvsp[(1) - (2)].node)->rstring, n);
3151 memcpy(s+n, (yyvsp[(2) - (2)].sval).s, (yyvsp[(2) - (2)].sval).l);
3152 *(TRune*)(s+n+(yyvsp[(2) - (2)].sval).l) = 0;
3153
3154 (yyval.node) = (yyvsp[(1) - (2)].node);
3155 (yyval.node)->type->width += (yyvsp[(2) - (2)].sval).l;
3156 (yyval.node)->rstring = (TRune*)s;
3157 }
3158 break;
3159
3160 case 177:
3161#line 919 "cc.y"
3162 {
3163 (yyval.node) = Z;
3164 }
3165 break;
3166
3167 case 180:
3168#line 927 "cc.y"
3169 {
3170 (yyval.node) = new(OLIST, (yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node));
3171 }
3172 break;
3173
3174 case 181:
3175#line 933 "cc.y"
3176 {
3177 (yyval.tyty).t1 = strf;
3178 (yyval.tyty).t2 = strl;
3179 (yyval.tyty).t3 = lasttype;
3180 (yyval.tyty).c = lastclass;
3181 strf = T;
3182 strl = T;
3183 lastbit = 0;
3184 firstbit = 1;
3185 lastclass = CXXX;
3186 lasttype = T;
3187 }
3188 break;
3189
3190 case 182:
3191#line 946 "cc.y"
3192 {
3193 (yyval.type) = strf;
3194 strf = (yyvsp[(2) - (4)].tyty).t1;
3195 strl = (yyvsp[(2) - (4)].tyty).t2;
3196 lasttype = (yyvsp[(2) - (4)].tyty).t3;
3197 lastclass = (yyvsp[(2) - (4)].tyty).c;
3198 }
3199 break;
3200
3201 case 183:
3202#line 955 "cc.y"
3203 {
3204 lastclass = CXXX;
3205 lasttype = types[TINT];
3206 }
3207 break;
3208
3209 case 185:
3210#line 963 "cc.y"
3211 {
3212 (yyval.tycl).t = (yyvsp[(1) - (1)].type);
3213 (yyval.tycl).c = CXXX;
3214 }
3215 break;
3216
3217 case 186:
3218#line 968 "cc.y"
3219 {
3220 (yyval.tycl).t = simplet((yyvsp[(1) - (1)].lval));
3221 (yyval.tycl).c = CXXX;
3222 }
3223 break;
3224
3225 case 187:
3226#line 973 "cc.y"
3227 {
3228 (yyval.tycl).t = simplet((yyvsp[(1) - (1)].lval));
3229 (yyval.tycl).c = simplec((yyvsp[(1) - (1)].lval));
3230 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (1)].lval));
3231 }
3232 break;
3233
3234 case 188:
3235#line 979 "cc.y"
3236 {
3237 (yyval.tycl).t = (yyvsp[(1) - (2)].type);
3238 (yyval.tycl).c = simplec((yyvsp[(2) - (2)].lval));
3239 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(2) - (2)].lval));
3240 if((yyvsp[(2) - (2)].lval) & ~BCLASS & ~BGARB)
3241 diag(Z, "duplicate types given: %T and %Q", (yyvsp[(1) - (2)].type), (yyvsp[(2) - (2)].lval));
3242 }
3243 break;
3244
3245 case 189:
3246#line 987 "cc.y"
3247 {
3248 (yyval.tycl).t = simplet(typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval)));
3249 (yyval.tycl).c = simplec((yyvsp[(2) - (2)].lval));
3250 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(2) - (2)].lval));
3251 }
3252 break;
3253
3254 case 190:
3255#line 993 "cc.y"
3256 {
3257 (yyval.tycl).t = (yyvsp[(2) - (3)].type);
3258 (yyval.tycl).c = simplec((yyvsp[(1) - (3)].lval));
3259 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (3)].lval)|(yyvsp[(3) - (3)].lval));
3260 }
3261 break;
3262
3263 case 191:
3264#line 999 "cc.y"
3265 {
3266 (yyval.tycl).t = simplet((yyvsp[(2) - (2)].lval));
3267 (yyval.tycl).c = simplec((yyvsp[(1) - (2)].lval));
3268 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (2)].lval));
3269 }
3270 break;
3271
3272 case 192:
3273#line 1005 "cc.y"
3274 {
3275 (yyval.tycl).t = simplet(typebitor((yyvsp[(2) - (3)].lval), (yyvsp[(3) - (3)].lval)));
3276 (yyval.tycl).c = simplec((yyvsp[(1) - (3)].lval)|(yyvsp[(3) - (3)].lval));
3277 (yyval.tycl).t = garbt((yyval.tycl).t, (yyvsp[(1) - (3)].lval)|(yyvsp[(3) - (3)].lval));
3278 }
3279 break;
3280
3281 case 193:
3282#line 1013 "cc.y"
3283 {
3284 (yyval.type) = (yyvsp[(1) - (1)].tycl).t;
3285 if((yyvsp[(1) - (1)].tycl).c != CXXX)
3286 diag(Z, "illegal combination of class 4: %s", cnames[(yyvsp[(1) - (1)].tycl).c]);
3287 }
3288 break;
3289
3290 case 194:
3291#line 1021 "cc.y"
3292 {
3293 lasttype = (yyvsp[(1) - (1)].tycl).t;
3294 lastclass = (yyvsp[(1) - (1)].tycl).c;
3295 }
3296 break;
3297
3298 case 195:
3299#line 1028 "cc.y"
3300 {
3301 dotag((yyvsp[(2) - (2)].sym), TSTRUCT, 0);
3302 (yyval.type) = (yyvsp[(2) - (2)].sym)->suetag;
3303 }
3304 break;
3305
3306 case 196:
3307#line 1033 "cc.y"
3308 {
3309 dotag((yyvsp[(2) - (2)].sym), TSTRUCT, autobn);
3310 }
3311 break;
3312
3313 case 197:
3314#line 1037 "cc.y"
3315 {
3316 (yyval.type) = (yyvsp[(2) - (4)].sym)->suetag;
3317 if((yyval.type)->link != T)
3318 diag(Z, "redeclare tag: %s", (yyvsp[(2) - (4)].sym)->name);
3319 (yyval.type)->link = (yyvsp[(4) - (4)].type);
3320 sualign((yyval.type));
3321 }
3322 break;
3323
3324 case 198:
3325#line 1045 "cc.y"
3326 {
3327 diag(Z, "struct must have tag");
3328 taggen++;
3329 sprint(symb, "_%d_", taggen);
3330 (yyval.type) = dotag(lookup(), TSTRUCT, autobn);
3331 (yyval.type)->link = (yyvsp[(2) - (2)].type);
3332 sualign((yyval.type));
3333 }
3334 break;
3335
3336 case 199:
3337#line 1054 "cc.y"
3338 {
3339 dotag((yyvsp[(2) - (2)].sym), TUNION, 0);
3340 (yyval.type) = (yyvsp[(2) - (2)].sym)->suetag;
3341 }
3342 break;
3343
3344 case 200:
3345#line 1059 "cc.y"
3346 {
3347 dotag((yyvsp[(2) - (2)].sym), TUNION, autobn);
3348 }
3349 break;
3350
3351 case 201:
3352#line 1063 "cc.y"
3353 {
3354 (yyval.type) = (yyvsp[(2) - (4)].sym)->suetag;
3355 if((yyval.type)->link != T)
3356 diag(Z, "redeclare tag: %s", (yyvsp[(2) - (4)].sym)->name);
3357 (yyval.type)->link = (yyvsp[(4) - (4)].type);
3358 sualign((yyval.type));
3359 }
3360 break;
3361
3362 case 202:
3363#line 1071 "cc.y"
3364 {
3365 taggen++;
3366 sprint(symb, "_%d_", taggen);
3367 (yyval.type) = dotag(lookup(), TUNION, autobn);
3368 (yyval.type)->link = (yyvsp[(2) - (2)].type);
3369 sualign((yyval.type));
3370 }
3371 break;
3372
3373 case 203:
3374#line 1079 "cc.y"
3375 {
3376 dotag((yyvsp[(2) - (2)].sym), TENUM, 0);
3377 (yyval.type) = (yyvsp[(2) - (2)].sym)->suetag;
3378 if((yyval.type)->link == T)
3379 (yyval.type)->link = types[TINT];
3380 (yyval.type) = (yyval.type)->link;
3381 }
3382 break;
3383
3384 case 204:
3385#line 1087 "cc.y"
3386 {
3387 dotag((yyvsp[(2) - (2)].sym), TENUM, autobn);
3388 }
3389 break;
3390
3391 case 205:
3392#line 1091 "cc.y"
3393 {
3394 en.tenum = T;
3395 en.cenum = T;
3396 }
3397 break;
3398
3399 case 206:
3400#line 1096 "cc.y"
3401 {
3402 (yyval.type) = (yyvsp[(2) - (7)].sym)->suetag;
3403 if((yyval.type)->link != T)
3404 diag(Z, "redeclare tag: %s", (yyvsp[(2) - (7)].sym)->name);
3405 if(en.tenum == T) {
3406 diag(Z, "enum type ambiguous: %s", (yyvsp[(2) - (7)].sym)->name);
3407 en.tenum = types[TINT];
3408 }
3409 (yyval.type)->link = en.tenum;
3410 (yyval.type) = en.tenum;
3411 }
3412 break;
3413
3414 case 207:
3415#line 1108 "cc.y"
3416 {
3417 en.tenum = T;
3418 en.cenum = T;
3419 }
3420 break;
3421
3422 case 208:
3423#line 1113 "cc.y"
3424 {
3425 (yyval.type) = en.tenum;
3426 }
3427 break;
3428
3429 case 209:
3430#line 1117 "cc.y"
3431 {
3432 (yyval.type) = tcopy((yyvsp[(1) - (1)].sym)->type);
3433 }
3434 break;
3435
3436 case 211:
3437#line 1124 "cc.y"
3438 {
3439 (yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval));
3440 }
3441 break;
3442
3443 case 212:
3444#line 1129 "cc.y"
3445 {
3446 (yyval.lval) = 0;
3447 }
3448 break;
3449
3450 case 213:
3451#line 1133 "cc.y"
3452 {
3453 (yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval));
3454 }
3455 break;
3456
3457 case 218:
3458#line 1145 "cc.y"
3459 {
3460 (yyval.lval) = typebitor((yyvsp[(1) - (2)].lval), (yyvsp[(2) - (2)].lval));
3461 }
3462 break;
3463
3464 case 221:
3465#line 1155 "cc.y"
3466 {
3467 doenum((yyvsp[(1) - (1)].sym), Z);
3468 }
3469 break;
3470
3471 case 222:
3472#line 1159 "cc.y"
3473 {
3474 doenum((yyvsp[(1) - (3)].sym), (yyvsp[(3) - (3)].node));
3475 }
3476 break;
3477
3478 case 225:
3479#line 1166 "cc.y"
3480 { (yyval.lval) = BCHAR; }
3481 break;
3482
3483 case 226:
3484#line 1167 "cc.y"
3485 { (yyval.lval) = BSHORT; }
3486 break;
3487
3488 case 227:
3489#line 1168 "cc.y"
3490 { (yyval.lval) = BINT; }
3491 break;
3492
3493 case 228:
3494#line 1169 "cc.y"
3495 { (yyval.lval) = BLONG; }
3496 break;
3497
3498 case 229:
3499#line 1170 "cc.y"
3500 { (yyval.lval) = BSIGNED; }
3501 break;
3502
3503 case 230:
3504#line 1171 "cc.y"
3505 { (yyval.lval) = BUNSIGNED; }
3506 break;
3507
3508 case 231:
3509#line 1172 "cc.y"
3510 { (yyval.lval) = BFLOAT; }
3511 break;
3512
3513 case 232:
3514#line 1173 "cc.y"
3515 { (yyval.lval) = BDOUBLE; }
3516 break;
3517
3518 case 233:
3519#line 1174 "cc.y"
3520 { (yyval.lval) = BVOID; }
3521 break;
3522
3523 case 234:
3524#line 1177 "cc.y"
3525 { (yyval.lval) = BAUTO; }
3526 break;
3527
3528 case 235:
3529#line 1178 "cc.y"
3530 { (yyval.lval) = BSTATIC; }
3531 break;
3532
3533 case 236:
3534#line 1179 "cc.y"
3535 { (yyval.lval) = BEXTERN; }
3536 break;
3537
3538 case 237:
3539#line 1180 "cc.y"
3540 { (yyval.lval) = BTYPEDEF; }
3541 break;
3542
3543 case 238:
3544#line 1181 "cc.y"
3545 { (yyval.lval) = BTYPESTR; }
3546 break;
3547
3548 case 239:
3549#line 1182 "cc.y"
3550 { (yyval.lval) = BREGISTER; }
3551 break;
3552
3553 case 240:
3554#line 1183 "cc.y"
3555 { (yyval.lval) = 0; }
3556 break;
3557
3558 case 241:
3559#line 1186 "cc.y"
3560 { (yyval.lval) = BCONSTNT; }
3561 break;
3562
3563 case 242:
3564#line 1187 "cc.y"
3565 { (yyval.lval) = BVOLATILE; }
3566 break;
3567
3568 case 243:
3569#line 1188 "cc.y"
3570 { (yyval.lval) = 0; }
3571 break;
3572
3573 case 244:
3574#line 1192 "cc.y"
3575 {
3576 (yyval.node) = new(ONAME, Z, Z);
3577 if((yyvsp[(1) - (1)].sym)->class == CLOCAL)
3578 (yyvsp[(1) - (1)].sym) = mkstatic((yyvsp[(1) - (1)].sym));
3579 (yyval.node)->sym = (yyvsp[(1) - (1)].sym);
3580 (yyval.node)->type = (yyvsp[(1) - (1)].sym)->type;
3581 (yyval.node)->etype = TVOID;
3582 if((yyval.node)->type != T)
3583 (yyval.node)->etype = (yyval.node)->type->etype;
3584 (yyval.node)->xoffset = (yyvsp[(1) - (1)].sym)->offset;
3585 (yyval.node)->class = (yyvsp[(1) - (1)].sym)->class;
3586 (yyvsp[(1) - (1)].sym)->aused = 1;
3587 }
3588 break;
3589
3590 case 245:
3591#line 1207 "cc.y"
3592 {
3593 (yyval.node) = new(ONAME, Z, Z);
3594 (yyval.node)->sym = (yyvsp[(1) - (1)].sym);
3595 (yyval.node)->type = (yyvsp[(1) - (1)].sym)->type;
3596 (yyval.node)->etype = TVOID;
3597 if((yyval.node)->type != T)
3598 (yyval.node)->etype = (yyval.node)->type->etype;
3599 (yyval.node)->xoffset = (yyvsp[(1) - (1)].sym)->offset;
3600 (yyval.node)->class = (yyvsp[(1) - (1)].sym)->class;
3601 }
3602 break;
3603
3604
3605/* Line 1267 of yacc.c. */
3606#line 3607 "y.tab.c"
3607 default: break;
3608 }
3609 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3610
3611 YYPOPSTACK (yylen);
3612 yylen = 0;
3613 YY_STACK_PRINT (yyss, yyssp);
3614
3615 *++yyvsp = yyval;
3616
3617
3618 /* Now `shift' the result of the reduction. Determine what state
3619 that goes to, based on the state we popped back to and the rule
3620 number reduced by. */
3621
3622 yyn = yyr1[yyn];
3623
3624 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3625 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3626 yystate = yytable[yystate];
3627 else
3628 yystate = yydefgoto[yyn - YYNTOKENS];
3629
3630 goto yynewstate;
3631
3632
3633/*------------------------------------.
3634| yyerrlab -- here on detecting error |
3635`------------------------------------*/
3636yyerrlab:
3637 /* If not already recovering from an error, report this error. */
3638 if (!yyerrstatus)
3639 {
3640 ++yynerrs;
3641#if ! YYERROR_VERBOSE
3642 yyerror (YY_("syntax error"));
3643#else
3644 {
3645 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3646 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3647 {
3648 YYSIZE_T yyalloc = 2 * yysize;
3649 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3650 yyalloc = YYSTACK_ALLOC_MAXIMUM;
3651 if (yymsg != yymsgbuf)
3652 YYSTACK_FREE (yymsg);
3653 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3654 if (yymsg)
3655 yymsg_alloc = yyalloc;
3656 else
3657 {
3658 yymsg = yymsgbuf;
3659 yymsg_alloc = sizeof yymsgbuf;
3660 }
3661 }
3662
3663 if (0 < yysize && yysize <= yymsg_alloc)
3664 {
3665 (void) yysyntax_error (yymsg, yystate, yychar);
3666 yyerror (yymsg);
3667 }
3668 else
3669 {
3670 yyerror (YY_("syntax error"));
3671 if (yysize != 0)
3672 goto yyexhaustedlab;
3673 }
3674 }
3675#endif
3676 }
3677
3678
3679
3680 if (yyerrstatus == 3)
3681 {
3682 /* If just tried and failed to reuse look-ahead token after an
3683 error, discard it. */
3684
3685 if (yychar <= YYEOF)
3686 {
3687 /* Return failure if at end of input. */
3688 if (yychar == YYEOF)
3689 YYABORT;
3690 }
3691 else
3692 {
3693 yydestruct ("Error: discarding",
3694 yytoken, &yylval);
3695 yychar = YYEMPTY;
3696 }
3697 }
3698
3699 /* Else will try to reuse look-ahead token after shifting the error
3700 token. */
3701 goto yyerrlab1;
3702
3703
3704/*---------------------------------------------------.
3705| yyerrorlab -- error raised explicitly by YYERROR. |
3706`---------------------------------------------------*/
3707yyerrorlab:
3708
3709 /* Pacify compilers like GCC when the user code never invokes
3710 YYERROR and the label yyerrorlab therefore never appears in user
3711 code. */
3712 if (/*CONSTCOND*/ 0)
3713 goto yyerrorlab;
3714
3715 /* Do not reclaim the symbols of the rule which action triggered
3716 this YYERROR. */
3717 YYPOPSTACK (yylen);
3718 yylen = 0;
3719 YY_STACK_PRINT (yyss, yyssp);
3720 yystate = *yyssp;
3721 goto yyerrlab1;
3722
3723
3724/*-------------------------------------------------------------.
3725| yyerrlab1 -- common code for both syntax error and YYERROR. |
3726`-------------------------------------------------------------*/
3727yyerrlab1:
3728 yyerrstatus = 3; /* Each real token shifted decrements this. */
3729
3730 for (;;)
3731 {
3732 yyn = yypact[yystate];
3733 if (yyn != YYPACT_NINF)
3734 {
3735 yyn += YYTERROR;
3736 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3737 {
3738 yyn = yytable[yyn];
3739 if (0 < yyn)
3740 break;
3741 }
3742 }
3743
3744 /* Pop the current state because it cannot handle the error token. */
3745 if (yyssp == yyss)
3746 YYABORT;
3747
3748
3749 yydestruct ("Error: popping",
3750 yystos[yystate], yyvsp);
3751 YYPOPSTACK (1);
3752 yystate = *yyssp;
3753 YY_STACK_PRINT (yyss, yyssp);
3754 }
3755
3756 if (yyn == YYFINAL)
3757 YYACCEPT;
3758
3759 *++yyvsp = yylval;
3760
3761
3762 /* Shift the error token. */
3763 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3764
3765 yystate = yyn;
3766 goto yynewstate;
3767
3768
3769/*-------------------------------------.
3770| yyacceptlab -- YYACCEPT comes here. |
3771`-------------------------------------*/
3772yyacceptlab:
3773 yyresult = 0;
3774 goto yyreturn;
3775
3776/*-----------------------------------.
3777| yyabortlab -- YYABORT comes here. |
3778`-----------------------------------*/
3779yyabortlab:
3780 yyresult = 1;
3781 goto yyreturn;
3782
3783#ifndef yyoverflow
3784/*-------------------------------------------------.
3785| yyexhaustedlab -- memory exhaustion comes here. |
3786`-------------------------------------------------*/
3787yyexhaustedlab:
3788 yyerror (YY_("memory exhausted"));
3789 yyresult = 2;
3790 /* Fall through. */
3791#endif
3792
3793yyreturn:
3794 if (yychar != YYEOF && yychar != YYEMPTY)
3795 yydestruct ("Cleanup: discarding lookahead",
3796 yytoken, &yylval);
3797 /* Do not reclaim the symbols of the rule which action triggered
3798 this YYABORT or YYACCEPT. */
3799 YYPOPSTACK (yylen);
3800 YY_STACK_PRINT (yyss, yyssp);
3801 while (yyssp != yyss)
3802 {
3803 yydestruct ("Cleanup: popping",
3804 yystos[*yyssp], yyvsp);
3805 YYPOPSTACK (1);
3806 }
3807#ifndef yyoverflow
3808 if (yyss != yyssa)
3809 YYSTACK_FREE (yyss);
3810#endif
3811#if YYERROR_VERBOSE
3812 if (yymsg != yymsgbuf)
3813 YYSTACK_FREE (yymsg);
3814#endif
3815 /* Make sure YYID is used. */
3816 return YYID (yyresult);
3817}
3818
3819
3820#line 1220 "cc.y"
3821
3822