used byacc instead of bison.
authorMilind Bhandarkar <milind@cs.uiuc.edu>
Fri, 6 Dec 1996 16:48:28 +0000 (16:48 +0000)
committerMilind Bhandarkar <milind@cs.uiuc.edu>
Fri, 6 Dec 1996 16:48:28 +0000 (16:48 +0000)
src/xlat-i/xi-parse.tab.C
src/xlat-i/xi-parse.tab.h

index d47ce81f41b3563f3e19bd705122e8f7a3490273..525a6fc3eb3e642d4e09b3a18babab7f12b91873 100644 (file)
@@ -1,23 +1,8 @@
-
-/*  A Bison parser, made from xi-parse.bison
- by  GNU Bison version 1.25
-  */
-
-#define YYBISON 1  /* Identify Bison output.  */
-
-#define        BOC     258
-#define        CHARE   259
-#define        ENTRY   260
-#define        MESSAGE 261
-#define        PACKMESSAGE     262
-#define        READONLY        263
-#define        TABLE   264
-#define        THREADED        265
-#define        EXTERN  266
-#define        IDENTIFIER      267
-
-#line 2 "xi-parse.bison"
-
+#ifndef lint
+static char yysccsid[] = "@(#)yaccpar  1.8 (Berkeley) 01/20/90";
+#endif
+#define YYBYACC 1
+#line 3 "xi-parse.bison"
 
 #include "xi-symbol.h"
 
@@ -25,967 +10,511 @@ extern int lineno;
 extern int yylex (void) ;
 extern Module *thismodule ;
 
-// Local data and functions
+/* Local data and functions*/
 int yyerror(char *);
 
-
 #line 19 "xi-parse.bison"
 typedef union {
        char *strval;
        int intval;
 } YYSTYPE;
