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