* bison.s1 (#line): All set to `#line' only, since the Makefile

[bison.git] / src / bison.s1

diff --git a/src/bison.s1 b/src/bison.s1
index fe702839e26a46fcc6bfdd2ae58f11c7e718bf23..8de2ccd341922aaa5f18a53edab67438b2e03bf4 100644 (file)
--- a/src/bison.s1
+++ b/src/bison.s1
@@ -1,5 +1,6 @@
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */

-#line 3 "bison.simple"
+#line
+/* This file comes from bison-@bison_version@.  */

 
 /* Skeleton output parser for bison,
    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 
 /* Skeleton output parser for bison,
    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.


@@ -16,43 +17,69 @@
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
 
    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.  */
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */

 
 

-
-#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);
-};
-#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.  */
+/* 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.  */

 
 /* 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.  */
 
 
 /* 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.  */
 

+#ifndef YYSTACK_USE_ALLOCA
+# ifdef alloca
+#  define YYSTACK_USE_ALLOCA
+# else /* alloca not defined */
+#  ifdef __GNUC__
+#   define YYSTACK_USE_ALLOCA
+#   define alloca __builtin_alloca
+#  else /* not GNU C.  */
+#   if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+#    define YYSTACK_USE_ALLOCA
+#    include <alloca.h>
+#   else /* not sparc */
+     /* We think this test detects Watcom and Microsoft C.  */
+     /* This used to test MSDOS, but that is a bad idea since that
+       symbol is in the user namespace.  */
+#    if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+#     if 0
+       /* No need for malloc.h, which pollutes the namespace; instead,
+         just don't use alloca.  */
+#      include <malloc.h>
+#     endif
+#    else /* not MSDOS, or __TURBOC__ */
+#     if defined(_AIX)
+       /* I don't know what this was needed for, but it pollutes the
+         namespace.  So I turned it off.  rms, 2 May 1997.  */
+       /* #include <malloc.h>  */
+ #pragma alloca
+#      define YYSTACK_USE_ALLOCA
+#     else /* not MSDOS, or __TURBOC__, or _AIX */
+#      if 0
+       /* haible@ilog.fr says this works for HPUX 9.05 and up, and on
+          HPUX 10.  Eventually we can turn this on.  */
+#       ifdef __hpux
+#        define YYSTACK_USE_ALLOCA
+#        define alloca __builtin_alloca
+#      endif /* __hpux */
+#      endif
+#     endif /* not _AIX */
+#    endif /* not MSDOS, or __TURBOC__ */
+#   endif /* not sparc */
+#  endif /* not GNU C */
+# endif /* alloca not defined */
+#endif /* YYSTACK_USE_ALLOCA not defined */
+
+#ifdef YYSTACK_USE_ALLOCA
+# define YYSTACK_ALLOC alloca
+#else
+# define YYSTACK_ALLOC malloc
+#endif
+

 /* 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.  */
 /* 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.  */


@@ -61,8 +88,8 @@ void *alloca ();
 #define yyclearin      (yychar = YYEMPTY)
 #define YYEMPTY                -2
 #define YYEOF          0
 #define yyclearin      (yychar = YYEMPTY)
 #define YYEMPTY                -2
 #define YYEOF          0

-#define YYACCEPT       return(0)
-#define YYABORT        return(1)
+#define YYACCEPT       goto yyacceptlab
+#define YYABORT        goto yyabortlab

 #define YYERROR                goto yyerrlab1
 /* Like YYERROR except do call yyerror.
    This remains here temporarily to ease the
 #define YYERROR                goto yyerrlab1
 /* Like YYERROR except do call yyerror.
    This remains here temporarily to ease the


@@ -86,23 +113,23 @@ while (0)
 #define YYERRCODE      256
 
 #ifndef YYPURE
 #define YYERRCODE      256
 
 #ifndef YYPURE

-#define YYLEX          yylex()
+# define YYLEX         yylex()

 #endif
 
 #ifdef YYPURE
 #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 */
+# 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 */
 #endif
 
 /* If nonreentrant, generate the variables here */


