bf6a9fcf5ed0e4222026e86e7964a8470075eae4
[charm.git] / src / xlat-i / xi-grammar.tab.C
1
2 /*  A Bison parser, made from xi-grammar.y
3     by GNU Bison version 1.28  */
4
5 #define YYBISON 1  /* Identify Bison output.  */
6
7 #define MODULE  257
8 #define MAINMODULE      258
9 #define EXTERN  259
10 #define READONLY        260
11 #define CHARE   261
12 #define GROUP   262
13 #define NODEGROUP       263
14 #define ARRAY   264
15 #define MESSAGE 265
16 #define CLASS   266
17 #define STACKSIZE       267
18 #define THREADED        268
19 #define MIGRATABLE      269
20 #define TEMPLATE        270
21 #define SYNC    271
22 #define EXCLUSIVE       272
23 #define VIRTUAL 273
24 #define VOID    274
25 #define PACKED  275
26 #define VARSIZE 276
27 #define ENTRY   277
28 #define MAINCHARE       278
29 #define IDENT   279
30 #define NUMBER  280
31 #define LITERAL 281
32 #define INT     282
33 #define LONG    283
34 #define SHORT   284
35 #define CHAR    285
36 #define FLOAT   286
37 #define DOUBLE  287
38 #define UNSIGNED        288
39
40 #line 1 "xi-grammar.y"
41
42 #include <iostream.h>
43 #include "xi-symbol.h"
44
45 extern int yylex (void) ;
46 void yyerror(const char *);
47 extern unsigned int lineno;
48 ModuleList *modlist;
49
50
51 #line 12 "xi-grammar.y"
52 typedef union {
53   ModuleList *modlist;
54   Module *module;
55   ConstructList *conslist;
56   Construct *construct;
57   TParam *tparam;
58   TParamList *tparlist;
59   Type *type;
60   EnType *rtype;
61   PtrType *ptype;
62   NamedType *ntype;
63   FuncType *ftype;
64   Readonly *readonly;
65   Message *message;
66   Chare *chare;
67   Entry *entry;
68   Template *templat;
69   TypeList *typelist;
70   MemberList *mbrlist;
71   Member *member;
72   TVar *tvar;
73   TVarList *tvarlist;
74   Value *val;
75   ValueList *vallist;
76   MsgVar *mv;
77   MsgVarList *mvlist;
78   char *strval;
79   int intval;
80 } YYSTYPE;
81 #include <stdio.h>
82
83 #ifndef __cplusplus
84 #ifndef __STDC__
85 #define const
86 #endif
87 #endif
88
89
90
91 #define YYFINAL         277
92 #define YYFLAG          -32768
93 #define YYNTBASE        48
94
95 #define YYTRANSLATE(x) ((unsigned)(x) <= 288 ? yytranslate[x] : 114)
96
97 static const char yytranslate[] = {     0,
98      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
99      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
100      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
101      2,     2,     2,     2,     2,     2,     2,     2,     2,    45,
102     46,    42,     2,    39,     2,     2,     2,     2,     2,     2,
103      2,     2,     2,     2,     2,     2,     2,    36,    35,    40,
104     47,    41,     2,     2,     2,     2,     2,     2,     2,     2,
105      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
106      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
107     43,     2,    44,     2,     2,     2,     2,     2,     2,     2,
108      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
109      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
110      2,     2,    37,     2,    38,     2,     2,     2,     2,     2,
111      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
112      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
113      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
114      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
115      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
116      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
117      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
118      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
119      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
120      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
121      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
122      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
123      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
124      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
125     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
126     27,    28,    29,    30,    31,    32,    33,    34
127 };
128
129 #if YYDEBUG != 0
130 static const short yyprhs[] = {     0,
131      0,     2,     3,     6,     7,     9,    10,    12,    14,    16,
132     21,    25,    29,    31,    36,    37,    40,    46,    49,    53,
133     57,    61,    64,    67,    70,    73,    76,    78,    80,    82,
134     84,    88,    89,    91,    92,    96,    98,   100,   102,   104,
135    107,   110,   113,   116,   119,   121,   123,   126,   128,   131,
136    133,   135,   138,   141,   144,   146,   148,   153,   162,   164,
137    166,   168,   170,   172,   173,   175,   179,   183,   184,   187,
138    192,   198,   199,   203,   205,   209,   211,   213,   214,   218,
139    220,   224,   226,   232,   234,   237,   241,   248,   255,   256,
140    259,   261,   265,   271,   277,   283,   289,   294,   298,   304,
141    310,   316,   322,   328,   334,   339,   340,   343,   344,   347,
142    350,   354,   357,   361,   363,   367,   372,   375,   378,   381,
143    384,   387,   389,   394,   395,   398,   401,   404,   407,   415,
144    423,   428,   429,   433,   435,   439,   441,   443,   445,   447,
145    448,   450,   452,   456,   457,   461,   462
146 };
147
148 static const short yyrhs[] = {    49,
149      0,     0,    54,    49,     0,     0,     5,     0,     0,    35,
150      0,    25,     0,    25,     0,    53,    36,    36,    25,     0,
151      3,    52,    55,     0,     4,    52,    55,     0,    35,     0,
152     37,    56,    38,    51,     0,     0,    57,    56,     0,    50,
153     37,    56,    38,    51,     0,    50,    54,     0,    50,    74,
154     35,     0,    50,    75,    35,     0,    50,    84,    35,     0,
155     50,    87,     0,    50,    88,     0,    50,    89,     0,    50,
156     91,     0,    50,   102,     0,    70,     0,    26,     0,    27,
157      0,    58,     0,    58,    39,    59,     0,     0,    59,     0,
158      0,    40,    60,    41,     0,    28,     0,    29,     0,    30,
159      0,    31,     0,    34,    28,     0,    34,    29,     0,    34,
160     30,     0,    34,    31,     0,    29,    29,     0,    32,     0,
161     33,     0,    29,    33,     0,    20,     0,    52,    61,     0,
162     62,     0,    63,     0,    64,    42,     0,    65,    42,     0,
163     66,    42,     0,    26,     0,    52,     0,    70,    43,    67,
164     44,     0,    70,    45,    42,    52,    46,    45,    71,    46,
165      0,    64,     0,    65,     0,    66,     0,    68,     0,    69,
166      0,     0,    70,     0,    70,    39,    71,     0,    43,    67,
167     44,     0,     0,    72,    73,     0,     6,    70,    53,    73,
168      0,     6,    11,    64,    42,    52,     0,     0,    43,    77,
169     44,     0,    78,     0,    78,    39,    77,     0,    21,     0,
170     22,     0,     0,    43,    80,    44,     0,    81,     0,    81,
171     39,    80,     0,    15,     0,    70,    52,    43,    44,    35,
172      0,    82,     0,    82,    83,     0,    11,    76,    63,     0,
173     11,    76,    63,    37,    71,    38,     0,    11,    76,    63,
174     37,    83,    38,     0,     0,    36,    86,     0,    63,     0,
175     63,    39,    86,     0,     7,    79,    63,    85,   103,     0,
176     24,    79,    63,    85,   103,     0,     8,    79,    63,    85,
177    103,     0,     9,    79,    63,    85,   103,     0,    43,    26,
178     52,    44,     0,    43,    52,    44,     0,    10,    90,    63,
179     85,   103,     0,     7,    79,    52,    85,   103,     0,    24,
180     79,    52,    85,   103,     0,     8,    79,    52,    85,   103,
181      0,     9,    79,    52,    85,   103,     0,    10,    90,    52,
182     85,   103,     0,    11,    76,    52,    35,     0,     0,    47,
183     70,     0,     0,    47,    26,     0,    47,    27,     0,    12,
184     52,    97,     0,    69,    98,     0,    70,    52,    98,     0,
185     99,     0,    99,    39,   100,     0,    16,    40,   100,    41,
186      0,   101,    92,     0,   101,    93,     0,   101,    94,     0,
187    101,    95,     0,   101,    96,     0,    35,     0,    37,   104,
188     38,    51,     0,     0,   105,   104,     0,   106,    35,     0,
189     74,    35,     0,    75,    35,     0,    23,   107,    20,    52,
190    111,   113,   112,     0,    23,   107,    65,    52,   111,   113,
191    112,     0,    23,   107,    52,   111,     0,     0,    43,   108,
192     44,     0,   109,     0,   109,    39,   108,     0,    14,     0,
193     17,     0,    18,     0,    19,     0,     0,    20,     0,    65,
194      0,    45,   110,    46,     0,     0,    13,    47,    26,     0,
195      0,    47,    26,     0
196 };
197
198 #endif
199
200 #if YYDEBUG != 0
201 static const short yyrline[] = { 0,
202     96,   100,   102,   106,   108,   112,   114,   118,   122,   124,
203    132,   134,   138,   140,   144,   146,   150,   152,   154,   156,
204    158,   160,   162,   164,   166,   168,   172,   174,   176,   180,
205    182,   186,   188,   192,   194,   198,   200,   202,   204,   206,
206    208,   210,   212,   214,   216,   218,   220,   222,   226,   230,
207    232,   236,   240,   242,   246,   248,   252,   256,   260,   262,
208    264,   266,   268,   272,   274,   276,   280,   284,   286,   290,
209    294,   298,   300,   304,   306,   310,   312,   316,   318,   322,
210    324,   328,   332,   336,   338,   342,   344,   346,   350,   352,
211    356,   358,   362,   364,   368,   372,   376,   382,   386,   390,
212    392,   396,   400,   404,   408,   412,   414,   418,   420,   422,
213    426,   428,   430,   434,   436,   440,   444,   446,   448,   450,
214    452,   456,   458,   462,   464,   468,   470,   472,   476,   478,
215    480,   484,   486,   490,   492,   496,   498,   500,   502,   506,
216    508,   510,   514,   518,   520,   524,   526
217 };
218 #endif
219
220
221 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
222
223 static const char * const yytname[] = {   "$","error","$undefined.","MODULE",
224 "MAINMODULE","EXTERN","READONLY","CHARE","GROUP","NODEGROUP","ARRAY","MESSAGE",
225 "CLASS","STACKSIZE","THREADED","MIGRATABLE","TEMPLATE","SYNC","EXCLUSIVE","VIRTUAL",
226 "VOID","PACKED","VARSIZE","ENTRY","MAINCHARE","IDENT","NUMBER","LITERAL","INT",
227 "LONG","SHORT","CHAR","FLOAT","DOUBLE","UNSIGNED","';'","':'","'{'","'}'","','",
228 "'<'","'>'","'*'","'['","']'","'('","')'","'='","File","ModuleEList","OptExtern",
229 "OptSemiColon","Name","QualName","Module","ConstructEList","ConstructList","Construct",
230 "TParam","TParamList","TParamEList","OptTParams","BuiltinType","NamedType","SimpleType",
231 "OnePtrType","PtrType","ArrayDim","ArrayType","FuncType","Type","TypeList","Dim",
232 "DimList","Readonly","ReadonlyMsg","MAttribs","MAttribList","MAttrib","CAttribs",
233 "CAttribList","CAttrib","Var","VarList","Message","OptBaseList","BaseList","Chare",
234 "Group","NodeGroup","ArrayIndexType","Array","TChare","TGroup","TNodeGroup",
235 "TArray","TMessage","OptTypeInit","OptNameInit","TVar","TVarList","TemplateSpec",
236 "Template","MemberEList","MemberList","Member","Entry","EAttribs","EAttribList",
237 "EAttrib","OptType","EParam","OptStackSize","OptPure", NULL
238 };
239 #endif
240
241 static const short yyr1[] = {     0,
242     48,    49,    49,    50,    50,    51,    51,    52,    53,    53,
243     54,    54,    55,    55,    56,    56,    57,    57,    57,    57,
244     57,    57,    57,    57,    57,    57,    58,    58,    58,    59,
245     59,    60,    60,    61,    61,    62,    62,    62,    62,    62,
246     62,    62,    62,    62,    62,    62,    62,    62,    63,    64,
247     64,    65,    66,    66,    67,    67,    68,    69,    70,    70,
248     70,    70,    70,    71,    71,    71,    72,    73,    73,    74,
249     75,    76,    76,    77,    77,    78,    78,    79,    79,    80,
250     80,    81,    82,    83,    83,    84,    84,    84,    85,    85,
251     86,    86,    87,    87,    88,    89,    90,    90,    91,    92,
252     92,    93,    94,    95,    96,    97,    97,    98,    98,    98,
253     99,    99,    99,   100,   100,   101,   102,   102,   102,   102,
254    102,   103,   103,   104,   104,   105,   105,   105,   106,   106,
255    106,   107,   107,   108,   108,   109,   109,   109,   109,   110,
256    110,   110,   111,   112,   112,   113,   113
257 };
258
259 static const short yyr2[] = {     0,
260      1,     0,     2,     0,     1,     0,     1,     1,     1,     4,
261      3,     3,     1,     4,     0,     2,     5,     2,     3,     3,
262      3,     2,     2,     2,     2,     2,     1,     1,     1,     1,
263      3,     0,     1,     0,     3,     1,     1,     1,     1,     2,
264      2,     2,     2,     2,     1,     1,     2,     1,     2,     1,
265      1,     2,     2,     2,     1,     1,     4,     8,     1,     1,
266      1,     1,     1,     0,     1,     3,     3,     0,     2,     4,
267      5,     0,     3,     1,     3,     1,     1,     0,     3,     1,
268      3,     1,     5,     1,     2,     3,     6,     6,     0,     2,
269      1,     3,     5,     5,     5,     5,     4,     3,     5,     5,
270      5,     5,     5,     5,     4,     0,     2,     0,     2,     2,
271      3,     2,     3,     1,     3,     4,     2,     2,     2,     2,
272      2,     1,     4,     0,     2,     2,     2,     2,     7,     7,
273      4,     0,     3,     1,     3,     1,     1,     1,     1,     0,
274      1,     1,     3,     0,     3,     0,     2
275 };
276
277 static const short yydefact[] = {     2,
278      0,     0,     1,     2,     8,     0,     0,     3,    13,     4,
279     11,    12,     5,     0,     0,     4,     0,    78,    78,    78,
280      0,    72,     0,    78,     4,    18,     0,     0,     0,    22,
281     23,    24,    25,     0,    26,     6,    16,     0,    48,    36,
282     37,    38,    39,    45,    46,     0,    34,    50,    51,    59,
283     60,    61,    62,    63,     0,     0,     0,     0,     0,     0,
284      0,     0,     0,     0,     0,     0,    19,    20,    21,    78,
285     78,    78,     0,    72,    78,   117,   118,   119,   120,   121,
286      7,    14,     0,    44,    47,    40,    41,    42,    43,    32,
287     49,    52,    53,    54,     9,     0,     0,    68,    82,     0,
288     80,    89,    89,    89,     0,     0,    89,    76,    77,     0,
289     74,    86,     0,    63,     0,   114,     0,    89,     6,     0,
290      0,     0,     0,     0,     0,     0,    28,    29,    30,    33,
291      0,    27,    55,    56,     0,     0,     0,     0,    68,    70,
292     79,     0,     0,     0,     0,     0,     0,    98,     0,    73,
293      0,    64,   106,     0,   112,   108,     0,   116,     0,    17,
294     89,    89,    89,    89,     0,    89,    71,     0,    35,    57,
295      0,     0,     0,    69,    81,    91,    90,   122,   124,    93,
296     95,    96,    97,    99,    75,    65,     0,    84,     0,     0,
297    111,   109,   110,   113,   115,    94,     0,     0,     0,     0,
298    105,     0,    31,     0,    10,    67,     0,   132,     0,     0,
299      0,   124,     0,    64,     0,    87,     0,    85,    88,   107,
300    100,   102,   103,   104,   101,    64,    92,     0,     0,   127,
301    128,     6,   125,   126,    65,    66,     0,     0,   136,   137,
302    138,   139,     0,   134,    48,    34,     0,     0,   123,     0,
303     58,   133,     0,     0,   140,   131,     0,    83,   135,   146,
304     48,   142,     0,   146,     0,   144,   143,   144,   147,     0,
305    129,   130,     0,   145,     0,     0,     0
306 };
307
308 static const short yydefgoto[] = {   275,
309      3,    14,    82,    47,    98,     4,    11,    15,    16,   129,
310    130,   131,    91,    48,    49,    50,    51,    52,   135,    53,
311     54,   115,   187,   139,   140,   209,   210,    63,   110,   111,
312     57,   100,   101,   188,   189,    29,   144,   177,    30,    31,
313     32,    61,    33,    76,    77,    78,    79,    80,   191,   155,
314    116,   117,    34,    35,   180,   211,   212,   213,   229,   243,
315    244,   263,   256,   271,   266
316 };
317
318 static const short yypact[] = {    67,
319      0,     0,-32768,    67,-32768,    10,    10,-32768,-32768,     5,
320 -32768,-32768,-32768,    45,    61,     5,    77,    50,    50,    50,
321     60,    73,    93,    50,     5,-32768,    83,   101,   123,-32768,
322 -32768,-32768,-32768,   142,-32768,   127,-32768,   139,-32768,-32768,
323     17,-32768,-32768,-32768,-32768,    99,   125,-32768,-32768,   121,
324    133,   135,-32768,-32768,    -4,   164,     0,     0,     0,   106,
325      0,   119,     0,   114,     0,   143,-32768,-32768,-32768,    50,
326     50,    50,    60,    73,    50,-32768,-32768,-32768,-32768,-32768,
327 -32768,-32768,   138,-32768,-32768,-32768,-32768,-32768,-32768,   176,
328 -32768,-32768,-32768,-32768,-32768,   131,   140,    22,-32768,   150,
329    145,   159,   159,   159,     0,   153,   159,-32768,-32768,   154,
330    160,   174,     0,   -19,    19,   175,   179,   159,   127,     0,
331      0,     0,     0,     0,     0,     0,-32768,-32768,   178,-32768,
332    188,    55,-32768,-32768,   171,     0,   194,   131,   189,-32768,
333 -32768,   164,     0,    78,    78,    78,   187,-32768,    78,-32768,
334    119,   139,   186,   134,-32768,   190,   114,-32768,    78,-32768,
335    159,   159,   159,   159,   199,   159,-32768,   176,-32768,-32768,
336    192,   210,   195,-32768,-32768,   197,-32768,-32768,    13,-32768,
337 -32768,-32768,-32768,-32768,-32768,    -8,   202,   139,   203,   139,
338 -32768,-32768,-32768,-32768,-32768,-32768,    78,    78,    78,    78,
339 -32768,    78,-32768,   198,-32768,-32768,     0,   205,   207,   211,
340    212,    13,   214,   139,   208,-32768,    19,-32768,-32768,    55,
341 -32768,-32768,-32768,-32768,-32768,   139,-32768,    49,   158,-32768,
342 -32768,   127,-32768,-32768,    51,-32768,   201,   206,-32768,-32768,
343 -32768,-32768,   209,   215,     0,    47,   121,     0,-32768,   220,
344 -32768,-32768,    49,   213,   193,-32768,   213,-32768,-32768,   216,
345    218,-32768,   219,   216,   230,   244,-32768,   244,-32768,   221,
346 -32768,-32768,   233,-32768,   260,   261,-32768
347 };
348
349 static const short yypgoto[] = {-32768,
350    258,-32768,  -115,    -1,-32768,   252,   262,     7,-32768,-32768,
351    102,-32768,-32768,-32768,   -52,   -36,  -213,-32768,   129,-32768,
352    -56,   -14,  -202,-32768,   132,   259,   263,   200,   124,-32768,
353     14,   130,-32768,-32768,    88,-32768,   -89,    71,-32768,-32768,
354 -32768,   217,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   126,
355 -32768,   122,-32768,-32768,  -119,    68,-32768,-32768,-32768,    28,
356 -32768,-32768,  -197,    15,    20
357 };
358
359
360 #define YYLAST          290
361
362
363 static const short yytable[] = {     6,
364      7,    83,    55,   160,   102,   103,   104,   114,   107,    13,
365    112,   236,   118,   145,   146,   248,     5,   149,    17,  -108,
366     95,  -108,    37,   238,     5,   181,   182,   154,   159,   184,
367    214,    66,    58,    59,    96,   208,    97,    65,    96,   196,
368     97,   262,   -15,     5,     9,    84,    10,     1,     2,    85,
369     17,    18,    19,    20,    21,    22,   260,   137,   106,   264,
370     23,    96,   239,    97,   138,   240,   241,   242,    24,     1,
371      2,   197,   198,   199,   200,   132,   202,   221,   222,   223,
372    224,    25,   225,   120,   121,   122,    90,    38,   125,   214,
373    176,   255,    56,    96,   134,    97,    39,    96,    36,    97,
374    114,     5,    60,   147,    40,    41,    42,    43,    44,    45,
375     46,   153,   178,   156,   179,    62,   249,    67,   161,   162,
376    163,   164,   165,   166,   167,   113,    86,    87,    88,    89,
377      5,   105,    64,    39,   171,    68,   134,   186,     5,   108,
378    109,    40,    41,    42,    43,    44,    45,    46,    70,    71,
379     72,    73,    74,   132,   176,     5,   133,    69,    39,   192,
380    193,    81,    92,     5,    90,    75,    40,    41,    42,    43,
381     44,    45,    46,   217,    93,   220,    94,   245,    99,   126,
382    119,   136,     5,   142,   215,    40,    41,    42,    43,    44,
383     45,    46,   247,   141,   143,    39,   148,   150,   151,   235,
384      5,   127,   128,    40,    41,    42,    43,    44,    45,    46,
385    152,   235,   261,   157,   170,   215,   168,     5,   247,   158,
386     40,    41,    42,    43,    44,    45,    46,   246,   169,   172,
387    183,   138,   190,   201,   205,   207,   154,   204,   206,   216,
388    219,   230,   226,   254,   250,   231,   257,   228,   234,   232,
389    237,   251,   252,   253,   258,   269,   270,   255,   274,   276,
390    277,     8,   265,  -141,   267,    26,   173,   273,    12,   203,
391    174,   175,    27,   124,   185,   218,    28,   227,   195,   233,
392    259,   194,   272,   268,     0,     0,     0,     0,     0,   123
393 };
394
395 static const short yycheck[] = {     1,
396      2,    38,    17,   119,    57,    58,    59,    64,    61,     5,
397     63,   214,    65,   103,   104,   229,    25,   107,     6,    39,
398     25,    41,    16,   226,    25,   145,   146,    47,   118,   149,
399     39,    25,    19,    20,    43,    23,    45,    24,    43,   159,
400     45,   255,    38,    25,    35,    29,    37,     3,     4,    33,
401      6,     7,     8,     9,    10,    11,   254,    36,    60,   257,
402     16,    43,    14,    45,    43,    17,    18,    19,    24,     3,
403      4,   161,   162,   163,   164,    90,   166,   197,   198,   199,
404    200,    37,   202,    70,    71,    72,    40,    11,    75,    39,
405    143,    45,    43,    43,    96,    45,    20,    43,    38,    45,
406    157,    25,    43,   105,    28,    29,    30,    31,    32,    33,
407     34,   113,    35,   115,    37,    43,   232,    35,   120,   121,
408    122,   123,   124,   125,   126,    12,    28,    29,    30,    31,
409     25,    26,    40,    20,   136,    35,   138,   152,    25,    21,
410     22,    28,    29,    30,    31,    32,    33,    34,     7,     8,
411      9,    10,    11,   168,   207,    25,    26,    35,    20,    26,
412     27,    35,    42,    25,    40,    24,    28,    29,    30,    31,
413     32,    33,    34,   188,    42,   190,    42,    20,    15,    42,
414     38,    42,    25,    39,   186,    28,    29,    30,    31,    32,
415     33,    34,   229,    44,    36,    20,    44,    44,    39,   214,
416     25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
417     37,   226,    20,    39,    44,   217,    39,    25,   255,    41,
418     28,    29,    30,    31,    32,    33,    34,   229,    41,    36,
419     44,    43,    47,    35,    25,    39,    47,    46,    44,    38,
420     38,    35,    45,   245,    44,    35,   248,    43,    35,    38,
421     43,    46,    44,    39,    35,    26,    13,    45,    26,     0,
422      0,     4,    47,    46,    46,    14,   138,    47,     7,   168,
423    139,   142,    14,    74,   151,   188,    14,   207,   157,   212,
424    253,   156,   268,   264,    -1,    -1,    -1,    -1,    -1,    73
425 };
426 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
427 #line 3 "/home/csar2/bhandark/share/bison.simple"
428 /* This file comes from bison-1.28.  */
429
430 /* Skeleton output parser for bison,
431    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
432
433    This program is free software; you can redistribute it and/or modify
434    it under the terms of the GNU General Public License as published by
435    the Free Software Foundation; either version 2, or (at your option)
436    any later version.
437
438    This program is distributed in the hope that it will be useful,
439    but WITHOUT ANY WARRANTY; without even the implied warranty of
440    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
441    GNU General Public License for more details.
442
443    You should have received a copy of the GNU General Public License
444    along with this program; if not, write to the Free Software
445    Foundation, Inc., 59 Temple Place - Suite 330,
446    Boston, MA 02111-1307, USA.  */
447
448 /* As a special exception, when this file is copied by Bison into a
449    Bison output file, you may use that output file without restriction.
450    This special exception was added by the Free Software Foundation
451    in version 1.24 of Bison.  */
452
453 /* This is the parser code that is written into each bison parser
454   when the %semantic_parser declaration is not specified in the grammar.
455   It was written by Richard Stallman by simplifying the hairy parser
456   used when %semantic_parser is specified.  */
457
458 #ifndef YYSTACK_USE_ALLOCA
459 #ifdef alloca
460 #define YYSTACK_USE_ALLOCA
461 #else /* alloca not defined */
462 #ifdef __GNUC__
463 #define YYSTACK_USE_ALLOCA
464 #define alloca __builtin_alloca
465 #else /* not GNU C.  */
466 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
467 #define YYSTACK_USE_ALLOCA
468 #include <alloca.h>
469 #else /* not sparc */
470 /* We think this test detects Watcom and Microsoft C.  */
471 /* This used to test MSDOS, but that is a bad idea
472    since that symbol is in the user namespace.  */
473 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
474 #if 0 /* No need for malloc.h, which pollutes the namespace;
475          instead, just don't use alloca.  */
476 #include <malloc.h>
477 #endif
478 #else /* not MSDOS, or __TURBOC__ */
479 #if defined(_AIX)
480 /* I don't know what this was needed for, but it pollutes the namespace.
481    So I turned it off.   rms, 2 May 1997.  */
482 /* #include <malloc.h>  */
483  #pragma alloca
484 #define YYSTACK_USE_ALLOCA
485 #else /* not MSDOS, or __TURBOC__, or _AIX */
486 #if 0
487 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
488                  and on HPUX 10.  Eventually we can turn this on.  */
489 #define YYSTACK_USE_ALLOCA
490 #define alloca __builtin_alloca
491 #endif /* __hpux */
492 #endif
493 #endif /* not _AIX */
494 #endif /* not MSDOS, or __TURBOC__ */
495 #endif /* not sparc */
496 #endif /* not GNU C */
497 #endif /* alloca not defined */
498 #endif /* YYSTACK_USE_ALLOCA not defined */
499
500 #ifdef YYSTACK_USE_ALLOCA
501 #define YYSTACK_ALLOC alloca
502 #else
503 #define YYSTACK_ALLOC malloc
504 #endif
505
506 /* Note: there must be only one dollar sign in this file.
507    It is replaced by the list of actions, each action
508    as one case of the switch.  */
509
510 #define yyerrok         (yyerrstatus = 0)
511 #define yyclearin       (yychar = YYEMPTY)
512 #define YYEMPTY         -2
513 #define YYEOF           0
514 #define YYACCEPT        goto yyacceptlab
515 #define YYABORT         goto yyabortlab
516 #define YYERROR         goto yyerrlab1
517 /* Like YYERROR except do call yyerror.
518    This remains here temporarily to ease the
519    transition to the new meaning of YYERROR, for GCC.
520    Once GCC version 2 has supplanted version 1, this can go.  */
521 #define YYFAIL          goto yyerrlab
522 #define YYRECOVERING()  (!!yyerrstatus)
523 #define YYBACKUP(token, value) \
524 do                                                              \
525   if (yychar == YYEMPTY && yylen == 1)                          \
526     { yychar = (token), yylval = (value);                       \
527       yychar1 = YYTRANSLATE (yychar);                           \
528       YYPOPSTACK;                                               \
529       goto yybackup;                                            \
530     }                                                           \
531   else                                                          \
532     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
533 while (0)
534
535 #define YYTERROR        1
536 #define YYERRCODE       256
537
538 #ifndef YYPURE
539 #define YYLEX           yylex()
540 #endif
541
542 #ifdef YYPURE
543 #ifdef YYLSP_NEEDED
544 #ifdef YYLEX_PARAM
545 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
546 #else
547 #define YYLEX           yylex(&yylval, &yylloc)
548 #endif
549 #else /* not YYLSP_NEEDED */
550 #ifdef YYLEX_PARAM
551 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
552 #else
553 #define YYLEX           yylex(&yylval)
554 #endif
555 #endif /* not YYLSP_NEEDED */
556 #endif
557
558 /* If nonreentrant, generate the variables here */
559
560 #ifndef YYPURE
561
562 int     yychar;                 /*  the lookahead symbol                */
563 YYSTYPE yylval;                 /*  the semantic value of the           */
564                                 /*  lookahead symbol                    */
565
566 #ifdef YYLSP_NEEDED
567 YYLTYPE yylloc;                 /*  location data for the lookahead     */
568                                 /*  symbol                              */
569 #endif
570
571 int yynerrs;                    /*  number of parse errors so far       */
572 #endif  /* not YYPURE */
573
574 #if YYDEBUG != 0
575 int yydebug;                    /*  nonzero means print parse trace     */
576 /* Since this is uninitialized, it does not stop multiple parsers
577    from coexisting.  */
578 #endif
579
580 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
581
582 #ifndef YYINITDEPTH
583 #define YYINITDEPTH 200
584 #endif
585
586 /*  YYMAXDEPTH is the maximum size the stacks can grow to
587     (effective only if the built-in stack extension method is used).  */
588
589 #if YYMAXDEPTH == 0
590 #undef YYMAXDEPTH
591 #endif
592
593 #ifndef YYMAXDEPTH
594 #define YYMAXDEPTH 10000
595 #endif
596 \f
597 /* Define __yy_memcpy.  Note that the size argument
598    should be passed with type unsigned int, because that is what the non-GCC
599    definitions require.  With GCC, __builtin_memcpy takes an arg
600    of type size_t, but it can handle unsigned int.  */
601
602 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
603 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
604 #else                           /* not GNU C or C++ */
605 #ifndef __cplusplus
606
607 /* This is the most reliable way to avoid incompatibilities
608    in available built-in functions on various systems.  */
609 static void
610 __yy_memcpy (to, from, count)
611      char *to;
612      char *from;
613      unsigned int count;
614 {
615   register char *f = from;
616   register char *t = to;
617   register int i = count;
618
619   while (i-- > 0)
620     *t++ = *f++;
621 }
622
623 #else /* __cplusplus */
624
625 /* This is the most reliable way to avoid incompatibilities
626    in available built-in functions on various systems.  */
627 static void
628 __yy_memcpy (char *to, char *from, unsigned int count)
629 {
630   register char *t = to;
631   register char *f = from;
632   register int i = count;
633
634   while (i-- > 0)
635     *t++ = *f++;
636 }
637
638 #endif
639 #endif
640 \f
641 #line 217 "/home/csar2/bhandark/share/bison.simple"
642
643 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
644    into yyparse.  The argument should have type void *.
645    It should actually point to an object.
646    Grammar actions can access the variable by casting it
647    to the proper pointer type.  */
648
649 #ifdef YYPARSE_PARAM
650 #ifdef __cplusplus
651 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
652 #define YYPARSE_PARAM_DECL
653 #else /* not __cplusplus */
654 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
655 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
656 #endif /* not __cplusplus */
657 #else /* not YYPARSE_PARAM */
658 #define YYPARSE_PARAM_ARG
659 #define YYPARSE_PARAM_DECL
660 #endif /* not YYPARSE_PARAM */
661
662 /* Prevent warning if -Wstrict-prototypes.  */
663 #ifdef __GNUC__
664 #ifdef YYPARSE_PARAM
665 int yyparse (void *);
666 #else
667 int yyparse (void);
668 #endif
669 #endif
670
671 int
672 yyparse(YYPARSE_PARAM_ARG)
673      YYPARSE_PARAM_DECL
674 {
675   register int yystate;
676   register int yyn;
677   register short *yyssp;
678   register YYSTYPE *yyvsp;
679   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
680   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
681
682   short yyssa[YYINITDEPTH];     /*  the state stack                     */
683   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
684
685   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
686   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
687
688 #ifdef YYLSP_NEEDED
689   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
690   YYLTYPE *yyls = yylsa;
691   YYLTYPE *yylsp;
692
693 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
694 #else
695 #define YYPOPSTACK   (yyvsp--, yyssp--)
696 #endif
697
698   int yystacksize = YYINITDEPTH;
699   int yyfree_stacks = 0;
700
701 #ifdef YYPURE
702   int yychar;
703   YYSTYPE yylval;
704   int yynerrs;
705 #ifdef YYLSP_NEEDED
706   YYLTYPE yylloc;
707 #endif
708 #endif
709
710   YYSTYPE yyval;                /*  the variable used to return         */
711                                 /*  semantic values from the action     */
712                                 /*  routines                            */
713
714   int yylen;
715
716 #if YYDEBUG != 0
717   if (yydebug)
718     fprintf(stderr, "Starting parse\n");
719 #endif
720
721   yystate = 0;
722   yyerrstatus = 0;
723   yynerrs = 0;
724   yychar = YYEMPTY;             /* Cause a token to be read.  */
725
726   /* Initialize stack pointers.
727      Waste one element of value and location stack
728      so that they stay on the same level as the state stack.
729      The wasted elements are never initialized.  */
730
731   yyssp = yyss - 1;
732   yyvsp = yyvs;
733 #ifdef YYLSP_NEEDED
734   yylsp = yyls;
735 #endif
736
737 /* Push a new state, which is found in  yystate  .  */
738 /* In all cases, when you get here, the value and location stacks
739    have just been pushed. so pushing a state here evens the stacks.  */
740 yynewstate:
741
742   *++yyssp = yystate;
743
744   if (yyssp >= yyss + yystacksize - 1)
745     {
746       /* Give user a chance to reallocate the stack */
747       /* Use copies of these so that the &'s don't force the real ones into memory. */
748       YYSTYPE *yyvs1 = yyvs;
749       short *yyss1 = yyss;
750 #ifdef YYLSP_NEEDED
751       YYLTYPE *yyls1 = yyls;
752 #endif
753
754       /* Get the current used size of the three stacks, in elements.  */
755       int size = yyssp - yyss + 1;
756
757 #ifdef yyoverflow
758       /* Each stack pointer address is followed by the size of
759          the data in use in that stack, in bytes.  */
760 #ifdef YYLSP_NEEDED
761       /* This used to be a conditional around just the two extra args,
762          but that might be undefined if yyoverflow is a macro.  */
763       yyoverflow("parser stack overflow",
764                  &yyss1, size * sizeof (*yyssp),
765                  &yyvs1, size * sizeof (*yyvsp),
766                  &yyls1, size * sizeof (*yylsp),
767                  &yystacksize);
768 #else
769       yyoverflow("parser stack overflow",
770                  &yyss1, size * sizeof (*yyssp),
771                  &yyvs1, size * sizeof (*yyvsp),
772                  &yystacksize);
773 #endif
774
775       yyss = yyss1; yyvs = yyvs1;
776 #ifdef YYLSP_NEEDED
777       yyls = yyls1;
778 #endif
779 #else /* no yyoverflow */
780       /* Extend the stack our own way.  */
781       if (yystacksize >= YYMAXDEPTH)
782         {
783           yyerror("parser stack overflow");
784           if (yyfree_stacks)
785             {
786               free (yyss);
787               free (yyvs);
788 #ifdef YYLSP_NEEDED
789               free (yyls);
790 #endif
791             }
792           return 2;
793         }
794       yystacksize *= 2;
795       if (yystacksize > YYMAXDEPTH)
796         yystacksize = YYMAXDEPTH;
797 #ifndef YYSTACK_USE_ALLOCA
798       yyfree_stacks = 1;
799 #endif
800       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
801       __yy_memcpy ((char *)yyss, (char *)yyss1,
802                    size * (unsigned int) sizeof (*yyssp));
803       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
804       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
805                    size * (unsigned int) sizeof (*yyvsp));
806 #ifdef YYLSP_NEEDED
807       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
808       __yy_memcpy ((char *)yyls, (char *)yyls1,
809                    size * (unsigned int) sizeof (*yylsp));
810 #endif
811 #endif /* no yyoverflow */
812
813       yyssp = yyss + size - 1;
814       yyvsp = yyvs + size - 1;
815 #ifdef YYLSP_NEEDED
816       yylsp = yyls + size - 1;
817 #endif
818
819 #if YYDEBUG != 0
820       if (yydebug)
821         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
822 #endif
823
824       if (yyssp >= yyss + yystacksize - 1)
825         YYABORT;
826     }
827
828 #if YYDEBUG != 0
829   if (yydebug)
830     fprintf(stderr, "Entering state %d\n", yystate);
831 #endif
832
833   goto yybackup;
834  yybackup:
835
836 /* Do appropriate processing given the current state.  */
837 /* Read a lookahead token if we need one and don't already have one.  */
838 /* yyresume: */
839
840   /* First try to decide what to do without reference to lookahead token.  */
841
842   yyn = yypact[yystate];
843   if (yyn == YYFLAG)
844     goto yydefault;
845
846   /* Not known => get a lookahead token if don't already have one.  */
847
848   /* yychar is either YYEMPTY or YYEOF
849      or a valid token in external form.  */
850
851   if (yychar == YYEMPTY)
852     {
853 #if YYDEBUG != 0
854       if (yydebug)
855         fprintf(stderr, "Reading a token: ");
856 #endif
857       yychar = YYLEX;
858     }
859
860   /* Convert token to internal form (in yychar1) for indexing tables with */
861
862   if (yychar <= 0)              /* This means end of input. */
863     {
864       yychar1 = 0;
865       yychar = YYEOF;           /* Don't call YYLEX any more */
866
867 #if YYDEBUG != 0
868       if (yydebug)
869         fprintf(stderr, "Now at end of input.\n");
870 #endif
871     }
872   else
873     {
874       yychar1 = YYTRANSLATE(yychar);
875
876 #if YYDEBUG != 0
877       if (yydebug)
878         {
879           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
880           /* Give the individual parser a way to print the precise meaning
881              of a token, for further debugging info.  */
882 #ifdef YYPRINT
883           YYPRINT (stderr, yychar, yylval);
884 #endif
885           fprintf (stderr, ")\n");
886         }
887 #endif
888     }
889
890   yyn += yychar1;
891   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
892     goto yydefault;
893
894   yyn = yytable[yyn];
895
896   /* yyn is what to do for this token type in this state.
897      Negative => reduce, -yyn is rule number.
898      Positive => shift, yyn is new state.
899        New state is final state => don't bother to shift,
900        just return success.
901      0, or most negative number => error.  */
902
903   if (yyn < 0)
904     {
905       if (yyn == YYFLAG)
906         goto yyerrlab;
907       yyn = -yyn;
908       goto yyreduce;
909     }
910   else if (yyn == 0)
911     goto yyerrlab;
912
913   if (yyn == YYFINAL)
914     YYACCEPT;
915
916   /* Shift the lookahead token.  */
917
918 #if YYDEBUG != 0
919   if (yydebug)
920     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
921 #endif
922
923   /* Discard the token being shifted unless it is eof.  */
924   if (yychar != YYEOF)
925     yychar = YYEMPTY;
926
927   *++yyvsp = yylval;
928 #ifdef YYLSP_NEEDED
929   *++yylsp = yylloc;
930 #endif
931
932   /* count tokens shifted since error; after three, turn off error status.  */
933   if (yyerrstatus) yyerrstatus--;
934
935   yystate = yyn;
936   goto yynewstate;
937
938 /* Do the default action for the current state.  */
939 yydefault:
940
941   yyn = yydefact[yystate];
942   if (yyn == 0)
943     goto yyerrlab;
944
945 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
946 yyreduce:
947   yylen = yyr2[yyn];
948   if (yylen > 0)
949     yyval = yyvsp[1-yylen]; /* implement default value of the action */
950
951 #if YYDEBUG != 0
952   if (yydebug)
953     {
954       int i;
955
956       fprintf (stderr, "Reducing via rule %d (line %d), ",
957                yyn, yyrline[yyn]);
958
959       /* Print the symbols being reduced, and their result.  */
960       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
961         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
962       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
963     }
964 #endif
965
966
967   switch (yyn) {
968
969 case 1:
970 #line 97 "xi-grammar.y"
971 { yyval.modlist = yyvsp[0].modlist; modlist = yyvsp[0].modlist; ;
972     break;}
973 case 2:
974 #line 101 "xi-grammar.y"
975 { yyval.modlist = 0; ;
976     break;}
977 case 3:
978 #line 103 "xi-grammar.y"
979 { yyval.modlist = new ModuleList(lineno, yyvsp[-1].module, yyvsp[0].modlist); ;
980     break;}
981 case 4:
982 #line 107 "xi-grammar.y"
983 { yyval.intval = 0; ;
984     break;}
985 case 5:
986 #line 109 "xi-grammar.y"
987 { yyval.intval = 1; ;
988     break;}
989 case 6:
990 #line 113 "xi-grammar.y"
991 { yyval.intval = 0; ;
992     break;}
993 case 7:
994 #line 115 "xi-grammar.y"
995 { yyval.intval = 1; ;
996     break;}
997 case 8:
998 #line 119 "xi-grammar.y"
999 { yyval.strval = yyvsp[0].strval; ;
1000     break;}
1001 case 9:
1002 #line 123 "xi-grammar.y"
1003 { yyval.strval = yyvsp[0].strval; ;
1004     break;}
1005 case 10:
1006 #line 125 "xi-grammar.y"
1007 {
1008                   char *tmp = new char[strlen(yyvsp[-3].strval)+strlen(yyvsp[0].strval)+3];
1009                   sprintf(tmp,"%s::%s", yyvsp[-3].strval, yyvsp[0].strval);
1010                   yyval.strval = tmp;
1011                 ;
1012     break;}
1013 case 11:
1014 #line 133 "xi-grammar.y"
1015 { yyval.module = new Module(lineno, yyvsp[-1].strval, yyvsp[0].conslist); ;
1016     break;}
1017 case 12:
1018 #line 135 "xi-grammar.y"
1019 { yyval.module = new Module(lineno, yyvsp[-1].strval, yyvsp[0].conslist); yyval.module->setMain(); ;
1020     break;}
1021 case 13:
1022 #line 139 "xi-grammar.y"
1023 { yyval.conslist = 0; ;
1024     break;}
1025 case 14:
1026 #line 141 "xi-grammar.y"
1027 { yyval.conslist = yyvsp[-2].conslist; ;
1028     break;}
1029 case 15:
1030 #line 145 "xi-grammar.y"
1031 { yyval.conslist = 0; ;
1032     break;}
1033 case 16:
1034 #line 147 "xi-grammar.y"
1035 { yyval.conslist = new ConstructList(lineno, yyvsp[-1].construct, yyvsp[0].conslist); ;
1036     break;}
1037 case 17:
1038 #line 151 "xi-grammar.y"
1039 { if(yyvsp[-2].conslist) yyvsp[-2].conslist->setExtern(yyvsp[-4].intval); yyval.construct = yyvsp[-2].conslist; ;
1040     break;}
1041 case 18:
1042 #line 153 "xi-grammar.y"
1043 { yyvsp[0].module->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].module; ;
1044     break;}
1045 case 19:
1046 #line 155 "xi-grammar.y"
1047 { yyvsp[-1].readonly->setExtern(yyvsp[-2].intval); yyval.construct = yyvsp[-1].readonly; ;
1048     break;}
1049 case 20:
1050 #line 157 "xi-grammar.y"
1051 { yyvsp[-1].readonly->setExtern(yyvsp[-2].intval); yyval.construct = yyvsp[-1].readonly; ;
1052     break;}
1053 case 21:
1054 #line 159 "xi-grammar.y"
1055 { yyvsp[-1].message->setExtern(yyvsp[-2].intval); yyval.construct = yyvsp[-1].message; ;
1056     break;}
1057 case 22:
1058 #line 161 "xi-grammar.y"
1059 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
1060     break;}
1061 case 23:
1062 #line 163 "xi-grammar.y"
1063 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
1064     break;}
1065 case 24:
1066 #line 165 "xi-grammar.y"
1067 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
1068     break;}
1069 case 25:
1070 #line 167 "xi-grammar.y"
1071 { yyvsp[0].chare->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].chare; ;
1072     break;}
1073 case 26:
1074 #line 169 "xi-grammar.y"
1075 { yyvsp[0].templat->setExtern(yyvsp[-1].intval); yyval.construct = yyvsp[0].templat; ;
1076     break;}
1077 case 27:
1078 #line 173 "xi-grammar.y"
1079 { yyval.tparam = new TParamType(yyvsp[0].type); ;
1080     break;}
1081 case 28:
1082 #line 175 "xi-grammar.y"
1083 { yyval.tparam = new TParamVal(yyvsp[0].strval); ;
1084     break;}
1085 case 29:
1086 #line 177 "xi-grammar.y"
1087 { yyval.tparam = new TParamVal(yyvsp[0].strval); ;
1088     break;}
1089 case 30:
1090 #line 181 "xi-grammar.y"
1091 { yyval.tparlist = new TParamList(yyvsp[0].tparam); ;
1092     break;}
1093 case 31:
1094 #line 183 "xi-grammar.y"
1095 { yyval.tparlist = new TParamList(yyvsp[-2].tparam, yyvsp[0].tparlist); ;
1096     break;}
1097 case 32:
1098 #line 187 "xi-grammar.y"
1099 { yyval.tparlist = 0; ;
1100     break;}
1101 case 33:
1102 #line 189 "xi-grammar.y"
1103 { yyval.tparlist = yyvsp[0].tparlist; ;
1104     break;}
1105 case 34:
1106 #line 193 "xi-grammar.y"
1107 { yyval.tparlist = 0; ;
1108     break;}
1109 case 35:
1110 #line 195 "xi-grammar.y"
1111 { yyval.tparlist = yyvsp[-1].tparlist; ;
1112     break;}
1113 case 36:
1114 #line 199 "xi-grammar.y"
1115 { yyval.type = new BuiltinType("int"); ;
1116     break;}
1117 case 37:
1118 #line 201 "xi-grammar.y"
1119 { yyval.type = new BuiltinType("long"); ;
1120     break;}
1121 case 38:
1122 #line 203 "xi-grammar.y"
1123 { yyval.type = new BuiltinType("short"); ;
1124     break;}
1125 case 39:
1126 #line 205 "xi-grammar.y"
1127 { yyval.type = new BuiltinType("char"); ;
1128     break;}
1129 case 40:
1130 #line 207 "xi-grammar.y"
1131 { yyval.type = new BuiltinType("unsigned int"); ;
1132     break;}
1133 case 41:
1134 #line 209 "xi-grammar.y"
1135 { yyval.type = new BuiltinType("long"); ;
1136     break;}
1137 case 42:
1138 #line 211 "xi-grammar.y"
1139 { yyval.type = new BuiltinType("short"); ;
1140     break;}
1141 case 43:
1142 #line 213 "xi-grammar.y"
1143 { yyval.type = new BuiltinType("char"); ;
1144     break;}
1145 case 44:
1146 #line 215 "xi-grammar.y"
1147 { yyval.type = new BuiltinType("long long"); ;
1148     break;}
1149 case 45:
1150 #line 217 "xi-grammar.y"
1151 { yyval.type = new BuiltinType("float"); ;
1152     break;}
1153 case 46:
1154 #line 219 "xi-grammar.y"
1155 { yyval.type = new BuiltinType("double"); ;
1156     break;}
1157 case 47:
1158 #line 221 "xi-grammar.y"
1159 { yyval.type = new BuiltinType("long double"); ;
1160     break;}
1161 case 48:
1162 #line 223 "xi-grammar.y"
1163 { yyval.type = new BuiltinType("void"); ;
1164     break;}
1165 case 49:
1166 #line 227 "xi-grammar.y"
1167 { yyval.ntype = new NamedType(yyvsp[-1].strval, yyvsp[0].tparlist); ;
1168     break;}
1169 case 50:
1170 #line 231 "xi-grammar.y"
1171 { yyval.type = yyvsp[0].type; ;
1172     break;}
1173 case 51:
1174 #line 233 "xi-grammar.y"
1175 { yyval.type = yyvsp[0].ntype; ;
1176     break;}
1177 case 52:
1178 #line 237 "xi-grammar.y"
1179 { yyval.ptype = new PtrType(yyvsp[-1].type); ;
1180     break;}
1181 case 53:
1182 #line 241 "xi-grammar.y"
1183 { yyvsp[-1].ptype->indirect(); yyval.ptype = yyvsp[-1].ptype; ;
1184     break;}
1185 case 54:
1186 #line 243 "xi-grammar.y"
1187 { yyvsp[-1].ptype->indirect(); yyval.ptype = yyvsp[-1].ptype; ;
1188     break;}
1189 case 55:
1190 #line 247 "xi-grammar.y"
1191 { yyval.val = new Value(yyvsp[0].strval); ;
1192     break;}
1193 case 56:
1194 #line 249 "xi-grammar.y"
1195 { yyval.val = new Value(yyvsp[0].strval); ;
1196     break;}
1197 case 57:
1198 #line 253 "xi-grammar.y"
1199 { yyval.type = new ArrayType(yyvsp[-3].type, yyvsp[-1].val); ;
1200     break;}
1201 case 58:
1202 #line 257 "xi-grammar.y"
1203 { yyval.ftype = new FuncType(yyvsp[-7].type, yyvsp[-4].strval, yyvsp[-1].typelist); ;
1204     break;}
1205 case 59:
1206 #line 261 "xi-grammar.y"
1207 { yyval.type = yyvsp[0].type; ;
1208     break;}
1209 case 60:
1210 #line 263 "xi-grammar.y"
1211 { yyval.type = (Type*) yyvsp[0].ptype; ;
1212     break;}
1213 case 61:
1214 #line 265 "xi-grammar.y"
1215 { yyval.type = (Type*) yyvsp[0].ptype; ;
1216     break;}
1217 case 62:
1218 #line 267 "xi-grammar.y"
1219 { yyval.type = yyvsp[0].type; ;
1220     break;}
1221 case 63:
1222 #line 269 "xi-grammar.y"
1223 { yyval.type = yyvsp[0].ftype; ;
1224     break;}
1225 case 64:
1226 #line 273 "xi-grammar.y"
1227 { yyval.typelist = 0; ;
1228     break;}
1229 case 65:
1230 #line 275 "xi-grammar.y"
1231 { yyval.typelist = new TypeList(yyvsp[0].type); ;
1232     break;}
1233 case 66:
1234 #line 277 "xi-grammar.y"
1235 { yyval.typelist = new TypeList(yyvsp[-2].type, yyvsp[0].typelist); ;
1236     break;}
1237 case 67:
1238 #line 281 "xi-grammar.y"
1239 { yyval.val = yyvsp[-1].val; ;
1240     break;}
1241 case 68:
1242 #line 285 "xi-grammar.y"
1243 { yyval.vallist = 0; ;
1244     break;}
1245 case 69:
1246 #line 287 "xi-grammar.y"
1247 { yyval.vallist = new ValueList(yyvsp[-1].val, yyvsp[0].vallist); ;
1248     break;}
1249 case 70:
1250 #line 291 "xi-grammar.y"
1251 { yyval.readonly = new Readonly(lineno, yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].vallist); ;
1252     break;}
1253 case 71:
1254 #line 295 "xi-grammar.y"
1255 { yyval.readonly = new Readonly(lineno, yyvsp[-2].type, yyvsp[0].strval, 0, 1); ;
1256     break;}
1257 case 72:
1258 #line 299 "xi-grammar.y"
1259 { yyval.intval = 0; ;
1260     break;}
1261 case 73:
1262 #line 301 "xi-grammar.y"
1263 { yyval.intval = yyvsp[-1].intval; ;
1264     break;}
1265 case 74:
1266 #line 305 "xi-grammar.y"
1267 { yyval.intval = yyvsp[0].intval; ;
1268     break;}
1269 case 75:
1270 #line 307 "xi-grammar.y"
1271 { yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
1272     break;}
1273 case 76:
1274 #line 311 "xi-grammar.y"
1275 { yyval.intval = SPACKED; ;
1276     break;}
1277 case 77:
1278 #line 313 "xi-grammar.y"
1279 { yyval.intval = SVARSIZE; ;
1280     break;}
1281 case 78:
1282 #line 317 "xi-grammar.y"
1283 { yyval.intval = 0; ;
1284     break;}
1285 case 79:
1286 #line 319 "xi-grammar.y"
1287 { yyval.intval = yyvsp[-1].intval; ;
1288     break;}
1289 case 80:
1290 #line 323 "xi-grammar.y"
1291 { yyval.intval = yyvsp[0].intval; ;
1292     break;}
1293 case 81:
1294 #line 325 "xi-grammar.y"
1295 { yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
1296     break;}
1297 case 82:
1298 #line 329 "xi-grammar.y"
1299 { yyval.intval = 0x01; ;
1300     break;}
1301 case 83:
1302 #line 333 "xi-grammar.y"
1303 { yyval.mv = new MsgVar(yyvsp[-4].type, yyvsp[-3].strval); ;
1304     break;}
1305 case 84:
1306 #line 337 "xi-grammar.y"
1307 { yyval.mvlist = new MsgVarList(yyvsp[0].mv); ;
1308     break;}
1309 case 85:
1310 #line 339 "xi-grammar.y"
1311 { yyval.mvlist = new MsgVarList(yyvsp[-1].mv, yyvsp[0].mvlist); ;
1312     break;}
1313 case 86:
1314 #line 343 "xi-grammar.y"
1315 { yyval.message = new Message(lineno, yyvsp[0].ntype, yyvsp[-1].intval); ;
1316     break;}
1317 case 87:
1318 #line 345 "xi-grammar.y"
1319 { yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-4].intval, yyvsp[-1].typelist); ;
1320     break;}
1321 case 88:
1322 #line 347 "xi-grammar.y"
1323 { yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-4].intval, 0, yyvsp[-1].mvlist); ;
1324     break;}
1325 case 89:
1326 #line 351 "xi-grammar.y"
1327 { yyval.typelist = 0; ;
1328     break;}
1329 case 90:
1330 #line 353 "xi-grammar.y"
1331 { yyval.typelist = yyvsp[0].typelist; ;
1332     break;}
1333 case 91:
1334 #line 357 "xi-grammar.y"
1335 { yyval.typelist = new TypeList(yyvsp[0].ntype); ;
1336     break;}
1337 case 92:
1338 #line 359 "xi-grammar.y"
1339 { yyval.typelist = new TypeList(yyvsp[-2].ntype, yyvsp[0].typelist); ;
1340     break;}
1341 case 93:
1342 #line 363 "xi-grammar.y"
1343 { yyval.chare = new Chare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1344     break;}
1345 case 94:
1346 #line 365 "xi-grammar.y"
1347 { yyval.chare = new MainChare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1348     break;}
1349 case 95:
1350 #line 369 "xi-grammar.y"
1351 { yyval.chare = new Group(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1352     break;}
1353 case 96:
1354 #line 373 "xi-grammar.y"
1355 { yyval.chare = new NodeGroup(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1356     break;}
1357 case 97:
1358 #line 377 "xi-grammar.y"
1359 {/*Stupid special case for [1D] indices*/
1360                         char *buf=new char[40];
1361                         sprintf(buf,"%sD",yyvsp[-2].strval);
1362                         yyval.ntype = new NamedType(buf); 
1363                 ;
1364     break;}
1365 case 98:
1366 #line 383 "xi-grammar.y"
1367 { yyval.ntype = new NamedType(yyvsp[-1].strval); ;
1368     break;}
1369 case 99:
1370 #line 387 "xi-grammar.y"
1371 { yyval.chare = new Array(lineno, yyvsp[-3].ntype, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
1372     break;}
1373 case 100:
1374 #line 391 "xi-grammar.y"
1375 { yyval.chare = new Chare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval);;
1376     break;}
1377 case 101:
1378 #line 393 "xi-grammar.y"
1379 { yyval.chare = new MainChare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1380     break;}
1381 case 102:
1382 #line 397 "xi-grammar.y"
1383 { yyval.chare = new Group(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1384     break;}
1385 case 103:
1386 #line 401 "xi-grammar.y"
1387 { yyval.chare = new NodeGroup( lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1388     break;}
1389 case 104:
1390 #line 405 "xi-grammar.y"
1391 { yyval.chare = new Array( lineno, yyvsp[-3].ntype, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
1392     break;}
1393 case 105:
1394 #line 409 "xi-grammar.y"
1395 { yyval.message = new Message(lineno, new NamedType(yyvsp[-1].strval), yyvsp[-2].intval); ;
1396     break;}
1397 case 106:
1398 #line 413 "xi-grammar.y"
1399 { yyval.type = 0; ;
1400     break;}
1401 case 107:
1402 #line 415 "xi-grammar.y"
1403 { yyval.type = yyvsp[0].type; ;
1404     break;}
1405 case 108:
1406 #line 419 "xi-grammar.y"
1407 { yyval.strval = 0; ;
1408     break;}
1409 case 109:
1410 #line 421 "xi-grammar.y"
1411 { yyval.strval = yyvsp[0].strval; ;
1412     break;}
1413 case 110:
1414 #line 423 "xi-grammar.y"
1415 { yyval.strval = yyvsp[0].strval; ;
1416     break;}
1417 case 111:
1418 #line 427 "xi-grammar.y"
1419 { yyval.tvar = new TType(new NamedType(yyvsp[-1].strval), yyvsp[0].type); ;
1420     break;}
1421 case 112:
1422 #line 429 "xi-grammar.y"
1423 { yyval.tvar = new TFunc(yyvsp[-1].ftype, yyvsp[0].strval); ;
1424     break;}
1425 case 113:
1426 #line 431 "xi-grammar.y"
1427 { yyval.tvar = new TName(yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].strval); ;
1428     break;}
1429 case 114:
1430 #line 435 "xi-grammar.y"
1431 { yyval.tvarlist = new TVarList(yyvsp[0].tvar); ;
1432     break;}
1433 case 115:
1434 #line 437 "xi-grammar.y"
1435 { yyval.tvarlist = new TVarList(yyvsp[-2].tvar, yyvsp[0].tvarlist); ;
1436     break;}
1437 case 116:
1438 #line 441 "xi-grammar.y"
1439 { yyval.tvarlist = yyvsp[-1].tvarlist; ;
1440     break;}
1441 case 117:
1442 #line 445 "xi-grammar.y"
1443 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1444     break;}
1445 case 118:
1446 #line 447 "xi-grammar.y"
1447 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1448     break;}
1449 case 119:
1450 #line 449 "xi-grammar.y"
1451 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1452     break;}
1453 case 120:
1454 #line 451 "xi-grammar.y"
1455 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1456     break;}
1457 case 121:
1458 #line 453 "xi-grammar.y"
1459 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].message); yyvsp[0].message->setTemplate(yyval.templat); ;
1460     break;}
1461 case 122:
1462 #line 457 "xi-grammar.y"
1463 { yyval.mbrlist = 0; ;
1464     break;}
1465 case 123:
1466 #line 459 "xi-grammar.y"
1467 { yyval.mbrlist = yyvsp[-2].mbrlist; ;
1468     break;}
1469 case 124:
1470 #line 463 "xi-grammar.y"
1471 { yyval.mbrlist = 0; ;
1472     break;}
1473 case 125:
1474 #line 465 "xi-grammar.y"
1475 { yyval.mbrlist = new MemberList(yyvsp[-1].member, yyvsp[0].mbrlist); ;
1476     break;}
1477 case 126:
1478 #line 469 "xi-grammar.y"
1479 { yyval.member = yyvsp[-1].entry; ;
1480     break;}
1481 case 127:
1482 #line 471 "xi-grammar.y"
1483 { yyval.member = yyvsp[-1].readonly; ;
1484     break;}
1485 case 128:
1486 #line 473 "xi-grammar.y"
1487 { yyval.member = yyvsp[-1].readonly; ;
1488     break;}
1489 case 129:
1490 #line 477 "xi-grammar.y"
1491 { yyval.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, new BuiltinType("void"), yyvsp[-3].strval, yyvsp[-2].rtype, yyvsp[0].val); ;
1492     break;}
1493 case 130:
1494 #line 479 "xi-grammar.y"
1495 { yyval.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, yyvsp[-4].ptype, yyvsp[-3].strval, yyvsp[-2].rtype, yyvsp[0].val); ;
1496     break;}
1497 case 131:
1498 #line 481 "xi-grammar.y"
1499 { yyval.entry = new Entry(lineno, yyvsp[-2].intval, 0, yyvsp[-1].strval, yyvsp[0].rtype, 0); ;
1500     break;}
1501 case 132:
1502 #line 485 "xi-grammar.y"
1503 { yyval.intval = 0; ;
1504     break;}
1505 case 133:
1506 #line 487 "xi-grammar.y"
1507 { yyval.intval = yyvsp[-1].intval; ;
1508     break;}
1509 case 134:
1510 #line 491 "xi-grammar.y"
1511 { yyval.intval = yyvsp[0].intval; ;
1512     break;}
1513 case 135:
1514 #line 493 "xi-grammar.y"
1515 { yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
1516     break;}
1517 case 136:
1518 #line 497 "xi-grammar.y"
1519 { yyval.intval = STHREADED; ;
1520     break;}
1521 case 137:
1522 #line 499 "xi-grammar.y"
1523 { yyval.intval = SSYNC; ;
1524     break;}
1525 case 138:
1526 #line 501 "xi-grammar.y"
1527 { yyval.intval = SLOCKED; ;
1528     break;}
1529 case 139:
1530 #line 503 "xi-grammar.y"
1531 { yyval.intval = SVIRTUAL; ;
1532     break;}
1533 case 140:
1534 #line 507 "xi-grammar.y"
1535 { yyval.rtype = 0; ;
1536     break;}
1537 case 141:
1538 #line 509 "xi-grammar.y"
1539 { yyval.rtype = new BuiltinType("void"); ;
1540     break;}
1541 case 142:
1542 #line 511 "xi-grammar.y"
1543 { yyval.rtype = yyvsp[0].ptype; ;
1544     break;}
1545 case 143:
1546 #line 515 "xi-grammar.y"
1547 { yyval.rtype = yyvsp[-1].rtype; ;
1548     break;}
1549 case 144:
1550 #line 519 "xi-grammar.y"
1551 { yyval.val = 0; ;
1552     break;}
1553 case 145:
1554 #line 521 "xi-grammar.y"
1555 { yyval.val = new Value(yyvsp[0].strval); ;
1556     break;}
1557 case 146:
1558 #line 525 "xi-grammar.y"
1559 { yyval.intval = 0; ;
1560     break;}
1561 case 147:
1562 #line 527 "xi-grammar.y"
1563 { if(strcmp(yyvsp[0].strval, "0")) { yyerror("expected 0"); exit(1); }
1564                   yyval.intval = SPURE; 
1565                 ;
1566     break;}
1567 }
1568    /* the action file gets copied in in place of this dollarsign */
1569 #line 543 "/home/csar2/bhandark/share/bison.simple"
1570 \f
1571   yyvsp -= yylen;
1572   yyssp -= yylen;
1573 #ifdef YYLSP_NEEDED
1574   yylsp -= yylen;
1575 #endif
1576
1577 #if YYDEBUG != 0
1578   if (yydebug)
1579     {
1580       short *ssp1 = yyss - 1;
1581       fprintf (stderr, "state stack now");
1582       while (ssp1 != yyssp)
1583         fprintf (stderr, " %d", *++ssp1);
1584       fprintf (stderr, "\n");
1585     }
1586 #endif
1587
1588   *++yyvsp = yyval;
1589
1590 #ifdef YYLSP_NEEDED
1591   yylsp++;
1592   if (yylen == 0)
1593     {
1594       yylsp->first_line = yylloc.first_line;
1595       yylsp->first_column = yylloc.first_column;
1596       yylsp->last_line = (yylsp-1)->last_line;
1597       yylsp->last_column = (yylsp-1)->last_column;
1598       yylsp->text = 0;
1599     }
1600   else
1601     {
1602       yylsp->last_line = (yylsp+yylen-1)->last_line;
1603       yylsp->last_column = (yylsp+yylen-1)->last_column;
1604     }
1605 #endif
1606
1607   /* Now "shift" the result of the reduction.
1608      Determine what state that goes to,
1609      based on the state we popped back to
1610      and the rule number reduced by.  */
1611
1612   yyn = yyr1[yyn];
1613
1614   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1615   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1616     yystate = yytable[yystate];
1617   else
1618     yystate = yydefgoto[yyn - YYNTBASE];
1619
1620   goto yynewstate;
1621
1622 yyerrlab:   /* here on detecting error */
1623
1624   if (! yyerrstatus)
1625     /* If not already recovering from an error, report this error.  */
1626     {
1627       ++yynerrs;
1628
1629 #ifdef YYERROR_VERBOSE
1630       yyn = yypact[yystate];
1631
1632       if (yyn > YYFLAG && yyn < YYLAST)
1633         {
1634           int size = 0;
1635           char *msg;
1636           int x, count;
1637
1638           count = 0;
1639           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1640           for (x = (yyn < 0 ? -yyn : 0);
1641                x < (sizeof(yytname) / sizeof(char *)); x++)
1642             if (yycheck[x + yyn] == x)
1643               size += strlen(yytname[x]) + 15, count++;
1644           msg = (char *) malloc(size + 15);
1645           if (msg != 0)
1646             {
1647               strcpy(msg, "parse error");
1648
1649               if (count < 5)
1650                 {
1651                   count = 0;
1652                   for (x = (yyn < 0 ? -yyn : 0);
1653                        x < (sizeof(yytname) / sizeof(char *)); x++)
1654                     if (yycheck[x + yyn] == x)
1655                       {
1656                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1657                         strcat(msg, yytname[x]);
1658                         strcat(msg, "'");
1659                         count++;
1660                       }
1661                 }
1662               yyerror(msg);
1663               free(msg);
1664             }
1665           else
1666             yyerror ("parse error; also virtual memory exceeded");
1667         }
1668       else
1669 #endif /* YYERROR_VERBOSE */
1670         yyerror("parse error");
1671     }
1672
1673   goto yyerrlab1;
1674 yyerrlab1:   /* here on error raised explicitly by an action */
1675
1676   if (yyerrstatus == 3)
1677     {
1678       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1679
1680       /* return failure if at end of input */
1681       if (yychar == YYEOF)
1682         YYABORT;
1683
1684 #if YYDEBUG != 0
1685       if (yydebug)
1686         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1687 #endif
1688
1689       yychar = YYEMPTY;
1690     }
1691
1692   /* Else will try to reuse lookahead token
1693      after shifting the error token.  */
1694
1695   yyerrstatus = 3;              /* Each real token shifted decrements this */
1696
1697   goto yyerrhandle;
1698
1699 yyerrdefault:  /* current state does not do anything special for the error token. */
1700
1701 #if 0
1702   /* This is wrong; only states that explicitly want error tokens
1703      should shift them.  */
1704   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1705   if (yyn) goto yydefault;
1706 #endif
1707
1708 yyerrpop:   /* pop the current state because it cannot handle the error token */
1709
1710   if (yyssp == yyss) YYABORT;
1711   yyvsp--;
1712   yystate = *--yyssp;
1713 #ifdef YYLSP_NEEDED
1714   yylsp--;
1715 #endif
1716
1717 #if YYDEBUG != 0
1718   if (yydebug)
1719     {
1720       short *ssp1 = yyss - 1;
1721       fprintf (stderr, "Error: state stack now");
1722       while (ssp1 != yyssp)
1723         fprintf (stderr, " %d", *++ssp1);
1724       fprintf (stderr, "\n");
1725     }
1726 #endif
1727
1728 yyerrhandle:
1729
1730   yyn = yypact[yystate];
1731   if (yyn == YYFLAG)
1732     goto yyerrdefault;
1733
1734   yyn += YYTERROR;
1735   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1736     goto yyerrdefault;
1737
1738   yyn = yytable[yyn];
1739   if (yyn < 0)
1740     {
1741       if (yyn == YYFLAG)
1742         goto yyerrpop;
1743       yyn = -yyn;
1744       goto yyreduce;
1745     }
1746   else if (yyn == 0)
1747     goto yyerrpop;
1748
1749   if (yyn == YYFINAL)
1750     YYACCEPT;
1751
1752 #if YYDEBUG != 0
1753   if (yydebug)
1754     fprintf(stderr, "Shifting error token, ");
1755 #endif
1756
1757   *++yyvsp = yylval;
1758 #ifdef YYLSP_NEEDED
1759   *++yylsp = yylloc;
1760 #endif
1761
1762   yystate = yyn;
1763   goto yynewstate;
1764
1765  yyacceptlab:
1766   /* YYACCEPT comes here.  */
1767   if (yyfree_stacks)
1768     {
1769       free (yyss);
1770       free (yyvs);
1771 #ifdef YYLSP_NEEDED
1772       free (yyls);
1773 #endif
1774     }
1775   return 0;
1776
1777  yyabortlab:
1778   /* YYABORT comes here.  */
1779   if (yyfree_stacks)
1780     {
1781       free (yyss);
1782       free (yyvs);
1783 #ifdef YYLSP_NEEDED
1784       free (yyls);
1785 #endif
1786     }
1787   return 1;
1788 }
1789 #line 531 "xi-grammar.y"
1790
1791 void yyerror(const char *mesg)
1792 {
1793   cout << "Syntax error at line " << lineno << ": " << mesg << endl;
1794   // return 0;
1795 }