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