@@ -113,54 +140,61 @@ int       yychar;                 /*  the lookahead symbol                */
 YYSTYPE        yylval;                 /*  the semantic value of the           */
                                /*  lookahead symbol                    */
 
 YYSTYPE        yylval;                 /*  the semantic value of the           */
                                /*  lookahead symbol                    */
 

-#ifdef YYLSP_NEEDED
+# ifdef YYLSP_NEEDED

 YYLTYPE yylloc;                        /*  location data for the lookahead     */
                                /*  symbol                              */
 YYLTYPE yylloc;                        /*  location data for the lookahead     */
                                /*  symbol                              */

-#endif
+# endif

 
 int yynerrs;                   /*  number of parse errors so far       */
 #endif  /* not YYPURE */
 
 
 int yynerrs;                   /*  number of parse errors so far       */
 #endif  /* not YYPURE */
 

+

 #if YYDEBUG != 0
 int yydebug;                   /*  nonzero means print parse trace     */
 #if YYDEBUG != 0
 int yydebug;                   /*  nonzero means print parse trace     */

-/* Since this is uninitialized, it does not stop multiple parsers
-   from coexisting.  */
+
+  /* [The following comment makes no sense to me.  Could someone
+     clarify it?  --akim] Since this is uninitialized, it does not
+     stop multiple parsers from coexisting.  */
+#else
+  /* To avoid crippling this file with `#if YYDEBUG', define `yydebug'
+     as `0', so that the `if (yydebug)' be removed as dead code.  */
+# define yydebug 0

 #endif
 
 /*  YYINITDEPTH indicates the initial size of the parser's stacks      */
 
 #ifndef        YYINITDEPTH
 #endif
 
 /*  YYINITDEPTH indicates the initial size of the parser's stacks      */
 
 #ifndef        YYINITDEPTH

-#define YYINITDEPTH 200
+# 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
 #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
+# undef YYMAXDEPTH

 #endif
 
 #ifndef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH

-#define YYMAXDEPTH 10000
-#endif
-
-/* Prevent warning if -Wstrict-prototypes.  */
-#ifdef __GNUC__
-int yyparse (void);
+# define YYMAXDEPTH 10000

 #endif
 \f
 #endif
 \f

+/* Define __yy_memcpy.  Note that the size argument
+   should be passed with type unsigned int, because that is what the non-GCC
+   definitions require.  With GCC, __builtin_memcpy takes an arg
+   of type size_t, but it can handle unsigned int.  */
+

 #if __GNUC__ > 1               /* GNU C and GNU C++ define this.  */
 #if __GNUC__ > 1               /* GNU C and GNU C++ define this.  */

-#define __yy_bcopy(FROM,TO,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
+# define __yy_memcpy(TO,FROM,COUNT)    __builtin_memcpy(TO,FROM,COUNT)

 #else                          /* not GNU C or C++ */
 #else                          /* not GNU C or C++ */

-#ifndef __cplusplus
+# ifndef __cplusplus

 
 /* This is the most reliable way to avoid incompatibilities
    in available built-in functions on various systems.  */
 static void
 
 /* This is the most reliable way to avoid incompatibilities
    in available built-in functions on various systems.  */
 static void

-__yy_bcopy (from, to, count)
-     char *from;
+__yy_memcpy (to, from, count)

      char *to;
      char *to;

-     int count;
+     char *from;
+     unsigned int count;

 {
   register char *f = from;
   register char *t = to;
 {
   register char *f = from;
   register char *t = to;


@@ -170,25 +204,25 @@ __yy_bcopy (from, to, count)
     *t++ = *f++;
 }
 
     *t++ = *f++;
 }
 

-#else /* __cplusplus */
+# else /* __cplusplus */

 
 /* This is the most reliable way to avoid incompatibilities
    in available built-in functions on various systems.  */
 static void
 
 /* This is the most reliable way to avoid incompatibilities
    in available built-in functions on various systems.  */
 static void

-__yy_bcopy (char *from, char *to, int count)
+__yy_memcpy (char *to, char *from, unsigned int count)

 {
 {

-  register char *f = from;

   register char *t = to;
   register char *t = to;

+  register char *f = from;

   register int i = count;
 
   while (i-- > 0)
     *t++ = *f++;
 }
 
   register int i = count;
 
   while (i-- > 0)
     *t++ = *f++;
 }
 