-#include <stdio.h>
-
-#ifndef __cplusplus
-#ifndef __STDC__
-#define const
-#endif
-#endif
-
-
-
-#define        YYFINAL         66
-#define        YYFLAG          -32768
-#define        YYNTBASE        19
-
-#define YYTRANSLATE(x) ((unsigned)(x) <= 267 ? yytranslate[x] : 44)
-
-static const char yytranslate[] = {     0,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,    17,
-    18,    16,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,    15,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,    13,     2,    14,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
-     2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
-     6,     7,     8,     9,    10,    11,    12
+#line 22 "y.tab.c"
+#define BOC 257
+#define CHARE 258
+#define ENTRY 259
+#define MESSAGE 260
+#define PACKMESSAGE 261
+#define READONLY 262
+#define TABLE 263
+#define THREADED 264
+#define EXTERN 265
+#define IDENTIFIER 266
+#define YYERRCODE 256
+short yylhs[] = {                                        -1,
+    0,   12,   12,   13,   13,   14,   14,   14,   14,   14,
+   14,   11,   11,   22,   15,   23,   16,    2,    1,   21,
+   21,    9,    9,   10,   10,   24,    3,   17,   20,    4,
+   18,   18,    7,    8,    5,   19,    6,
 };
-
-#if YYDEBUG != 0
-static const short yyprhs[] = {     0,
-     0,     2,     3,     5,     7,    10,    12,    14,    16,    18,
-    20,    22,    23,    25,    26,    35,    36,    45,    47,    49,
-    51,    54,    55,    58,    59,    61,    70,    72,    77,    82,
-    84,    89,    94,    96,    99,   101,   105
-};
-
-static const short yyrhs[] = {    20,
-     0,     0,    21,     0,    22,     0,    21,    22,     0,    24,
-     0,    26,     0,    35,     0,    38,     0,    42,     0,    36,
-     0,     0,    11,     0,     0,    23,     3,    28,    13,    25,
-    30,    14,    15,     0,     0,    23,     4,    28,    13,    27,
-    30,    14,    15,     0,    29,     0,    12,     0,    33,     0,
-    30,    33,     0,     0,    37,    16,     0,     0,    10,     0,
-    32,    31,     5,    34,    17,    31,    18,    15,     0,    29,
-     0,    23,     6,    37,    15,     0,    23,     7,    37,    15,
-     0,    29,     0,     8,    39,    41,    15,     0,     8,    40,
-    41,    15,     0,    29,     0,    29,    16,     0,    29,     0,
-     9,    43,    15,     0,    29,     0
-};
-
-#endif
-
-#if YYDEBUG != 0
-static const short yyrline[] = { 0,
-    41,    44,    45,    48,    49,    52,    52,    52,    52,    52,
-    52,    57,    59,    63,    69,    72,    78,    81,    84,    87,
-    88,    92,    96,   100,   102,   106,   113,   116,   124,   132,
-   135,   141,   149,   152,   159,   162,   170
+short yylen[] = {                                         2,
+    1,    0,    1,    1,    2,    1,    1,    1,    1,    1,
+    1,    0,    1,    0,    8,    0,    8,    1,    1,    1,
+    2,    0,    2,    0,    1,    8,    1,    4,    4,    1,
+    4,    4,    1,    2,    1,    3,    1,
 };
-#endif
-
-
-#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
-
-static const char * const yytname[] = {   "$","error","$undefined.","BOC","CHARE",
-"ENTRY","MESSAGE","PACKMESSAGE","READONLY","TABLE","THREADED","EXTERN","IDENTIFIER",
-"'{'","'}'","';'","'*'","'('","')'","File","ItemElist","ItemList","Item","OptionalExtern",
-"Boc","@1","Chare","@2","ChareName","Id","EntryList","OptionalMessagePtr","OptionalThreaded",
-"Entry","EntryName","Message","PackMessage","MessageName","ReadOnly","SimpleType",
-"PtrType","ReadOnlyName","Table","TableName", NULL
-};
-#endif
-
-static const short yyr1[] = {     0,
-    19,    20,    20,    21,    21,    22,    22,    22,    22,    22,
-    22,    23,    23,    25,    24,    27,    26,    28,    29,    30,
-    30,    31,    31,    32,    32,    33,    34,    35,    36,    37,
-    38,    38,    39,    40,    41,    42,    43
+short yydefred[] = {                                      0,
+    0,    0,   13,    0,    0,    1,    0,    4,    6,    7,
+    8,    9,   10,   11,   19,    0,    0,    0,   37,    0,
+    0,    0,    0,    0,    5,   34,   35,    0,    0,   36,
+   18,    0,    0,   30,    0,    0,   31,   32,   14,   16,
+   28,   29,    0,    0,   25,    0,    0,   20,    0,    0,
+    0,    0,   21,    0,   23,    0,   15,   17,   27,    0,
+    0,    0,    0,   26,
 };
-
-static const short yyr2[] = {     0,
-     1,     0,     1,     1,     2,     1,     1,     1,     1,     1,
-     1,     0,     1,     0,     8,     0,     8,     1,     1,     1,
-     2,     0,     2,     0,     1,     8,     1,     4,     4,     1,
-     4,     4,     1,     2,     1,     3,     1
+short yydgoto[] = {                                       4,
+   34,   32,   60,   50,   28,   20,   17,   18,   51,   46,
+    5,    6,    7,    8,    9,   10,   11,   12,   13,   14,
+   47,   43,   44,   48,
 };
-
-static const short yydefact[] = {    12,
-     0,     0,    13,     1,    12,     4,     0,     6,     7,     8,
-    11,     9,    10,    19,    33,     0,     0,    37,     0,     5,
-     0,     0,     0,     0,    34,    35,     0,     0,    36,     0,
-    18,     0,    30,     0,     0,    31,    32,    14,    16,    28,
-    29,    24,    24,    25,    24,    22,    20,    24,     0,    21,
-     0,     0,     0,    15,     0,    23,    17,    27,     0,    22,
-     0,     0,    26,     0,     0,     0
+short yysindex[] = {                                   -249,
+ -257, -257,    0,    0, -250,    0, -249,    0,    0,    0,
+    0,    0,    0,    0,    0,  -24, -257, -257,    0,  -34,
+ -257, -257, -257, -257,    0,    0,    0,  -33,  -31,    0,
+    0,  -96,  -94,    0,  -29,  -28,    0,    0,    0,    0,
+    0,    0, -232, -232,    0, -257, -125,    0, -123,   -9,
+ -225,  -23,    0,  -22,    0, -257,    0,    0,    0,   -5,
+ -257,   -3,  -20,    0,
 };
-
-static const short yydefgoto[] = {    64,
-     4,     5,     6,     7,     8,    42,     9,    43,    30,    33,
-    45,    51,    46,    47,    59,    10,    11,    52,    12,    16,
-    17,    27,    13,    19
+short yyrindex[] = {                                      1,
+    0,    0,    0,    0,    0,    0,    6,    0,    0,    0,
+    0,    0,    0,    0,    0, -226,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0, -254, -254,    0, -218, -254,    0, -254,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    3,    0,    0,    0,
 };
-
-static const short yypact[] = {     2,
-     7,     7,-32768,-32768,    14,-32768,     0,-32768,-32768,-32768,
--32768,-32768,-32768,-32768,    10,     7,     7,-32768,    13,-32768,
-     7,     7,     7,     7,-32768,-32768,    15,    16,-32768,    19,
--32768,    20,-32768,    21,    22,-32768,-32768,-32768,-32768,-32768,
--32768,    24,    24,-32768,    -5,     7,-32768,    -2,    23,-32768,
-    30,    25,    27,-32768,     7,-32768,-32768,-32768,    12,     7,
-    26,    28,-32768,    39,    40,-32768
+short yygindex[] = {                                      0,
+    2,   20,    0,   -2,   25,    0,    0,    0,  -16,    0,
+    0,    0,    0,   39,    0,    0,    0,    0,    0,    0,
+    4,    0,    0,  -32,
 };
-
-static const short yypgoto[] = {-32768,
--32768,-32768,    41,-32768,-32768,-32768,-32768,-32768,    29,    -1,
-     4,   -15,-32768,   -21,-32768,-32768,-32768,    -6,-32768,-32768,
--32768,    31,-32768,-32768
+#define YYTABLESIZE 267
+short yytable[] = {                                      52,
+    2,   54,   16,   19,   24,    3,   21,   22,   15,   23,
+   24,   24,    1,    2,   53,    3,   53,   26,   27,   27,
+   35,   36,   31,   31,   30,   37,   39,   38,   40,   41,
+   42,   45,   55,   56,   61,   57,   58,   63,   64,   33,
+   22,   33,   29,   22,   62,   25,    0,   49,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   59,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,   45,    0,
+   45,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   12,   12,    0,
+   12,   12,   12,   12,    0,   12,   12,
 };
-
-
-#define        YYLAST          54
-
-
-static const short yytable[] = {    15,
-    18,    -2,    21,    22,    44,    23,    24,    44,    49,     1,
-     2,    53,     3,    -3,    26,    26,    34,    35,    14,    31,
-    31,     1,     2,    50,     3,    25,    50,    29,    60,    36,
-    37,    38,    39,    44,    55,    40,    41,    54,    65,    66,
-    56,    57,    63,    62,    61,    20,    48,    28,     0,     0,
-    32,     0,     0,    58
+short yycheck[] = {                                     125,
+    0,  125,    1,    2,  259,    0,  257,  258,  266,  260,
+  261,  266,  262,  263,   47,  265,   49,   42,   17,   18,
+   23,   24,   21,   22,   59,   59,  123,   59,  123,   59,
+   59,  264,   42,  259,   40,   59,   59,   41,   59,  266,
+  259,   22,   18,   41,   61,    7,   -1,   44,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   56,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  264,   -1,
+  264,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,  258,   -1,
+  260,  261,  257,  258,   -1,  260,  261,
 };
-
-static const short yycheck[] = {     1,
-     2,     0,     3,     4,    10,     6,     7,    10,    14,     8,
-     9,    14,    11,     0,    16,    17,    23,    24,    12,    21,
-    22,     8,     9,    45,    11,    16,    48,    15,    17,    15,
-    15,    13,    13,    10,     5,    15,    15,    15,     0,     0,
-    16,    15,    15,    18,    60,     5,    43,    17,    -1,    -1,
-    22,    -1,    -1,    55
+#define YYFINAL 4
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 266
+#if YYDEBUG
+char *yyname[] = {
+"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'('","')'","'*'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"';'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'{'",0,"'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"BOC",
+"CHARE","ENTRY","MESSAGE","PACKMESSAGE","READONLY","TABLE","THREADED","EXTERN",
+"IDENTIFIER",
 };
-/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
-#line 3 "/local/encap/bison-1.25/share/bison.simple"
-
-/* Skeleton output parser for bison,
-   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* As a special exception, when this file is copied by Bison into a
-   Bison output file, you may use that output file without restriction.
-   This special exception was added by the Free Software Foundation
-   in version 1.24 of Bison.  */
-
-#ifndef alloca
-#ifdef __GNUC__
-#define alloca __builtin_alloca
-#else /* not GNU C.  */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
-#include <alloca.h>
-#else /* not sparc */
-#if defined (MSDOS) && !defined (__TURBOC__)
-#include <malloc.h>
-#else /* not MSDOS, or __TURBOC__ */
-#if defined(_AIX)
-#include <malloc.h>
- #pragma alloca
-#else /* not MSDOS, __TURBOC__, or _AIX */
-#ifdef __hpux
-#ifdef __cplusplus
-extern "C" {
-void *alloca (unsigned int);
+char *yyrule[] = {
+"$accept : File",
+"File : ItemElist",
+"ItemElist :",
+"ItemElist : ItemList",
+"ItemList : Item",
+"ItemList : ItemList Item",
+"Item : Boc",
+"Item : Chare",
+"Item : Message",
+"Item : ReadOnly",
+"Item : Table",
+"Item : PackMessage",
+"OptionalExtern :",
+"OptionalExtern : EXTERN",
+"$$1 :",
+"Boc : OptionalExtern BOC ChareName '{' $$1 EntryList '}' ';'",
+"$$2 :",
+"Chare : OptionalExtern CHARE ChareName '{' $$2 EntryList '}' ';'",
+"ChareName : Id",
+"Id : IDENTIFIER",
+"EntryList : Entry",
+"EntryList : EntryList Entry",
+"OptionalMessagePtr :",
+"OptionalMessagePtr : MessageName '*'",
+"OptionalThreaded :",
+"OptionalThreaded : THREADED",
+"Entry : OptionalThreaded OptionalMessagePtr ENTRY EntryName '(' OptionalMessagePtr ')' ';'",
+"EntryName : Id",
+"Message : OptionalExtern MESSAGE MessageName ';'",
+"PackMessage : OptionalExtern PACKMESSAGE MessageName ';'",
+"MessageName : Id",
+"ReadOnly : READONLY SimpleType ReadOnlyName ';'",
+"ReadOnly : READONLY PtrType ReadOnlyName ';'",
+"SimpleType : Id",
+"PtrType : Id '*'",
+"ReadOnlyName : Id",
+"Table : TABLE TableName ';'",
+"TableName : Id",
 };
-#else /* not __cplusplus */
-void *alloca ();
-#endif /* not __cplusplus */
-#endif /* __hpux */
-#endif /* not _AIX */
-#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc.  */
-#endif /* not GNU C.  */
-#endif /* alloca not defined.  */
-
-/* This is the parser code that is written into each bison parser
-  when the %semantic_parser declaration is not specified in the grammar.
-  It was written by Richard Stallman by simplifying the hairy parser
-  used when %semantic_parser is specified.  */
-
-/* Note: there must be only one dollar sign in this file.
-   It is replaced by the list of actions, each action
-   as one case of the switch.  */
-
-#define yyerrok                (yyerrstatus = 0)
-#define yyclearin      (yychar = YYEMPTY)
-#define YYEMPTY                -2
-#define YYEOF          0
-#define YYACCEPT       return(0)
-#define YYABORT        return(1)
-#define YYERROR                goto yyerrlab1
-/* Like YYERROR except do call yyerror.
-   This remains here temporarily to ease the
-   transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  */
-#define YYFAIL         goto yyerrlab
-#define YYRECOVERING()  (!!yyerrstatus)
-#define YYBACKUP(token, value) \
-do                                                             \
-  if (yychar == YYEMPTY && yylen == 1)                         \
-    { yychar = (token), yylval = (value);                      \
-      yychar1 = YYTRANSLATE (yychar);                          \
-      YYPOPSTACK;                                              \
-      goto yybackup;                                           \
-    }                                                          \
-  else                                                         \
-    { yyerror ("syntax error: cannot back up"); YYERROR; }     \
-while (0)
-
-#define YYTERROR       1
-#define YYERRCODE      256
-
-#ifndef YYPURE
-#define YYLEX          yylex()
-#endif
-
-#ifdef YYPURE
-#ifdef YYLSP_NEEDED
-#ifdef YYLEX_PARAM
-#define YYLEX          yylex(&yylval, &yylloc, YYLEX_PARAM)
-#else
-#define YYLEX          yylex(&yylval, &yylloc)
-#endif
-#else /* not YYLSP_NEEDED */
-#ifdef YYLEX_PARAM
-#define YYLEX          yylex(&yylval, YYLEX_PARAM)
-#else
-#define YYLEX          yylex(&yylval)
-#endif
-#endif /* not YYLSP_NEEDED */
-#endif
-
-/* If nonreentrant, generate the variables here */
-
-#ifndef YYPURE
-
-int    yychar;                 /*  the lookahead symbol                */
-YYSTYPE        yylval;                 /*  the semantic value of the           */
-                               /*  lookahead symbol                    */
-
-#ifdef YYLSP_NEEDED
-YYLTYPE yylloc;                        /*  location data for the lookahead     */
-                               /*  symbol                              */
-#endif
-
-int yynerrs;                   /*  number of parse errors so far       */
-#endif  /* not YYPURE */
-
-#if YYDEBUG != 0
-int yydebug;                   /*  nonzero means print parse trace     */
-/* Since this is uninitialized, it does not stop multiple parsers
-   from coexisting.  */
 #endif
-
-/*  YYINITDEPTH indicates the initial size of the parser's stacks      */
-
-#ifndef        YYINITDEPTH
-#define YYINITDEPTH 200
-#endif
-
-/*  YYMAXDEPTH is the maximum size the stacks can grow to
-    (effective only if the built-in stack extension method is used).  */
-
-#if YYMAXDEPTH == 0
-#undef YYMAXDEPTH
-#endif
-
+#define yyclearin (yychar=(-1))
+#define yyerrok (yyerrflag=0)
+#ifdef YYSTACKSIZE
 #ifndef YYMAXDEPTH
-#define YYMAXDEPTH 10000
-#endif
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
-int yyparse (void);
+#define YYMAXDEPTH YYSTACKSIZE
 #endif
-\f
-#if __GNUC__ > 1               /* GNU C and GNU C++ define this.  */
-#define __yy_memcpy(TO,FROM,COUNT)     __builtin_memcpy(TO,FROM,COUNT)
-#else                          /* not GNU C or C++ */
-#ifndef __cplusplus
-
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
-static void
-__yy_memcpy (to, from, count)
-     char *to;
-     char *from;
-     int count;
-{
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
-}
-
-#else /* __cplusplus */
+#else
+#ifdef YYMAXDEPTH
+#define YYSTACKSIZE YYMAXDEPTH
+#else
+#define YYSTACKSIZE 500
+#define YYMAXDEPTH 500
+#endif
+#endif
+int yydebug;
+int yynerrs;
+int yyerrflag;
+int yychar;
+short *yyssp;
+YYSTYPE *yyvsp;
+YYSTYPE yyval;
+YYSTYPE yylval;
+short yyss[YYSTACKSIZE];
+YYSTYPE yyvs[YYSTACKSIZE];
+#define yystacksize YYSTACKSIZE
+#line 174 "xi-parse.bison"
 
-/* This is the most reliable way to avoid incompatibilities
-   in available built-in functions on various systems.  */
-static void
-__yy_memcpy (char *to, char *from, int count)
+int yyerror(char *mesg)
 {
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
-
-  while (i-- > 0)
-    *t++ = *f++;
+       cout << "Syntax error at line " << lineno << ": " << mesg << endl;
+       return 0;
 }
 
-#endif
-#endif
-\f
-#line 196 "/local/encap/bison-1.25/share/bison.simple"
-
-/* The user can define YYPARSE_PARAM as the name of an argument to be passed
-   into yyparse.  The argument should have type void *.
-   It should actually point to an object.
-   Grammar actions can access the variable by casting it
-   to the proper pointer type.  */
-
-#ifdef YYPARSE_PARAM
-#ifdef __cplusplus
-#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL
-#else /* not __cplusplus */
-#define YYPARSE_PARAM_ARG YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-#endif /* not __cplusplus */
-#else /* not YYPARSE_PARAM */
-#define YYPARSE_PARAM_ARG
-#define YYPARSE_PARAM_DECL
-#endif /* not YYPARSE_PARAM */
-
+#line 233 "y.tab.c"
+#define YYABORT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR goto yyerrlab
 int
-yyparse(YYPARSE_PARAM_ARG)
-     YYPARSE_PARAM_DECL
+yyparse()
 {
-  register int yystate;
-  register int yyn;
-  register short *yyssp;
-  register YYSTYPE *yyvsp;
-  int yyerrstatus;     /*  number of tokens to shift before error messages enabled */
-  int yychar1 = 0;             /*  lookahead token as an internal (translated) token number */
-
-  short        yyssa[YYINITDEPTH];     /*  the state stack                     */
-  YYSTYPE yyvsa[YYINITDEPTH];  /*  the semantic value stack            */
-
-  short *yyss = yyssa;         /*  refer to the stacks thru separate pointers */
-  YYSTYPE *yyvs = yyvsa;       /*  to allow yyoverflow to reallocate them elsewhere */
-
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylsa[YYINITDEPTH];  /*  the location stack                  */
-  YYLTYPE *yyls = yylsa;
-  YYLTYPE *yylsp;
-
-#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
-#else
-#define YYPOPSTACK   (yyvsp--, yyssp--)
-#endif
+    register int yym, yyn, yystate;
+#if YYDEBUG
+    register char *yys;
+    extern char *getenv();
 
-  int yystacksize = YYINITDEPTH;
-
-#ifdef YYPURE
-  int yychar;
-  YYSTYPE yylval;
-  int yynerrs;
-#ifdef YYLSP_NEEDED
-  YYLTYPE yylloc;
-#endif
-#endif
-
-  YYSTYPE yyval;               /*  the variable used to return         */
-                               /*  semantic values from the action     */
-                               /*  routines                            */
-
-  int yylen;
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Starting parse\n");
-#endif
-
-  yystate = 0;
-  yyerrstatus = 0;
-  yynerrs = 0;
-  yychar = YYEMPTY;            /* Cause a token to be read.  */
-
-  /* Initialize stack pointers.
-     Waste one element of value and location stack
-     so that they stay on the same level as the state stack.
-     The wasted elements are never initialized.  */
-
-  yyssp = yyss - 1;
-  yyvsp = yyvs;
-#ifdef YYLSP_NEEDED
-  yylsp = yyls;
-#endif
-
-/* Push a new state, which is found in  yystate  .  */
-/* In all cases, when you get here, the value and location stacks
-   have just been pushed. so pushing a state here evens the stacks.  */
-yynewstate:
-
-  *++yyssp = yystate;
-
-  if (yyssp >= yyss + yystacksize - 1)
+    if (yys = getenv("YYDEBUG"))
     {
-      /* Give user a chance to reallocate the stack */
-      /* Use copies of these so that the &'s don't force the real ones into memory. */
-      YYSTYPE *yyvs1 = yyvs;
-      short *yyss1 = yyss;
-#ifdef YYLSP_NEEDED
-      YYLTYPE *yyls1 = yyls;
-#endif
-
-      /* Get the current used size of the three stacks, in elements.  */
-      int size = yyssp - yyss + 1;
-
-#ifdef yyoverflow
-      /* Each stack pointer address is followed by the size of
-        the data in use in that stack, in bytes.  */
-#ifdef YYLSP_NEEDED
-      /* This used to be a conditional around just the two extra args,
-        but that might be undefined if yyoverflow is a macro.  */
-      yyoverflow("parser stack overflow",
-                &yyss1, size * sizeof (*yyssp),
-                &yyvs1, size * sizeof (*yyvsp),
-                &yyls1, size * sizeof (*yylsp),
-                &yystacksize);
-#else
-      yyoverflow("parser stack overflow",
-                &yyss1, size * sizeof (*yyssp),
-                &yyvs1, size * sizeof (*yyvsp),
-                &yystacksize);
-#endif
-
-      yyss = yyss1; yyvs = yyvs1;
-#ifdef YYLSP_NEEDED
-      yyls = yyls1;
-#endif
-#else /* no yyoverflow */
-      /* Extend the stack our own way.  */
-      if (yystacksize >= YYMAXDEPTH)
-       {
-         yyerror("parser stack overflow");
-         return 2;
-       }
-      yystacksize *= 2;
-      if (yystacksize > YYMAXDEPTH)
-       yystacksize = YYMAXDEPTH;
-      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
-      __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
-      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
-      __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
-#ifdef YYLSP_NEEDED
-      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
-      __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
-#endif
-#endif /* no yyoverflow */
-
-      yyssp = yyss + size - 1;
-      yyvsp = yyvs + size - 1;
-#ifdef YYLSP_NEEDED
-      yylsp = yyls + size - 1;
-#endif
-
-#if YYDEBUG != 0
-      if (yydebug)
-       fprintf(stderr, "Stack size increased to %d\n", yystacksize);
-#endif
-
-      if (yyssp >= yyss + yystacksize - 1)
-       YYABORT;
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
     }
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Entering state %d\n", yystate);
 #endif
 
-  goto yybackup;
- yybackup:
-
-/* Do appropriate processing given the current state.  */
-/* Read a lookahead token if we need one and don't already have one.  */
-/* yyresume: */
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = (-1);
 
-  /* First try to decide what to do without reference to lookahead token.  */
+    yyssp = yyss;
+    yyvsp = yyvs;
+    *yyssp = yystate = 0;
 
-  yyn = yypact[yystate];
-  if (yyn == YYFLAG)
-    goto yydefault;
-
-  /* Not known => get a lookahead token if don't already have one.  */
-
-  /* yychar is either YYEMPTY or YYEOF
-     or a valid token in external form.  */
-
-  if (yychar == YYEMPTY)
+yyloop:
+    if (yyn = yydefred[yystate]) goto yyreduce;
+    if (yychar < 0)
     {
-#if YYDEBUG != 0
-      if (yydebug)
-       fprintf(stderr, "Reading a token: ");
+        if ((yychar = yylex()) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = 0;
+            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+            if (!yys) yys = "illegal-symbol";
+            printf("yydebug: state %d, reading %d (%s)\n", yystate,
+                    yychar, yys);
+        }
 #endif
-      yychar = YYLEX;
     }
-
-  /* Convert token to internal form (in yychar1) for indexing tables with */
-
-  if (yychar <= 0)             /* This means end of input. */
+    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
     {
-      yychar1 = 0;
-      yychar = YYEOF;          /* Don't call YYLEX any more */
-
-#if YYDEBUG != 0
-      if (yydebug)
-       fprintf(stderr, "Now at end of input.\n");
-#endif
+#if YYDEBUG
+        if (yydebug)
+            printf("yydebug: state %d, shifting to state %d\n",
+                    yystate, yytable[yyn]);
+#endif
+        if (yyssp >= yyss + yystacksize - 1)
+        {
+            goto yyoverflow;
+        }
+        *++yyssp = yystate = yytable[yyn];
+        *++yyvsp = yylval;
+        yychar = (-1);
+        if (yyerrflag > 0)  --yyerrflag;
+        goto yyloop;
     }
-  else
+    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
     {
-      yychar1 = YYTRANSLATE(yychar);
-
-#if YYDEBUG != 0
-      if (yydebug)
-       {
-         fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
-         /* Give the individual parser a way to print the precise meaning
-            of a token, for further debugging info.  */
-#ifdef YYPRINT
-         YYPRINT (stderr, yychar, yylval);
+        yyn = yytable[yyn];
+        goto yyreduce;
+    }
+    if (yyerrflag) goto yyinrecovery;
+#ifdef lint
+    goto yynewerror;
 #endif
-         fprintf (stderr, ")\n");
-       }
+yynewerror:
+    yyerror("syntax error");
+#ifdef lint
+    goto yyerrlab;
 #endif
+yyerrlab:
+    ++yynerrs;
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("yydebug: state %d, error recovery shifting\
+ to state %d\n", *yyssp, yytable[yyn]);
+#endif
+                if (yyssp >= yyss + yystacksize - 1)
+                {
+                    goto yyoverflow;
+                }
+                *++yyssp = yystate = yytable[yyn];
+                *++yyvsp = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("yydebug: error recovery discarding state %d\n",
+                            *yyssp);
+#endif
+                if (yyssp <= yyss) goto yyabort;
+                --yyssp;
+                --yyvsp;
+            }
+        }
     }
-
-  yyn += yychar1;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
-    goto yydefault;
-
-  yyn = yytable[yyn];
-
-  /* yyn is what to do for this token type in this state.
-     Negative => reduce, -yyn is rule number.
-     Positive => shift, yyn is new state.
-       New state is final state => don't bother to shift,
-       just return success.
-     0, or most negative number => error.  */
-
-  if (yyn < 0)
+    else
     {
-      if (yyn == YYFLAG)
-       goto yyerrlab;
-      yyn = -yyn;
-      goto yyreduce;
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = 0;
+            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+            if (!yys) yys = "illegal-symbol";
+            printf("yydebug: state %d, error recovery discards token %d (%s)\n",
+                    yystate, yychar, yys);
+        }
+#endif
+        yychar = (-1);
+        goto yyloop;
     }
-  else if (yyn == 0)
-    goto yyerrlab;
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-  /* Shift the lookahead token.  */
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
-
-  /* Discard the token being shifted unless it is eof.  */
-  if (yychar != YYEOF)
-    yychar = YYEMPTY;
-
-  *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
-
-  /* count tokens shifted since error; after three, turn off error status.  */
-  if (yyerrstatus) yyerrstatus--;
-
-  yystate = yyn;
-  goto yynewstate;
-
-/* Do the default action for the current state.  */
-yydefault:
-
-  yyn = yydefact[yystate];
-  if (yyn == 0)
-    goto yyerrlab;
-
-/* Do a reduction.  yyn is the number of a rule to reduce with.  */
 yyreduce:
-  yylen = yyr2[yyn];
-  if (yylen > 0)
-    yyval = yyvsp[1-yylen]; /* implement default value of the action */
-
-#if YYDEBUG != 0
-  if (yydebug)
+#if YYDEBUG
+    if (yydebug)
+        printf("yydebug: state %d, reducing by rule %d (%s)\n",
+                yystate, yyn, yyrule[yyn]);
+#endif
+    yym = yylen[yyn];
+    yyval = yyvsp[1-yym];
+    switch (yyn)
     {
-      int i;
-
-      fprintf (stderr, "Reducing via rule %d (line %d), ",
-              yyn, yyrline[yyn]);
-
-      /* Print the symbols being reduced, and their result.  */
-      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
-       fprintf (stderr, "%s ", yytname[yyrhs[i]]);
-      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
-    }
-#endif
-
-
-  switch (yyn) {
-
 case 12:
 #line 58 "xi-parse.bison"
-{ yyval.intval = FALSE; ;
-    break;}
+{ yyval.intval = FALSE; }
+break;
 case 13:
 #line 60 "xi-parse.bison"
-{ yyval.intval = TRUE; ;
-    break;}
+{ yyval.intval = TRUE; }
+break;
 case 14:
 #line 64 "xi-parse.bison"
 {
                        Chare *c = new Chare(yyvsp[-1].strval, BOC, yyvsp[-3].intval) ;
                        delete yyvsp[-1].strval;
                        thismodule->AddChare(c) ;
-               ;
-    break;}
+               }
+break;
 case 16:
 #line 73 "xi-parse.bison"
 {
                        Chare *c = new Chare(yyvsp[-1].strval, CHARE, yyvsp[-3].intval) ;
                        delete yyvsp[-1].strval;
                        thismodule->AddChare(c) ;
-               ;
-    break;}
+               }
+break;
 case 22:
 #line 93 "xi-parse.bison"
 {
                        yyval.strval = NULL;
-               ;
-    break;}
+               }
+break;
 case 24:
 #line 101 "xi-parse.bison"
-{ yyval.intval = FALSE; ;
-    break;}
+{ yyval.intval = FALSE; }
+break;
 case 25:
 #line 103 "xi-parse.bison"
-{ yyval.intval = TRUE; ;
-    break;}
+{ yyval.intval = TRUE; }
+break;
 case 26:
 #line 107 "xi-parse.bison"
 {
                        thismodule->chares->AddEntry(yyvsp[-4].strval, yyvsp[-2].strval, yyvsp[-7].intval, yyvsp[-6].strval) ;
                        delete yyvsp[-4].strval; delete yyvsp[-2].strval;
-               ;
-    break;}
+               }
+break;
 case 28:
 #line 117 "xi-parse.bison"
 {
                        Message *m = new Message(yyvsp[-1].strval, 0, yyvsp[-3].intval) ;
                        delete yyvsp[-1].strval;
                        thismodule->AddMessage(m) ;
-               ;
-    break;}
+               }
+break;
 case 29:
 #line 125 "xi-parse.bison"
 {
                        Message *m = new Message(yyvsp[-1].strval, 1, yyvsp[-3].intval) ;
                        delete yyvsp[-1].strval;
                        thismodule->AddMessage(m) ;
-               ;
-    break;}
+               }
+break;
 case 31:
 #line 136 "xi-parse.bison"
 {
                        ReadOnly *r = new ReadOnly(yyvsp[-1].strval, yyvsp[-2].strval, 0) ;
                        delete yyvsp[-2].strval;
                        thismodule->AddReadOnly(r) ;
-               ;
-    break;}
+               }
+break;
 case 32:
 #line 142 "xi-parse.bison"
 {
                        ReadOnly *r = new ReadOnly(yyvsp[-1].strval, yyvsp[-2].strval, 1) ;
                        delete yyvsp[-2].strval;
                        thismodule->AddReadOnly(r) ;
-               ;
-    break;}
+               }
+break;
 case 34:
 #line 153 "xi-parse.bison"
 {
                        yyval.strval = strcat(strcpy(new char[2+strlen(yyvsp[-1].strval)], yyvsp[-1].strval), "*");
                        delete yyvsp[-1].strval;
-               ;
-    break;}
+               }
+break;
 case 36:
 #line 163 "xi-parse.bison"
 {
                        Table *t = new Table(yyvsp[-1].strval) ;
                        delete yyvsp[-1].strval;
                        thismodule->AddTable(t) ;
-               ;
-    break;}
-}
-   /* the action file gets copied in in place of this dollarsign */
-#line 498 "/local/encap/bison-1.25/share/bison.simple"
-\f
-  yyvsp -= yylen;
-  yyssp -= yylen;
-#ifdef YYLSP_NEEDED
-  yylsp -= yylen;
-#endif
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "state stack now");
-      while (ssp1 != yyssp)
-       fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
-    }
-#endif
-
-  *++yyvsp = yyval;
-
-#ifdef YYLSP_NEEDED
-  yylsp++;
-  if (yylen == 0)
-    {
-      yylsp->first_line = yylloc.first_line;
-      yylsp->first_column = yylloc.first_column;
-      yylsp->last_line = (yylsp-1)->last_line;
-      yylsp->last_column = (yylsp-1)->last_column;
-      yylsp->text = 0;
-    }
-  else
-    {
-      yylsp->last_line = (yylsp+yylen-1)->last_line;
-      yylsp->last_column = (yylsp+yylen-1)->last_column;
-    }
-#endif
-
-  /* Now "shift" the result of the reduction.
-     Determine what state that goes to,
-     based on the state we popped back to
-     and the rule number reduced by.  */
-
-  yyn = yyr1[yyn];
-
-  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
-  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
-    yystate = yytable[yystate];
-  else
-    yystate = yydefgoto[yyn - YYNTBASE];
-
-  goto yynewstate;
-
-yyerrlab:   /* here on detecting error */
-
-  if (! yyerrstatus)
-    /* If not already recovering from an error, report this error.  */
-    {
-      ++yynerrs;
-
-#ifdef YYERROR_VERBOSE
-      yyn = yypact[yystate];
-
-      if (yyn > YYFLAG && yyn < YYLAST)
-       {
-         int size = 0;
-         char *msg;
-         int x, count;
-
-         count = 0;
-         /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
-         for (x = (yyn < 0 ? -yyn : 0);
-              x < (sizeof(yytname) / sizeof(char *)); x++)
-           if (yycheck[x + yyn] == x)
-             size += strlen(yytname[x]) + 15, count++;
-         msg = (char *) malloc(size + 15);
-         if (msg != 0)
-           {
-             strcpy(msg, "parse error");
-
-             if (count < 5)
-               {
-                 count = 0;
-                 for (x = (yyn < 0 ? -yyn : 0);
-                      x < (sizeof(yytname) / sizeof(char *)); x++)
-                   if (yycheck[x + yyn] == x)
-                     {
-                       strcat(msg, count == 0 ? ", expecting `" : " or `");
-                       strcat(msg, yytname[x]);
-                       strcat(msg, "'");
-                       count++;
-                     }
                }
-             yyerror(msg);
-             free(msg);
-           }
-         else
-           yyerror ("parse error; also virtual memory exceeded");
-       }
-      else
-#endif /* YYERROR_VERBOSE */
-       yyerror("parse error");
+break;
+#line 465 "y.tab.c"
     }
