* 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 701139be0ca06c67b9820aba19d90f3c1cd22bff..8de2ccd341922aaa5f18a53edab67438b2e03bf4 100644 (file)
--- a/src/bison.s1
+++ b/src/bison.s1
@@ -1,12 +1,13 @@
 /* -*-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,
 
 /* Skeleton output parser for bison,

-   Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
+   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
 
    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 1, or (at your option)
+   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,
    any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -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,15 +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
-#define YYLEX          yylex(&yylval, &yylloc)
-#else
-#define YYLEX          yylex(&yylval)
-#endif
+# 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 */


@@ -105,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;


@@ -162,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 184 "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 *.


@@ -189,59 +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
+# 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;


@@ -282,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;


@@ -327,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:


@@ -361,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;
     }
 


@@ -375,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;


@@ -426,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)


@@ -459,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;


@@ -473,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 479 "bison.simple"
+#line

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


@@ -483,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;


@@ -492,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;
 


@@ -590,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;
     }


@@ -623,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;


@@ -632,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:
 


@@ -658,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


@@ -670,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;

 }
 }