Initial revision
[charm.git] / src / xlat-i / xi-parse.tab.C
1
2 /*  A Bison parser, made from xi-parse.y
3  by  GNU Bison version 1.25
4   */
5
6 #define YYBISON 1  /* Identify Bison output.  */
7
8 #define BOC     258
9 #define CHARE   259
10 #define ENTRY   260
11 #define MESSAGE 261
12 #define READONLY        262
13 #define TABLE   263
14 #define THREADED        264
15 #define EXTERN  265
16 #define IDENTIFIER      266
17
18 #line 2 "xi-parse.y"
19
20
21 #include "xi-symbol.h"
22
23 extern int lineno;
24 extern int yylex (void) ;
25 extern Module *thismodule ;
26
27 // Local data and functions
28 int yyerror(char *);
29
30
31 #line 19 "xi-parse.y"
32 typedef union {
33         char *strval;
34         int intval;
35 } YYSTYPE;
36 #include <stdio.h>
37
38 #ifndef __cplusplus
39 #ifndef __STDC__
40 #define const
41 #endif
42 #endif
43
44
45
46 #define YYFINAL         62
47 #define YYFLAG          -32768
48 #define YYNTBASE        18
49
50 #define YYTRANSLATE(x) ((unsigned)(x) <= 266 ? yytranslate[x] : 42)
51
52 static const char yytranslate[] = {     0,
53      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
54      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
55      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
56      2,     2,     2,     2,     2,     2,     2,     2,     2,    16,
57     17,    15,     2,     2,     2,     2,     2,     2,     2,     2,
58      2,     2,     2,     2,     2,     2,     2,     2,    14,     2,
59      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
60      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
61      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
62      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
63      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
64      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
65      2,     2,    12,     2,    13,     2,     2,     2,     2,     2,
66      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
67      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
68      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
69      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
70      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
71      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
72      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
73      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
74      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
75      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
76      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
77      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
78      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
79      6,     7,     8,     9,    10,    11
80 };
81
82 #if YYDEBUG != 0
83 static const short yyprhs[] = {     0,
84      0,     2,     3,     5,     7,    10,    12,    14,    16,    18,
85     20,    21,    23,    24,    33,    34,    43,    45,    47,    49,
86     52,    53,    56,    57,    59,    68,    70,    75,    77,    82,
87     87,    89,    92,    94,    98
88 };
89
90 static const short yyrhs[] = {    19,
91      0,     0,    20,     0,    21,     0,    20,    21,     0,    23,
92      0,    25,     0,    34,     0,    36,     0,    40,     0,     0,
93     10,     0,     0,    22,     3,    27,    12,    24,    29,    13,
94     14,     0,     0,    22,     4,    27,    12,    26,    29,    13,
95     14,     0,    28,     0,    11,     0,    32,     0,    29,    32,
96      0,     0,    35,    15,     0,     0,     9,     0,    31,    30,
97      5,    33,    16,    30,    17,    14,     0,    28,     0,    22,
98      6,    35,    14,     0,    28,     0,     7,    37,    39,    14,
99      0,     7,    38,    39,    14,     0,    28,     0,    28,    15,
100      0,    28,     0,     8,    41,    14,     0,    28,     0
101 };
102
103 #endif
104
105 #if YYDEBUG != 0
106 static const short yyrline[] = { 0,
107     40,    43,    44,    47,    48,    51,    51,    51,    51,    51,
108     55,    57,    61,    67,    70,    76,    79,    82,    85,    86,
109     90,    94,    98,   100,   104,   111,   114,   122,   125,   131,
110    139,   142,   149,   152,   160
111 };
112 #endif
113
114
115 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
116
117 static const char * const yytname[] = {   "$","error","$undefined.","BOC","CHARE",
118 "ENTRY","MESSAGE","READONLY","TABLE","THREADED","EXTERN","IDENTIFIER","'{'",
119 "'}'","';'","'*'","'('","')'","File","ItemElist","ItemList","Item","OptionalExtern",
120 "Boc","@1","Chare","@2","ChareName","Id","EntryList","OptionalMessagePtr","OptionalThreaded",
121 "Entry","EntryName","Message","MessageName","ReadOnly","SimpleType","PtrType",
122 "ReadOnlyName","Table","TableName", NULL
123 };
124 #endif
125
126 static const short yyr1[] = {     0,
127     18,    19,    19,    20,    20,    21,    21,    21,    21,    21,
128     22,    22,    24,    23,    26,    25,    27,    28,    29,    29,
129     30,    30,    31,    31,    32,    33,    34,    35,    36,    36,
130     37,    38,    39,    40,    41
131 };
132
133 static const short yyr2[] = {     0,
134      1,     0,     1,     1,     2,     1,     1,     1,     1,     1,
135      0,     1,     0,     8,     0,     8,     1,     1,     1,     2,
136      0,     2,     0,     1,     8,     1,     4,     1,     4,     4,
137      1,     2,     1,     3,     1
138 };
139
140 static const short yydefact[] = {    11,
141      0,     0,    12,     1,    11,     4,     0,     6,     7,     8,
142      9,    10,    18,    31,     0,     0,    35,     0,     5,     0,
143      0,     0,    32,    33,     0,     0,    34,     0,    17,     0,
144     28,     0,    29,    30,    13,    15,    27,    23,    23,    24,
145     23,    21,    19,    23,     0,    20,     0,     0,     0,    14,
146      0,    22,    16,    26,     0,    21,     0,     0,    25,     0,
147      0,     0
148 };
149
150 static const short yydefgoto[] = {    60,
151      4,     5,     6,     7,     8,    38,     9,    39,    28,    31,
152     41,    47,    42,    43,    55,    10,    48,    11,    15,    16,
153     25,    12,    18
154 };
155
156 static const short yypact[] = {     2,
157      0,     0,-32768,-32768,    16,-32768,    24,-32768,-32768,-32768,
158 -32768,-32768,-32768,   -10,     0,     0,-32768,    -8,-32768,     0,
159      0,     0,-32768,-32768,     3,     8,-32768,     1,-32768,    13,
160 -32768,    15,-32768,-32768,-32768,-32768,-32768,    22,    22,-32768,
161     -6,     0,-32768,    -5,    18,-32768,    28,    19,    21,-32768,
162      0,-32768,-32768,-32768,    20,     0,    23,    25,-32768,    37,
163     38,-32768
164 };
165
166 static const short yypgoto[] = {-32768,
167 -32768,-32768,    36,-32768,-32768,-32768,-32768,-32768,    26,    -1,
168      4,   -14,-32768,   -23,-32768,-32768,    27,-32768,-32768,-32768,
169     29,-32768,-32768
170 };
171
172
173 #define YYLAST          50
174
175
176 static const short yytable[] = {    14,
177     17,    -2,    40,    40,    23,    27,    45,    49,     1,     2,
178     13,     3,    35,    24,    24,    -3,    33,    46,    29,    29,
179     46,    34,     1,     2,    36,     3,    20,    21,    37,    22,
180     40,    50,    51,    52,    53,    56,    61,    62,    59,    58,
181     19,    57,    44,     0,    26,     0,    30,     0,    32,    54
182 };
183
184 static const short yycheck[] = {     1,
185      2,     0,     9,     9,    15,    14,    13,    13,     7,     8,
186     11,    10,    12,    15,    16,     0,    14,    41,    20,    21,
187     44,    14,     7,     8,    12,    10,     3,     4,    14,     6,
188      9,    14,     5,    15,    14,    16,     0,     0,    14,    17,
189      5,    56,    39,    -1,    16,    -1,    21,    -1,    22,    51
190 };
191 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
192 #line 3 "/local/encap/bison-1.25/share/bison.simple"
193
194 /* Skeleton output parser for bison,
195    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
196
197    This program is free software; you can redistribute it and/or modify
198    it under the terms of the GNU General Public License as published by
199    the Free Software Foundation; either version 2, or (at your option)
200    any later version.
201
202    This program is distributed in the hope that it will be useful,
203    but WITHOUT ANY WARRANTY; without even the implied warranty of
204    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
205    GNU General Public License for more details.
206
207    You should have received a copy of the GNU General Public License
208    along with this program; if not, write to the Free Software
209    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
210
211 /* As a special exception, when this file is copied by Bison into a
212    Bison output file, you may use that output file without restriction.
213    This special exception was added by the Free Software Foundation
214    in version 1.24 of Bison.  */
215
216 #ifndef alloca
217 #ifdef __GNUC__
218 #define alloca __builtin_alloca
219 #else /* not GNU C.  */
220 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
221 #include <alloca.h>
222 #else /* not sparc */
223 #if defined (MSDOS) && !defined (__TURBOC__)
224 #include <malloc.h>
225 #else /* not MSDOS, or __TURBOC__ */
226 #if defined(_AIX)
227 #include <malloc.h>
228  #pragma alloca
229 #else /* not MSDOS, __TURBOC__, or _AIX */
230 #ifdef __hpux
231 #ifdef __cplusplus
232 extern "C" {
233 void *alloca (unsigned int);
234 };
235 #else /* not __cplusplus */
236 void *alloca ();
237 #endif /* not __cplusplus */
238 #endif /* __hpux */
239 #endif /* not _AIX */
240 #endif /* not MSDOS, or __TURBOC__ */
241 #endif /* not sparc.  */
242 #endif /* not GNU C.  */
243 #endif /* alloca not defined.  */
244
245 /* This is the parser code that is written into each bison parser
246   when the %semantic_parser declaration is not specified in the grammar.
247   It was written by Richard Stallman by simplifying the hairy parser
248   used when %semantic_parser is specified.  */
249
250 /* Note: there must be only one dollar sign in this file.
251    It is replaced by the list of actions, each action
252    as one case of the switch.  */
253
254 #define yyerrok         (yyerrstatus = 0)
255 #define yyclearin       (yychar = YYEMPTY)
256 #define YYEMPTY         -2
257 #define YYEOF           0
258 #define YYACCEPT        return(0)
259 #define YYABORT         return(1)
260 #define YYERROR         goto yyerrlab1
261 /* Like YYERROR except do call yyerror.
262    This remains here temporarily to ease the
263    transition to the new meaning of YYERROR, for GCC.
264    Once GCC version 2 has supplanted version 1, this can go.  */
265 #define YYFAIL          goto yyerrlab
266 #define YYRECOVERING()  (!!yyerrstatus)
267 #define YYBACKUP(token, value) \
268 do                                                              \
269   if (yychar == YYEMPTY && yylen == 1)                          \
270     { yychar = (token), yylval = (value);                       \
271       yychar1 = YYTRANSLATE (yychar);                           \
272       YYPOPSTACK;                                               \
273       goto yybackup;                                            \
274     }                                                           \
275   else                                                          \
276     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
277 while (0)
278
279 #define YYTERROR        1
280 #define YYERRCODE       256
281
282 #ifndef YYPURE
283 #define YYLEX           yylex()
284 #endif
285
286 #ifdef YYPURE
287 #ifdef YYLSP_NEEDED
288 #ifdef YYLEX_PARAM
289 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
290 #else
291 #define YYLEX           yylex(&yylval, &yylloc)
292 #endif
293 #else /* not YYLSP_NEEDED */
294 #ifdef YYLEX_PARAM
295 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
296 #else
297 #define YYLEX           yylex(&yylval)
298 #endif
299 #endif /* not YYLSP_NEEDED */
300 #endif
301
302 /* If nonreentrant, generate the variables here */
303
304 #ifndef YYPURE
305
306 int     yychar;                 /*  the lookahead symbol                */
307 YYSTYPE yylval;                 /*  the semantic value of the           */
308                                 /*  lookahead symbol                    */
309
310 #ifdef YYLSP_NEEDED
311 YYLTYPE yylloc;                 /*  location data for the lookahead     */
312                                 /*  symbol                              */
313 #endif
314
315 int yynerrs;                    /*  number of parse errors so far       */
316 #endif  /* not YYPURE */
317
318 #if YYDEBUG != 0
319 int yydebug;                    /*  nonzero means print parse trace     */
320 /* Since this is uninitialized, it does not stop multiple parsers
321    from coexisting.  */
322 #endif
323
324 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
325
326 #ifndef YYINITDEPTH
327 #define YYINITDEPTH 200
328 #endif
329
330 /*  YYMAXDEPTH is the maximum size the stacks can grow to
331     (effective only if the built-in stack extension method is used).  */
332
333 #if YYMAXDEPTH == 0
334 #undef YYMAXDEPTH
335 #endif
336
337 #ifndef YYMAXDEPTH
338 #define YYMAXDEPTH 10000
339 #endif
340
341 /* Prevent warning if -Wstrict-prototypes.  */
342 #ifdef __GNUC__
343 int yyparse (void);
344 #endif
345 \f
346 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
347 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
348 #else                           /* not GNU C or C++ */
349 #ifndef __cplusplus
350
351 /* This is the most reliable way to avoid incompatibilities
352    in available built-in functions on various systems.  */
353 static void
354 __yy_memcpy (to, from, count)
355      char *to;
356      char *from;
357      int count;
358 {
359   register char *f = from;
360   register char *t = to;
361   register int i = count;
362
363   while (i-- > 0)
364     *t++ = *f++;
365 }
366
367 #else /* __cplusplus */
368
369 /* This is the most reliable way to avoid incompatibilities
370    in available built-in functions on various systems.  */
371 static void
372 __yy_memcpy (char *to, char *from, int count)
373 {
374   register char *f = from;
375   register char *t = to;
376   register int i = count;
377
378   while (i-- > 0)
379     *t++ = *f++;
380 }
381
382 #endif
383 #endif
384 \f
385 #line 196 "/local/encap/bison-1.25/share/bison.simple"
386
387 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
388    into yyparse.  The argument should have type void *.
389    It should actually point to an object.
390    Grammar actions can access the variable by casting it
391    to the proper pointer type.  */
392
393 #ifdef YYPARSE_PARAM
394 #ifdef __cplusplus
395 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
396 #define YYPARSE_PARAM_DECL
397 #else /* not __cplusplus */
398 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
399 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
400 #endif /* not __cplusplus */
401 #else /* not YYPARSE_PARAM */
402 #define YYPARSE_PARAM_ARG
403 #define YYPARSE_PARAM_DECL
404 #endif /* not YYPARSE_PARAM */
405
406 int
407 yyparse(YYPARSE_PARAM_ARG)
408      YYPARSE_PARAM_DECL
409 {
410   register int yystate;
411   register int yyn;
412   register short *yyssp;
413   register YYSTYPE *yyvsp;
414   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
415   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
416
417   short yyssa[YYINITDEPTH];     /*  the state stack                     */
418   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
419
420   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
421   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
422
423 #ifdef YYLSP_NEEDED
424   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
425   YYLTYPE *yyls = yylsa;
426   YYLTYPE *yylsp;
427
428 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
429 #else
430 #define YYPOPSTACK   (yyvsp--, yyssp--)
431 #endif
432
433   int yystacksize = YYINITDEPTH;
434
435 #ifdef YYPURE
436   int yychar;
437   YYSTYPE yylval;
438   int yynerrs;
439 #ifdef YYLSP_NEEDED
440   YYLTYPE yylloc;
441 #endif
442 #endif
443
444   YYSTYPE yyval;                /*  the variable used to return         */
445                                 /*  semantic values from the action     */
446                                 /*  routines                            */
447
448   int yylen;
449
450 #if YYDEBUG != 0
451   if (yydebug)
452     fprintf(stderr, "Starting parse\n");
453 #endif
454
455   yystate = 0;
456   yyerrstatus = 0;
457   yynerrs = 0;
458   yychar = YYEMPTY;             /* Cause a token to be read.  */
459
460   /* Initialize stack pointers.
461      Waste one element of value and location stack
462      so that they stay on the same level as the state stack.
463      The wasted elements are never initialized.  */
464
465   yyssp = yyss - 1;
466   yyvsp = yyvs;
467 #ifdef YYLSP_NEEDED
468   yylsp = yyls;
469 #endif
470
471 /* Push a new state, which is found in  yystate  .  */
472 /* In all cases, when you get here, the value and location stacks
473    have just been pushed. so pushing a state here evens the stacks.  */
474 yynewstate:
475
476   *++yyssp = yystate;
477
478   if (yyssp >= yyss + yystacksize - 1)
479     {
480       /* Give user a chance to reallocate the stack */
481       /* Use copies of these so that the &'s don't force the real ones into memory. */
482       YYSTYPE *yyvs1 = yyvs;
483       short *yyss1 = yyss;
484 #ifdef YYLSP_NEEDED
485       YYLTYPE *yyls1 = yyls;
486 #endif
487
488       /* Get the current used size of the three stacks, in elements.  */
489       int size = yyssp - yyss + 1;
490
491 #ifdef yyoverflow
492       /* Each stack pointer address is followed by the size of
493          the data in use in that stack, in bytes.  */
494 #ifdef YYLSP_NEEDED
495       /* This used to be a conditional around just the two extra args,
496          but that might be undefined if yyoverflow is a macro.  */
497       yyoverflow("parser stack overflow",
498                  &yyss1, size * sizeof (*yyssp),
499                  &yyvs1, size * sizeof (*yyvsp),
500                  &yyls1, size * sizeof (*yylsp),
501                  &yystacksize);
502 #else
503       yyoverflow("parser stack overflow",
504                  &yyss1, size * sizeof (*yyssp),
505                  &yyvs1, size * sizeof (*yyvsp),
506                  &yystacksize);
507 #endif
508
509       yyss = yyss1; yyvs = yyvs1;
510 #ifdef YYLSP_NEEDED
511       yyls = yyls1;
512 #endif
513 #else /* no yyoverflow */
514       /* Extend the stack our own way.  */
515       if (yystacksize >= YYMAXDEPTH)
516         {
517           yyerror("parser stack overflow");
518           return 2;
519         }
520       yystacksize *= 2;
521       if (yystacksize > YYMAXDEPTH)
522         yystacksize = YYMAXDEPTH;
523       yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
524       __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
525       yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
526       __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
527 #ifdef YYLSP_NEEDED
528       yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
529       __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
530 #endif
531 #endif /* no yyoverflow */
532
533       yyssp = yyss + size - 1;
534       yyvsp = yyvs + size - 1;
535 #ifdef YYLSP_NEEDED
536       yylsp = yyls + size - 1;
537 #endif
538
539 #if YYDEBUG != 0
540       if (yydebug)
541         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
542 #endif
543
544       if (yyssp >= yyss + yystacksize - 1)
545         YYABORT;
546     }
547
548 #if YYDEBUG != 0
549   if (yydebug)
550     fprintf(stderr, "Entering state %d\n", yystate);
551 #endif
552
553   goto yybackup;
554  yybackup:
555
556 /* Do appropriate processing given the current state.  */
557 /* Read a lookahead token if we need one and don't already have one.  */
558 /* yyresume: */
559
560   /* First try to decide what to do without reference to lookahead token.  */
561
562   yyn = yypact[yystate];
563   if (yyn == YYFLAG)
564     goto yydefault;
565
566   /* Not known => get a lookahead token if don't already have one.  */
567
568   /* yychar is either YYEMPTY or YYEOF
569      or a valid token in external form.  */
570
571   if (yychar == YYEMPTY)
572     {
573 #if YYDEBUG != 0
574       if (yydebug)
575         fprintf(stderr, "Reading a token: ");
576 #endif
577       yychar = YYLEX;
578     }
579
580   /* Convert token to internal form (in yychar1) for indexing tables with */
581
582   if (yychar <= 0)              /* This means end of input. */
583     {
584       yychar1 = 0;
585       yychar = YYEOF;           /* Don't call YYLEX any more */
586
587 #if YYDEBUG != 0
588       if (yydebug)
589         fprintf(stderr, "Now at end of input.\n");
590 #endif
591     }
592   else
593     {
594       yychar1 = YYTRANSLATE(yychar);
595
596 #if YYDEBUG != 0
597       if (yydebug)
598         {
599           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
600           /* Give the individual parser a way to print the precise meaning
601              of a token, for further debugging info.  */
602 #ifdef YYPRINT
603           YYPRINT (stderr, yychar, yylval);
604 #endif
605           fprintf (stderr, ")\n");
606         }
607 #endif
608     }
609
610   yyn += yychar1;
611   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
612     goto yydefault;
613
614   yyn = yytable[yyn];
615
616   /* yyn is what to do for this token type in this state.
617      Negative => reduce, -yyn is rule number.
618      Positive => shift, yyn is new state.
619        New state is final state => don't bother to shift,
620        just return success.
621      0, or most negative number => error.  */
622
623   if (yyn < 0)
624     {
625       if (yyn == YYFLAG)
626         goto yyerrlab;
627       yyn = -yyn;
628       goto yyreduce;
629     }
630   else if (yyn == 0)
631     goto yyerrlab;
632
633   if (yyn == YYFINAL)
634     YYACCEPT;
635
636   /* Shift the lookahead token.  */
637
638 #if YYDEBUG != 0
639   if (yydebug)
640     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
641 #endif
642
643   /* Discard the token being shifted unless it is eof.  */
644   if (yychar != YYEOF)
645     yychar = YYEMPTY;
646
647   *++yyvsp = yylval;
648 #ifdef YYLSP_NEEDED
649   *++yylsp = yylloc;
650 #endif
651
652   /* count tokens shifted since error; after three, turn off error status.  */
653   if (yyerrstatus) yyerrstatus--;
654
655   yystate = yyn;
656   goto yynewstate;
657
658 /* Do the default action for the current state.  */
659 yydefault:
660
661   yyn = yydefact[yystate];
662   if (yyn == 0)
663     goto yyerrlab;
664
665 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
666 yyreduce:
667   yylen = yyr2[yyn];
668   if (yylen > 0)
669     yyval = yyvsp[1-yylen]; /* implement default value of the action */
670
671 #if YYDEBUG != 0
672   if (yydebug)
673     {
674       int i;
675
676       fprintf (stderr, "Reducing via rule %d (line %d), ",
677                yyn, yyrline[yyn]);
678
679       /* Print the symbols being reduced, and their result.  */
680       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
681         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
682       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
683     }
684 #endif
685
686
687   switch (yyn) {
688
689 case 11:
690 #line 56 "xi-parse.y"
691 { yyval.intval = FALSE; ;
692     break;}
693 case 12:
694 #line 58 "xi-parse.y"
695 { yyval.intval = TRUE; ;
696     break;}
697 case 13:
698 #line 62 "xi-parse.y"
699 {
700                         Chare *c = new Chare(yyvsp[-1].strval, BOC, yyvsp[-3].intval) ;
701                         delete yyvsp[-1].strval;
702                         thismodule->AddChare(c) ;
703                 ;
704     break;}
705 case 15:
706 #line 71 "xi-parse.y"
707 {
708                         Chare *c = new Chare(yyvsp[-1].strval, CHARE, yyvsp[-3].intval) ;
709                         delete yyvsp[-1].strval;
710                         thismodule->AddChare(c) ;
711                 ;
712     break;}
713 case 21:
714 #line 91 "xi-parse.y"
715 {
716                         yyval.strval = NULL;
717                 ;
718     break;}
719 case 23:
720 #line 99 "xi-parse.y"
721 { yyval.intval = FALSE; ;
722     break;}
723 case 24:
724 #line 101 "xi-parse.y"
725 { yyval.intval = TRUE; ;
726     break;}
727 case 25:
728 #line 105 "xi-parse.y"
729 {
730                         thismodule->chares->AddEntry(yyvsp[-4].strval, yyvsp[-2].strval, yyvsp[-7].intval, yyvsp[-6].strval) ;
731                         delete yyvsp[-4].strval; delete yyvsp[-2].strval;
732                 ;
733     break;}
734 case 27:
735 #line 115 "xi-parse.y"
736 {
737                         Message *m = new Message(yyvsp[-1].strval, 0, yyvsp[-3].intval) ;
738                         delete yyvsp[-1].strval;
739                         thismodule->AddMessage(m) ;
740                 ;
741     break;}
742 case 29:
743 #line 126 "xi-parse.y"
744 {
745                         ReadOnly *r = new ReadOnly(yyvsp[-1].strval, yyvsp[-2].strval, 0) ;
746                         delete yyvsp[-2].strval;
747                         thismodule->AddReadOnly(r) ;
748                 ;
749     break;}
750 case 30:
751 #line 132 "xi-parse.y"
752 {
753                         ReadOnly *r = new ReadOnly(yyvsp[-1].strval, yyvsp[-2].strval, 1) ;
754                         delete yyvsp[-2].strval;
755                         thismodule->AddReadOnly(r) ;
756                 ;
757     break;}
758 case 32:
759 #line 143 "xi-parse.y"
760 {
761                         yyval.strval = strcat(strcpy(new char[2+strlen(yyvsp[-1].strval)], yyvsp[-1].strval), "*");
762                         delete yyvsp[-1].strval;
763                 ;
764     break;}
765 case 34:
766 #line 153 "xi-parse.y"
767 {
768                         Table *t = new Table(yyvsp[-1].strval) ;
769                         delete yyvsp[-1].strval;
770                         thismodule->AddTable(t) ;
771                 ;
772     break;}
773 }
774    /* the action file gets copied in in place of this dollarsign */
775 #line 498 "/local/encap/bison-1.25/share/bison.simple"
776 \f
777   yyvsp -= yylen;
778   yyssp -= yylen;
779 #ifdef YYLSP_NEEDED
780   yylsp -= yylen;
781 #endif
782
783 #if YYDEBUG != 0
784   if (yydebug)
785     {
786       short *ssp1 = yyss - 1;
787       fprintf (stderr, "state stack now");
788       while (ssp1 != yyssp)
789         fprintf (stderr, " %d", *++ssp1);
790       fprintf (stderr, "\n");
791     }
792 #endif
793
794   *++yyvsp = yyval;
795
796 #ifdef YYLSP_NEEDED
797   yylsp++;
798   if (yylen == 0)
799     {
800       yylsp->first_line = yylloc.first_line;
801       yylsp->first_column = yylloc.first_column;
802       yylsp->last_line = (yylsp-1)->last_line;
803       yylsp->last_column = (yylsp-1)->last_column;
804       yylsp->text = 0;
805     }
806   else
807     {
808       yylsp->last_line = (yylsp+yylen-1)->last_line;
809       yylsp->last_column = (yylsp+yylen-1)->last_column;
810     }
811 #endif
812
813   /* Now "shift" the result of the reduction.
814      Determine what state that goes to,
815      based on the state we popped back to
816      and the rule number reduced by.  */
817
818   yyn = yyr1[yyn];
819
820   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
821   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
822     yystate = yytable[yystate];
823   else
824     yystate = yydefgoto[yyn - YYNTBASE];
825
826   goto yynewstate;
827
828 yyerrlab:   /* here on detecting error */
829
830   if (! yyerrstatus)
831     /* If not already recovering from an error, report this error.  */
832     {
833       ++yynerrs;
834
835 #ifdef YYERROR_VERBOSE
836       yyn = yypact[yystate];
837
838       if (yyn > YYFLAG && yyn < YYLAST)
839         {
840           int size = 0;
841           char *msg;
842           int x, count;
843
844           count = 0;
845           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
846           for (x = (yyn < 0 ? -yyn : 0);
847                x < (sizeof(yytname) / sizeof(char *)); x++)
848             if (yycheck[x + yyn] == x)
849               size += strlen(yytname[x]) + 15, count++;
850           msg = (char *) malloc(size + 15);
851           if (msg != 0)
852             {
853               strcpy(msg, "parse error");
854
855               if (count < 5)
856                 {
857                   count = 0;
858                   for (x = (yyn < 0 ? -yyn : 0);
859                        x < (sizeof(yytname) / sizeof(char *)); x++)
860                     if (yycheck[x + yyn] == x)
861                       {
862                         strcat(msg, count == 0 ? ", expecting `" : " or `");
863                         strcat(msg, yytname[x]);
864                         strcat(msg, "'");
865                         count++;
866                       }
867                 }
868               yyerror(msg);
869               free(msg);
870             }
871           else
872             yyerror ("parse error; also virtual memory exceeded");
873         }
874       else
875 #endif /* YYERROR_VERBOSE */
876         yyerror("parse error");
877     }
878
879   goto yyerrlab1;
880 yyerrlab1:   /* here on error raised explicitly by an action */
881
882   if (yyerrstatus == 3)
883     {
884       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
885
886       /* return failure if at end of input */
887       if (yychar == YYEOF)
888         YYABORT;
889
890 #if YYDEBUG != 0
891       if (yydebug)
892         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
893 #endif
894
895       yychar = YYEMPTY;
896     }
897
898   /* Else will try to reuse lookahead token
899      after shifting the error token.  */
900
901   yyerrstatus = 3;              /* Each real token shifted decrements this */
902
903   goto yyerrhandle;
904
905 yyerrdefault:  /* current state does not do anything special for the error token. */
906
907 #if 0
908   /* This is wrong; only states that explicitly want error tokens
909      should shift them.  */
910   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
911   if (yyn) goto yydefault;
912 #endif
913
914 yyerrpop:   /* pop the current state because it cannot handle the error token */
915
916   if (yyssp == yyss) YYABORT;
917   yyvsp--;
918   yystate = *--yyssp;
919 #ifdef YYLSP_NEEDED
920   yylsp--;
921 #endif
922
923 #if YYDEBUG != 0
924   if (yydebug)
925     {
926       short *ssp1 = yyss - 1;
927       fprintf (stderr, "Error: state stack now");
928       while (ssp1 != yyssp)
929         fprintf (stderr, " %d", *++ssp1);
930       fprintf (stderr, "\n");
931     }
932 #endif
933
934 yyerrhandle:
935
936   yyn = yypact[yystate];
937   if (yyn == YYFLAG)
938     goto yyerrdefault;
939
940   yyn += YYTERROR;
941   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
942     goto yyerrdefault;
943
944   yyn = yytable[yyn];
945   if (yyn < 0)
946     {
947       if (yyn == YYFLAG)
948         goto yyerrpop;
949       yyn = -yyn;
950       goto yyreduce;
951     }
952   else if (yyn == 0)
953     goto yyerrpop;
954
955   if (yyn == YYFINAL)
956     YYACCEPT;
957
958 #if YYDEBUG != 0
959   if (yydebug)
960     fprintf(stderr, "Shifting error token, ");
961 #endif
962
963   *++yyvsp = yylval;
964 #ifdef YYLSP_NEEDED
965   *++yylsp = yylloc;
966 #endif
967
968   yystate = yyn;
969   goto yynewstate;
970 }
971 #line 163 "xi-parse.y"
972
973
974 int yyerror(char *mesg)
975 {
976         cout << "Syntax error at line " << lineno << ": " << mesg << endl;
977         return 0;
978 }
979