charmxi: Declare virtual destructor for abstract Type to silence warning from Clang
[charm.git] / src / xlat-i / xi-grammar.tab.C
1
2 /* A Bison parser, made by GNU Bison 2.4.1.  */
3
4 /* Skeleton implementation for Bison's Yacc-like parsers in C
5    
6       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7    Free Software Foundation, Inc.
8    
9    This program is free software: you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation, either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21
22 /* As a special exception, you may create a larger work that contains
23    part or all of the Bison parser skeleton and distribute that work
24    under terms of your choice, so long as that work isn't itself a
25    parser generator using the skeleton or a modified version thereof
26    as a parser skeleton.  Alternatively, if you modify or redistribute
27    the parser skeleton itself, you may (at your option) remove this
28    special exception, which will cause the skeleton and the resulting
29    Bison output files to be licensed under the GNU General Public
30    License without this special exception.
31    
32    This special exception was added by the Free Software Foundation in
33    version 2.2 of Bison.  */
34
35 /* C LALR(1) parser skeleton written by Richard Stallman, by
36    simplifying the original so-called "semantic" parser.  */
37
38 /* All symbols defined below should begin with yy or YY, to avoid
39    infringing on user name space.  This should be done even for local
40    variables, as they might otherwise be expanded by user macros.
41    There are some unavoidable exceptions within include files to
42    define necessary library symbols; they are noted "INFRINGES ON
43    USER NAME SPACE" below.  */
44
45 /* Identify Bison output.  */
46 #define YYBISON 1
47
48 /* Bison version.  */
49 #define YYBISON_VERSION "2.4.1"
50
51 /* Skeleton name.  */
52 #define YYSKELETON_NAME "yacc.c"
53
54 /* Pure parsers.  */
55 #define YYPURE 0
56
57 /* Push parsers.  */
58 #define YYPUSH 0
59
60 /* Pull parsers.  */
61 #define YYPULL 1
62
63 /* Using locations.  */
64 #define YYLSP_NEEDED 0
65
66
67
68 /* Copy the first part of user declarations.  */
69
70 /* Line 189 of yacc.c  */
71 #line 2 "xi-grammar.y"
72
73 #include <iostream>
74 #include <string>
75 #include <string.h>
76 #include "xi-symbol.h"
77 #include "EToken.h"
78 using namespace xi;
79 extern int yylex (void) ;
80 extern unsigned char in_comment;
81 void yyerror(const char *);
82 extern unsigned int lineno;
83 extern int in_bracket,in_braces,in_int_expr;
84 extern TList<Entry *> *connectEntries;
85 ModuleList *modlist;
86 namespace xi {
87 extern int macroDefined(const char *str, int istrue);
88 extern const char *python_doc;
89 void splitScopedName(const char* name, const char** scope, const char** basename);
90 }
91
92
93 /* Line 189 of yacc.c  */
94 #line 95 "y.tab.c"
95
96 /* Enabling traces.  */
97 #ifndef YYDEBUG
98 # define YYDEBUG 0
99 #endif
100
101 /* Enabling verbose error messages.  */
102 #ifdef YYERROR_VERBOSE
103 # undef YYERROR_VERBOSE
104 # define YYERROR_VERBOSE 1
105 #else
106 # define YYERROR_VERBOSE 0
107 #endif
108
109 /* Enabling the token table.  */
110 #ifndef YYTOKEN_TABLE
111 # define YYTOKEN_TABLE 0
112 #endif
113
114
115 /* Tokens.  */
116 #ifndef YYTOKENTYPE
117 # define YYTOKENTYPE
118    /* Put the tokens into the symbol table, so that GDB and other debuggers
119       know about them.  */
120    enum yytokentype {
121      MODULE = 258,
122      MAINMODULE = 259,
123      EXTERN = 260,
124      READONLY = 261,
125      INITCALL = 262,
126      INITNODE = 263,
127      INITPROC = 264,
128      PUPABLE = 265,
129      CHARE = 266,
130      MAINCHARE = 267,
131      GROUP = 268,
132      NODEGROUP = 269,
133      ARRAY = 270,
134      MESSAGE = 271,
135      CONDITIONAL = 272,
136      CLASS = 273,
137      INCLUDE = 274,
138      STACKSIZE = 275,
139      THREADED = 276,
140      TEMPLATE = 277,
141      SYNC = 278,
142      IGET = 279,
143      EXCLUSIVE = 280,
144      IMMEDIATE = 281,
145      SKIPSCHED = 282,
146      INLINE = 283,
147      VIRTUAL = 284,
148      MIGRATABLE = 285,
149      CREATEHERE = 286,
150      CREATEHOME = 287,
151      NOKEEP = 288,
152      NOTRACE = 289,
153      VOID = 290,
154      CONST = 291,
155      PACKED = 292,
156      VARSIZE = 293,
157      ENTRY = 294,
158      FOR = 295,
159      FORALL = 296,
160      WHILE = 297,
161      WHEN = 298,
162      OVERLAP = 299,
163      ATOMIC = 300,
164      FORWARD = 301,
165      IF = 302,
166      ELSE = 303,
167      CONNECT = 304,
168      PUBLISHES = 305,
169      PYTHON = 306,
170      LOCAL = 307,
171      NAMESPACE = 308,
172      USING = 309,
173      IDENT = 310,
174      NUMBER = 311,
175      LITERAL = 312,
176      CPROGRAM = 313,
177      HASHIF = 314,
178      HASHIFDEF = 315,
179      INT = 316,
180      LONG = 317,
181      SHORT = 318,
182      CHAR = 319,
183      FLOAT = 320,
184      DOUBLE = 321,
185      UNSIGNED = 322,
186      ACCEL = 323,
187      READWRITE = 324,
188      WRITEONLY = 325,
189      ACCELBLOCK = 326,
190      MEMCRITICAL = 327,
191      REDUCTIONTARGET = 328
192    };
193 #endif
194 /* Tokens.  */
195 #define MODULE 258
196 #define MAINMODULE 259
197 #define EXTERN 260
198 #define READONLY 261
199 #define INITCALL 262
200 #define INITNODE 263
201 #define INITPROC 264
202 #define PUPABLE 265
203 #define CHARE 266
204 #define MAINCHARE 267
205 #define GROUP 268
206 #define NODEGROUP 269
207 #define ARRAY 270
208 #define MESSAGE 271
209 #define CONDITIONAL 272
210 #define CLASS 273
211 #define INCLUDE 274
212 #define STACKSIZE 275
213 #define THREADED 276
214 #define TEMPLATE 277
215 #define SYNC 278
216 #define IGET 279
217 #define EXCLUSIVE 280
218 #define IMMEDIATE 281
219 #define SKIPSCHED 282
220 #define INLINE 283
221 #define VIRTUAL 284
222 #define MIGRATABLE 285
223 #define CREATEHERE 286
224 #define CREATEHOME 287
225 #define NOKEEP 288
226 #define NOTRACE 289
227 #define VOID 290
228 #define CONST 291
229 #define PACKED 292
230 #define VARSIZE 293
231 #define ENTRY 294
232 #define FOR 295
233 #define FORALL 296
234 #define WHILE 297
235 #define WHEN 298
236 #define OVERLAP 299
237 #define ATOMIC 300
238 #define FORWARD 301
239 #define IF 302
240 #define ELSE 303
241 #define CONNECT 304
242 #define PUBLISHES 305
243 #define PYTHON 306
244 #define LOCAL 307
245 #define NAMESPACE 308
246 #define USING 309
247 #define IDENT 310
248 #define NUMBER 311
249 #define LITERAL 312
250 #define CPROGRAM 313
251 #define HASHIF 314
252 #define HASHIFDEF 315
253 #define INT 316
254 #define LONG 317
255 #define SHORT 318
256 #define CHAR 319
257 #define FLOAT 320
258 #define DOUBLE 321
259 #define UNSIGNED 322
260 #define ACCEL 323
261 #define READWRITE 324
262 #define WRITEONLY 325
263 #define ACCELBLOCK 326
264 #define MEMCRITICAL 327
265 #define REDUCTIONTARGET 328
266
267
268
269
270 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
271 typedef union YYSTYPE
272 {
273
274 /* Line 214 of yacc.c  */
275 #line 23 "xi-grammar.y"
276
277   ModuleList *modlist;
278   Module *module;
279   ConstructList *conslist;
280   Construct *construct;
281   TParam *tparam;
282   TParamList *tparlist;
283   Type *type;
284   PtrType *ptype;
285   NamedType *ntype;
286   FuncType *ftype;
287   Readonly *readonly;
288   Message *message;
289   Chare *chare;
290   Entry *entry;
291   EntryList *entrylist;
292   Parameter *pname;
293   ParamList *plist;
294   Template *templat;
295   TypeList *typelist;
296   MemberList *mbrlist;
297   Member *member;
298   TVar *tvar;
299   TVarList *tvarlist;
300   Value *val;
301   ValueList *vallist;
302   MsgVar *mv;
303   MsgVarList *mvlist;
304   PUPableClass *pupable;
305   IncludeFile *includeFile;
306   const char *strval;
307   int intval;
308   Chare::attrib_t cattr;
309   SdagConstruct *sc;
310   XStr* xstrptr;
311   AccelBlock* accelBlock;
312
313
314
315 /* Line 214 of yacc.c  */
316 #line 317 "y.tab.c"
317 } YYSTYPE;
318 # define YYSTYPE_IS_TRIVIAL 1
319 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
320 # define YYSTYPE_IS_DECLARED 1
321 #endif
322
323
324 /* Copy the second part of user declarations.  */
325
326
327 /* Line 264 of yacc.c  */
328 #line 329 "y.tab.c"
329
330 #ifdef short
331 # undef short
332 #endif
333
334 #ifdef YYTYPE_UINT8
335 typedef YYTYPE_UINT8 yytype_uint8;
336 #else
337 typedef unsigned char yytype_uint8;
338 #endif
339
340 #ifdef YYTYPE_INT8
341 typedef YYTYPE_INT8 yytype_int8;
342 #elif (defined __STDC__ || defined __C99__FUNC__ \
343      || defined __cplusplus || defined _MSC_VER)
344 typedef signed char yytype_int8;
345 #else
346 typedef short int yytype_int8;
347 #endif
348
349 #ifdef YYTYPE_UINT16
350 typedef YYTYPE_UINT16 yytype_uint16;
351 #else
352 typedef unsigned short int yytype_uint16;
353 #endif
354
355 #ifdef YYTYPE_INT16
356 typedef YYTYPE_INT16 yytype_int16;
357 #else
358 typedef short int yytype_int16;
359 #endif
360
361 #ifndef YYSIZE_T
362 # ifdef __SIZE_TYPE__
363 #  define YYSIZE_T __SIZE_TYPE__
364 # elif defined size_t
365 #  define YYSIZE_T size_t
366 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
367      || defined __cplusplus || defined _MSC_VER)
368 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
369 #  define YYSIZE_T size_t
370 # else
371 #  define YYSIZE_T unsigned int
372 # endif
373 #endif
374
375 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
376
377 #ifndef YY_
378 # if YYENABLE_NLS
379 #  if ENABLE_NLS
380 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
381 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
382 #  endif
383 # endif
384 # ifndef YY_
385 #  define YY_(msgid) msgid
386 # endif
387 #endif
388
389 /* Suppress unused-variable warnings by "using" E.  */
390 #if ! defined lint || defined __GNUC__
391 # define YYUSE(e) ((void) (e))
392 #else
393 # define YYUSE(e) /* empty */
394 #endif
395
396 /* Identity function, used to suppress warnings about constant conditions.  */
397 #ifndef lint
398 # define YYID(n) (n)
399 #else
400 #if (defined __STDC__ || defined __C99__FUNC__ \
401      || defined __cplusplus || defined _MSC_VER)
402 static int
403 YYID (int yyi)
404 #else
405 static int
406 YYID (yyi)
407     int yyi;
408 #endif
409 {
410   return yyi;
411 }
412 #endif
413
414 #if ! defined yyoverflow || YYERROR_VERBOSE
415
416 /* The parser invokes alloca or malloc; define the necessary symbols.  */
417
418 # ifdef YYSTACK_USE_ALLOCA
419 #  if YYSTACK_USE_ALLOCA
420 #   ifdef __GNUC__
421 #    define YYSTACK_ALLOC __builtin_alloca
422 #   elif defined __BUILTIN_VA_ARG_INCR
423 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
424 #   elif defined _AIX
425 #    define YYSTACK_ALLOC __alloca
426 #   elif defined _MSC_VER
427 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
428 #    define alloca _alloca
429 #   else
430 #    define YYSTACK_ALLOC alloca
431 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
432      || defined __cplusplus || defined _MSC_VER)
433 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
434 #     ifndef _STDLIB_H
435 #      define _STDLIB_H 1
436 #     endif
437 #    endif
438 #   endif
439 #  endif
440 # endif
441
442 # ifdef YYSTACK_ALLOC
443    /* Pacify GCC's `empty if-body' warning.  */
444 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
445 #  ifndef YYSTACK_ALLOC_MAXIMUM
446     /* The OS might guarantee only one guard page at the bottom of the stack,
447        and a page size can be as small as 4096 bytes.  So we cannot safely
448        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
449        to allow for a few compiler-allocated temporary stack slots.  */
450 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
451 #  endif
452 # else
453 #  define YYSTACK_ALLOC YYMALLOC
454 #  define YYSTACK_FREE YYFREE
455 #  ifndef YYSTACK_ALLOC_MAXIMUM
456 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
457 #  endif
458 #  if (defined __cplusplus && ! defined _STDLIB_H \
459        && ! ((defined YYMALLOC || defined malloc) \
460              && (defined YYFREE || defined free)))
461 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
462 #   ifndef _STDLIB_H
463 #    define _STDLIB_H 1
464 #   endif
465 #  endif
466 #  ifndef YYMALLOC
467 #   define YYMALLOC malloc
468 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
469      || defined __cplusplus || defined _MSC_VER)
470 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
471 #   endif
472 #  endif
473 #  ifndef YYFREE
474 #   define YYFREE free
475 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
476      || defined __cplusplus || defined _MSC_VER)
477 void free (void *); /* INFRINGES ON USER NAME SPACE */
478 #   endif
479 #  endif
480 # endif
481 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
482
483
484 #if (! defined yyoverflow \
485      && (! defined __cplusplus \
486          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
487
488 /* A type that is properly aligned for any stack member.  */
489 union yyalloc
490 {
491   yytype_int16 yyss_alloc;
492   YYSTYPE yyvs_alloc;
493 };
494
495 /* The size of the maximum gap between one aligned stack and the next.  */
496 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
497
498 /* The size of an array large to enough to hold all stacks, each with
499    N elements.  */
500 # define YYSTACK_BYTES(N) \
501      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
502       + YYSTACK_GAP_MAXIMUM)
503
504 /* Copy COUNT objects from FROM to TO.  The source and destination do
505    not overlap.  */
506 # ifndef YYCOPY
507 #  if defined __GNUC__ && 1 < __GNUC__
508 #   define YYCOPY(To, From, Count) \
509       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
510 #  else
511 #   define YYCOPY(To, From, Count)              \
512       do                                        \
513         {                                       \
514           YYSIZE_T yyi;                         \
515           for (yyi = 0; yyi < (Count); yyi++)   \
516             (To)[yyi] = (From)[yyi];            \
517         }                                       \
518       while (YYID (0))
519 #  endif
520 # endif
521
522 /* Relocate STACK from its old location to the new one.  The
523    local variables YYSIZE and YYSTACKSIZE give the old and new number of
524    elements in the stack, and YYPTR gives the new location of the
525    stack.  Advance YYPTR to a properly aligned location for the next
526    stack.  */
527 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
528     do                                                                  \
529       {                                                                 \
530         YYSIZE_T yynewbytes;                                            \
531         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
532         Stack = &yyptr->Stack_alloc;                                    \
533         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
534         yyptr += yynewbytes / sizeof (*yyptr);                          \
535       }                                                                 \
536     while (YYID (0))
537
538 #endif
539
540 /* YYFINAL -- State number of the termination state.  */
541 #define YYFINAL  9
542 /* YYLAST -- Last index in YYTABLE.  */
543 #define YYLAST   741
544
545 /* YYNTOKENS -- Number of terminals.  */
546 #define YYNTOKENS  90
547 /* YYNNTS -- Number of nonterminals.  */
548 #define YYNNTS  110
549 /* YYNRULES -- Number of rules.  */
550 #define YYNRULES  283
551 /* YYNRULES -- Number of states.  */
552 #define YYNSTATES  598
553
554 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
555 #define YYUNDEFTOK  2
556 #define YYMAXUTOK   328
557
558 #define YYTRANSLATE(YYX)                                                \
559   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
560
561 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
562 static const yytype_uint8 yytranslate[] =
563 {
564        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
565        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
566        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
567        2,     2,     2,     2,     2,     2,     2,     2,    84,     2,
568       82,    83,    81,     2,    78,    88,    89,     2,     2,     2,
569        2,     2,     2,     2,     2,     2,     2,     2,    75,    74,
570       79,    87,    80,     2,     2,     2,     2,     2,     2,     2,
571        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
572        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
573        2,    85,     2,    86,     2,     2,     2,     2,     2,     2,
574        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
575        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
576        2,     2,     2,    76,     2,    77,     2,     2,     2,     2,
577        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
578        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
579        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
580        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
581        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
582        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
583        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
584        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
585        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
586        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
587        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
588        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
589        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
590        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
591       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
592       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
593       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
594       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
595       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
596       65,    66,    67,    68,    69,    70,    71,    72,    73
597 };
598
599 #if YYDEBUG
600 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
601    YYRHS.  */
602 static const yytype_uint16 yyprhs[] =
603 {
604        0,     0,     3,     5,     6,     9,    10,    12,    13,    15,
605       17,    19,    24,    28,    32,    34,    39,    40,    43,    49,
606       55,    60,    64,    67,    70,    74,    77,    80,    83,    86,
607       89,    98,   100,   102,   104,   106,   108,   110,   112,   116,
608      117,   119,   120,   124,   126,   128,   130,   132,   135,   138,
609      142,   146,   149,   152,   155,   157,   159,   162,   164,   167,
610      170,   172,   174,   177,   180,   183,   192,   194,   196,   198,
611      200,   203,   206,   209,   211,   213,   215,   219,   220,   223,
612      228,   234,   235,   237,   238,   242,   244,   248,   250,   252,
613      253,   257,   259,   263,   264,   266,   268,   269,   273,   275,
614      279,   281,   283,   284,   286,   287,   290,   296,   298,   301,
615      305,   312,   313,   316,   318,   322,   328,   334,   340,   346,
616      351,   355,   362,   369,   375,   381,   387,   393,   399,   404,
617      412,   413,   416,   417,   420,   423,   427,   430,   434,   436,
618      440,   445,   448,   451,   454,   457,   460,   462,   467,   468,
619      471,   474,   477,   480,   483,   487,   491,   495,   499,   506,
620      516,   520,   527,   531,   538,   548,   558,   560,   564,   566,
621      569,   573,   575,   583,   589,   602,   608,   611,   613,   615,
622      616,   620,   622,   626,   628,   630,   632,   634,   636,   638,
623      640,   642,   644,   646,   648,   650,   653,   655,   657,   659,
624      661,   663,   664,   666,   670,   671,   673,   679,   685,   691,
625      696,   700,   702,   704,   706,   710,   715,   719,   721,   723,
626      725,   727,   732,   736,   741,   746,   751,   755,   763,   769,
627      776,   778,   782,   784,   788,   792,   795,   799,   802,   803,
628      807,   808,   810,   814,   816,   819,   821,   824,   825,   830,
629      832,   836,   838,   839,   846,   855,   860,   864,   870,   875,
630      887,   897,   910,   925,   932,   941,   947,   955,   959,   963,
631      964,   967,   972,   974,   978,   980,   982,   985,   991,   993,
632      997,   999,  1001,  1004
633 };
634
635 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
636 static const yytype_int16 yyrhs[] =
637 {
638       91,     0,    -1,    92,    -1,    -1,    97,    92,    -1,    -1,
639        5,    -1,    -1,    74,    -1,    55,    -1,    55,    -1,    96,
640       75,    75,    55,    -1,     3,    95,    98,    -1,     4,    95,
641       98,    -1,    74,    -1,    76,    99,    77,    94,    -1,    -1,
642      100,    99,    -1,    93,    76,    99,    77,    94,    -1,    53,
643       95,    76,    99,    77,    -1,    54,    53,    96,    74,    -1,
644       54,    96,    74,    -1,    93,    97,    -1,    93,   155,    -1,
645       93,   134,    74,    -1,    93,   137,    -1,    93,   138,    -1,
646       93,   139,    -1,    93,   141,    -1,    93,   152,    -1,     5,
647       39,   163,   107,    95,   104,   180,    74,    -1,   198,    -1,
648      199,    -1,   162,    -1,   113,    -1,    56,    -1,    57,    -1,
649      101,    -1,   101,    78,   102,    -1,    -1,   102,    -1,    -1,
650       79,   103,    80,    -1,    61,    -1,    62,    -1,    63,    -1,
651       64,    -1,    67,    61,    -1,    67,    62,    -1,    67,    62,
652       61,    -1,    67,    62,    62,    -1,    67,    63,    -1,    67,
653       64,    -1,    62,    62,    -1,    65,    -1,    66,    -1,    62,
654       66,    -1,    35,    -1,    95,   104,    -1,    96,   104,    -1,
655      105,    -1,   107,    -1,   108,    81,    -1,   109,    81,    -1,
656      110,    81,    -1,   112,    82,    81,    95,    83,    82,   178,
657       83,    -1,   108,    -1,   109,    -1,   110,    -1,   111,    -1,
658       36,   112,    -1,   112,    36,    -1,   112,    84,    -1,   112,
659       -1,    56,    -1,    96,    -1,    85,   114,    86,    -1,    -1,
660      115,   116,    -1,     6,   113,    96,   116,    -1,     6,    16,
661      108,    81,    95,    -1,    -1,    35,    -1,    -1,    85,   121,
662       86,    -1,   122,    -1,   122,    78,   121,    -1,    37,    -1,
663       38,    -1,    -1,    85,   124,    86,    -1,   129,    -1,   129,
664       78,   124,    -1,    -1,    57,    -1,    51,    -1,    -1,    85,
665      128,    86,    -1,   126,    -1,   126,    78,   128,    -1,    30,
666       -1,    51,    -1,    -1,    17,    -1,    -1,    85,    86,    -1,
667      130,   113,    95,   131,    74,    -1,   132,    -1,   132,   133,
668       -1,    16,   120,   106,    -1,    16,   120,   106,    76,   133,
669       77,    -1,    -1,    75,   136,    -1,   107,    -1,   107,    78,
670      136,    -1,    11,   123,   106,   135,   153,    -1,    12,   123,
671      106,   135,   153,    -1,    13,   123,   106,   135,   153,    -1,
672       14,   123,   106,   135,   153,    -1,    85,    56,    95,    86,
673       -1,    85,    95,    86,    -1,    15,   127,   140,   106,   135,
674      153,    -1,    15,   140,   127,   106,   135,   153,    -1,    11,
675      123,    95,   135,   153,    -1,    12,   123,    95,   135,   153,
676       -1,    13,   123,    95,   135,   153,    -1,    14,   123,    95,
677      135,   153,    -1,    15,   140,    95,   135,   153,    -1,    16,
678      120,    95,    74,    -1,    16,   120,    95,    76,   133,    77,
679       74,    -1,    -1,    87,   113,    -1,    -1,    87,    56,    -1,
680       87,    57,    -1,    18,    95,   147,    -1,   111,   148,    -1,
681      113,    95,   148,    -1,   149,    -1,   149,    78,   150,    -1,
682       22,    79,   150,    80,    -1,   151,   142,    -1,   151,   143,
683       -1,   151,   144,    -1,   151,   145,    -1,   151,   146,    -1,
684       74,    -1,    76,   154,    77,    94,    -1,    -1,   160,   154,
685       -1,   117,    74,    -1,   118,    74,    -1,   157,    74,    -1,
686      156,    74,    -1,    10,   158,    74,    -1,    19,   159,    74,
687       -1,    18,    95,    74,    -1,     8,   119,    96,    -1,     8,
688      119,    96,    82,   119,    83,    -1,     8,   119,    96,    79,
689      102,    80,    82,   119,    83,    -1,     7,   119,    96,    -1,
690        7,   119,    96,    82,   119,    83,    -1,     9,   119,    96,
691       -1,     9,   119,    96,    82,   119,    83,    -1,     9,   119,
692       96,    79,   102,    80,    82,   119,    83,    -1,     9,    85,
693       68,    86,   119,    96,    82,   119,    83,    -1,   107,    -1,
694      107,    78,   158,    -1,    57,    -1,   161,    74,    -1,   151,
695      161,    74,    -1,   155,    -1,    39,   164,   163,    95,   180,
696      182,   183,    -1,    39,   164,    95,   180,   183,    -1,    39,
697       85,    68,    86,    35,    95,   180,   181,   171,   169,   172,
698       95,    -1,    71,   171,   169,   172,    74,    -1,    71,    74,
699       -1,    35,    -1,   109,    -1,    -1,    85,   165,    86,    -1,
700      166,    -1,   166,    78,   165,    -1,    21,    -1,    23,    -1,
701       24,    -1,    25,    -1,    31,    -1,    32,    -1,    33,    -1,
702       34,    -1,    26,    -1,    27,    -1,    28,    -1,    52,    -1,
703       51,   125,    -1,    72,    -1,    73,    -1,    57,    -1,    56,
704       -1,    96,    -1,    -1,    58,    -1,    58,    78,   168,    -1,
705       -1,    58,    -1,    58,    85,   169,    86,   169,    -1,    58,
706       76,   169,    77,   169,    -1,    58,    82,   168,    83,   169,
707       -1,    82,   169,    83,   169,    -1,   113,    95,    85,    -1,
708       76,    -1,    77,    -1,   113,    -1,   113,    95,   130,    -1,
709      113,    95,    87,   167,    -1,   170,   169,    86,    -1,     6,
710       -1,    69,    -1,    70,    -1,    95,    -1,   175,    88,    80,
711       95,    -1,   175,    89,    95,    -1,   175,    85,   175,    86,
712       -1,   175,    85,    56,    86,    -1,   175,    82,   175,    83,
713       -1,   170,   169,    86,    -1,   174,    75,   113,    95,    79,
714      175,    80,    -1,   113,    95,    79,   175,    80,    -1,   174,
715       75,   176,    79,   175,    80,    -1,   173,    -1,   173,    78,
716      178,    -1,   177,    -1,   177,    78,   179,    -1,    82,   178,
717       83,    -1,    82,    83,    -1,    85,   179,    86,    -1,    85,
718       86,    -1,    -1,    20,    87,    56,    -1,    -1,   189,    -1,
719       76,   184,    77,    -1,   189,    -1,   189,   184,    -1,   189,
720       -1,   189,   184,    -1,    -1,    50,    82,   187,    83,    -1,
721       55,    -1,    55,    78,   187,    -1,    57,    -1,    -1,    45,
722      188,   171,   169,   172,   186,    -1,    49,    82,    55,   180,
723       83,   171,   169,    77,    -1,    43,   195,    76,    77,    -1,
724       43,   195,   189,    -1,    43,   195,    76,   184,    77,    -1,
725       44,    76,   185,    77,    -1,    40,   193,   169,    74,   169,
726       74,   169,   192,    76,   184,    77,    -1,    40,   193,   169,
727       74,   169,    74,   169,   192,   189,    -1,    41,    85,    55,
728       86,   193,   169,    75,   169,    78,   169,   192,   189,    -1,
729       41,    85,    55,    86,   193,   169,    75,   169,    78,   169,
730      192,    76,   184,    77,    -1,    47,   193,   169,   192,   189,
731      190,    -1,    47,   193,   169,   192,    76,   184,    77,   190,
732       -1,    42,   193,   169,   192,   189,    -1,    42,   193,   169,
733      192,    76,   184,    77,    -1,    46,   191,    74,    -1,   171,
734      169,   172,    -1,    -1,    48,   189,    -1,    48,    76,   184,
735       77,    -1,    55,    -1,    55,    78,   191,    -1,    83,    -1,
736       82,    -1,    55,   180,    -1,    55,   196,   169,   197,   180,
737       -1,   194,    -1,   194,    78,   195,    -1,    85,    -1,    86,
738       -1,    59,    95,    -1,    60,    95,    -1
739 };
740
741 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
742 static const yytype_uint16 yyrline[] =
743 {
744        0,   154,   154,   159,   162,   167,   168,   173,   174,   178,
745      182,   184,   192,   196,   203,   205,   210,   211,   215,   217,
746      219,   221,   223,   225,   227,   229,   231,   233,   235,   237,
747      239,   249,   251,   253,   257,   259,   261,   265,   267,   272,
748      273,   278,   279,   283,   285,   287,   289,   291,   293,   295,
749      297,   299,   301,   303,   305,   307,   309,   311,   315,   316,
750      323,   325,   329,   333,   335,   339,   343,   345,   347,   349,
751      352,   354,   358,   360,   364,   366,   370,   375,   376,   380,
752      384,   389,   390,   395,   396,   406,   408,   412,   414,   419,
753      420,   424,   426,   431,   432,   436,   441,   442,   446,   448,
754      452,   454,   459,   460,   464,   465,   468,   472,   474,   478,
755      480,   485,   486,   490,   492,   496,   498,   502,   506,   510,
756      516,   520,   522,   526,   528,   532,   536,   540,   544,   546,
757      551,   552,   557,   558,   560,   564,   566,   568,   572,   574,
758      578,   582,   584,   586,   588,   590,   594,   596,   601,   619,
759      623,   625,   627,   628,   630,   632,   634,   638,   640,   642,
760      648,   651,   656,   658,   660,   666,   674,   676,   679,   683,
761      685,   690,   694,   702,   715,   733,   735,   739,   741,   746,
762      747,   751,   753,   757,   759,   761,   763,   765,   767,   769,
763      771,   773,   775,   777,   779,   781,   783,   785,   789,   791,
764      793,   798,   799,   801,   810,   811,   813,   819,   825,   831,
765      839,   846,   854,   861,   863,   865,   867,   874,   875,   876,
766      879,   880,   881,   882,   889,   895,   904,   911,   917,   923,
767      931,   933,   937,   939,   943,   945,   949,   951,   956,   957,
768      962,   963,   965,   969,   971,   975,   977,   982,   983,   987,
769      989,   993,   996,   999,  1003,  1017,  1019,  1021,  1023,  1025,
770     1028,  1031,  1034,  1037,  1039,  1041,  1043,  1045,  1047,  1051,
771     1052,  1054,  1057,  1059,  1063,  1067,  1071,  1073,  1077,  1079,
772     1083,  1086,  1090,  1094
773 };
774 #endif
775
776 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
777 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
778    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
779 static const char *const yytname[] =
780 {
781   "$end", "error", "$undefined", "MODULE", "MAINMODULE", "EXTERN",
782   "READONLY", "INITCALL", "INITNODE", "INITPROC", "PUPABLE", "CHARE",
783   "MAINCHARE", "GROUP", "NODEGROUP", "ARRAY", "MESSAGE", "CONDITIONAL",
784   "CLASS", "INCLUDE", "STACKSIZE", "THREADED", "TEMPLATE", "SYNC", "IGET",
785   "EXCLUSIVE", "IMMEDIATE", "SKIPSCHED", "INLINE", "VIRTUAL", "MIGRATABLE",
786   "CREATEHERE", "CREATEHOME", "NOKEEP", "NOTRACE", "VOID", "CONST",
787   "PACKED", "VARSIZE", "ENTRY", "FOR", "FORALL", "WHILE", "WHEN",
788   "OVERLAP", "ATOMIC", "FORWARD", "IF", "ELSE", "CONNECT", "PUBLISHES",
789   "PYTHON", "LOCAL", "NAMESPACE", "USING", "IDENT", "NUMBER", "LITERAL",
790   "CPROGRAM", "HASHIF", "HASHIFDEF", "INT", "LONG", "SHORT", "CHAR",
791   "FLOAT", "DOUBLE", "UNSIGNED", "ACCEL", "READWRITE", "WRITEONLY",
792   "ACCELBLOCK", "MEMCRITICAL", "REDUCTIONTARGET", "';'", "':'", "'{'",
793   "'}'", "','", "'<'", "'>'", "'*'", "'('", "')'", "'&'", "'['", "']'",
794   "'='", "'-'", "'.'", "$accept", "File", "ModuleEList", "OptExtern",
795   "OptSemiColon", "Name", "QualName", "Module", "ConstructEList",
796   "ConstructList", "Construct", "TParam", "TParamList", "TParamEList",
797   "OptTParams", "BuiltinType", "NamedType", "QualNamedType", "SimpleType",
798   "OnePtrType", "PtrType", "FuncType", "BaseType", "Type", "ArrayDim",
799   "Dim", "DimList", "Readonly", "ReadonlyMsg", "OptVoid", "MAttribs",
800   "MAttribList", "MAttrib", "CAttribs", "CAttribList", "PythonOptions",
801   "ArrayAttrib", "ArrayAttribs", "ArrayAttribList", "CAttrib",
802   "OptConditional", "MsgArray", "Var", "VarList", "Message", "OptBaseList",
803   "BaseList", "Chare", "Group", "NodeGroup", "ArrayIndexType", "Array",
804   "TChare", "TGroup", "TNodeGroup", "TArray", "TMessage", "OptTypeInit",
805   "OptNameInit", "TVar", "TVarList", "TemplateSpec", "Template",
806   "MemberEList", "MemberList", "NonEntryMember", "InitNode", "InitProc",
807   "PUPableClass", "IncludeFile", "Member", "Entry", "AccelBlock",
808   "EReturn", "EAttribs", "EAttribList", "EAttrib", "DefaultParameter",
809   "CPROGRAM_List", "CCode", "ParamBracketStart", "ParamBraceStart",
810   "ParamBraceEnd", "Parameter", "AccelBufferType", "AccelInstName",
811   "AccelArrayParam", "AccelParameter", "ParamList", "AccelParamList",
812   "EParameters", "AccelEParameters", "OptStackSize", "OptSdagCode",
813   "Slist", "Olist", "OptPubList", "PublishesList", "OptTraceName",
814   "SingleConstruct", "HasElse", "ForwardList", "EndIntExpr",
815   "StartIntExpr", "SEntry", "SEntryList", "SParamBracketStart",
816   "SParamBracketEnd", "HashIFComment", "HashIFDefComment", 0
817 };
818 #endif
819
820 # ifdef YYPRINT
821 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
822    token YYLEX-NUM.  */
823 static const yytype_uint16 yytoknum[] =
824 {
825        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
826      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
827      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
828      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
829      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
830      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
831      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
832      325,   326,   327,   328,    59,    58,   123,   125,    44,    60,
833       62,    42,    40,    41,    38,    91,    93,    61,    45,    46
834 };
835 # endif
836
837 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
838 static const yytype_uint8 yyr1[] =
839 {
840        0,    90,    91,    92,    92,    93,    93,    94,    94,    95,
841       96,    96,    97,    97,    98,    98,    99,    99,   100,   100,
842      100,   100,   100,   100,   100,   100,   100,   100,   100,   100,
843      100,   100,   100,   100,   101,   101,   101,   102,   102,   103,
844      103,   104,   104,   105,   105,   105,   105,   105,   105,   105,
845      105,   105,   105,   105,   105,   105,   105,   105,   106,   107,
846      108,   108,   109,   110,   110,   111,   112,   112,   112,   112,
847      112,   112,   113,   113,   114,   114,   115,   116,   116,   117,
848      118,   119,   119,   120,   120,   121,   121,   122,   122,   123,
849      123,   124,   124,   125,   125,   126,   127,   127,   128,   128,
850      129,   129,   130,   130,   131,   131,   132,   133,   133,   134,
851      134,   135,   135,   136,   136,   137,   137,   138,   139,   140,
852      140,   141,   141,   142,   142,   143,   144,   145,   146,   146,
853      147,   147,   148,   148,   148,   149,   149,   149,   150,   150,
854      151,   152,   152,   152,   152,   152,   153,   153,   154,   154,
855      155,   155,   155,   155,   155,   155,   155,   156,   156,   156,
856      156,   156,   157,   157,   157,   157,   158,   158,   159,   160,
857      160,   160,   161,   161,   161,   162,   162,   163,   163,   164,
858      164,   165,   165,   166,   166,   166,   166,   166,   166,   166,
859      166,   166,   166,   166,   166,   166,   166,   166,   167,   167,
860      167,   168,   168,   168,   169,   169,   169,   169,   169,   169,
861      170,   171,   172,   173,   173,   173,   173,   174,   174,   174,
862      175,   175,   175,   175,   175,   175,   176,   177,   177,   177,
863      178,   178,   179,   179,   180,   180,   181,   181,   182,   182,
864      183,   183,   183,   184,   184,   185,   185,   186,   186,   187,
865      187,   188,   188,   189,   189,   189,   189,   189,   189,   189,
866      189,   189,   189,   189,   189,   189,   189,   189,   189,   190,
867      190,   190,   191,   191,   192,   193,   194,   194,   195,   195,
868      196,   197,   198,   199
869 };
870
871 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
872 static const yytype_uint8 yyr2[] =
873 {
874        0,     2,     1,     0,     2,     0,     1,     0,     1,     1,
875        1,     4,     3,     3,     1,     4,     0,     2,     5,     5,
876        4,     3,     2,     2,     3,     2,     2,     2,     2,     2,
877        8,     1,     1,     1,     1,     1,     1,     1,     3,     0,
878        1,     0,     3,     1,     1,     1,     1,     2,     2,     3,
879        3,     2,     2,     2,     1,     1,     2,     1,     2,     2,
880        1,     1,     2,     2,     2,     8,     1,     1,     1,     1,
881        2,     2,     2,     1,     1,     1,     3,     0,     2,     4,
882        5,     0,     1,     0,     3,     1,     3,     1,     1,     0,
883        3,     1,     3,     0,     1,     1,     0,     3,     1,     3,
884        1,     1,     0,     1,     0,     2,     5,     1,     2,     3,
885        6,     0,     2,     1,     3,     5,     5,     5,     5,     4,
886        3,     6,     6,     5,     5,     5,     5,     5,     4,     7,
887        0,     2,     0,     2,     2,     3,     2,     3,     1,     3,
888        4,     2,     2,     2,     2,     2,     1,     4,     0,     2,
889        2,     2,     2,     2,     3,     3,     3,     3,     6,     9,
890        3,     6,     3,     6,     9,     9,     1,     3,     1,     2,
891        3,     1,     7,     5,    12,     5,     2,     1,     1,     0,
892        3,     1,     3,     1,     1,     1,     1,     1,     1,     1,
893        1,     1,     1,     1,     1,     2,     1,     1,     1,     1,
894        1,     0,     1,     3,     0,     1,     5,     5,     5,     4,
895        3,     1,     1,     1,     3,     4,     3,     1,     1,     1,
896        1,     4,     3,     4,     4,     4,     3,     7,     5,     6,
897        1,     3,     1,     3,     3,     2,     3,     2,     0,     3,
898        0,     1,     3,     1,     2,     1,     2,     0,     4,     1,
899        3,     1,     0,     6,     8,     4,     3,     5,     4,    11,
900        9,    12,    14,     6,     8,     5,     7,     3,     3,     0,
901        2,     4,     1,     3,     1,     1,     2,     5,     1,     3,
902        1,     1,     2,     2
903 };
904
905 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
906    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
907    means the default is an error.  */
908 static const yytype_uint16 yydefact[] =
909 {
910        3,     0,     0,     0,     2,     3,     9,     0,     0,     1,
911        4,    14,     5,    12,    13,     6,     0,     0,     0,     0,
912        0,     0,     0,     5,    33,    31,    32,     0,     0,     0,
913       10,     0,   282,   283,   176,   211,   204,     0,    81,    81,
914       81,     0,    89,    89,    89,    89,     0,    83,     0,     0,
915        0,     5,    22,     0,     0,     0,    25,    26,    27,    28,
916        0,    29,    23,     0,     0,     7,    17,    57,    43,    44,
917       45,    46,    54,    55,     0,    41,    60,    61,     0,   178,
918        0,     5,     0,    21,     0,   205,   204,     0,     0,    57,
919        0,    66,    67,    68,    69,    73,     0,    82,     0,     0,
920        0,     0,   166,     0,     0,     0,     0,     0,     0,     0,
921        0,    96,     0,     0,     0,   168,     0,     0,     0,   150,
922      151,    24,    89,    89,    89,    89,     0,    83,   141,   142,
923      143,   144,   145,   153,   152,     8,    15,    53,    56,    47,
924       48,    51,    52,    39,    59,    62,     0,     0,    20,     0,
925      204,   201,   204,     0,   212,     0,     0,    70,    63,    64,
926       71,     0,    72,    77,   160,   157,     0,   162,     0,   154,
927      100,   101,     0,    91,    41,   111,   111,   111,   111,    95,
928        0,     0,    98,     0,     0,     0,     0,     0,    87,    88,
929        0,    85,   109,   156,   155,     0,    69,     0,   138,     0,
930        7,     0,     0,     0,     0,     0,     0,    49,    50,    35,
931       36,    37,    40,     0,    34,    41,    19,    11,     0,   202,
932        0,     0,   204,   175,     0,     0,     0,    77,    79,    81,
933        0,    81,    81,     0,    81,   167,    90,     0,    58,     0,
934        0,     0,     0,     0,     0,   120,     0,    97,   111,   111,
935       84,     0,   102,   130,     0,   136,   132,     0,   140,    18,
936      111,   111,   111,   111,   111,     0,     0,    42,     0,   204,
937      201,   204,   204,   209,    80,     0,    74,    75,     0,    78,
938        0,     0,     0,     0,     0,     0,    92,   113,   112,   146,
939      148,   115,   116,   117,   118,   119,    99,     0,     0,    86,
940      103,     0,   102,     0,     0,   135,   133,   134,   137,   139,
941        0,     0,     0,     0,     0,   128,   102,    38,     0,     0,
942      207,   203,   208,   206,     0,    76,   161,     0,   158,     0,
943        0,   163,     0,   179,     0,     0,   171,   148,     0,   121,
944      122,     0,   108,   110,   131,   123,   124,   125,   126,   127,
945        0,   235,   213,   204,   230,     0,    30,     0,    81,    81,
946       81,   114,     0,     0,     0,     7,   149,   169,   104,     0,
947      102,     0,     0,   234,     0,     0,     0,     0,   183,   184,
948      185,   186,   191,   192,   193,   187,   188,   189,   190,    93,
949      194,     0,   196,   197,     0,   181,    10,     0,     0,   170,
950      147,     0,     0,   129,   210,     0,   214,   216,   231,    65,
951      159,   165,   164,    94,   195,     0,   180,     0,   240,     0,
952      105,   106,   199,   198,   200,   215,     0,   182,     0,     0,
953        0,     0,     0,   252,     0,     0,     0,   211,   204,   173,
954      241,   238,     0,   275,   204,     0,   204,     0,   278,     0,
955        0,   251,     0,   272,     0,   204,     0,     0,   243,     0,
956        0,   240,     0,     0,     0,     0,   280,   276,   204,     0,
957      211,   256,     0,   245,   204,     0,   267,     0,     0,   242,
958      244,   268,     0,   172,     0,     0,   204,     0,   274,     0,
959        0,   279,   255,     0,   258,   246,     0,   273,     0,     0,
960      239,   217,   218,   219,   237,     0,     0,   232,     0,   204,
961        0,   204,   211,   265,   281,     0,   257,   247,   211,   269,
962        0,     0,     0,     0,   236,     0,   204,     0,     0,   277,
963        0,   253,     0,     0,   263,   204,     0,     0,   204,     0,
964      233,     0,     0,   204,   266,     0,   269,   211,   270,     0,
965      220,     0,     0,     0,     0,   174,     0,     0,   249,     0,
966      264,     0,   254,   228,     0,     0,     0,     0,     0,   226,
967        0,   211,   260,   204,     0,   248,   271,     0,     0,     0,
968        0,   222,     0,   229,     0,     0,   250,   225,   224,   223,
969      221,   227,   259,     0,   211,   261,     0,   262
970 };
971
972 /* YYDEFGOTO[NTERM-NUM].  */
973 static const yytype_int16 yydefgoto[] =
974 {
975       -1,     3,     4,    21,   136,   174,    75,     5,    13,    22,
976       23,   211,   212,   213,   144,    76,   175,    77,    91,    92,
977       93,    94,    95,   214,   278,   227,   228,    53,    54,    98,
978      113,   190,   191,   105,   172,   414,   182,   110,   183,   173,
979      301,   402,   302,   303,    55,   240,   288,    56,    57,    58,
980      111,    59,   128,   129,   130,   131,   132,   305,   255,   198,
981      199,   334,    61,   291,   335,   336,    63,    64,   103,   116,
982      337,   338,    24,    80,   363,   394,   395,   425,   220,    87,
983      353,   438,   155,   354,   506,   551,   539,   507,   355,   508,
984      319,   485,   461,   439,   457,   472,   531,   559,   452,   458,
985      534,   454,   489,   444,   448,   449,   468,   515,    25,    26
986 };
987
988 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
989    STATE-NUM.  */
990 #define YYPACT_NINF -462
991 static const yytype_int16 yypact[] =
992 {
993      306,    -2,    -2,    36,  -462,   306,  -462,    73,    73,  -462,
994     -462,  -462,    19,  -462,  -462,    24,    -2,   175,    -2,    -2,
995      203,   239,    43,    19,  -462,  -462,  -462,   494,    50,    83,
996     -462,   271,  -462,  -462,  -462,  -462,   -26,   357,   123,   123,
997       17,    83,    87,    87,    87,    87,    95,   100,    -2,   140,
998      127,    19,  -462,   159,   162,   185,  -462,  -462,  -462,  -462,
999      323,  -462,  -462,   198,   206,   223,  -462,   231,  -462,   156,
1000     -462,  -462,  -462,  -462,   261,   187,  -462,  -462,   221,  -462,
1001       83,    19,   282,  -462,   241,    52,   -26,   249,   600,  -462,
1002      582,   221,   247,   262,  -462,    81,    83,  -462,    83,    83,
1003      279,    83,   276,   275,     3,    -2,    -2,    -2,    -2,   165,
1004      294,   299,   344,    -2,   291,  -462,   316,   409,   319,  -462,
1005     -462,  -462,    87,    87,    87,    87,   294,   100,  -462,  -462,
1006     -462,  -462,  -462,  -462,  -462,  -462,  -462,  -462,  -462,  -462,
1007      327,  -462,  -462,   567,  -462,  -462,    -2,   322,  -462,   347,
1008      -26,   353,   -26,   325,  -462,   356,   336,    40,  -462,  -462,
1009     -462,   351,  -462,   -15,    66,    77,   360,   181,    83,  -462,
1010     -462,  -462,   361,   355,   352,   367,   367,   367,   367,  -462,
1011       -2,   362,   371,   364,   345,    -2,   400,    -2,  -462,  -462,
1012      370,   375,   382,  -462,  -462,    -2,    53,    -2,   381,   383,
1013      223,    -2,    -2,    -2,    -2,    -2,    -2,  -462,  -462,  -462,
1014     -462,   384,  -462,   385,  -462,   352,  -462,  -462,   389,   390,
1015      378,   399,   -26,  -462,    -2,    -2,   349,   402,  -462,   123,
1016      567,   123,   123,   567,   123,  -462,  -462,     3,  -462,    83,
1017      209,   209,   209,   209,   403,  -462,   400,  -462,   367,   367,
1018     -462,   344,   452,   401,   350,  -462,   404,   409,  -462,  -462,
1019      367,   367,   367,   367,   367,   213,   567,  -462,   423,   -26,
1020      353,   -26,   -26,  -462,  -462,   424,  -462,   431,   422,  -462,
1021      426,   430,   428,    83,   432,   440,  -462,   447,  -462,  -462,
1022      311,  -462,  -462,  -462,  -462,  -462,  -462,   209,   209,  -462,
1023     -462,   582,     6,   449,   582,  -462,  -462,  -462,  -462,  -462,
1024      209,   209,   209,   209,   209,  -462,   452,  -462,   374,   453,
1025     -462,  -462,  -462,  -462,   446,  -462,  -462,   450,  -462,    91,
1026      451,  -462,    83,   467,   492,   457,  -462,   311,   463,  -462,
1027     -462,    -2,  -462,  -462,  -462,  -462,  -462,  -462,  -462,  -462,
1028      461,  -462,    -2,   -26,   476,   456,  -462,   582,   123,   123,
1029      123,  -462,   280,   615,   488,   223,  -462,  -462,   480,   514,
1030       10,   482,   582,  -462,   515,   517,   518,   521,  -462,  -462,
1031     -462,  -462,  -462,  -462,  -462,  -462,  -462,  -462,  -462,   557,
1032     -462,   533,  -462,  -462,   534,   543,   545,   423,    -2,  -462,
1033     -462,   539,   562,  -462,  -462,   212,  -462,  -462,  -462,  -462,
1034     -462,  -462,  -462,  -462,  -462,   603,  -462,   343,   168,   423,
1035     -462,  -462,  -462,  -462,   431,  -462,    -2,  -462,   558,   554,
1036      558,   586,   575,   595,   598,   558,   572,   454,   -26,  -462,
1037     -462,   636,   423,  -462,   -26,   602,   -26,    75,   580,   475,
1038      454,  -462,   583,   590,   597,   -26,   605,   592,   454,   249,
1039      585,   168,   588,   601,   599,   591,  -462,  -462,   -26,   586,
1040      437,  -462,   606,   454,   -26,   598,  -462,   591,   423,  -462,
1041     -462,  -462,   628,  -462,    49,   583,   -26,   558,  -462,   501,
1042      604,  -462,  -462,   609,  -462,  -462,   249,  -462,   529,   608,
1043     -462,  -462,  -462,  -462,  -462,    -2,   612,   610,   607,   -26,
1044      618,   -26,   454,  -462,  -462,   423,  -462,   639,   454,   646,
1045      583,   616,   582,   229,  -462,   249,   -26,   621,   620,  -462,
1046      617,  -462,   623,   540,  -462,   -26,    -2,    -2,   -26,   619,
1047     -462,    -2,   591,   -26,  -462,   647,   646,   454,  -462,   624,
1048     -462,   102,   -20,   622,    -2,  -462,   550,   625,   626,   627,
1049     -462,   629,  -462,  -462,    -2,   358,   631,    -2,    -2,  -462,
1050      193,   454,  -462,   -26,   647,  -462,  -462,   110,   630,    82,
1051       -2,  -462,   298,  -462,   632,   591,  -462,  -462,  -462,  -462,
1052     -462,  -462,  -462,   566,   454,  -462,   635,  -462
1053 };
1054
1055 /* YYPGOTO[NTERM-NUM].  */
1056 static const yytype_int16 yypgoto[] =
1057 {
1058     -462,  -462,   700,  -462,  -196,    -1,    -7,   686,   705,   -10,
1059     -462,  -462,  -202,  -462,   -86,  -462,   -62,   -32,   -22,   -19,
1060     -462,  -106,   633,   -30,  -462,  -462,   487,  -462,  -462,     0,
1061      593,   464,  -462,   -24,   481,  -462,  -462,   611,   471,  -462,
1062      354,  -462,  -462,  -241,  -462,   -23,   387,  -462,  -462,  -462,
1063      -68,  -462,  -462,  -462,  -462,  -462,  -462,  -462,   465,  -462,
1064      468,   706,  -462,  -136,   391,   708,  -462,  -462,   563,  -462,
1065     -462,   392,  -462,   369,  -462,   313,  -462,  -462,   466,   -83,
1066      211,   -18,  -416,  -462,  -462,  -422,  -462,  -462,  -322,   214,
1067     -385,  -462,  -462,   273,  -444,  -462,  -462,   161,  -462,  -412,
1068      192,   264,  -461,  -405,  -462,   272,  -462,  -462,  -462,  -462
1069 };
1070
1071 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1072    positive, shift that token.  If negative, reduce the rule which
1073    number is the opposite.  If zero, do what YYDEFACT says.
1074    If YYTABLE_NINF, syntax error.  */
1075 #define YYTABLE_NINF -178
1076 static const yytype_int16 yytable[] =
1077 {
1078        7,     8,    36,   153,   259,    78,   440,    96,    79,   102,
1079       31,   196,   418,    66,   480,    28,   498,    32,    33,   106,
1080      107,   108,    82,   300,    15,   446,   493,   300,   281,   495,
1081      455,   284,    85,   170,   441,   374,     9,   471,   473,    99,
1082      101,   118,   185,   481,   176,   177,   178,   114,   146,   440,
1083      408,   192,    97,     6,   171,   501,    86,   462,   205,   568,
1084       84,   342,   467,    27,   317,   404,   156,   218,   528,   221,
1085      226,   147,    16,    17,   532,   350,   160,   513,    18,    19,
1086      517,   556,   511,  -107,    89,    90,   519,   197,   238,   163,
1087       20,   164,   165,   499,   167,   404,   -16,   405,   201,   202,
1088      203,   204,   100,   561,    30,   292,   293,   294,   181,   541,
1089       68,    69,    70,    71,    72,    73,    74,   160,   502,   503,
1090       65,   548,   161,   248,   593,   249,    81,   584,   150,   268,
1091      529,  -132,   570,  -132,   151,   504,   102,   152,    30,   273,
1092      254,    84,   577,   579,   572,   215,   582,    11,   229,    12,
1093      596,   196,    84,   241,   242,   243,   230,   318,    97,   231,
1094      466,   339,   340,   161,   564,   162,    84,   565,   589,   400,
1095      566,   567,   104,   359,   345,   346,   347,   348,   349,   244,
1096      109,   595,   563,   181,   564,   112,   320,   565,   322,   323,
1097      566,   567,   564,   587,   253,   565,   256,   115,   566,   567,
1098      260,   261,   262,   263,   264,   265,   117,   287,   428,   429,
1099      430,   431,   432,   433,   434,   435,   179,   436,   137,   277,
1100        6,   180,   138,   274,   275,   297,   298,   197,    29,   280,
1101       30,   282,   283,   119,   285,   501,   120,   310,   311,   312,
1102      313,   314,     1,     2,   437,    37,    38,    39,    40,    41,
1103       42,    43,    44,    45,    46,    47,    84,    48,    49,   121,
1104      233,    50,    84,   234,    89,    90,   143,    30,   422,   423,
1105      371,   341,   133,   583,   344,   564,   329,    34,   565,    35,
1106      134,   566,   567,   289,    30,   290,  -177,   315,   352,   316,
1107       68,    69,    70,    71,    72,    73,    74,   135,   502,   503,
1108      287,   378,   145,   379,   380,   381,   382,   383,   384,     1,
1109        2,   385,   386,   387,   388,    51,   149,    37,    38,    39,
1110       40,    41,   139,   140,   141,   142,   154,   352,   158,    48,
1111       49,   389,   390,    50,   122,   123,   124,   125,   126,   127,
1112      368,    78,   352,   159,    79,    83,    84,   166,   391,   169,
1113      333,   370,   392,   393,   168,   459,   148,    84,   375,   376,
1114      377,   463,   397,   465,   378,   193,   379,   380,   381,   382,
1115      383,   384,   477,    88,   385,   386,   387,   388,   591,   184,
1116      564,   188,   189,   565,   186,   490,   566,   567,   207,   208,
1117      194,   496,    89,    90,   389,   390,   200,   419,   424,   216,
1118        6,   180,   217,   510,    30,   276,   306,   307,   222,    89,
1119       90,   219,    30,     6,   578,   392,   393,   224,    68,    69,
1120       70,    71,    72,    73,    74,   442,   525,   195,   527,    30,
1121      223,   143,   225,   237,   474,    68,    69,    70,    71,    72,
1122       73,    74,   239,   542,    89,    90,   232,   236,   245,   246,
1123      247,   179,   549,   251,   505,   553,   250,   351,   252,   257,
1124      557,   271,   266,   258,    30,   267,   269,   509,   270,   300,
1125       68,    69,    70,    71,    72,    73,    74,   428,   429,   430,
1126      431,   432,   433,   434,   435,   272,   436,   226,   304,   295,
1127      585,   254,   537,   505,   428,   429,   430,   431,   432,   433,
1128      434,   435,   535,   436,   521,   318,    84,   324,   325,   326,
1129      327,   328,   330,    35,   492,   428,   429,   430,   431,   432,
1130      433,   434,   435,   331,   436,   332,   343,   356,   357,    67,
1131       35,   333,   358,   360,   365,   550,   552,   367,   369,   373,
1132      555,   428,   429,   430,   431,   432,   433,   434,   435,    30,
1133      436,   470,   362,   550,   372,    68,    69,    70,    71,    72,
1134       73,    74,   399,   550,   550,   401,   581,   550,   407,   428,
1135      429,   430,   431,   432,   433,   434,   435,   512,   436,   590,
1136      428,   429,   430,   431,   432,   433,   434,   435,   403,   436,
1137      428,   429,   430,   431,   432,   433,   434,   435,   409,   436,
1138      410,   411,    89,    90,   412,   518,   428,   429,   430,   431,
1139      432,   433,   434,   435,   413,   436,   547,    89,    90,   415,
1140      416,   417,    30,   209,   210,   420,   571,    -9,    68,    69,
1141       70,    71,    72,    73,    74,    89,   421,    30,   426,   445,
1142      443,   447,   594,    68,    69,    70,    71,    72,    73,    74,
1143       67,   450,   451,   453,   456,    30,   460,   464,   469,    35,
1144      478,    68,    69,    70,    71,    72,    73,    74,   475,   479,
1145      396,   476,   482,   484,   488,   486,    68,    69,    70,    71,
1146       72,    73,    74,   494,   500,   487,   516,   522,   523,   530,
1147      514,   520,   526,   524,   533,   536,   543,   544,   554,   545,
1148      546,   562,   558,   573,   574,    10,   576,    52,   569,   592,
1149      575,   580,   597,    14,   279,   299,   588,   296,   286,   361,
1150      206,   308,   187,   157,   406,   309,   364,    60,   366,    62,
1151      427,   235,   398,   538,   483,   586,   321,   540,   560,   497,
1152        0,   491
1153 };
1154
1155 static const yytype_int16 yycheck[] =
1156 {
1157        1,     2,    20,    86,   200,    27,   418,    37,    27,    41,
1158       17,   117,   397,    23,   458,    16,   477,    18,    19,    43,
1159       44,    45,    29,    17,     5,   430,   470,    17,   230,   473,
1160      435,   233,    58,    30,   419,   357,     0,   449,   450,    39,
1161       40,    51,   110,   459,   106,   107,   108,    48,    80,   461,
1162      372,   113,    35,    55,    51,     6,    82,   442,   126,    79,
1163       75,   302,   447,    39,   266,    85,    88,   150,   512,   152,
1164       85,    81,    53,    54,   518,   316,    36,   489,    59,    60,
1165      496,   542,   487,    77,    35,    36,   498,   117,   174,    96,
1166       71,    98,    99,   478,   101,    85,    77,    87,   122,   123,
1167      124,   125,    85,   547,    55,   241,   242,   243,   109,   525,
1168       61,    62,    63,    64,    65,    66,    67,    36,    69,    70,
1169       77,   533,    82,   185,   585,   187,    76,   571,    76,   215,
1170      515,    78,   554,    80,    82,    86,   168,    85,    55,   222,
1171       87,    75,   564,   565,   556,   146,   568,    74,    82,    76,
1172      594,   257,    75,   176,   177,   178,    79,    82,    35,    82,
1173       85,   297,   298,    82,    82,    84,    75,    85,    86,   365,
1174       88,    89,    85,    82,   310,   311,   312,   313,   314,   180,
1175       85,   593,    80,   184,    82,    85,   269,    85,   271,   272,
1176       88,    89,    82,    83,   195,    85,   197,    57,    88,    89,
1177      201,   202,   203,   204,   205,   206,    79,   239,    40,    41,
1178       42,    43,    44,    45,    46,    47,    51,    49,    62,   226,
1179       55,    56,    66,   224,   225,   248,   249,   257,    53,   229,
1180       55,   231,   232,    74,   234,     6,    74,   260,   261,   262,
1181      263,   264,     3,     4,    76,     6,     7,     8,     9,    10,
1182       11,    12,    13,    14,    15,    16,    75,    18,    19,    74,
1183       79,    22,    75,    82,    35,    36,    79,    55,    56,    57,
1184      353,   301,    74,    80,   304,    82,   283,    74,    85,    76,
1185       74,    88,    89,    74,    55,    76,    55,    74,   318,    76,
1186       61,    62,    63,    64,    65,    66,    67,    74,    69,    70,
1187      332,    21,    81,    23,    24,    25,    26,    27,    28,     3,
1188        4,    31,    32,    33,    34,    76,    75,     6,     7,     8,
1189        9,    10,    61,    62,    63,    64,    77,   357,    81,    18,
1190       19,    51,    52,    22,    11,    12,    13,    14,    15,    16,
1191      341,   363,   372,    81,   363,    74,    75,    68,    68,    74,
1192       39,   352,    72,    73,    78,   438,    74,    75,   358,   359,
1193      360,   444,   363,   446,    21,    74,    23,    24,    25,    26,
1194       27,    28,   455,    16,    31,    32,    33,    34,    80,    85,
1195       82,    37,    38,    85,    85,   468,    88,    89,    61,    62,
1196       74,   474,    35,    36,    51,    52,    77,   398,   405,    77,
1197       55,    56,    55,   486,    55,    56,    56,    57,    83,    35,
1198       36,    58,    55,    55,    56,    72,    73,    81,    61,    62,
1199       63,    64,    65,    66,    67,   426,   509,    18,   511,    55,
1200       74,    79,    81,    78,   452,    61,    62,    63,    64,    65,
1201       66,    67,    75,   526,    35,    36,    86,    86,    86,    78,
1202       86,    51,   535,    78,   484,   538,    86,    83,    76,    78,
1203      543,    83,    78,    80,    55,    80,    77,   485,    78,    17,
1204       61,    62,    63,    64,    65,    66,    67,    40,    41,    42,
1205       43,    44,    45,    46,    47,    86,    49,    85,    87,    86,
1206      573,    87,   522,   523,    40,    41,    42,    43,    44,    45,
1207       46,    47,   520,    49,   505,    82,    75,    83,    86,    83,
1208       80,    83,    80,    76,    77,    40,    41,    42,    43,    44,
1209       45,    46,    47,    83,    49,    78,    77,    74,    82,    35,
1210       76,    39,    82,    82,    77,   536,   537,    74,    77,    83,
1211      541,    40,    41,    42,    43,    44,    45,    46,    47,    55,
1212       49,    76,    85,   554,    78,    61,    62,    63,    64,    65,
1213       66,    67,    74,   564,   565,    85,   567,   568,    86,    40,
1214       41,    42,    43,    44,    45,    46,    47,    76,    49,   580,
1215       40,    41,    42,    43,    44,    45,    46,    47,    74,    49,
1216       40,    41,    42,    43,    44,    45,    46,    47,    83,    49,
1217       83,    83,    35,    36,    83,    76,    40,    41,    42,    43,
1218       44,    45,    46,    47,    57,    49,    76,    35,    36,    86,
1219       86,    78,    55,    56,    57,    86,    76,    82,    61,    62,
1220       63,    64,    65,    66,    67,    35,    74,    55,    35,    85,
1221       82,    55,    76,    61,    62,    63,    64,    65,    66,    67,
1222       35,    76,    57,    55,    82,    55,    20,    55,    78,    76,
1223       55,    61,    62,    63,    64,    65,    66,    67,    78,    77,
1224       55,    74,    87,    85,    83,    74,    61,    62,    63,    64,
1225       65,    66,    67,    77,    56,    86,    77,    75,    78,    50,
1226       86,    83,    74,    86,    48,    79,    75,    77,    79,    82,
1227       77,    77,    55,    78,    78,     5,    77,    21,    86,    77,
1228       83,    80,    77,     8,   227,   251,    86,   246,   237,   332,
1229      127,   256,   111,    90,   370,   257,   334,    21,   337,    21,
1230      417,   168,   363,   522,   461,   574,   270,   523,   546,   475,
1231       -1,   469
1232 };
1233
1234 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1235    symbol of state STATE-NUM.  */
1236 static const yytype_uint8 yystos[] =
1237 {
1238        0,     3,     4,    91,    92,    97,    55,    95,    95,     0,
1239       92,    74,    76,    98,    98,     5,    53,    54,    59,    60,
1240       71,    93,    99,   100,   162,   198,   199,    39,    95,    53,
1241       55,    96,    95,    95,    74,    76,   171,     6,     7,     8,
1242        9,    10,    11,    12,    13,    14,    15,    16,    18,    19,
1243       22,    76,    97,   117,   118,   134,   137,   138,   139,   141,
1244      151,   152,   155,   156,   157,    77,    99,    35,    61,    62,
1245       63,    64,    65,    66,    67,    96,   105,   107,   108,   109,
1246      163,    76,    96,    74,    75,    58,    82,   169,    16,    35,
1247       36,   108,   109,   110,   111,   112,   113,    35,   119,   119,
1248       85,   119,   107,   158,    85,   123,   123,   123,   123,    85,
1249      127,   140,    85,   120,    95,    57,   159,    79,    99,    74,
1250       74,    74,    11,    12,    13,    14,    15,    16,   142,   143,
1251      144,   145,   146,    74,    74,    74,    94,    62,    66,    61,
1252       62,    63,    64,    79,   104,    81,   107,    99,    74,    75,
1253       76,    82,    85,   169,    77,   172,   108,   112,    81,    81,
1254       36,    82,    84,    96,    96,    96,    68,    96,    78,    74,
1255       30,    51,   124,   129,    95,   106,   106,   106,   106,    51,
1256       56,    95,   126,   128,    85,   140,    85,   127,    37,    38,
1257      121,   122,   106,    74,    74,    18,   111,   113,   149,   150,
1258       77,   123,   123,   123,   123,   140,   120,    61,    62,    56,
1259       57,   101,   102,   103,   113,    95,    77,    55,   169,    58,
1260      168,   169,    83,    74,    81,    81,    85,   115,   116,    82,
1261       79,    82,    86,    79,    82,   158,    86,    78,   104,    75,
1262      135,   135,   135,   135,    95,    86,    78,    86,   106,   106,
1263       86,    78,    76,    95,    87,   148,    95,    78,    80,    94,
1264       95,    95,    95,    95,    95,    95,    78,    80,   104,    77,
1265       78,    83,    86,   169,    95,    95,    56,    96,   114,   116,
1266      119,   102,   119,   119,   102,   119,   124,   107,   136,    74,
1267       76,   153,   153,   153,   153,    86,   128,   135,   135,   121,
1268       17,   130,   132,   133,    87,   147,    56,    57,   148,   150,
1269      135,   135,   135,   135,   135,    74,    76,   102,    82,   180,
1270      169,   168,   169,   169,    83,    86,    83,    80,    83,    96,
1271       80,    83,    78,    39,   151,   154,   155,   160,   161,   153,
1272      153,   113,   133,    77,   113,   153,   153,   153,   153,   153,
1273      133,    83,   113,   170,   173,   178,    74,    82,    82,    82,
1274       82,   136,    85,   164,   161,    77,   154,    74,    95,    77,
1275       95,   169,    78,    83,   178,   119,   119,   119,    21,    23,
1276       24,    25,    26,    27,    28,    31,    32,    33,    34,    51,
1277       52,    68,    72,    73,   165,   166,    55,    95,   163,    74,
1278       94,    85,   131,    74,    85,    87,   130,    86,   178,    83,
1279       83,    83,    83,    57,   125,    86,    86,    78,   180,    95,
1280       86,    74,    56,    57,    96,   167,    35,   165,    40,    41,
1281       42,    43,    44,    45,    46,    47,    49,    76,   171,   183,
1282      189,   180,    95,    82,   193,    85,   193,    55,   194,   195,
1283       76,    57,   188,    55,   191,   193,    82,   184,   189,   169,
1284       20,   182,   180,   169,    55,   169,    85,   180,   196,    78,
1285       76,   189,   185,   189,   171,    78,    74,   169,    55,    77,
1286      184,   172,    87,   183,    85,   181,    74,    86,    83,   192,
1287      169,   195,    77,   184,    77,   184,   169,   191,   192,   180,
1288       56,     6,    69,    70,    86,   113,   174,   177,   179,   171,
1289      169,   193,    76,   189,    86,   197,    77,   172,    76,   189,
1290       83,    95,    75,    78,    86,   169,    74,   169,   184,   180,
1291       50,   186,   184,    48,   190,   171,    79,   113,   170,   176,
1292      179,   172,   169,    75,    77,    82,    77,    76,   189,   169,
1293       95,   175,    95,   169,    79,    95,   192,   169,    55,   187,
1294      190,   184,    77,    80,    82,    85,    88,    89,    79,    86,
1295      175,    76,   189,    78,    78,    83,    77,   175,    56,   175,
1296       80,    95,   175,    80,   184,   169,   187,    83,    86,    86,
1297       95,    80,    77,   192,    76,   189,   184,    77
1298 };
1299
1300 #define yyerrok         (yyerrstatus = 0)
1301 #define yyclearin       (yychar = YYEMPTY)
1302 #define YYEMPTY         (-2)
1303 #define YYEOF           0
1304
1305 #define YYACCEPT        goto yyacceptlab
1306 #define YYABORT         goto yyabortlab
1307 #define YYERROR         goto yyerrorlab
1308
1309
1310 /* Like YYERROR except do call yyerror.  This remains here temporarily
1311    to ease the transition to the new meaning of YYERROR, for GCC.
1312    Once GCC version 2 has supplanted version 1, this can go.  */
1313
1314 #define YYFAIL          goto yyerrlab
1315
1316 #define YYRECOVERING()  (!!yyerrstatus)
1317
1318 #define YYBACKUP(Token, Value)                                  \
1319 do                                                              \
1320   if (yychar == YYEMPTY && yylen == 1)                          \
1321     {                                                           \
1322       yychar = (Token);                                         \
1323       yylval = (Value);                                         \
1324       yytoken = YYTRANSLATE (yychar);                           \
1325       YYPOPSTACK (1);                                           \
1326       goto yybackup;                                            \
1327     }                                                           \
1328   else                                                          \
1329     {                                                           \
1330       yyerror (YY_("syntax error: cannot back up")); \
1331       YYERROR;                                                  \
1332     }                                                           \
1333 while (YYID (0))
1334
1335
1336 #define YYTERROR        1
1337 #define YYERRCODE       256
1338
1339
1340 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1341    If N is 0, then set CURRENT to the empty location which ends
1342    the previous symbol: RHS[0] (always defined).  */
1343
1344 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1345 #ifndef YYLLOC_DEFAULT
1346 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
1347     do                                                                  \
1348       if (YYID (N))                                                    \
1349         {                                                               \
1350           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
1351           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
1352           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
1353           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
1354         }                                                               \
1355       else                                                              \
1356         {                                                               \
1357           (Current).first_line   = (Current).last_line   =              \
1358             YYRHSLOC (Rhs, 0).last_line;                                \
1359           (Current).first_column = (Current).last_column =              \
1360             YYRHSLOC (Rhs, 0).last_column;                              \
1361         }                                                               \
1362     while (YYID (0))
1363 #endif
1364
1365
1366 /* YY_LOCATION_PRINT -- Print the location on the stream.
1367    This macro was not mandated originally: define only if we know
1368    we won't break user code: when these are the locations we know.  */
1369
1370 #ifndef YY_LOCATION_PRINT
1371 # if YYLTYPE_IS_TRIVIAL
1372 #  define YY_LOCATION_PRINT(File, Loc)                  \
1373      fprintf (File, "%d.%d-%d.%d",                      \
1374               (Loc).first_line, (Loc).first_column,     \
1375               (Loc).last_line,  (Loc).last_column)
1376 # else
1377 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1378 # endif
1379 #endif
1380
1381
1382 /* YYLEX -- calling `yylex' with the right arguments.  */
1383
1384 #ifdef YYLEX_PARAM
1385 # define YYLEX yylex (YYLEX_PARAM)
1386 #else
1387 # define YYLEX yylex ()
1388 #endif
1389
1390 /* Enable debugging if requested.  */
1391 #if YYDEBUG
1392
1393 # ifndef YYFPRINTF
1394 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1395 #  define YYFPRINTF fprintf
1396 # endif
1397
1398 # define YYDPRINTF(Args)                        \
1399 do {                                            \
1400   if (yydebug)                                  \
1401     YYFPRINTF Args;                             \
1402 } while (YYID (0))
1403
1404 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1405 do {                                                                      \
1406   if (yydebug)                                                            \
1407     {                                                                     \
1408       YYFPRINTF (stderr, "%s ", Title);                                   \
1409       yy_symbol_print (stderr,                                            \
1410                   Type, Value); \
1411       YYFPRINTF (stderr, "\n");                                           \
1412     }                                                                     \
1413 } while (YYID (0))
1414
1415
1416 /*--------------------------------.
1417 | Print this symbol on YYOUTPUT.  |
1418 `--------------------------------*/
1419
1420 /*ARGSUSED*/
1421 #if (defined __STDC__ || defined __C99__FUNC__ \
1422      || defined __cplusplus || defined _MSC_VER)
1423 static void
1424 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1425 #else
1426 static void
1427 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1428     FILE *yyoutput;
1429     int yytype;
1430     YYSTYPE const * const yyvaluep;
1431 #endif
1432 {
1433   if (!yyvaluep)
1434     return;
1435 # ifdef YYPRINT
1436   if (yytype < YYNTOKENS)
1437     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1438 # else
1439   YYUSE (yyoutput);
1440 # endif
1441   switch (yytype)
1442     {
1443       default:
1444         break;
1445     }
1446 }
1447
1448
1449 /*--------------------------------.
1450 | Print this symbol on YYOUTPUT.  |
1451 `--------------------------------*/
1452
1453 #if (defined __STDC__ || defined __C99__FUNC__ \
1454      || defined __cplusplus || defined _MSC_VER)
1455 static void
1456 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1457 #else
1458 static void
1459 yy_symbol_print (yyoutput, yytype, yyvaluep)
1460     FILE *yyoutput;
1461     int yytype;
1462     YYSTYPE const * const yyvaluep;
1463 #endif
1464 {
1465   if (yytype < YYNTOKENS)
1466     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1467   else
1468     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1469
1470   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1471   YYFPRINTF (yyoutput, ")");
1472 }
1473
1474 /*------------------------------------------------------------------.
1475 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1476 | TOP (included).                                                   |
1477 `------------------------------------------------------------------*/
1478
1479 #if (defined __STDC__ || defined __C99__FUNC__ \
1480      || defined __cplusplus || defined _MSC_VER)
1481 static void
1482 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1483 #else
1484 static void
1485 yy_stack_print (yybottom, yytop)
1486     yytype_int16 *yybottom;
1487     yytype_int16 *yytop;
1488 #endif
1489 {
1490   YYFPRINTF (stderr, "Stack now");
1491   for (; yybottom <= yytop; yybottom++)
1492     {
1493       int yybot = *yybottom;
1494       YYFPRINTF (stderr, " %d", yybot);
1495     }
1496   YYFPRINTF (stderr, "\n");
1497 }
1498
1499 # define YY_STACK_PRINT(Bottom, Top)                            \
1500 do {                                                            \
1501   if (yydebug)                                                  \
1502     yy_stack_print ((Bottom), (Top));                           \
1503 } while (YYID (0))
1504
1505
1506 /*------------------------------------------------.
1507 | Report that the YYRULE is going to be reduced.  |
1508 `------------------------------------------------*/
1509
1510 #if (defined __STDC__ || defined __C99__FUNC__ \
1511      || defined __cplusplus || defined _MSC_VER)
1512 static void
1513 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1514 #else
1515 static void
1516 yy_reduce_print (yyvsp, yyrule)
1517     YYSTYPE *yyvsp;
1518     int yyrule;
1519 #endif
1520 {
1521   int yynrhs = yyr2[yyrule];
1522   int yyi;
1523   unsigned long int yylno = yyrline[yyrule];
1524   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1525              yyrule - 1, yylno);
1526   /* The symbols being reduced.  */
1527   for (yyi = 0; yyi < yynrhs; yyi++)
1528     {
1529       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1530       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1531                        &(yyvsp[(yyi + 1) - (yynrhs)])
1532                                        );
1533       YYFPRINTF (stderr, "\n");
1534     }
1535 }
1536
1537 # define YY_REDUCE_PRINT(Rule)          \
1538 do {                                    \
1539   if (yydebug)                          \
1540     yy_reduce_print (yyvsp, Rule); \
1541 } while (YYID (0))
1542
1543 /* Nonzero means print parse trace.  It is left uninitialized so that
1544    multiple parsers can coexist.  */
1545 int yydebug;
1546 #else /* !YYDEBUG */
1547 # define YYDPRINTF(Args)
1548 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1549 # define YY_STACK_PRINT(Bottom, Top)
1550 # define YY_REDUCE_PRINT(Rule)
1551 #endif /* !YYDEBUG */
1552
1553
1554 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1555 #ifndef YYINITDEPTH
1556 # define YYINITDEPTH 200
1557 #endif
1558
1559 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1560    if the built-in stack extension method is used).
1561
1562    Do not make this value too large; the results are undefined if
1563    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1564    evaluated with infinite-precision integer arithmetic.  */
1565
1566 #ifndef YYMAXDEPTH
1567 # define YYMAXDEPTH 10000
1568 #endif
1569
1570 \f
1571
1572 #if YYERROR_VERBOSE
1573
1574 # ifndef yystrlen
1575 #  if defined __GLIBC__ && defined _STRING_H
1576 #   define yystrlen strlen
1577 #  else
1578 /* Return the length of YYSTR.  */
1579 #if (defined __STDC__ || defined __C99__FUNC__ \
1580      || defined __cplusplus || defined _MSC_VER)
1581 static YYSIZE_T
1582 yystrlen (const char *yystr)
1583 #else
1584 static YYSIZE_T
1585 yystrlen (yystr)
1586     const char *yystr;
1587 #endif
1588 {
1589   YYSIZE_T yylen;
1590   for (yylen = 0; yystr[yylen]; yylen++)
1591     continue;
1592   return yylen;
1593 }
1594 #  endif
1595 # endif
1596
1597 # ifndef yystpcpy
1598 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1599 #   define yystpcpy stpcpy
1600 #  else
1601 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1602    YYDEST.  */
1603 #if (defined __STDC__ || defined __C99__FUNC__ \
1604      || defined __cplusplus || defined _MSC_VER)
1605 static char *
1606 yystpcpy (char *yydest, const char *yysrc)
1607 #else
1608 static char *
1609 yystpcpy (yydest, yysrc)
1610     char *yydest;
1611     const char *yysrc;
1612 #endif
1613 {
1614   char *yyd = yydest;
1615   const char *yys = yysrc;
1616
1617   while ((*yyd++ = *yys++) != '\0')
1618     continue;
1619
1620   return yyd - 1;
1621 }
1622 #  endif
1623 # endif
1624
1625 # ifndef yytnamerr
1626 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1627    quotes and backslashes, so that it's suitable for yyerror.  The
1628    heuristic is that double-quoting is unnecessary unless the string
1629    contains an apostrophe, a comma, or backslash (other than
1630    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1631    null, do not copy; instead, return the length of what the result
1632    would have been.  */
1633 static YYSIZE_T
1634 yytnamerr (char *yyres, const char *yystr)
1635 {
1636   if (*yystr == '"')
1637     {
1638       YYSIZE_T yyn = 0;
1639       char const *yyp = yystr;
1640
1641       for (;;)
1642         switch (*++yyp)
1643           {
1644           case '\'':
1645           case ',':
1646             goto do_not_strip_quotes;
1647
1648           case '\\':
1649             if (*++yyp != '\\')
1650               goto do_not_strip_quotes;
1651             /* Fall through.  */
1652           default:
1653             if (yyres)
1654               yyres[yyn] = *yyp;
1655             yyn++;
1656             break;
1657
1658           case '"':
1659             if (yyres)
1660               yyres[yyn] = '\0';
1661             return yyn;
1662           }
1663     do_not_strip_quotes: ;
1664     }
1665
1666   if (! yyres)
1667     return yystrlen (yystr);
1668
1669   return yystpcpy (yyres, yystr) - yyres;
1670 }
1671 # endif
1672
1673 /* Copy into YYRESULT an error message about the unexpected token
1674    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1675    including the terminating null byte.  If YYRESULT is null, do not
1676    copy anything; just return the number of bytes that would be
1677    copied.  As a special case, return 0 if an ordinary "syntax error"
1678    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1679    size calculation.  */
1680 static YYSIZE_T
1681 yysyntax_error (char *yyresult, int yystate, int yychar)
1682 {
1683   int yyn = yypact[yystate];
1684
1685   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1686     return 0;
1687   else
1688     {
1689       int yytype = YYTRANSLATE (yychar);
1690       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1691       YYSIZE_T yysize = yysize0;
1692       YYSIZE_T yysize1;
1693       int yysize_overflow = 0;
1694       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1695       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1696       int yyx;
1697
1698 # if 0
1699       /* This is so xgettext sees the translatable formats that are
1700          constructed on the fly.  */
1701       YY_("syntax error, unexpected %s");
1702       YY_("syntax error, unexpected %s, expecting %s");
1703       YY_("syntax error, unexpected %s, expecting %s or %s");
1704       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1705       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1706 # endif
1707       char *yyfmt;
1708       char const *yyf;
1709       static char const yyunexpected[] = "syntax error, unexpected %s";
1710       static char const yyexpecting[] = ", expecting %s";
1711       static char const yyor[] = " or %s";
1712       char yyformat[sizeof yyunexpected
1713                     + sizeof yyexpecting - 1
1714                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1715                        * (sizeof yyor - 1))];
1716       char const *yyprefix = yyexpecting;
1717
1718       /* Start YYX at -YYN if negative to avoid negative indexes in
1719          YYCHECK.  */
1720       int yyxbegin = yyn < 0 ? -yyn : 0;
1721
1722       /* Stay within bounds of both yycheck and yytname.  */
1723       int yychecklim = YYLAST - yyn + 1;
1724       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1725       int yycount = 1;
1726
1727       yyarg[0] = yytname[yytype];
1728       yyfmt = yystpcpy (yyformat, yyunexpected);
1729
1730       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1731         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1732           {
1733             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1734               {
1735                 yycount = 1;
1736                 yysize = yysize0;
1737                 yyformat[sizeof yyunexpected - 1] = '\0';
1738                 break;
1739               }
1740             yyarg[yycount++] = yytname[yyx];
1741             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1742             yysize_overflow |= (yysize1 < yysize);
1743             yysize = yysize1;
1744             yyfmt = yystpcpy (yyfmt, yyprefix);
1745             yyprefix = yyor;
1746           }
1747
1748       yyf = YY_(yyformat);
1749       yysize1 = yysize + yystrlen (yyf);
1750       yysize_overflow |= (yysize1 < yysize);
1751       yysize = yysize1;
1752
1753       if (yysize_overflow)
1754         return YYSIZE_MAXIMUM;
1755
1756       if (yyresult)
1757         {
1758           /* Avoid sprintf, as that infringes on the user's name space.
1759              Don't have undefined behavior even if the translation
1760              produced a string with the wrong number of "%s"s.  */
1761           char *yyp = yyresult;
1762           int yyi = 0;
1763           while ((*yyp = *yyf) != '\0')
1764             {
1765               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1766                 {
1767                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1768                   yyf += 2;
1769                 }
1770               else
1771                 {
1772                   yyp++;
1773                   yyf++;
1774                 }
1775             }
1776         }
1777       return yysize;
1778     }
1779 }
1780 #endif /* YYERROR_VERBOSE */
1781 \f
1782
1783 /*-----------------------------------------------.
1784 | Release the memory associated to this symbol.  |
1785 `-----------------------------------------------*/
1786
1787 /*ARGSUSED*/
1788 #if (defined __STDC__ || defined __C99__FUNC__ \
1789      || defined __cplusplus || defined _MSC_VER)
1790 static void
1791 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1792 #else
1793 static void
1794 yydestruct (yymsg, yytype, yyvaluep)
1795     const char *yymsg;
1796     int yytype;
1797     YYSTYPE *yyvaluep;
1798 #endif
1799 {
1800   YYUSE (yyvaluep);
1801
1802   if (!yymsg)
1803     yymsg = "Deleting";
1804   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1805
1806   switch (yytype)
1807     {
1808
1809       default:
1810         break;
1811     }
1812 }
1813
1814 /* Prevent warnings from -Wmissing-prototypes.  */
1815 #ifdef YYPARSE_PARAM
1816 #if defined __STDC__ || defined __cplusplus
1817 int yyparse (void *YYPARSE_PARAM);
1818 #else
1819 int yyparse ();
1820 #endif
1821 #else /* ! YYPARSE_PARAM */
1822 #if defined __STDC__ || defined __cplusplus
1823 int yyparse (void);
1824 #else
1825 int yyparse ();
1826 #endif
1827 #endif /* ! YYPARSE_PARAM */
1828
1829
1830 /* The lookahead symbol.  */
1831 int yychar;
1832
1833 /* The semantic value of the lookahead symbol.  */
1834 YYSTYPE yylval;
1835
1836 /* Number of syntax errors so far.  */
1837 int yynerrs;
1838
1839
1840
1841 /*-------------------------.
1842 | yyparse or yypush_parse.  |
1843 `-------------------------*/
1844
1845 #ifdef YYPARSE_PARAM
1846 #if (defined __STDC__ || defined __C99__FUNC__ \
1847      || defined __cplusplus || defined _MSC_VER)
1848 int
1849 yyparse (void *YYPARSE_PARAM)
1850 #else
1851 int
1852 yyparse (YYPARSE_PARAM)
1853     void *YYPARSE_PARAM;
1854 #endif
1855 #else /* ! YYPARSE_PARAM */
1856 #if (defined __STDC__ || defined __C99__FUNC__ \
1857      || defined __cplusplus || defined _MSC_VER)
1858 int
1859 yyparse (void)
1860 #else
1861 int
1862 yyparse ()
1863
1864 #endif
1865 #endif
1866 {
1867
1868
1869     int yystate;
1870     /* Number of tokens to shift before error messages enabled.  */
1871     int yyerrstatus;
1872
1873     /* The stacks and their tools:
1874        `yyss': related to states.
1875        `yyvs': related to semantic values.
1876
1877        Refer to the stacks thru separate pointers, to allow yyoverflow
1878        to reallocate them elsewhere.  */
1879
1880     /* The state stack.  */
1881     yytype_int16 yyssa[YYINITDEPTH];
1882     yytype_int16 *yyss;
1883     yytype_int16 *yyssp;
1884
1885     /* The semantic value stack.  */
1886     YYSTYPE yyvsa[YYINITDEPTH];
1887     YYSTYPE *yyvs;
1888     YYSTYPE *yyvsp;
1889
1890     YYSIZE_T yystacksize;
1891
1892   int yyn;
1893   int yyresult;
1894   /* Lookahead token as an internal (translated) token number.  */
1895   int yytoken;
1896   /* The variables used to return semantic value and location from the
1897      action routines.  */
1898   YYSTYPE yyval;
1899
1900 #if YYERROR_VERBOSE
1901   /* Buffer for error messages, and its allocated size.  */
1902   char yymsgbuf[128];
1903   char *yymsg = yymsgbuf;
1904   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1905 #endif
1906
1907 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1908
1909   /* The number of symbols on the RHS of the reduced rule.
1910      Keep to zero when no symbol should be popped.  */
1911   int yylen = 0;
1912
1913   yytoken = 0;
1914   yyss = yyssa;
1915   yyvs = yyvsa;
1916   yystacksize = YYINITDEPTH;
1917
1918   YYDPRINTF ((stderr, "Starting parse\n"));
1919
1920   yystate = 0;
1921   yyerrstatus = 0;
1922   yynerrs = 0;
1923   yychar = YYEMPTY; /* Cause a token to be read.  */
1924
1925   /* Initialize stack pointers.
1926      Waste one element of value and location stack
1927      so that they stay on the same level as the state stack.
1928      The wasted elements are never initialized.  */
1929   yyssp = yyss;
1930   yyvsp = yyvs;
1931
1932   goto yysetstate;
1933
1934 /*------------------------------------------------------------.
1935 | yynewstate -- Push a new state, which is found in yystate.  |
1936 `------------------------------------------------------------*/
1937  yynewstate:
1938   /* In all cases, when you get here, the value and location stacks
1939      have just been pushed.  So pushing a state here evens the stacks.  */
1940   yyssp++;
1941
1942  yysetstate:
1943   *yyssp = yystate;
1944
1945   if (yyss + yystacksize - 1 <= yyssp)
1946     {
1947       /* Get the current used size of the three stacks, in elements.  */
1948       YYSIZE_T yysize = yyssp - yyss + 1;
1949
1950 #ifdef yyoverflow
1951       {
1952         /* Give user a chance to reallocate the stack.  Use copies of
1953            these so that the &'s don't force the real ones into
1954            memory.  */
1955         YYSTYPE *yyvs1 = yyvs;
1956         yytype_int16 *yyss1 = yyss;
1957
1958         /* Each stack pointer address is followed by the size of the
1959            data in use in that stack, in bytes.  This used to be a
1960            conditional around just the two extra args, but that might
1961            be undefined if yyoverflow is a macro.  */
1962         yyoverflow (YY_("memory exhausted"),
1963                     &yyss1, yysize * sizeof (*yyssp),
1964                     &yyvs1, yysize * sizeof (*yyvsp),
1965                     &yystacksize);
1966
1967         yyss = yyss1;
1968         yyvs = yyvs1;
1969       }
1970 #else /* no yyoverflow */
1971 # ifndef YYSTACK_RELOCATE
1972       goto yyexhaustedlab;
1973 # else
1974       /* Extend the stack our own way.  */
1975       if (YYMAXDEPTH <= yystacksize)
1976         goto yyexhaustedlab;
1977       yystacksize *= 2;
1978       if (YYMAXDEPTH < yystacksize)
1979         yystacksize = YYMAXDEPTH;
1980
1981       {
1982         yytype_int16 *yyss1 = yyss;
1983         union yyalloc *yyptr =
1984           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1985         if (! yyptr)
1986           goto yyexhaustedlab;
1987         YYSTACK_RELOCATE (yyss_alloc, yyss);
1988         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1989 #  undef YYSTACK_RELOCATE
1990         if (yyss1 != yyssa)
1991           YYSTACK_FREE (yyss1);
1992       }
1993 # endif
1994 #endif /* no yyoverflow */
1995
1996       yyssp = yyss + yysize - 1;
1997       yyvsp = yyvs + yysize - 1;
1998
1999       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2000                   (unsigned long int) yystacksize));
2001
2002       if (yyss + yystacksize - 1 <= yyssp)
2003         YYABORT;
2004     }
2005
2006   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2007
2008   if (yystate == YYFINAL)
2009     YYACCEPT;
2010
2011   goto yybackup;
2012
2013 /*-----------.
2014 | yybackup.  |
2015 `-----------*/
2016 yybackup:
2017
2018   /* Do appropriate processing given the current state.  Read a
2019      lookahead token if we need one and don't already have one.  */
2020
2021   /* First try to decide what to do without reference to lookahead token.  */
2022   yyn = yypact[yystate];
2023   if (yyn == YYPACT_NINF)
2024     goto yydefault;
2025
2026   /* Not known => get a lookahead token if don't already have one.  */
2027
2028   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
2029   if (yychar == YYEMPTY)
2030     {
2031       YYDPRINTF ((stderr, "Reading a token: "));
2032       yychar = YYLEX;
2033     }
2034
2035   if (yychar <= YYEOF)
2036     {
2037       yychar = yytoken = YYEOF;
2038       YYDPRINTF ((stderr, "Now at end of input.\n"));
2039     }
2040   else
2041     {
2042       yytoken = YYTRANSLATE (yychar);
2043       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2044     }
2045
2046   /* If the proper action on seeing token YYTOKEN is to reduce or to
2047      detect an error, take that action.  */
2048   yyn += yytoken;
2049   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2050     goto yydefault;
2051   yyn = yytable[yyn];
2052   if (yyn <= 0)
2053     {
2054       if (yyn == 0 || yyn == YYTABLE_NINF)
2055         goto yyerrlab;
2056       yyn = -yyn;
2057       goto yyreduce;
2058     }
2059
2060   /* Count tokens shifted since error; after three, turn off error
2061      status.  */
2062   if (yyerrstatus)
2063     yyerrstatus--;
2064
2065   /* Shift the lookahead token.  */
2066   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2067
2068   /* Discard the shifted token.  */
2069   yychar = YYEMPTY;
2070
2071   yystate = yyn;
2072   *++yyvsp = yylval;
2073
2074   goto yynewstate;
2075
2076
2077 /*-----------------------------------------------------------.
2078 | yydefault -- do the default action for the current state.  |
2079 `-----------------------------------------------------------*/
2080 yydefault:
2081   yyn = yydefact[yystate];
2082   if (yyn == 0)
2083     goto yyerrlab;
2084   goto yyreduce;
2085
2086
2087 /*-----------------------------.
2088 | yyreduce -- Do a reduction.  |
2089 `-----------------------------*/
2090 yyreduce:
2091   /* yyn is the number of a rule to reduce with.  */
2092   yylen = yyr2[yyn];
2093
2094   /* If YYLEN is nonzero, implement the default value of the action:
2095      `$$ = $1'.
2096
2097      Otherwise, the following line sets YYVAL to garbage.
2098      This behavior is undocumented and Bison
2099      users should not rely upon it.  Assigning to YYVAL
2100      unconditionally makes the parser a bit smaller, and it avoids a
2101      GCC warning that YYVAL may be used uninitialized.  */
2102   yyval = yyvsp[1-yylen];
2103
2104
2105   YY_REDUCE_PRINT (yyn);
2106   switch (yyn)
2107     {
2108         case 2:
2109
2110 /* Line 1455 of yacc.c  */
2111 #line 155 "xi-grammar.y"
2112     { (yyval.modlist) = (yyvsp[(1) - (1)].modlist); modlist = (yyvsp[(1) - (1)].modlist); }
2113     break;
2114
2115   case 3:
2116
2117 /* Line 1455 of yacc.c  */
2118 #line 159 "xi-grammar.y"
2119     { 
2120                   (yyval.modlist) = 0; 
2121                 }
2122     break;
2123
2124   case 4:
2125
2126 /* Line 1455 of yacc.c  */
2127 #line 163 "xi-grammar.y"
2128     { (yyval.modlist) = new ModuleList(lineno, (yyvsp[(1) - (2)].module), (yyvsp[(2) - (2)].modlist)); }
2129     break;
2130
2131   case 5:
2132
2133 /* Line 1455 of yacc.c  */
2134 #line 167 "xi-grammar.y"
2135     { (yyval.intval) = 0; }
2136     break;
2137
2138   case 6:
2139
2140 /* Line 1455 of yacc.c  */
2141 #line 169 "xi-grammar.y"
2142     { (yyval.intval) = 1; }
2143     break;
2144
2145   case 7:
2146
2147 /* Line 1455 of yacc.c  */
2148 #line 173 "xi-grammar.y"
2149     { (yyval.intval) = 0; }
2150     break;
2151
2152   case 8:
2153
2154 /* Line 1455 of yacc.c  */
2155 #line 175 "xi-grammar.y"
2156     { (yyval.intval) = 1; }
2157     break;
2158
2159   case 9:
2160
2161 /* Line 1455 of yacc.c  */
2162 #line 179 "xi-grammar.y"
2163     { (yyval.strval) = (yyvsp[(1) - (1)].strval); }
2164     break;
2165
2166   case 10:
2167
2168 /* Line 1455 of yacc.c  */
2169 #line 183 "xi-grammar.y"
2170     { (yyval.strval) = (yyvsp[(1) - (1)].strval); }
2171     break;
2172
2173   case 11:
2174
2175 /* Line 1455 of yacc.c  */
2176 #line 185 "xi-grammar.y"
2177     {
2178                   char *tmp = new char[strlen((yyvsp[(1) - (4)].strval))+strlen((yyvsp[(4) - (4)].strval))+3];
2179                   sprintf(tmp,"%s::%s", (yyvsp[(1) - (4)].strval), (yyvsp[(4) - (4)].strval));
2180                   (yyval.strval) = tmp;
2181                 }
2182     break;
2183
2184   case 12:
2185
2186 /* Line 1455 of yacc.c  */
2187 #line 193 "xi-grammar.y"
2188     { 
2189                     (yyval.module) = new Module(lineno, (yyvsp[(2) - (3)].strval), (yyvsp[(3) - (3)].conslist)); 
2190                 }
2191     break;
2192
2193   case 13:
2194
2195 /* Line 1455 of yacc.c  */
2196 #line 197 "xi-grammar.y"
2197     {  
2198                     (yyval.module) = new Module(lineno, (yyvsp[(2) - (3)].strval), (yyvsp[(3) - (3)].conslist)); 
2199                     (yyval.module)->setMain();
2200                 }
2201     break;
2202
2203   case 14:
2204
2205 /* Line 1455 of yacc.c  */
2206 #line 204 "xi-grammar.y"
2207     { (yyval.conslist) = 0; }
2208     break;
2209
2210   case 15:
2211
2212 /* Line 1455 of yacc.c  */
2213 #line 206 "xi-grammar.y"
2214     { (yyval.conslist) = (yyvsp[(2) - (4)].conslist); }
2215     break;
2216
2217   case 16:
2218
2219 /* Line 1455 of yacc.c  */
2220 #line 210 "xi-grammar.y"
2221     { (yyval.conslist) = 0; }
2222     break;
2223
2224   case 17:
2225
2226 /* Line 1455 of yacc.c  */
2227 #line 212 "xi-grammar.y"
2228     { (yyval.conslist) = new ConstructList(lineno, (yyvsp[(1) - (2)].construct), (yyvsp[(2) - (2)].conslist)); }
2229     break;
2230
2231   case 18:
2232
2233 /* Line 1455 of yacc.c  */
2234 #line 216 "xi-grammar.y"
2235     { if((yyvsp[(3) - (5)].conslist)) (yyvsp[(3) - (5)].conslist)->setExtern((yyvsp[(1) - (5)].intval)); (yyval.construct) = (yyvsp[(3) - (5)].conslist); }
2236     break;
2237
2238   case 19:
2239
2240 /* Line 1455 of yacc.c  */
2241 #line 218 "xi-grammar.y"
2242     { (yyval.construct) = new Scope((yyvsp[(2) - (5)].strval), (yyvsp[(4) - (5)].conslist)); }
2243     break;
2244
2245   case 20:
2246
2247 /* Line 1455 of yacc.c  */
2248 #line 220 "xi-grammar.y"
2249     { (yyval.construct) = new UsingScope((yyvsp[(3) - (4)].strval), false); }
2250     break;
2251
2252   case 21:
2253
2254 /* Line 1455 of yacc.c  */
2255 #line 222 "xi-grammar.y"
2256     { (yyval.construct) = new UsingScope((yyvsp[(2) - (3)].strval), true); }
2257     break;
2258
2259   case 22:
2260
2261 /* Line 1455 of yacc.c  */
2262 #line 224 "xi-grammar.y"
2263     { (yyvsp[(2) - (2)].module)->setExtern((yyvsp[(1) - (2)].intval)); (yyval.construct) = (yyvsp[(2) - (2)].module); }
2264     break;
2265
2266   case 23:
2267
2268 /* Line 1455 of yacc.c  */
2269 #line 226 "xi-grammar.y"
2270     { (yyvsp[(2) - (2)].member)->setExtern((yyvsp[(1) - (2)].intval)); (yyval.construct) = (yyvsp[(2) - (2)].member); }
2271     break;
2272
2273   case 24:
2274
2275 /* Line 1455 of yacc.c  */
2276 #line 228 "xi-grammar.y"
2277     { (yyvsp[(2) - (3)].message)->setExtern((yyvsp[(1) - (3)].intval)); (yyval.construct) = (yyvsp[(2) - (3)].message); }
2278     break;
2279
2280   case 25:
2281
2282 /* Line 1455 of yacc.c  */
2283 #line 230 "xi-grammar.y"
2284     { (yyvsp[(2) - (2)].chare)->setExtern((yyvsp[(1) - (2)].intval)); (yyval.construct) = (yyvsp[(2) - (2)].chare); }
2285     break;
2286
2287   case 26:
2288
2289 /* Line 1455 of yacc.c  */
2290 #line 232 "xi-grammar.y"
2291     { (yyvsp[(2) - (2)].chare)->setExtern((yyvsp[(1) - (2)].intval)); (yyval.construct) = (yyvsp[(2) - (2)].chare); }
2292     break;
2293
2294   case 27:
2295
2296 /* Line 1455 of yacc.c  */
2297 #line 234 "xi-grammar.y"
2298     { (yyvsp[(2) - (2)].chare)->setExtern((yyvsp[(1) - (2)].intval)); (yyval.construct) = (yyvsp[(2) - (2)].chare); }
2299     break;
2300
2301   case 28:
2302
2303 /* Line 1455 of yacc.c  */
2304 #line 236 "xi-grammar.y"
2305     { (yyvsp[(2) - (2)].chare)->setExtern((yyvsp[(1) - (2)].intval)); (yyval.construct) = (yyvsp[(2) - (2)].chare); }
2306     break;
2307
2308   case 29:
2309
2310 /* Line 1455 of yacc.c  */
2311 #line 238 "xi-grammar.y"
2312     { (yyvsp[(2) - (2)].templat)->setExtern((yyvsp[(1) - (2)].intval)); (yyval.construct) = (yyvsp[(2) - (2)].templat); }
2313     break;
2314
2315   case 30:
2316
2317 /* Line 1455 of yacc.c  */
2318 #line 240 "xi-grammar.y"
2319     {
2320           Entry *e = new Entry(lineno, 0, (yyvsp[(3) - (8)].type), (yyvsp[(5) - (8)].strval), (yyvsp[(7) - (8)].plist), 0, 0, 0, 0, 0);
2321           int isExtern = 1;
2322           e->setExtern(isExtern);
2323           e->targs = (yyvsp[(6) - (8)].tparlist);
2324           e->label = new XStr;
2325           (yyvsp[(4) - (8)].ntype)->print(*e->label);
2326           (yyval.construct) = e;
2327         }
2328     break;
2329
2330   case 31:
2331
2332 /* Line 1455 of yacc.c  */
2333 #line 250 "xi-grammar.y"
2334     { (yyval.construct) = NULL; }
2335     break;
2336
2337   case 32:
2338
2339 /* Line 1455 of yacc.c  */
2340 #line 252 "xi-grammar.y"
2341     { (yyval.construct) = NULL; }
2342     break;
2343
2344   case 33:
2345
2346 /* Line 1455 of yacc.c  */
2347 #line 254 "xi-grammar.y"
2348     { (yyval.construct) = (yyvsp[(1) - (1)].accelBlock); }
2349     break;
2350
2351   case 34:
2352
2353 /* Line 1455 of yacc.c  */
2354 #line 258 "xi-grammar.y"
2355     { (yyval.tparam) = new TParamType((yyvsp[(1) - (1)].type)); }
2356     break;
2357
2358   case 35:
2359
2360 /* Line 1455 of yacc.c  */
2361 #line 260 "xi-grammar.y"
2362     { (yyval.tparam) = new TParamVal((yyvsp[(1) - (1)].strval)); }
2363     break;
2364
2365   case 36:
2366
2367 /* Line 1455 of yacc.c  */
2368 #line 262 "xi-grammar.y"
2369     { (yyval.tparam) = new TParamVal((yyvsp[(1) - (1)].strval)); }
2370     break;
2371
2372   case 37:
2373
2374 /* Line 1455 of yacc.c  */
2375 #line 266 "xi-grammar.y"
2376     { (yyval.tparlist) = new TParamList((yyvsp[(1) - (1)].tparam)); }
2377     break;
2378
2379   case 38:
2380
2381 /* Line 1455 of yacc.c  */
2382 #line 268 "xi-grammar.y"
2383     { (yyval.tparlist) = new TParamList((yyvsp[(1) - (3)].tparam), (yyvsp[(3) - (3)].tparlist)); }
2384     break;
2385
2386   case 39:
2387
2388 /* Line 1455 of yacc.c  */
2389 #line 272 "xi-grammar.y"
2390     { (yyval.tparlist) = 0; }
2391     break;
2392
2393   case 40:
2394
2395 /* Line 1455 of yacc.c  */
2396 #line 274 "xi-grammar.y"
2397     { (yyval.tparlist) = (yyvsp[(1) - (1)].tparlist); }
2398     break;
2399
2400   case 41:
2401
2402 /* Line 1455 of yacc.c  */
2403 #line 278 "xi-grammar.y"
2404     { (yyval.tparlist) = 0; }
2405     break;
2406
2407   case 42:
2408
2409 /* Line 1455 of yacc.c  */
2410 #line 280 "xi-grammar.y"
2411     { (yyval.tparlist) = (yyvsp[(2) - (3)].tparlist); }
2412     break;
2413
2414   case 43:
2415
2416 /* Line 1455 of yacc.c  */
2417 #line 284 "xi-grammar.y"
2418     { (yyval.type) = new BuiltinType("int"); }
2419     break;
2420
2421   case 44:
2422
2423 /* Line 1455 of yacc.c  */
2424 #line 286 "xi-grammar.y"
2425     { (yyval.type) = new BuiltinType("long"); }
2426     break;
2427
2428   case 45:
2429
2430 /* Line 1455 of yacc.c  */
2431 #line 288 "xi-grammar.y"
2432     { (yyval.type) = new BuiltinType("short"); }
2433     break;
2434
2435   case 46:
2436
2437 /* Line 1455 of yacc.c  */
2438 #line 290 "xi-grammar.y"
2439     { (yyval.type) = new BuiltinType("char"); }
2440     break;
2441
2442   case 47:
2443
2444 /* Line 1455 of yacc.c  */
2445 #line 292 "xi-grammar.y"
2446     { (yyval.type) = new BuiltinType("unsigned int"); }
2447     break;
2448
2449   case 48:
2450
2451 /* Line 1455 of yacc.c  */
2452 #line 294 "xi-grammar.y"
2453     { (yyval.type) = new BuiltinType("unsigned long"); }
2454     break;
2455
2456   case 49:
2457
2458 /* Line 1455 of yacc.c  */
2459 #line 296 "xi-grammar.y"
2460     { (yyval.type) = new BuiltinType("unsigned long"); }
2461     break;
2462
2463   case 50:
2464
2465 /* Line 1455 of yacc.c  */
2466 #line 298 "xi-grammar.y"
2467     { (yyval.type) = new BuiltinType("unsigned long long"); }
2468     break;
2469
2470   case 51:
2471
2472 /* Line 1455 of yacc.c  */
2473 #line 300 "xi-grammar.y"
2474     { (yyval.type) = new BuiltinType("unsigned short"); }
2475     break;
2476
2477   case 52:
2478
2479 /* Line 1455 of yacc.c  */
2480 #line 302 "xi-grammar.y"
2481     { (yyval.type) = new BuiltinType("unsigned char"); }
2482     break;
2483
2484   case 53:
2485
2486 /* Line 1455 of yacc.c  */
2487 #line 304 "xi-grammar.y"
2488     { (yyval.type) = new BuiltinType("long long"); }
2489     break;
2490
2491   case 54:
2492
2493 /* Line 1455 of yacc.c  */
2494 #line 306 "xi-grammar.y"
2495     { (yyval.type) = new BuiltinType("float"); }
2496     break;
2497
2498   case 55:
2499
2500 /* Line 1455 of yacc.c  */
2501 #line 308 "xi-grammar.y"
2502     { (yyval.type) = new BuiltinType("double"); }
2503     break;
2504
2505   case 56:
2506
2507 /* Line 1455 of yacc.c  */
2508 #line 310 "xi-grammar.y"
2509     { (yyval.type) = new BuiltinType("long double"); }
2510     break;
2511
2512   case 57:
2513
2514 /* Line 1455 of yacc.c  */
2515 #line 312 "xi-grammar.y"
2516     { (yyval.type) = new BuiltinType("void"); }
2517     break;
2518
2519   case 58:
2520
2521 /* Line 1455 of yacc.c  */
2522 #line 315 "xi-grammar.y"
2523     { (yyval.ntype) = new NamedType((yyvsp[(1) - (2)].strval),(yyvsp[(2) - (2)].tparlist)); }
2524     break;
2525
2526   case 59:
2527
2528 /* Line 1455 of yacc.c  */
2529 #line 316 "xi-grammar.y"
2530     { 
2531                     const char* basename, *scope;
2532                     splitScopedName((yyvsp[(1) - (2)].strval), &scope, &basename);
2533                     (yyval.ntype) = new NamedType(basename, (yyvsp[(2) - (2)].tparlist), scope);
2534                 }
2535     break;
2536
2537   case 60:
2538
2539 /* Line 1455 of yacc.c  */
2540 #line 324 "xi-grammar.y"
2541     { (yyval.type) = (yyvsp[(1) - (1)].type); }
2542     break;
2543
2544   case 61:
2545
2546 /* Line 1455 of yacc.c  */
2547 #line 326 "xi-grammar.y"
2548     { (yyval.type) = (yyvsp[(1) - (1)].ntype); }
2549     break;
2550
2551   case 62:
2552
2553 /* Line 1455 of yacc.c  */
2554 #line 330 "xi-grammar.y"
2555     { (yyval.ptype) = new PtrType((yyvsp[(1) - (2)].type)); }
2556     break;
2557
2558   case 63:
2559
2560 /* Line 1455 of yacc.c  */
2561 #line 334 "xi-grammar.y"
2562     { (yyvsp[(1) - (2)].ptype)->indirect(); (yyval.ptype) = (yyvsp[(1) - (2)].ptype); }
2563     break;
2564
2565   case 64:
2566
2567 /* Line 1455 of yacc.c  */
2568 #line 336 "xi-grammar.y"
2569     { (yyvsp[(1) - (2)].ptype)->indirect(); (yyval.ptype) = (yyvsp[(1) - (2)].ptype); }
2570     break;
2571
2572   case 65:
2573
2574 /* Line 1455 of yacc.c  */
2575 #line 340 "xi-grammar.y"
2576     { (yyval.ftype) = new FuncType((yyvsp[(1) - (8)].type), (yyvsp[(4) - (8)].strval), (yyvsp[(7) - (8)].plist)); }
2577     break;
2578
2579   case 66:
2580
2581 /* Line 1455 of yacc.c  */
2582 #line 344 "xi-grammar.y"
2583     { (yyval.type) = (yyvsp[(1) - (1)].type); }
2584     break;
2585
2586   case 67:
2587
2588 /* Line 1455 of yacc.c  */
2589 #line 346 "xi-grammar.y"
2590     { (yyval.type) = (yyvsp[(1) - (1)].ptype); }
2591     break;
2592
2593   case 68:
2594
2595 /* Line 1455 of yacc.c  */
2596 #line 348 "xi-grammar.y"
2597     { (yyval.type) = (yyvsp[(1) - (1)].ptype); }
2598     break;
2599
2600   case 69:
2601
2602 /* Line 1455 of yacc.c  */
2603 #line 350 "xi-grammar.y"
2604     { (yyval.type) = (yyvsp[(1) - (1)].ftype); }
2605     break;
2606
2607   case 70:
2608
2609 /* Line 1455 of yacc.c  */
2610 #line 353 "xi-grammar.y"
2611     { (yyval.type) = (yyvsp[(2) - (2)].type); }
2612     break;
2613
2614   case 71:
2615
2616 /* Line 1455 of yacc.c  */
2617 #line 355 "xi-grammar.y"
2618     { (yyval.type) = (yyvsp[(1) - (2)].type); }
2619     break;
2620
2621   case 72:
2622
2623 /* Line 1455 of yacc.c  */
2624 #line 359 "xi-grammar.y"
2625     { (yyval.type) = new ReferenceType((yyvsp[(1) - (2)].type)); }
2626     break;
2627
2628   case 73:
2629
2630 /* Line 1455 of yacc.c  */
2631 #line 361 "xi-grammar.y"
2632     { (yyval.type) = (yyvsp[(1) - (1)].type); }
2633     break;
2634
2635   case 74:
2636
2637 /* Line 1455 of yacc.c  */
2638 #line 365 "xi-grammar.y"
2639     { (yyval.val) = new Value((yyvsp[(1) - (1)].strval)); }
2640     break;
2641
2642   case 75:
2643
2644 /* Line 1455 of yacc.c  */
2645 #line 367 "xi-grammar.y"
2646     { (yyval.val) = new Value((yyvsp[(1) - (1)].strval)); }
2647     break;
2648
2649   case 76:
2650
2651 /* Line 1455 of yacc.c  */
2652 #line 371 "xi-grammar.y"
2653     { (yyval.val) = (yyvsp[(2) - (3)].val); }
2654     break;
2655
2656   case 77:
2657
2658 /* Line 1455 of yacc.c  */
2659 #line 375 "xi-grammar.y"
2660     { (yyval.vallist) = 0; }
2661     break;
2662
2663   case 78:
2664
2665 /* Line 1455 of yacc.c  */
2666 #line 377 "xi-grammar.y"
2667     { (yyval.vallist) = new ValueList((yyvsp[(1) - (2)].val), (yyvsp[(2) - (2)].vallist)); }
2668     break;
2669
2670   case 79:
2671
2672 /* Line 1455 of yacc.c  */
2673 #line 381 "xi-grammar.y"
2674     { (yyval.readonly) = new Readonly(lineno, (yyvsp[(2) - (4)].type), (yyvsp[(3) - (4)].strval), (yyvsp[(4) - (4)].vallist)); }
2675     break;
2676
2677   case 80:
2678
2679 /* Line 1455 of yacc.c  */
2680 #line 385 "xi-grammar.y"
2681     { (yyval.readonly) = new Readonly(lineno, (yyvsp[(3) - (5)].type), (yyvsp[(5) - (5)].strval), 0, 1); }
2682     break;
2683
2684   case 81:
2685
2686 /* Line 1455 of yacc.c  */
2687 #line 389 "xi-grammar.y"
2688     { (yyval.intval) = 0;}
2689     break;
2690
2691   case 82:
2692
2693 /* Line 1455 of yacc.c  */
2694 #line 391 "xi-grammar.y"
2695     { (yyval.intval) = 0;}
2696     break;
2697
2698   case 83:
2699
2700 /* Line 1455 of yacc.c  */
2701 #line 395 "xi-grammar.y"
2702     { (yyval.intval) = 0; }
2703     break;
2704
2705   case 84:
2706
2707 /* Line 1455 of yacc.c  */
2708 #line 397 "xi-grammar.y"
2709     { 
2710                   /*
2711                   printf("Warning: Message attributes are being phased out.\n");
2712                   printf("Warning: Please remove them from interface files.\n");
2713                   */
2714                   (yyval.intval) = (yyvsp[(2) - (3)].intval); 
2715                 }
2716     break;
2717
2718   case 85:
2719
2720 /* Line 1455 of yacc.c  */
2721 #line 407 "xi-grammar.y"
2722     { (yyval.intval) = (yyvsp[(1) - (1)].intval); }
2723     break;
2724
2725   case 86:
2726
2727 /* Line 1455 of yacc.c  */
2728 #line 409 "xi-grammar.y"
2729     { (yyval.intval) = (yyvsp[(1) - (3)].intval) | (yyvsp[(3) - (3)].intval); }
2730     break;
2731
2732   case 87:
2733
2734 /* Line 1455 of yacc.c  */
2735 #line 413 "xi-grammar.y"
2736     { (yyval.intval) = 0; }
2737     break;
2738
2739   case 88:
2740
2741 /* Line 1455 of yacc.c  */
2742 #line 415 "xi-grammar.y"
2743     { (yyval.intval) = 0; }
2744     break;
2745
2746   case 89:
2747
2748 /* Line 1455 of yacc.c  */
2749 #line 419 "xi-grammar.y"
2750     { (yyval.cattr) = 0; }
2751     break;
2752
2753   case 90:
2754
2755 /* Line 1455 of yacc.c  */
2756 #line 421 "xi-grammar.y"
2757     { (yyval.cattr) = (yyvsp[(2) - (3)].cattr); }
2758     break;
2759
2760   case 91:
2761
2762 /* Line 1455 of yacc.c  */
2763 #line 425 "xi-grammar.y"
2764     { (yyval.cattr) = (yyvsp[(1) - (1)].cattr); }
2765     break;
2766
2767   case 92:
2768
2769 /* Line 1455 of yacc.c  */
2770 #line 427 "xi-grammar.y"
2771     { (yyval.cattr) = (yyvsp[(1) - (3)].cattr) | (yyvsp[(3) - (3)].cattr); }
2772     break;
2773
2774   case 93:
2775
2776 /* Line 1455 of yacc.c  */
2777 #line 431 "xi-grammar.y"
2778     { python_doc = NULL; (yyval.intval) = 0; }
2779     break;
2780
2781   case 94:
2782
2783 /* Line 1455 of yacc.c  */
2784 #line 433 "xi-grammar.y"
2785     { python_doc = (yyvsp[(1) - (1)].strval); (yyval.intval) = 0; }
2786     break;
2787
2788   case 95:
2789
2790 /* Line 1455 of yacc.c  */
2791 #line 437 "xi-grammar.y"
2792     { (yyval.cattr) = Chare::CPYTHON; }
2793     break;
2794
2795   case 96:
2796
2797 /* Line 1455 of yacc.c  */
2798 #line 441 "xi-grammar.y"
2799     { (yyval.cattr) = 0; }
2800     break;
2801
2802   case 97:
2803
2804 /* Line 1455 of yacc.c  */
2805 #line 443 "xi-grammar.y"
2806     { (yyval.cattr) = (yyvsp[(2) - (3)].cattr); }
2807     break;
2808
2809   case 98:
2810
2811 /* Line 1455 of yacc.c  */
2812 #line 447 "xi-grammar.y"
2813     { (yyval.cattr) = (yyvsp[(1) - (1)].cattr); }
2814     break;
2815
2816   case 99:
2817
2818 /* Line 1455 of yacc.c  */
2819 #line 449 "xi-grammar.y"
2820     { (yyval.cattr) = (yyvsp[(1) - (3)].cattr) | (yyvsp[(3) - (3)].cattr); }
2821     break;
2822
2823   case 100:
2824
2825 /* Line 1455 of yacc.c  */
2826 #line 453 "xi-grammar.y"
2827     { (yyval.cattr) = Chare::CMIGRATABLE; }
2828     break;
2829
2830   case 101:
2831
2832 /* Line 1455 of yacc.c  */
2833 #line 455 "xi-grammar.y"
2834     { (yyval.cattr) = Chare::CPYTHON; }
2835     break;
2836
2837   case 102:
2838
2839 /* Line 1455 of yacc.c  */
2840 #line 459 "xi-grammar.y"
2841     { (yyval.intval) = 0; }
2842     break;
2843
2844   case 103:
2845
2846 /* Line 1455 of yacc.c  */
2847 #line 461 "xi-grammar.y"
2848     { (yyval.intval) = 1; }
2849     break;
2850
2851   case 104:
2852
2853 /* Line 1455 of yacc.c  */
2854 #line 464 "xi-grammar.y"
2855     { (yyval.intval) = 0; }
2856     break;
2857
2858   case 105:
2859
2860 /* Line 1455 of yacc.c  */
2861 #line 466 "xi-grammar.y"
2862     { (yyval.intval) = 1; }
2863     break;
2864
2865   case 106:
2866
2867 /* Line 1455 of yacc.c  */
2868 #line 469 "xi-grammar.y"
2869     { (yyval.mv) = new MsgVar((yyvsp[(2) - (5)].type), (yyvsp[(3) - (5)].strval), (yyvsp[(1) - (5)].intval), (yyvsp[(4) - (5)].intval)); }
2870     break;
2871
2872   case 107:
2873
2874 /* Line 1455 of yacc.c  */
2875 #line 473 "xi-grammar.y"
2876     { (yyval.mvlist) = new MsgVarList((yyvsp[(1) - (1)].mv)); }
2877     break;
2878
2879   case 108:
2880
2881 /* Line 1455 of yacc.c  */
2882 #line 475 "xi-grammar.y"
2883     { (yyval.mvlist) = new MsgVarList((yyvsp[(1) - (2)].mv), (yyvsp[(2) - (2)].mvlist)); }
2884     break;
2885
2886   case 109:
2887
2888 /* Line 1455 of yacc.c  */
2889 #line 479 "xi-grammar.y"
2890     { (yyval.message) = new Message(lineno, (yyvsp[(3) - (3)].ntype)); }
2891     break;
2892
2893   case 110:
2894
2895 /* Line 1455 of yacc.c  */
2896 #line 481 "xi-grammar.y"
2897     { (yyval.message) = new Message(lineno, (yyvsp[(3) - (6)].ntype), (yyvsp[(5) - (6)].mvlist)); }
2898     break;
2899
2900   case 111:
2901
2902 /* Line 1455 of yacc.c  */
2903 #line 485 "xi-grammar.y"
2904     { (yyval.typelist) = 0; }
2905     break;
2906
2907   case 112:
2908
2909 /* Line 1455 of yacc.c  */
2910 #line 487 "xi-grammar.y"
2911     { (yyval.typelist) = (yyvsp[(2) - (2)].typelist); }
2912     break;
2913
2914   case 113:
2915
2916 /* Line 1455 of yacc.c  */
2917 #line 491 "xi-grammar.y"
2918     { (yyval.typelist) = new TypeList((yyvsp[(1) - (1)].ntype)); }
2919     break;
2920
2921   case 114:
2922
2923 /* Line 1455 of yacc.c  */
2924 #line 493 "xi-grammar.y"
2925     { (yyval.typelist) = new TypeList((yyvsp[(1) - (3)].ntype), (yyvsp[(3) - (3)].typelist)); }
2926     break;
2927
2928   case 115:
2929
2930 /* Line 1455 of yacc.c  */
2931 #line 497 "xi-grammar.y"
2932     { (yyval.chare) = new Chare(lineno, (yyvsp[(2) - (5)].cattr)|Chare::CCHARE, (yyvsp[(3) - (5)].ntype), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
2933     break;
2934
2935   case 116:
2936
2937 /* Line 1455 of yacc.c  */
2938 #line 499 "xi-grammar.y"
2939     { (yyval.chare) = new MainChare(lineno, (yyvsp[(2) - (5)].cattr), (yyvsp[(3) - (5)].ntype), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
2940     break;
2941
2942   case 117:
2943
2944 /* Line 1455 of yacc.c  */
2945 #line 503 "xi-grammar.y"
2946     { (yyval.chare) = new Group(lineno, (yyvsp[(2) - (5)].cattr), (yyvsp[(3) - (5)].ntype), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
2947     break;
2948
2949   case 118:
2950
2951 /* Line 1455 of yacc.c  */
2952 #line 507 "xi-grammar.y"
2953     { (yyval.chare) = new NodeGroup(lineno, (yyvsp[(2) - (5)].cattr), (yyvsp[(3) - (5)].ntype), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
2954     break;
2955
2956   case 119:
2957
2958 /* Line 1455 of yacc.c  */
2959 #line 511 "xi-grammar.y"
2960     {/*Stupid special case for [1D] indices*/
2961                         char *buf=new char[40];
2962                         sprintf(buf,"%sD",(yyvsp[(2) - (4)].strval));
2963                         (yyval.ntype) = new NamedType(buf); 
2964                 }
2965     break;
2966
2967   case 120:
2968
2969 /* Line 1455 of yacc.c  */
2970 #line 517 "xi-grammar.y"
2971     { (yyval.ntype) = new NamedType((yyvsp[(2) - (3)].strval)); }
2972     break;
2973
2974   case 121:
2975
2976 /* Line 1455 of yacc.c  */
2977 #line 521 "xi-grammar.y"
2978     {  (yyval.chare) = new Array(lineno, (yyvsp[(2) - (6)].cattr), (yyvsp[(3) - (6)].ntype), (yyvsp[(4) - (6)].ntype), (yyvsp[(5) - (6)].typelist), (yyvsp[(6) - (6)].mbrlist)); }
2979     break;
2980
2981   case 122:
2982
2983 /* Line 1455 of yacc.c  */
2984 #line 523 "xi-grammar.y"
2985     {  (yyval.chare) = new Array(lineno, (yyvsp[(3) - (6)].cattr), (yyvsp[(2) - (6)].ntype), (yyvsp[(4) - (6)].ntype), (yyvsp[(5) - (6)].typelist), (yyvsp[(6) - (6)].mbrlist)); }
2986     break;
2987
2988   case 123:
2989
2990 /* Line 1455 of yacc.c  */
2991 #line 527 "xi-grammar.y"
2992     { (yyval.chare) = new Chare(lineno, (yyvsp[(2) - (5)].cattr)|Chare::CCHARE, new NamedType((yyvsp[(3) - (5)].strval)), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist));}
2993     break;
2994
2995   case 124:
2996
2997 /* Line 1455 of yacc.c  */
2998 #line 529 "xi-grammar.y"
2999     { (yyval.chare) = new MainChare(lineno, (yyvsp[(2) - (5)].cattr), new NamedType((yyvsp[(3) - (5)].strval)), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
3000     break;
3001
3002   case 125:
3003
3004 /* Line 1455 of yacc.c  */
3005 #line 533 "xi-grammar.y"
3006     { (yyval.chare) = new Group(lineno, (yyvsp[(2) - (5)].cattr), new NamedType((yyvsp[(3) - (5)].strval)), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
3007     break;
3008
3009   case 126:
3010
3011 /* Line 1455 of yacc.c  */
3012 #line 537 "xi-grammar.y"
3013     { (yyval.chare) = new NodeGroup( lineno, (yyvsp[(2) - (5)].cattr), new NamedType((yyvsp[(3) - (5)].strval)), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
3014     break;
3015
3016   case 127:
3017
3018 /* Line 1455 of yacc.c  */
3019 #line 541 "xi-grammar.y"
3020     { (yyval.chare) = new Array( lineno, 0, (yyvsp[(2) - (5)].ntype), new NamedType((yyvsp[(3) - (5)].strval)), (yyvsp[(4) - (5)].typelist), (yyvsp[(5) - (5)].mbrlist)); }
3021     break;
3022
3023   case 128:
3024
3025 /* Line 1455 of yacc.c  */
3026 #line 545 "xi-grammar.y"
3027     { (yyval.message) = new Message(lineno, new NamedType((yyvsp[(3) - (4)].strval))); }
3028     break;
3029
3030   case 129:
3031
3032 /* Line 1455 of yacc.c  */
3033 #line 547 "xi-grammar.y"
3034     { (yyval.message) = new Message(lineno, new NamedType((yyvsp[(3) - (7)].strval)), (yyvsp[(5) - (7)].mvlist)); }
3035     break;
3036
3037   case 130:
3038
3039 /* Line 1455 of yacc.c  */
3040 #line 551 "xi-grammar.y"
3041     { (yyval.type) = 0; }
3042     break;
3043
3044   case 131:
3045
3046 /* Line 1455 of yacc.c  */
3047 #line 553 "xi-grammar.y"
3048     { (yyval.type) = (yyvsp[(2) - (2)].type); }
3049     break;
3050
3051   case 132:
3052
3053 /* Line 1455 of yacc.c  */
3054 #line 557 "xi-grammar.y"
3055     { (yyval.strval) = 0; }
3056     break;
3057
3058   case 133:
3059
3060 /* Line 1455 of yacc.c  */
3061 #line 559 "xi-grammar.y"
3062     { (yyval.strval) = (yyvsp[(2) - (2)].strval); }
3063     break;
3064
3065   case 134:
3066
3067 /* Line 1455 of yacc.c  */
3068 #line 561 "xi-grammar.y"
3069     { (yyval.strval) = (yyvsp[(2) - (2)].strval); }
3070     break;
3071
3072   case 135:
3073
3074 /* Line 1455 of yacc.c  */
3075 #line 565 "xi-grammar.y"
3076     { (yyval.tvar) = new TType(new NamedType((yyvsp[(2) - (3)].strval)), (yyvsp[(3) - (3)].type)); }
3077     break;
3078
3079   case 136:
3080
3081 /* Line 1455 of yacc.c  */
3082 #line 567 "xi-grammar.y"
3083     { (yyval.tvar) = new TFunc((yyvsp[(1) - (2)].ftype), (yyvsp[(2) - (2)].strval)); }
3084     break;
3085
3086   case 137:
3087
3088 /* Line 1455 of yacc.c  */
3089 #line 569 "xi-grammar.y"
3090     { (yyval.tvar) = new TName((yyvsp[(1) - (3)].type), (yyvsp[(2) - (3)].strval), (yyvsp[(3) - (3)].strval)); }
3091     break;
3092
3093   case 138:
3094
3095 /* Line 1455 of yacc.c  */
3096 #line 573 "xi-grammar.y"
3097     { (yyval.tvarlist) = new TVarList((yyvsp[(1) - (1)].tvar)); }
3098     break;
3099
3100   case 139:
3101
3102 /* Line 1455 of yacc.c  */
3103 #line 575 "xi-grammar.y"
3104     { (yyval.tvarlist) = new TVarList((yyvsp[(1) - (3)].tvar), (yyvsp[(3) - (3)].tvarlist)); }
3105     break;
3106
3107   case 140:
3108
3109 /* Line 1455 of yacc.c  */
3110 #line 579 "xi-grammar.y"
3111     { (yyval.tvarlist) = (yyvsp[(3) - (4)].tvarlist); }
3112     break;
3113
3114   case 141:
3115
3116 /* Line 1455 of yacc.c  */
3117 #line 583 "xi-grammar.y"
3118     { (yyval.templat) = new Template((yyvsp[(1) - (2)].tvarlist), (yyvsp[(2) - (2)].chare)); (yyvsp[(2) - (2)].chare)->setTemplate((yyval.templat)); }
3119     break;
3120
3121   case 142:
3122
3123 /* Line 1455 of yacc.c  */
3124 #line 585 "xi-grammar.y"
3125     { (yyval.templat) = new Template((yyvsp[(1) - (2)].tvarlist), (yyvsp[(2) - (2)].chare)); (yyvsp[(2) - (2)].chare)->setTemplate((yyval.templat)); }
3126     break;
3127
3128   case 143:
3129
3130 /* Line 1455 of yacc.c  */
3131 #line 587 "xi-grammar.y"
3132     { (yyval.templat) = new Template((yyvsp[(1) - (2)].tvarlist), (yyvsp[(2) - (2)].chare)); (yyvsp[(2) - (2)].chare)->setTemplate((yyval.templat)); }
3133     break;
3134
3135   case 144:
3136
3137 /* Line 1455 of yacc.c  */
3138 #line 589 "xi-grammar.y"
3139     { (yyval.templat) = new Template((yyvsp[(1) - (2)].tvarlist), (yyvsp[(2) - (2)].chare)); (yyvsp[(2) - (2)].chare)->setTemplate((yyval.templat)); }
3140     break;
3141
3142   case 145:
3143
3144 /* Line 1455 of yacc.c  */
3145 #line 591 "xi-grammar.y"
3146     { (yyval.templat) = new Template((yyvsp[(1) - (2)].tvarlist), (yyvsp[(2) - (2)].message)); (yyvsp[(2) - (2)].message)->setTemplate((yyval.templat)); }
3147     break;
3148
3149   case 146:
3150
3151 /* Line 1455 of yacc.c  */
3152 #line 595 "xi-grammar.y"
3153     { (yyval.mbrlist) = 0; }
3154     break;
3155
3156   case 147:
3157
3158 /* Line 1455 of yacc.c  */
3159 #line 597 "xi-grammar.y"
3160     { (yyval.mbrlist) = (yyvsp[(2) - (4)].mbrlist); }
3161     break;
3162
3163   case 148:
3164
3165 /* Line 1455 of yacc.c  */
3166 #line 601 "xi-grammar.y"
3167     { 
3168                   Entry *tempEntry;
3169                   if (!connectEntries->empty()) {
3170                     tempEntry = connectEntries->begin();
3171                     MemberList *ml;
3172                     ml = new MemberList(tempEntry, 0);
3173                     tempEntry = connectEntries->next();
3174                     for(; !connectEntries->end(); tempEntry = connectEntries->next()) {
3175                       ml->appendMember(tempEntry); 
3176                     }
3177                     while (!connectEntries->empty())
3178                       connectEntries->pop();
3179                     (yyval.mbrlist) = ml; 
3180                   }
3181                   else {
3182                     (yyval.mbrlist) = 0; 
3183                   }
3184                 }
3185     break;
3186
3187   case 149:
3188
3189 /* Line 1455 of yacc.c  */
3190 #line 620 "xi-grammar.y"
3191     { (yyval.mbrlist) = new MemberList((yyvsp[(1) - (2)].member), (yyvsp[(2) - (2)].mbrlist)); }
3192     break;
3193
3194   case 150:
3195
3196 /* Line 1455 of yacc.c  */
3197 #line 624 "xi-grammar.y"
3198     { (yyval.member) = (yyvsp[(1) - (2)].readonly); }
3199     break;
3200
3201   case 151:
3202
3203 /* Line 1455 of yacc.c  */
3204 #line 626 "xi-grammar.y"
3205     { (yyval.member) = (yyvsp[(1) - (2)].readonly); }
3206     break;
3207
3208   case 153:
3209
3210 /* Line 1455 of yacc.c  */
3211 #line 629 "xi-grammar.y"
3212     { (yyval.member) = (yyvsp[(1) - (2)].member); }
3213     break;
3214
3215   case 154:
3216
3217 /* Line 1455 of yacc.c  */
3218 #line 631 "xi-grammar.y"
3219     { (yyval.member) = (yyvsp[(2) - (3)].pupable); }
3220     break;
3221
3222   case 155:
3223
3224 /* Line 1455 of yacc.c  */
3225 #line 633 "xi-grammar.y"
3226     { (yyval.member) = (yyvsp[(2) - (3)].includeFile); }
3227     break;
3228
3229   case 156:
3230
3231 /* Line 1455 of yacc.c  */
3232 #line 635 "xi-grammar.y"
3233     { (yyval.member) = new ClassDeclaration(lineno,(yyvsp[(2) - (3)].strval)); }
3234     break;
3235
3236   case 157:
3237
3238 /* Line 1455 of yacc.c  */
3239 #line 639 "xi-grammar.y"
3240     { (yyval.member) = new InitCall(lineno, (yyvsp[(3) - (3)].strval), 1); }
3241     break;
3242
3243   case 158:
3244
3245 /* Line 1455 of yacc.c  */
3246 #line 641 "xi-grammar.y"
3247     { (yyval.member) = new InitCall(lineno, (yyvsp[(3) - (6)].strval), 1); }
3248     break;
3249
3250   case 159:
3251
3252 /* Line 1455 of yacc.c  */
3253 #line 643 "xi-grammar.y"
3254     { (yyval.member) = new InitCall(lineno,
3255                                     strdup((std::string((yyvsp[(3) - (9)].strval)) + '<' +
3256                                             ((yyvsp[(5) - (9)].tparlist))->to_string() + '>').c_str()),
3257                                     1);
3258                 }
3259     break;
3260
3261   case 160:
3262
3263 /* Line 1455 of yacc.c  */
3264 #line 649 "xi-grammar.y"