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