* tests/regression.at, tests/torture.at, tests/calc.at: Adjust to

[bison.git] / src / bison.simple

diff --git a/src/bison.simple b/src/bison.simple
index f0418796d4a69b5a132453615a4e7fb712a755b3..72cd1487273437cf25ffaba051ec3cff060164bd 100644 (file)
--- a/src/bison.simple
+++ b/src/bison.simple
@@ -1,9 +1,9 @@
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 #line
 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 #line

-/* This file comes from bison-@bison_version@.  */
-

 /* Skeleton output parser for bison,
 /* Skeleton output parser for bison,

-   Copyright 1984, 1989, 1990, 2000 Free Software Foundation, Inc.
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 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


@@ -30,59 +30,119 @@
    It was written by Richard Stallman by simplifying the hairy parser
    used when %semantic_parser is specified.  */
 
    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
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+#ifdef __cplusplus
+# define YYSTD(x) std::x

 #else
 #else

-# define YYSTACK_ALLOC malloc
+# define YYSTD(x) x

 #endif
 
 #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.  */
+#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# if YYSTACK_USE_ALLOCA
+#  define YYSTACK_ALLOC alloca
+# else
+#  ifndef YYSTACK_USE_ALLOCA
+#   if defined (alloca) || defined (_ALLOCA_H)
+#    define YYSTACK_ALLOC alloca
+#   else
+#    ifdef __GNUC__
+#     define YYSTACK_ALLOC __builtin_alloca
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning. */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+#  ifdef __cplusplus
+#   include <cstdlib> /* INFRINGES ON USER NAME SPACE */
+#   define YYSIZE_T std::size_t
+#  else
+#   ifdef __STDC__
+#    include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#    define YYSIZE_T size_t
+#   endif
+#  endif
+#  define YYSTACK_ALLOC YYSTD (malloc)
+#  define YYSTACK_FREE YYSTD (free)
+# endif
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  short yyss;
+  YYSTYPE yyvs;
+# if YYLSP_NEEDED
+  YYLTYPE yyls;
+# endif
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# if YYLSP_NEEDED
+#  define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))     \
+      + 2 * YYSTACK_GAP_MAX)
+# else
+#  define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (short) + sizeof (YYSTYPE))                                \
+      + YYSTACK_GAP_MAX)
+# endif
+
+/* Relocate the TYPE STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Type, Stack)                                 \
+    do                                                                 \
+      {                                                                        \
+       YYSIZE_T yynewbytes;                                            \
+       yymemcpy ((char *) yyptr, (char *) (Stack),                     \
+                 yysize * (YYSIZE_T) sizeof (Type));                   \
+       Stack = &yyptr->Stack;                                          \
+       yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX;     \
+       yyptr += yynewbytes / sizeof (*yyptr);                          \
+      }                                                                        \
+    while (0)
+
+#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
+
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# ifdef __cplusplus
+#  include <cstddef> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T std::size_t
+# else
+#  ifdef __STDC__
+#   include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#   define YYSIZE_T size_t
+#  endif
+# endif
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif

 
 #define yyerrok                (yyerrstatus = 0)
 #define yyclearin      (yychar = YYEMPTY)
 
 #define yyerrok                (yyerrstatus = 0)
 #define yyclearin      (yychar = YYEMPTY)


@@ -125,9 +185,9 @@ while (0)
    its range to the last symbol.  */
 
 #ifndef YYLLOC_DEFAULT
    its range to the last symbol.  */
 
 #ifndef YYLLOC_DEFAULT

-# define YYLLOC_DEFAULT(Current, Last)         \
-   Current.last_line   = Last.last_line;       \
-   Current.last_column = Last.last_column;
+# define YYLLOC_DEFAULT(Current, Rhs, N)               \
+   Current.last_line   = Rhs[N].last_line;     \
+   Current.last_column = Rhs[N].last_column;

 #endif
 
 
 #endif
 
 