-
-  goto yyerrlab1;
-yyerrlab1:   /* here on error raised explicitly by an action */
-
-  if (yyerrstatus == 3)
+    yyssp -= yym;
+    yystate = *yyssp;
+    yyvsp -= yym;
+    yym = yylhs[yyn];
+    if (yystate == 0 && yym == 0)
     {
-      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
-
-      /* return failure if at end of input */
-      if (yychar == YYEOF)
-       YYABORT;
-
-#if YYDEBUG != 0
-      if (yydebug)
-       fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
-#endif
-
-      yychar = YYEMPTY;
+#if YYDEBUG
+        if (yydebug)
+            printf("yydebug: after reduction, shifting from state 0 to\
+ state %d\n", YYFINAL);
+#endif
+        yystate = YYFINAL;
+        *++yyssp = YYFINAL;
+        *++yyvsp = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = yylex()) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = 0;
+                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
+                if (!yys) yys = "illegal-symbol";
+                printf("yydebug: state %d, reading %d (%s)\n",
+                        YYFINAL, yychar, yys);
+            }
+#endif
+        }
+        if (yychar == 0) goto yyaccept;
+        goto yyloop;
     }
-
-  /* Else will try to reuse lookahead token
-     after shifting the error token.  */
-
-  yyerrstatus = 3;             /* Each real token shifted decrements this */
-
-  goto yyerrhandle;
-
-yyerrdefault:  /* current state does not do anything special for the error token. */
-
-#if 0
-  /* This is wrong; only states that explicitly want error tokens
-     should shift them.  */
-  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
-  if (yyn) goto yydefault;
-#endif
-
-yyerrpop:   /* pop the current state because it cannot handle the error token */
-
-  if (yyssp == yyss) YYABORT;
-  yyvsp--;
-  yystate = *--yyssp;
-#ifdef YYLSP_NEEDED
-  yylsp--;
-#endif
-
-#if YYDEBUG != 0
-  if (yydebug)
-    {
-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "Error: state stack now");
-      while (ssp1 != yyssp)
-       fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
-    }
-#endif
-
-yyerrhandle:
-
-  yyn = yypact[yystate];
-  if (yyn == YYFLAG)
-    goto yyerrdefault;
-
-  yyn += YYTERROR;
-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
-    goto yyerrdefault;
-
-  yyn = yytable[yyn];
-  if (yyn < 0)
+    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
+            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
+        yystate = yytable[yyn];
+    else
+        yystate = yydgoto[yym];
+#if YYDEBUG
+    if (yydebug)
+        printf("yydebug: after reduction, shifting from state %d \
+to state %d\n", *yyssp, yystate);
+#endif
+    if (yyssp >= yyss + yystacksize - 1)
     {
-      if (yyn == YYFLAG)
-       goto yyerrpop;
-      yyn = -yyn;
-      goto yyreduce;
+        goto yyoverflow;
     }