-#endif
+# endif

 #endif
 \f
 #endif
 \f

-#line 192 "bison.simple"
+#line

 
 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
    into yyparse.  The argument should have type void *.
 
 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
    into yyparse.  The argument should have type void *.


@@ -197,60 +231,90 @@ __yy_bcopy (char *from, char *to, int count)
    to the proper pointer type.  */
 
 #ifdef YYPARSE_PARAM
    to the proper pointer type.  */
 
 #ifdef YYPARSE_PARAM

-#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-#else
-#define YYPARSE_PARAM
-#define YYPARSE_PARAM_DECL
+# 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 */
+
+/* Prevent warning if -Wstrict-prototypes.  */
+#ifdef __GNUC__
+# ifdef YYPARSE_PARAM
+int yyparse (void *);
+# else
+int yyparse (void);
+# endif

 #endif
 
 int
 #endif
 
 int

-yyparse(YYPARSE_PARAM)
+yyparse(YYPARSE_PARAM_ARG)

      YYPARSE_PARAM_DECL
 {
   register int yystate;
   register int yyn;
      YYPARSE_PARAM_DECL
 {
   register int yystate;
   register int yyn;

+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yychar1 = 0;
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yysv': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack. */
+  short        yyssa[YYINITDEPTH];
+  short *yyss = yyssa;

   register short *yyssp;
   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 */
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  register YYSTYPE *yyvsp;

 
 #ifdef YYLSP_NEEDED
 
 #ifdef YYLSP_NEEDED

-  YYLTYPE yylsa[YYINITDEPTH];  /*  the location stack                  */
+  /* The location stack.  */
+  YYLTYPE yylsa[YYINITDEPTH];

   YYLTYPE *yyls = yylsa;
   YYLTYPE *yylsp;
   YYLTYPE *yyls = yylsa;
   YYLTYPE *yylsp;

+#endif

 
 

-#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#ifdef YYLSP_NEEDED
+# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)

 #else
 #else

-#define YYPOPSTACK   (yyvsp--, yyssp--)
+# define YYPOPSTACK   (yyvsp--, yyssp--)

 #endif
 
   int yystacksize = YYINITDEPTH;
 #endif
 
   int yystacksize = YYINITDEPTH;

+  int yyfree_stacks = 0;

 
 #ifdef YYPURE
   int yychar;
   YYSTYPE yylval;
   int yynerrs;
 
 #ifdef YYPURE
   int yychar;
   YYSTYPE yylval;
   int yynerrs;

-#ifdef YYLSP_NEEDED
+# ifdef YYLSP_NEEDED

   YYLTYPE yylloc;
   YYLTYPE yylloc;

+# endif

 #endif
 #endif

-#endif

 
 

-  YYSTYPE yyval;               /*  the variable used to return         */
-                               /*  semantic values from the action     */
-                               /*  routines                            */
+
+  /* The variable used to return semantic values from the action
+     routines.  */
+  YYSTYPE yyval;

 
   int yylen;
 
 
   int yylen;
 

-#if YYDEBUG != 0

   if (yydebug)
   if (yydebug)

-    fprintf(stderr, "Starting parse\n");
-#endif
+    fprintf (stderr, "Starting parse\n");

 
   yystate = 0;
   yyerrstatus = 0;
 
   yystate = 0;
   yyerrstatus = 0;


@@ -291,43 +355,57 @@ yynewstate:
 #ifdef yyoverflow
       /* Each stack pointer address is followed by the size of
         the data in use in that stack, in bytes.  */
 #ifdef yyoverflow
       /* Each stack pointer address is followed by the size of
         the data in use in that stack, in bytes.  */

-#ifdef YYLSP_NEEDED
+# 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.  */
       /* 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
+      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;
 
       yyss = yyss1; yyvs = yyvs1;

-#ifdef YYLSP_NEEDED
+# ifdef YYLSP_NEEDED

       yyls = yyls1;
       yyls = yyls1;

-#endif
+# endif

 #else /* no yyoverflow */
       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)
        {
          yyerror("parser stack overflow");
 #else /* no yyoverflow */
       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)
        {
          yyerror("parser stack overflow");

+         if (yyfree_stacks)
+           {
+             free (yyss);
+             free (yyvs);
+# ifdef YYLSP_NEEDED
+             free (yyls);
+# endif
+           }

          return 2;
        }
       yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)
        yystacksize = YYMAXDEPTH;
          return 2;
        }
       yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)
        yystacksize = YYMAXDEPTH;