@@ -154,10 +214,20 @@ while (0)
 
 /* Enable debugging if requested.  */
 #if YYDEBUG
 
 /* Enable debugging if requested.  */
 #if YYDEBUG

+
+# ifndef YYFPRINTF
+#  ifdef __cplusplus
+#   include <cstdio>  /* INFRINGES ON USER NAME SPACE */
+#  else
+#   include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  endif
+#  define YYFPRINTF YYSTD (fprintf)
+# endif
+

 # define YYDPRINTF(Args)                       \
 do {                                           \
   if (yydebug)                                 \
 # define YYDPRINTF(Args)                       \
 do {                                           \
   if (yydebug)                                 \

-    fprintf Args;                              \
+    YYFPRINTF Args;                            \

 } while (0)
 /* Nonzero means print parse trace. [The following comment makes no
    sense to me.  Could someone clarify it?  --akim] Since this is
 } while (0)
 /* Nonzero means print parse trace. [The following comment makes no
    sense to me.  Could someone clarify it?  --akim] Since this is


@@ -174,7 +244,12 @@ int yydebug;
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only

-   if the built-in stack extension method is used).  */
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+

 #if YYMAXDEPTH == 0
 # undef YYMAXDEPTH
 #endif
 #if YYMAXDEPTH == 0
 # undef YYMAXDEPTH
 #endif


@@ -183,47 +258,82 @@ int yydebug;
 # define YYMAXDEPTH 10000
 #endif
 \f
 # define YYMAXDEPTH 10000
 #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.  */
-# define __yy_memcpy(To, From, Count)  __builtin_memcpy (To, From, Count)
-#else                          /* not GNU C or C++ */
-# ifndef __cplusplus
+#if ! defined (yyoverflow) && ! defined (yymemcpy)
+# if __GNUC__ > 1              /* GNU C and GNU C++ define this.  */
+#  define yymemcpy __builtin_memcpy
+# else                         /* not GNU C or C++ */

 
 /* 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_memcpy (to, from, count)
-     char *to;
-     char *from;
-     unsigned int count;
+#  if defined (__STDC__) || defined (__cplusplus)
+yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
+#  else
+yymemcpy (yyto, yyfrom, yycount)
+     char *yyto;
+     const char *yyfrom;
+     YYSIZE_T yycount;
+#  endif

 {
 {

-  register char *f = from;
-  register char *t = to;
-  register int i = count;
+  register const char *yyf = yyfrom;
+  register char *yyt = yyto;
+  register YYSIZE_T yyi = yycount;

 
 

-  while (i-- > 0)
-    *t++ = *f++;
+  while (yyi-- != 0)
+    *yyt++ = *yyf++;

 }
 }

+# endif
+#endif

 
 

-# else /* __cplusplus */
+#ifdef YYERROR_VERBOSE

 
 

-/* 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, unsigned int count)
+# ifndef yystrlen
+#  if defined (__GLIBC__) && defined (_STRING_H)
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+#   if defined (__STDC__) || defined (__cplusplus)
+yystrlen (const char *yystr)
+#   else
+yystrlen (yystr)
+     const char *yystr;
+#   endif

 {
 {

-  register char *t = to;
-  register char *f = from;
-  register int i = count;
+  register const char *yys = yystr;
+
+  while (*yys++ != '\0')
+    continue;

 
 

-  while (i-- > 0)
-    *t++ = *f++;
+  return yys - yystr - 1;

 }
 }

+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+#   if defined (__STDC__) || defined (__cplusplus)
+yystpcpy (char *yydest, const char *yysrc)
+#   else
+yystpcpy (yydest, yysrc)
+     char *yydest;
+     const char *yysrc;
+#   endif
+{
+  register char *yyd = yydest;
+  register const char *yys = yysrc;

 
 

+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif

 # endif
 #endif
 \f
 # endif
 #endif
 \f


@@ -260,7 +370,7 @@ int yyparse (void);
 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
    variables are global, or local to YYPARSE.  */
 
 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
    variables are global, or local to YYPARSE.  */
 

-#define _YY_DECL_VARIABLES                             \
+#define YY_DECL_NON_LSP_VARIABLES                      \

 /* The lookahead symbol.  */                           \
 int yychar;                                            \
                                                        \
 /* The lookahead symbol.  */                           \
 int yychar;                                            \
                                                        \


@@ -272,13 +382,13 @@ int yynerrs;
 
 #if YYLSP_NEEDED
 # define YY_DECL_VARIABLES                     \
 
 #if YYLSP_NEEDED
 # define YY_DECL_VARIABLES                     \

-_YY_DECL_VARIABLES                             \
+YY_DECL_NON_LSP_VARIABLES                      \

                                                \
 /* Location data for the lookahead symbol.  */ \
 YYLTYPE yylloc;
 #else
 # define YY_DECL_VARIABLES                     \
                                                \
 /* Location data for the lookahead symbol.  */ \
 YYLTYPE yylloc;
 #else
 # define YY_DECL_VARIABLES                     \

-_YY_DECL_VARIABLES
+YY_DECL_NON_LSP_VARIABLES

 #endif
 
 
 #endif
 
 


@@ -299,6 +409,7 @@ yyparse (YYPARSE_PARAM_ARG)
 
   register int yystate;
   register int yyn;
 
   register int yystate;
   register int yyn;

+  int yyresult;

   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   /* Lookahead token as an internal (translated) token number.  */
   /* Number of tokens to shift before error messages enabled.  */
   int yyerrstatus;
   /* Lookahead token as an internal (translated) token number.  */


@@ -306,7 +417,7 @@ yyparse (YYPARSE_PARAM_ARG)
 
   /* Three stacks and their tools:
      `yyss': related to states,
 
   /* Three stacks and their tools:
      `yyss': related to states,

-     `yysv': related to semantic values,
+     `yyvs': related to semantic values,

      `yyls': related to locations.
 
      Refer to the stacks thru separate pointers, to allow yyoverflow
      `yyls': related to locations.
 
      Refer to the stacks thru separate pointers, to allow yyoverflow


@@ -335,16 +446,15 @@ yyparse (YYPARSE_PARAM_ARG)
 # define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif
 
 # define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif
 

-  int yystacksize = YYINITDEPTH;
-  int yyfree_stacks = 0;
+  YYSIZE_T yystacksize = YYINITDEPTH;

 
 
   /* The variables used to return semantic value and location from the
      action routines.  */
   YYSTYPE yyval;
 
 
   /* The variables used to return semantic value and location from the
      action routines.  */
   YYSTYPE yyval;

-# if YYLSP_NEEDED
+#if YYLSP_NEEDED

   YYLTYPE yyloc;
   YYLTYPE yyloc;

-# endif
+#endif

 
   /* When reducing, the number of symbols on the RHS of the reduced
      rule. */
 
   /* When reducing, the number of symbols on the RHS of the reduced
      rule. */


@@ -362,99 +472,92 @@ yyparse (YYPARSE_PARAM_ARG)
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
 
      so that they stay on the same level as the state stack.
      The wasted elements are never initialized.  */
 

-  yyssp = yyss - 1;
+  yyssp = yyss;

   yyvsp = yyvs;
 #if YYLSP_NEEDED
   yylsp = yyls;
 #endif
   yyvsp = yyvs;
 #if YYLSP_NEEDED
   yylsp = yyls;
 #endif

-
+  goto yysetstate;

 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
 `------------------------------------------------------------*/
 
 /*------------------------------------------------------------.
 | yynewstate -- Push a new state, which is found in yystate.  |
 `------------------------------------------------------------*/

-yynewstate:
+ yynewstate:

   /* In all cases, when you get here, the value and location stacks
      have just been pushed. so pushing a state here evens the stacks.
      */
   /* In all cases, when you get here, the value and location stacks
      have just been pushed. so pushing a state here evens the stacks.
      */

-  *++yyssp = yystate;
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;

 
   if (yyssp >= yyss + yystacksize - 1)
     {
 
   if (yyssp >= yyss + yystacksize - 1)
     {

-      /* 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;
-#if YYLSP_NEEDED
-      YYLTYPE *yyls1 = yyls;
-#endif
-

       /* Get the current used size of the three stacks, in elements.  */
       /* Get the current used size of the three stacks, in elements.  */

-      int size = yyssp - yyss + 1;
+      YYSIZE_T yysize = yyssp - yyss + 1;

 
 #ifdef yyoverflow
 
 #ifdef yyoverflow

-      /* Each stack pointer address is followed by the size of the
-        data in use in that stack, in bytes.  */
+      {
+       /* 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;
+
+       /* Each stack pointer address is followed by the size of the
+          data in use in that stack, in bytes.  */

 # if YYLSP_NEEDED
 # if 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);
+       YYLTYPE *yyls1 = yyls;
+       /* 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, yysize * sizeof (*yyssp),
+                   &yyvs1, yysize * sizeof (*yyvsp),
+                   &yyls1, yysize * sizeof (*yylsp),
+                   &yystacksize);
+       yyls = yyls1;

 # else
 # else

-      yyoverflow ("parser stack overflow",
-                 &yyss1, size * sizeof (*yyssp),
-                 &yyvs1, size * sizeof (*yyvsp),
-                 &yystacksize);
-# endif
-
-      yyss = yyss1; yyvs = yyvs1;
-# if YYLSP_NEEDED
-      yyls = yyls1;
+       yyoverflow ("parser stack overflow",
+                   &yyss1, yysize * sizeof (*yyssp),
+                   &yyvs1, yysize * sizeof (*yyvsp),
+                   &yystacksize);

 # endif
 # endif

+       yyss = yyss1;
+       yyvs = yyvs1;
+      }

 #else /* no yyoverflow */
       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)
 #else /* no yyoverflow */
       /* Extend the stack our own way.  */
       if (yystacksize >= YYMAXDEPTH)

-       {
-         yyerror ("parser stack overflow");
-         if (yyfree_stacks)
-           {
-             free (yyss);
-             free (yyvs);
-# if YYLSP_NEEDED
-             free (yyls);
-# endif
-           }
-         return 2;
-       }
+       goto yyoverflowlab;

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

-# 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));
+
+      {
+       short *yyss1 = yyss;
+       union yyalloc *yyptr =
+         (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+       if (! yyptr)
+         goto yyoverflowlab;
+       YYSTACK_RELOCATE (short, yyss);
+       YYSTACK_RELOCATE (YYSTYPE, yyvs);

 # if YYLSP_NEEDED
 # if YYLSP_NEEDED

-      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
-      __yy_memcpy ((char *)yyls, (char *)yyls1,
-                  size * (unsigned int) sizeof (*yylsp));
+       YYSTACK_RELOCATE (YYLTYPE, yyls);

 # endif
 # endif

+# undef YYSTACK_RELOCATE
+       if (yyss1 != yyssa)
+         YYSTACK_FREE (yyss1);
+      }

 #endif /* no yyoverflow */
 
 #endif /* no yyoverflow */
 

-      yyssp = yyss + size - 1;
-      yyvsp = yyvs + size - 1;
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;

 #if YYLSP_NEEDED
 #if YYLSP_NEEDED

-      yylsp = yyls + size - 1;
+      yylsp = yyls + yysize - 1;

 #endif
 
 #endif
 

-      YYDPRINTF ((stderr, "Stack size increased to %d\n", yystacksize));
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                 (unsigned long int) yystacksize));

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


@@ -509,13 +612,14 @@ yybackup:
        which are defined only if `YYDEBUG' is set.  */
       if (yydebug)
        {
        which are defined only if `YYDEBUG' is set.  */
       if (yydebug)
        {

-         fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+         YYFPRINTF (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);
 # endif
          /* Give the individual parser a way to print the precise
             meaning of a token, for further debugging info.  */
 # ifdef YYPRINT
          YYPRINT (stderr, yychar, yylval);
 # endif

-         fprintf (stderr, ")\n");
+         YYFPRINTF (stderr, ")\n");

        }
 #endif
     }
        }
 #endif
     }


