Got rid of message attributes (varsize and packed).
[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,   310,   312,   316,   318,   322,   324,   328,
210    330,   334,   338,   342,   344,   348,   350,   352,   356,   358,
211    362,   364,   368,   370,   374,   378,   382,   388,   392,   396,
212    398,   402,   406,   410,   414,   418,   420,   424,   426,   428,
213    432,   434,   436,   440,   442,   446,   450,   452,   454,   456,
214    458,   462,   464,   468,   470,   474,   476,   478,   482,   484,
215    486,   490,   492,   496,   498,   502,   504,   506,   508,   512,
216    514,   516,   520,   524,   526,   530,   532
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 "/usr/lib/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 "/usr/lib/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
1264                   /*
1265                   printf("Warning: Message attributes are being phased out.\n");
1266                   printf("Warning: Please remove them from interface files.\n");
1267                   */
1268                   yyval.intval = yyvsp[-1].intval; 
1269                 ;
1270     break;}
1271 case 74:
1272 #line 311 "xi-grammar.y"
1273 { yyval.intval = yyvsp[0].intval; ;
1274     break;}
1275 case 75:
1276 #line 313 "xi-grammar.y"
1277 { yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
1278     break;}
1279 case 76:
1280 #line 317 "xi-grammar.y"
1281 { yyval.intval = 0; ;
1282     break;}
1283 case 77:
1284 #line 319 "xi-grammar.y"
1285 { yyval.intval = 0; ;
1286     break;}
1287 case 78:
1288 #line 323 "xi-grammar.y"
1289 { yyval.intval = 0; ;
1290     break;}
1291 case 79:
1292 #line 325 "xi-grammar.y"
1293 { yyval.intval = yyvsp[-1].intval; ;
1294     break;}
1295 case 80:
1296 #line 329 "xi-grammar.y"
1297 { yyval.intval = yyvsp[0].intval; ;
1298     break;}
1299 case 81:
1300 #line 331 "xi-grammar.y"
1301 { yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
1302     break;}
1303 case 82:
1304 #line 335 "xi-grammar.y"
1305 { yyval.intval = 0x01; ;
1306     break;}
1307 case 83:
1308 #line 339 "xi-grammar.y"
1309 { yyval.mv = new MsgVar(yyvsp[-4].type, yyvsp[-3].strval); ;
1310     break;}
1311 case 84:
1312 #line 343 "xi-grammar.y"
1313 { yyval.mvlist = new MsgVarList(yyvsp[0].mv); ;
1314     break;}
1315 case 85:
1316 #line 345 "xi-grammar.y"
1317 { yyval.mvlist = new MsgVarList(yyvsp[-1].mv, yyvsp[0].mvlist); ;
1318     break;}
1319 case 86:
1320 #line 349 "xi-grammar.y"
1321 { yyval.message = new Message(lineno, yyvsp[0].ntype); ;
1322     break;}
1323 case 87:
1324 #line 351 "xi-grammar.y"
1325 { yyval.message = new Message(lineno, yyvsp[-3].ntype, yyvsp[-1].typelist); ;
1326     break;}
1327 case 88:
1328 #line 353 "xi-grammar.y"
1329 { yyval.message = new Message(lineno, yyvsp[-3].ntype, 0, yyvsp[-1].mvlist); ;
1330     break;}
1331 case 89:
1332 #line 357 "xi-grammar.y"
1333 { yyval.typelist = 0; ;
1334     break;}
1335 case 90:
1336 #line 359 "xi-grammar.y"
1337 { yyval.typelist = yyvsp[0].typelist; ;
1338     break;}
1339 case 91:
1340 #line 363 "xi-grammar.y"
1341 { yyval.typelist = new TypeList(yyvsp[0].ntype); ;
1342     break;}
1343 case 92:
1344 #line 365 "xi-grammar.y"
1345 { yyval.typelist = new TypeList(yyvsp[-2].ntype, yyvsp[0].typelist); ;
1346     break;}
1347 case 93:
1348 #line 369 "xi-grammar.y"
1349 { yyval.chare = new Chare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1350     break;}
1351 case 94:
1352 #line 371 "xi-grammar.y"
1353 { yyval.chare = new MainChare(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1354     break;}
1355 case 95:
1356 #line 375 "xi-grammar.y"
1357 { yyval.chare = new Group(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1358     break;}
1359 case 96:
1360 #line 379 "xi-grammar.y"
1361 { yyval.chare = new NodeGroup(lineno, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1362     break;}
1363 case 97:
1364 #line 383 "xi-grammar.y"
1365 {/*Stupid special case for [1D] indices*/
1366                         char *buf=new char[40];
1367                         sprintf(buf,"%sD",yyvsp[-2].strval);
1368                         yyval.ntype = new NamedType(buf); 
1369                 ;
1370     break;}
1371 case 98:
1372 #line 389 "xi-grammar.y"
1373 { yyval.ntype = new NamedType(yyvsp[-1].strval); ;
1374     break;}
1375 case 99:
1376 #line 393 "xi-grammar.y"
1377 { yyval.chare = new Array(lineno, yyvsp[-3].ntype, yyvsp[-2].ntype, yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
1378     break;}
1379 case 100:
1380 #line 397 "xi-grammar.y"
1381 { yyval.chare = new Chare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval);;
1382     break;}
1383 case 101:
1384 #line 399 "xi-grammar.y"
1385 { yyval.chare = new MainChare(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1386     break;}
1387 case 102:
1388 #line 403 "xi-grammar.y"
1389 { yyval.chare = new Group(lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1390     break;}
1391 case 103:
1392 #line 407 "xi-grammar.y"
1393 { yyval.chare = new NodeGroup( lineno, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist, yyvsp[-3].intval); ;
1394     break;}
1395 case 104:
1396 #line 411 "xi-grammar.y"
1397 { yyval.chare = new Array( lineno, yyvsp[-3].ntype, new NamedType(yyvsp[-2].strval), yyvsp[-1].typelist, yyvsp[0].mbrlist); ;
1398     break;}
1399 case 105:
1400 #line 415 "xi-grammar.y"
1401 { yyval.message = new Message(lineno, new NamedType(yyvsp[-1].strval)); ;
1402     break;}
1403 case 106:
1404 #line 419 "xi-grammar.y"
1405 { yyval.type = 0; ;
1406     break;}
1407 case 107:
1408 #line 421 "xi-grammar.y"
1409 { yyval.type = yyvsp[0].type; ;
1410     break;}
1411 case 108:
1412 #line 425 "xi-grammar.y"
1413 { yyval.strval = 0; ;
1414     break;}
1415 case 109:
1416 #line 427 "xi-grammar.y"
1417 { yyval.strval = yyvsp[0].strval; ;
1418     break;}
1419 case 110:
1420 #line 429 "xi-grammar.y"
1421 { yyval.strval = yyvsp[0].strval; ;
1422     break;}
1423 case 111:
1424 #line 433 "xi-grammar.y"
1425 { yyval.tvar = new TType(new NamedType(yyvsp[-1].strval), yyvsp[0].type); ;
1426     break;}
1427 case 112:
1428 #line 435 "xi-grammar.y"
1429 { yyval.tvar = new TFunc(yyvsp[-1].ftype, yyvsp[0].strval); ;
1430     break;}
1431 case 113:
1432 #line 437 "xi-grammar.y"
1433 { yyval.tvar = new TName(yyvsp[-2].type, yyvsp[-1].strval, yyvsp[0].strval); ;
1434     break;}
1435 case 114:
1436 #line 441 "xi-grammar.y"
1437 { yyval.tvarlist = new TVarList(yyvsp[0].tvar); ;
1438     break;}
1439 case 115:
1440 #line 443 "xi-grammar.y"
1441 { yyval.tvarlist = new TVarList(yyvsp[-2].tvar, yyvsp[0].tvarlist); ;
1442     break;}
1443 case 116:
1444 #line 447 "xi-grammar.y"
1445 { yyval.tvarlist = yyvsp[-1].tvarlist; ;
1446     break;}
1447 case 117:
1448 #line 451 "xi-grammar.y"
1449 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1450     break;}
1451 case 118:
1452 #line 453 "xi-grammar.y"
1453 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1454     break;}
1455 case 119:
1456 #line 455 "xi-grammar.y"
1457 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1458     break;}
1459 case 120:
1460 #line 457 "xi-grammar.y"
1461 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].chare); yyvsp[0].chare->setTemplate(yyval.templat); ;
1462     break;}
1463 case 121:
1464 #line 459 "xi-grammar.y"
1465 { yyval.templat = new Template(yyvsp[-1].tvarlist, yyvsp[0].message); yyvsp[0].message->setTemplate(yyval.templat); ;
1466     break;}
1467 case 122:
1468 #line 463 "xi-grammar.y"
1469 { yyval.mbrlist = 0; ;
1470     break;}
1471 case 123:
1472 #line 465 "xi-grammar.y"
1473 { yyval.mbrlist = yyvsp[-2].mbrlist; ;
1474     break;}
1475 case 124:
1476 #line 469 "xi-grammar.y"
1477 { yyval.mbrlist = 0; ;
1478     break;}
1479 case 125:
1480 #line 471 "xi-grammar.y"
1481 { yyval.mbrlist = new MemberList(yyvsp[-1].member, yyvsp[0].mbrlist); ;
1482     break;}
1483 case 126:
1484 #line 475 "xi-grammar.y"
1485 { yyval.member = yyvsp[-1].entry; ;
1486     break;}
1487 case 127:
1488 #line 477 "xi-grammar.y"
1489 { yyval.member = yyvsp[-1].readonly; ;
1490     break;}
1491 case 128:
1492 #line 479 "xi-grammar.y"
1493 { yyval.member = yyvsp[-1].readonly; ;
1494     break;}
1495 case 129:
1496 #line 483 "xi-grammar.y"
1497 { yyval.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, new BuiltinType("void"), yyvsp[-3].strval, yyvsp[-2].rtype, yyvsp[0].val); ;
1498     break;}
1499 case 130:
1500 #line 485 "xi-grammar.y"
1501 { yyval.entry = new Entry(lineno, yyvsp[-5].intval|yyvsp[-1].intval, yyvsp[-4].ptype, yyvsp[-3].strval, yyvsp[-2].rtype, yyvsp[0].val); ;
1502     break;}
1503 case 131:
1504 #line 487 "xi-grammar.y"
1505 { yyval.entry = new Entry(lineno, yyvsp[-2].intval, 0, yyvsp[-1].strval, yyvsp[0].rtype, 0); ;
1506     break;}
1507 case 132:
1508 #line 491 "xi-grammar.y"
1509 { yyval.intval = 0; ;
1510     break;}
1511 case 133:
1512 #line 493 "xi-grammar.y"
1513 { yyval.intval = yyvsp[-1].intval; ;
1514     break;}
1515 case 134:
1516 #line 497 "xi-grammar.y"
1517 { yyval.intval = yyvsp[0].intval; ;
1518     break;}
1519 case 135:
1520 #line 499 "xi-grammar.y"
1521 { yyval.intval = yyvsp[-2].intval | yyvsp[0].intval; ;
1522     break;}
1523 case 136:
1524 #line 503 "xi-grammar.y"
1525 { yyval.intval = STHREADED; ;
1526     break;}
1527 case 137:
1528 #line 505 "xi-grammar.y"
1529 { yyval.intval = SSYNC; ;
1530     break;}
1531 case 138:
1532 #line 507 "xi-grammar.y"
1533 { yyval.intval = SLOCKED; ;
1534     break;}
1535 case 139:
1536 #line 509 "xi-grammar.y"
1537 { yyval.intval = SVIRTUAL; ;
1538     break;}
1539 case 140:
1540 #line 513 "xi-grammar.y"
1541 { yyval.rtype = 0; ;
1542     break;}
1543 case 141:
1544 #line 515 "xi-grammar.y"
1545 { yyval.rtype = new BuiltinType("void"); ;
1546     break;}
1547 case 142:
1548 #line 517 "xi-grammar.y"
1549 { yyval.rtype = yyvsp[0].ptype; ;
1550     break;}
1551 case 143:
1552 #line 521 "xi-grammar.y"
1553 { yyval.rtype = yyvsp[-1].rtype; ;
1554     break;}
1555 case 144:
1556 #line 525 "xi-grammar.y"
1557 { yyval.val = 0; ;
1558     break;}
1559 case 145:
1560 #line 527 "xi-grammar.y"
1561 { yyval.val = new Value(yyvsp[0].strval); ;
1562     break;}
1563 case 146:
1564 #line 531 "xi-grammar.y"
1565 { yyval.intval = 0; ;
1566     break;}
1567 case 147:
1568 #line 533 "xi-grammar.y"
1569 { if(strcmp(yyvsp[0].strval, "0")) { yyerror("expected 0"); exit(1); }
1570                   yyval.intval = SPURE; 
1571                 ;
1572     break;}
1573 }
1574    /* the action file gets copied in in place of this dollarsign */
1575 #line 543 "/usr/lib/bison.simple"
1576 \f
1577   yyvsp -= yylen;
1578   yyssp -= yylen;
1579 #ifdef YYLSP_NEEDED
1580   yylsp -= yylen;
1581 #endif
1582
1583 #if YYDEBUG != 0
1584   if (yydebug)
1585     {
1586       short *ssp1 = yyss - 1;
1587       fprintf (stderr, "state stack now");
1588       while (ssp1 != yyssp)
1589         fprintf (stderr, " %d", *++ssp1);
1590       fprintf (stderr, "\n");
1591     }
1592 #endif
1593
1594   *++yyvsp = yyval;
1595
1596 #ifdef YYLSP_NEEDED
1597   yylsp++;
1598   if (yylen == 0)
1599     {
1600       yylsp->first_line = yylloc.first_line;
1601       yylsp->first_column = yylloc.first_column;
1602       yylsp->last_line = (yylsp-1)->last_line;
1603       yylsp->last_column = (yylsp-1)->last_column;
1604       yylsp->text = 0;
1605     }
1606   else
1607     {
1608       yylsp->last_line = (yylsp+yylen-1)->last_line;
1609       yylsp->last_column = (yylsp+yylen-1)->last_column;
1610     }
1611 #endif
1612
1613   /* Now "shift" the result of the reduction.
1614      Determine what state that goes to,
1615      based on the state we popped back to
1616      and the rule number reduced by.  */
1617
1618   yyn = yyr1[yyn];
1619
1620   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1621   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1622     yystate = yytable[yystate];
1623   else
1624     yystate = yydefgoto[yyn - YYNTBASE];
1625
1626   goto yynewstate;
1627
1628 yyerrlab:   /* here on detecting error */
1629
1630   if (! yyerrstatus)
1631     /* If not already recovering from an error, report this error.  */
1632     {
1633       ++yynerrs;
1634
1635 #ifdef YYERROR_VERBOSE
1636       yyn = yypact[yystate];
1637
1638       if (yyn > YYFLAG && yyn < YYLAST)
1639         {
1640           int size = 0;
1641           char *msg;
1642           int x, count;
1643
1644           count = 0;
1645           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1646           for (x = (yyn < 0 ? -yyn : 0);
1647                x < (sizeof(yytname) / sizeof(char *)); x++)
1648             if (yycheck[x + yyn] == x)
1649               size += strlen(yytname[x]) + 15, count++;
1650           msg = (char *) malloc(size + 15);
1651           if (msg != 0)
1652             {
1653               strcpy(msg, "parse error");
1654
1655               if (count < 5)
1656                 {
1657                   count = 0;
1658                   for (x = (yyn < 0 ? -yyn : 0);
1659                        x < (sizeof(yytname) / sizeof(char *)); x++)
1660                     if (yycheck[x + yyn] == x)
1661                       {
1662                         strcat(msg, count == 0 ? ", expecting `" : " or `");
1663                         strcat(msg, yytname[x]);
1664                         strcat(msg, "'");
1665                         count++;
1666                       }
1667                 }
1668               yyerror(msg);
1669               free(msg);
1670             }
1671           else
1672             yyerror ("parse error; also virtual memory exceeded");
1673         }
1674       else
1675 #endif /* YYERROR_VERBOSE */
1676         yyerror("parse error");
1677     }
1678
1679   goto yyerrlab1;
1680 yyerrlab1:   /* here on error raised explicitly by an action */
1681
1682   if (yyerrstatus == 3)
1683     {
1684       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1685
1686       /* return failure if at end of input */
1687       if (yychar == YYEOF)
1688         YYABORT;
1689
1690 #if YYDEBUG != 0
1691       if (yydebug)
1692         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1693 #endif
1694
1695       yychar = YYEMPTY;
1696     }
1697
1698   /* Else will try to reuse lookahead token
1699      after shifting the error token.  */
1700
1701   yyerrstatus = 3;              /* Each real token shifted decrements this */
1702
1703   goto yyerrhandle;
1704
1705 yyerrdefault:  /* current state does not do anything special for the error token. */
1706
1707 #if 0
1708   /* This is wrong; only states that explicitly want error tokens
1709      should shift them.  */
1710   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1711   if (yyn) goto yydefault;
1712 #endif
1713
1714 yyerrpop:   /* pop the current state because it cannot handle the error token */
1715
1716   if (yyssp == yyss) YYABORT;
1717   yyvsp--;
1718   yystate = *--yyssp;
1719 #ifdef YYLSP_NEEDED
1720   yylsp--;
1721 #endif
1722
1723 #if YYDEBUG != 0
1724   if (yydebug)
1725     {
1726       short *ssp1 = yyss - 1;
1727       fprintf (stderr, "Error: state stack now");
1728       while (ssp1 != yyssp)
1729         fprintf (stderr, " %d", *++ssp1);
1730       fprintf (stderr, "\n");
1731     }
1732 #endif
1733
1734 yyerrhandle:
1735
1736   yyn = yypact[yystate];
1737   if (yyn == YYFLAG)
1738     goto yyerrdefault;
1739
1740   yyn += YYTERROR;
1741   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1742     goto yyerrdefault;
1743
1744   yyn = yytable[yyn];
1745   if (yyn < 0)
1746     {
1747       if (yyn == YYFLAG)
1748         goto yyerrpop;
1749       yyn = -yyn;
1750       goto yyreduce;
1751     }
1752   else if (yyn == 0)
1753     goto yyerrpop;
1754
1755   if (yyn == YYFINAL)
1756     YYACCEPT;
1757
1758 #if YYDEBUG != 0
1759   if (yydebug)
1760     fprintf(stderr, "Shifting error token, ");
1761 #endif
1762
1763   *++yyvsp = yylval;
1764 #ifdef YYLSP_NEEDED
1765   *++yylsp = yylloc;
1766 #endif
1767
1768   yystate = yyn;
1769   goto yynewstate;
1770
1771  yyacceptlab:
1772   /* YYACCEPT comes here.  */
1773   if (yyfree_stacks)
1774     {
1775       free (yyss);
1776       free (yyvs);
1777 #ifdef YYLSP_NEEDED
1778       free (yyls);
1779 #endif
1780     }
1781   return 0;
1782
1783  yyabortlab:
1784   /* YYABORT comes here.  */
1785   if (yyfree_stacks)
1786     {
1787       free (yyss);
1788       free (yyvs);
1789 #ifdef YYLSP_NEEDED
1790       free (yyls);
1791 #endif
1792     }
1793   return 1;
1794 }
1795 #line 537 "xi-grammar.y"
1796
1797 void yyerror(const char *mesg)
1798 {
1799   cout << "Syntax error at line " << lineno << ": " << mesg << endl;
1800   // return 0;
1801 }