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