@@ -547,7 +651,8 @@ yybackup:
     YYACCEPT;
 
   /* Shift the lookahead token.  */
     YYACCEPT;
 
   /* Shift the lookahead token.  */

-  YYDPRINTF ((stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]));
+  YYDPRINTF ((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)


@@ -585,7 +690,7 @@ yyreduce:
   yylen = yyr2[yyn];
 
   /* If YYLEN is nonzero, implement the default value of the action:
   yylen = yyr2[yyn];
 
   /* If YYLEN is nonzero, implement the default value of the action:

-     `{dollar}{dollar} = {dollar}1'.
+     `$$ = $1'.

 
      Otherwise, the following line sets YYVAL to the semantic value of
      the lookahead token.  This behavior is undocumented and Bison
 
      Otherwise, the following line sets YYVAL to the semantic value of
      the lookahead token.  This behavior is undocumented and Bison


@@ -598,7 +703,7 @@ yyreduce:
   /* Similarly for the default location.  Let the user run additional
      commands if for instance locations are ranges.  */
   yyloc = yylsp[1-yylen];
   /* Similarly for the default location.  Let the user run additional
      commands if for instance locations are ranges.  */
   yyloc = yylsp[1-yylen];

-  YYLLOC_DEFAULT (yyloc, yylsp[0]);
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);

 #endif
 
 #if YYDEBUG
 #endif
 
 #if YYDEBUG


