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