-  else if (yyn == 0)
-    goto yyerrpop;
-
-  if (yyn == YYFINAL)
-    YYACCEPT;
-
-#if YYDEBUG != 0
-  if (yydebug)
-    fprintf(stderr, "Shifting error token, ");
-#endif
-
-  *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
-  *++yylsp = yylloc;
-#endif
-
-  yystate = yyn;
-  goto yynewstate;
-}
-#line 173 "xi-parse.bison"
-
-
-int yyerror(char *mesg)
-{
-       cout << "Syntax error at line " << lineno << ": " << mesg << endl;
-       return 0;
+    *++yyssp = yystate;
+    *++yyvsp = yyval;
+    goto yyloop;
+yyoverflow:
+    yyerror("yacc stack overflow");
+yyabort:
+    return (1);
+yyaccept:
+    return (0);
 }
-
index e9575e7aaebe999e1cbb8a544d354f1ef85e695f..1f007d563e1c10b994a64e293f0bcc932ac4edcb 100644 (file)
@@ -1,17 +1,15 @@
+#define BOC 257
+#define CHARE 258
+#define ENTRY 259
+#define MESSAGE 260
+#define PACKMESSAGE 261
+#define READONLY 262
+#define TABLE 263
+#define THREADED 264
+#define EXTERN 265
+#define IDENTIFIER 266
 typedef union {
        char *strval;
        int intval;
 } YYSTYPE;
-#define        BOC     258
-#define        CHARE   259
-#define        ENTRY   260
-#define        MESSAGE 261
-#define        PACKMESSAGE     262
-#define        READONLY        263
-#define        TABLE   264
-#define        THREADED        265
-#define        EXTERN  266
-#define        IDENTIFIER      267
-
-
 extern YYSTYPE yylval;