@@ -606,18 +711,18 @@ yyreduce:
      are defined only if `YYDEBUG' is set.  */
   if (yydebug)
     {
      are defined only if `YYDEBUG' is set.  */
   if (yydebug)
     {

-      int i;
+      int yyi;

 
 

-      fprintf (stderr, "Reducing via rule %d (line %d), ",
-              yyn, yyrline[yyn]);
+      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+                yyn, yyrline[yyn]);

 
       /* Print the symbols being reduced, and their result.  */
 
       /* 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]]);
+      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
+       YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);

     }
 #endif
     }
 #endif

-$ /* The action file replaces this line marked with this dollarsign. */
+%% actions /* The action file replaces this line. */

 #line
 \f
   yyvsp -= yylen;
 #line
 \f
   yyvsp -= yylen;


@@ -629,11 +734,11 @@ $ /* The action file replaces this line marked with this dollarsign. */
 #if YYDEBUG
   if (yydebug)
     {
 #if YYDEBUG
   if (yydebug)
     {

-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "state stack now");
-      while (ssp1 != yyssp)
-       fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
+      short *yyssp1 = yyss - 1;
+      YYFPRINTF (stderr, "state stack now");
+      while (yyssp1 != yyssp)
+       YYFPRINTF (stderr, " %d", *++yyssp1);
+      YYFPRINTF (stderr, "\n");

     }
 #endif
 
     }
 #endif
 