-      yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
-      __yy_bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
-      yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
-      __yy_bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
-#ifdef YYLSP_NEEDED
-      yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
-      __yy_bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
-#endif
+# ifndef YYSTACK_USE_ALLOCA
+      yyfree_stacks = 1;
+# endif
+      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
+      __yy_memcpy ((char *)yyss, (char *)yyss1,
+                  size * (unsigned int) sizeof (*yyssp));
+      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
+      __yy_memcpy ((char *)yyvs, (char *)yyvs1,
+                  size * (unsigned int) sizeof (*yyvsp));
+# ifdef YYLSP_NEEDED
+      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
+      __yy_memcpy ((char *)yyls, (char *)yyls1,
+                  size * (unsigned int) sizeof (*yylsp));
+# endif

 #endif /* no yyoverflow */
 
       yyssp = yyss + size - 1;
 #endif /* no yyoverflow */
 
       yyssp = yyss + size - 1;


@@ -336,19 +414,15 @@ yynewstate:
       yylsp = yyls + size - 1;
 #endif
 
       yylsp = yyls + size - 1;
 #endif
 

-#if YYDEBUG != 0

       if (yydebug)
       if (yydebug)

-       fprintf(stderr, "Stack size increased to %d\n", yystacksize);
-#endif
+       fprintf (stderr, "Stack size increased to %d\n", yystacksize);

 
       if (yyssp >= yyss + yystacksize - 1)
        YYABORT;
     }
 
 
       if (yyssp >= yyss + yystacksize - 1)
        YYABORT;
     }
 

-#if YYDEBUG != 0

   if (yydebug)
   if (yydebug)

-    fprintf(stderr, "Entering state %d\n", yystate);
-#endif
+    fprintf (stderr, "Entering state %d\n", yystate);

 
   goto yybackup;
  yybackup:
 
   goto yybackup;
  yybackup:


@@ -370,10 +444,8 @@ yynewstate:
 
   if (yychar == YYEMPTY)
     {
 
   if (yychar == YYEMPTY)
     {

-#if YYDEBUG != 0

       if (yydebug)
       if (yydebug)

-       fprintf(stderr, "Reading a token: ");
-#endif
+       fprintf (stderr, "Reading a token: ");

       yychar = YYLEX;
     }
 
       yychar = YYLEX;
     }
 


@@ -384,27 +456,23 @@ yynewstate:
       yychar1 = 0;
       yychar = YYEOF;          /* Don't call YYLEX any more */
 
       yychar1 = 0;
       yychar = YYEOF;          /* Don't call YYLEX any more */
 

-#if YYDEBUG != 0

       if (yydebug)
       if (yydebug)

-       fprintf(stderr, "Now at end of input.\n");
-#endif
+       fprintf (stderr, "Now at end of input.\n");

     }
   else
     {
       yychar1 = YYTRANSLATE(yychar);
 
     }
   else
     {
       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.  */
       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
+# ifdef YYPRINT

          YYPRINT (stderr, yychar, yylval);
          YYPRINT (stderr, yychar, yylval);

-#endif
+# endif

          fprintf (stderr, ")\n");
        }
          fprintf (stderr, ")\n");
        }

-#endif

     }
 
   yyn += yychar1;
     }
 
   yyn += yychar1;


@@ -435,10 +503,8 @@ yynewstate:
 
   /* Shift the lookahead token.  */
 
 
   /* Shift the lookahead token.  */
 

-#if YYDEBUG != 0

   if (yydebug)
   if (yydebug)

-    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
+    fprintf (stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);

 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)


