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