@@ -671,46 +776,47 @@ yyerrlab:
 
       if (yyn > YYFLAG && yyn < YYLAST)
        {
 
       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++;
-         size += strlen ("parse error, unexpected `") + 1;
-         size += strlen (yytname[YYTRANSLATE (yychar)]);
-         msg = (char *) malloc (size);
-         if (msg != 0)
+         YYSIZE_T yysize = 0;
+         char *yymsg;
+         int yyx, yycount;
+
+         yycount = 0;
+         /* Start YYX at -YYN if negative to avoid negative indexes in
+            YYCHECK.  */
+         for (yyx = yyn < 0 ? -yyn : 0;
+              yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+           if (yycheck[yyx + yyn] == yyx)
+             yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+         yysize += yystrlen ("parse error, unexpected ") + 1;
+         yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
+         yymsg = (char *) YYSTACK_ALLOC (yysize);
+         if (yymsg != 0)

            {
            {

-             strcpy (msg, "parse error, unexpected `");
-             strcat (msg, yytname[YYTRANSLATE (yychar)]);
-             strcat (msg, "'");
+             char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+             yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);

 
 

-             if (count < 5)
+             if (yycount < 5)

                {
                {

-                 count = 0;
-                 for (x = (yyn < 0 ? -yyn : 0);
-                      x < (sizeof (yytname) / sizeof (char *)); x++)
-                   if (yycheck[x + yyn] == x)
+                 yycount = 0;
+                 for (yyx = yyn < 0 ? -yyn : 0;
+                      yyx < (int) (sizeof (yytname) / sizeof (char *));
+                      yyx++)
+                   if (yycheck[yyx + yyn] == yyx)

                      {
                      {

-                       strcat (msg, count == 0 ? ", expecting `" : " or `");
-                       strcat (msg, yytname[x]);
-                       strcat (msg, "'");
-                       count++;
+                       const char *yyq = ! yycount ? ", expecting " : " or ";
+                       yyp = yystpcpy (yyp, yyq);
+                       yyp = yystpcpy (yyp, yytname[yyx]);
+                       yycount++;

                      }
                }
                      }
                }

-             yyerror (msg);
-             free (msg);
+             yyerror (yymsg);
+             YYSTACK_FREE (yymsg);

            }
          else
            }
          else

-           yyerror ("parse error; also virtual memory exceeded");
+           yyerror ("parse error; also virtual memory exhausted");

        }
       else
        }
       else