@@ -468,7 +534,9 @@ yyreduce:
   if (yylen > 0)
     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 
   if (yylen > 0)
     yyval = yyvsp[1-yylen]; /* implement default value of the action */
 

-#if YYDEBUG != 0
+#if YYDEBUG
+  /* We have to keep this `#if YYDEBUG', since we use variables which
+     are defined only if `YYDEBUG' is set.  */

   if (yydebug)
     {
       int i;
   if (yydebug)
     {
       int i;


@@ -482,9 +550,8 @@ yyreduce:
       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     }
 #endif
       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     }
 #endif

-

 $   /* the action file gets copied in in place of this dollarsign */
 $   /* the action file gets copied in in place of this dollarsign */

-#line 487 "bison.simple"
+#line

 \f
   yyvsp -= yylen;
   yyssp -= yylen;
 \f
   yyvsp -= yylen;
   yyssp -= yylen;


@@ -492,7 +559,6 @@ $   /* the action file gets copied in in place of this dollarsign */
   yylsp -= yylen;
 #endif
 
   yylsp -= yylen;
 #endif
 

-#if YYDEBUG != 0

   if (yydebug)
     {
       short *ssp1 = yyss - 1;
   if (yydebug)
     {
       short *ssp1 = yyss - 1;


@@ -501,7 +567,6 @@ $   /* the action file gets copied in in place of this dollarsign */
        fprintf (stderr, " %d", *++ssp1);
       fprintf (stderr, "\n");
     }
        fprintf (stderr, " %d", *++ssp1);
       fprintf (stderr, "\n");
     }

-#endif

 
   *++yyvsp = yyval;
 
 
   *++yyvsp = yyval;
 


@@ -599,10 +664,9 @@ yyerrlab1:   /* here on error raised explicitly by an action */
       if (yychar == YYEOF)
        YYABORT;
 
       if (yychar == YYEOF)
        YYABORT;
 

-#if YYDEBUG != 0

       if (yydebug)
       if (yydebug)

-       fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
-#endif
+       fprintf (stderr, "Discarding token %d (%s).\n",
+                yychar, yytname[yychar1]);

 
       yychar = YYEMPTY;
     }
 
       yychar = YYEMPTY;
     }


@@ -632,7 +696,6 @@ yyerrpop:   /* pop the current state because it cannot handle the error token */
   yylsp--;
 #endif
 
   yylsp--;
 #endif
 

-#if YYDEBUG != 0

   if (yydebug)
     {
       short *ssp1 = yyss - 1;
   if (yydebug)
     {
       short *ssp1 = yyss - 1;


@@ -641,7 +704,6 @@ yyerrpop:   /* pop the current state because it cannot handle the error token */
        fprintf (stderr, " %d", *++ssp1);
       fprintf (stderr, "\n");
     }
        fprintf (stderr, " %d", *++ssp1);
       fprintf (stderr, "\n");
     }

-#endif

 
 yyerrhandle:
 
 
 yyerrhandle:
 


@@ -667,10 +729,8 @@ yyerrhandle:
   if (yyn == YYFINAL)
     YYACCEPT;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 

-#if YYDEBUG != 0

   if (yydebug)
   if (yydebug)

-    fprintf(stderr, "Shifting error token, ");
-#endif
+    fprintf (stderr, "Shifting error token, ");

 
   *++yyvsp = yylval;
 #ifdef YYLSP_NEEDED
 
   *++yyvsp = yylval;
 #ifdef YYLSP_NEEDED


@@ -679,4 +739,28 @@ yyerrhandle:
 
   yystate = yyn;
   goto yynewstate;
 
   yystate = yyn;
   goto yynewstate;

+
+ yyacceptlab:
+  /* YYACCEPT comes here.  */
+  if (yyfree_stacks)
+    {
+      free (yyss);
+      free (yyvs);
+#ifdef YYLSP_NEEDED
+      free (yyls);
+#endif
+    }
+  return 0;
+
+ yyabortlab:
+  /* YYABORT comes here.  */
+  if (yyfree_stacks)
+    {
+      free (yyss);
+      free (yyvs);
+#ifdef YYLSP_NEEDED
+      free (yyls);
+#endif
+    }
+  return 1;

 }
 }