-#endif /* YYERROR_VERBOSE */
+#endif /* defined (YYERROR_VERBOSE) */

        yyerror ("parse error");
     }
   goto yyerrlab1;
        yyerror ("parse error");
     }
   goto yyerrlab1;


@@ -773,11 +879,11 @@ yyerrpop:
 #if YYDEBUG
   if (yydebug)
     {
 #if YYDEBUG
   if (yydebug)
     {

-      short *ssp1 = yyss - 1;
-      fprintf (stderr, "Error: state stack now");
-      while (ssp1 != yyssp)
-       fprintf (stderr, " %d", *++ssp1);
-      fprintf (stderr, "\n");
+      short *yyssp1 = yyss - 1;
+      YYFPRINTF (stderr, "Error: state stack now");
+      while (yyssp1 != yyssp)
+       YYFPRINTF (stderr, " %d", *++yyssp1);
+      YYFPRINTF (stderr, "\n");

     }
 #endif
 
     }
 #endif
 


@@ -822,28 +928,28 @@ yyerrhandle:
 | yyacceptlab -- YYACCEPT comes here.  |
 `-------------------------------------*/
 yyacceptlab:
 | yyacceptlab -- YYACCEPT comes here.  |
 `-------------------------------------*/
 yyacceptlab:

-  if (yyfree_stacks)
-    {
-      free (yyss);
-      free (yyvs);
-#if YYLSP_NEEDED
-      free (yyls);
-#endif
-    }
-  return 0;
-
+  yyresult = 0;
+  goto yyreturn;

 
 /*-----------------------------------.
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
 yyabortlab:
 
 /*-----------------------------------.
 | yyabortlab -- YYABORT comes here.  |
 `-----------------------------------*/
 yyabortlab:

-  if (yyfree_stacks)
-    {
-      free (yyss);
-      free (yyvs);
-#if YYLSP_NEEDED
-      free (yyls);
+  yyresult = 1;
+  goto yyreturn;
+
+/*---------------------------------------------.
+| yyoverflowab -- parser overflow comes here.  |
+`---------------------------------------------*/
+yyoverflowlab:
+  yyerror ("parser stack overflow");
+  yyresult = 2;
+  /* Fall through.  */
+
+yyreturn:
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);

 #endif
 #endif

-    }
-  return 1;
+  return yyresult;

 }
 }