]> git.saurik.com Git - bison.git/blobdiff - src/bison.simple
Name space cleanup in generated parser.
[bison.git] / src / bison.simple
index 62859b2724af262a4b5dd358dcb313ca6a51a150..cc349befb40d14525e812af87331564d43ec426e 100644 (file)
@@ -1,9 +1,10 @@
-/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
-#line
-/* This file comes from bison-@bison_version@.  */
+/* -*- C -*- */
+
+/* A Bison parser, made from %%filename
+   by GNU bison %%version.  */
 
 /* Skeleton output parser for bison,
 
 /* Skeleton output parser for bison,
-   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+   Copyright 1984, 1989, 1990, 2000, 2001 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
    This special exception was added by the Free Software Foundation
    in version 1.24 of Bison.  */
 
    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.  */
-
-#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>
+/* 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.  */
+
+/* Identify Bison output.  */
+#define YYBISON        1
+
+/* Pure parsers.  */
+#define YYPURE %%pure
+
+/* Using locations.  */
+#define YYLSP_NEEDED %%locations-flag
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG %%debug
+#endif
+
+/* Enabling verbose error messages.  */
+#undef YYERROR_VERBOSE
+#define YYERROR_VERBOSE %%error-verbose
+
+/* If name_prefix is specify substitute the variables and functions
+   names.  */
+#define yyparse %%prefix##parse
+#define yylex   %%prefix##lex
+#define yyerror %%prefix##error
+#define yylval  %%prefix##lval
+#define yychar  %%prefix##char
+#define yydebug %%prefix##debug
+#define yynerrs %%prefix##nerrs
+
+#ifndef YYSTYPE
+typedef %%stype yystype;
+# define YYSTYPE yystype
+#endif
+
+#ifndef YYLTYPE
+typedef struct yyltype
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} yyltype;
+# define YYLTYPE %%ltype
+#endif
+
+/* Copy the user declarations.  */
+#line %%input-line "%%filename"
+%%prologue
+
+#line %%line "%%skeleton"
+
+#include <stdio.h>
+
+#ifndef __cplusplus
+# ifndef __STDC__
+#  define const
+# endif
+#endif
+
+/* 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 C library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+#if ! defined (yyoverflow) || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# if YYSTACK_USE_ALLOCA
+#  define YYSTACK_ALLOC alloca
+#  define YYSIZE_T size_t
+# else
+#  ifndef YYSTACK_USE_ALLOCA
+#   if defined (alloca) || defined (_ALLOCA_H)
+#    define YYSTACK_ALLOC alloca
+#    define YYSIZE_T size_t
+#   else
+#    if defined (__GNUC__) || defined (_AIX) || defined (__hpux)
+#     define YYSTACK_ALLOC __builtin_alloca
+#    endif
+#    ifndef __GNUC__
+#     ifdef _AIX
+ #     pragma alloca
 #     endif
 #     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
+#     if defined (__sgi) || defined (__sparc__) || defined (__sparc) || defined (__sun)
+#      include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#      define YYSTACK_ALLOC alloca
+#      define YYSIZE_T size_t
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning. */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+#  define YYSTACK_ALLOC malloc
+#  define YYSTACK_FREE(Ptr) free (Ptr)
+#  if defined (__STDC__) || defined (__cplusplus)
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   define YYSIZE_T size_t
+#  endif
+# endif
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  short yys;
+  YYSTYPE yyv;
+# if YYLSP_NEEDED
+  YYLTYPE yyl;
+# 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 (yyptr, (char *) (Stack),                              \
+                 yysize * (YYSIZE_T) sizeof (Type));                   \
+       (Stack) = (Type *) yyptr;                                       \
+       yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX;     \
+       yynewbytes -= yynewbytes % sizeof (union yyalloc);              \
+       yyptr += yynewbytes;                                            \
+      }                                                                        \
+    while (0)
+
+#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+
+/* Tokens.  */
+%%tokendef
+
+#define YYFINAL                %%final
+#define YYFLAG         %%flag
+#define YYNTBASE       %%ntbase
+#define YYLAST         %%last
+
+#define YYNTOKENS      %%ntokens
+#define YYNNTS         %%nnts
+#define YYNRULES       %%nrules
+#define YYNSTATES      %%nstates
+#define YYMAXUTOK      %%maxtok
+
+/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX.  */
+#define YYTRANSLATE(x) ((unsigned)(x) <= %%maxtok ? yytranslate[x] : %%nsym)
+
+/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX.  */
+static const char yytranslate[] =
+{
+  %%translate
+};
+
+#if YYDEBUG
+static const short yyprhs[] =
+{
+  %%prhs
+};
+
+static const short yyrhs[] =
+{
+  %%rhs
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const short yyrline[] =
+{
+  %%rline
+};
 #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 YYDEBUG || YYERROR_VERBOSE
+/* YYTNME[TOKEN_NUM] -- String name of the token TOKEN_NUM.  */
+static const char *const yytname[] =
+{
+  %%tname
+};
+#endif
+
+/* YYTOKNUM[YYN] -- Index in YYTNAME corresponding to YYLEX.  */
+static const short yytoknum[] =
+{
+  %%toknum
+};
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const short yyr1[] =
+{
+  %%r1
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const short yyr2[] =
+{
+  %%r2
+};
+
+/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
+   doesn't specify something else to do.  Zero means the default is an
+   error.  */
+static const short yydefact[] =
+{
+  %%defact
+};
+
+static const short yydefgoto[] =
+{
+  %%defgoto
+};
+
+static const short yypact[] =
+{
+  %%pact
+};
+
+static const short yypgoto[] =
+{
+  %%pgoto
+};
+
+static const short yytable[] =
+{
+  %%table
+};
+
+static const short yycheck[] =
+{
+  %%check
+};
+
+
+#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) && (defined (__STDC__) || defined (__cplusplus))
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
 
 #define yyerrok                (yyerrstatus = 0)
 #define yyclearin      (yychar = YYEMPTY)
 #define YYEMPTY                -2
 #define YYEOF          0
 
 #define yyerrok                (yyerrstatus = 0)
 #define yyclearin      (yychar = YYEMPTY)
 #define YYEMPTY                -2
 #define YYEOF          0
+
 #define YYACCEPT       goto yyacceptlab
 #define YYACCEPT       goto yyacceptlab
-#define YYABORT        goto yyabortlab
+#define YYABORT                goto yyabortlab
 #define YYERROR                goto yyerrlab1
 #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.
+
+/* 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.  */
    Once GCC version 2 has supplanted version 1, this can go.  */
+
 #define YYFAIL         goto yyerrlab
 #define YYFAIL         goto yyerrlab
+
 #define YYRECOVERING()  (!!yyerrstatus)
 #define YYRECOVERING()  (!!yyerrstatus)
-#define YYBACKUP(token, value) \
+
+#define YYBACKUP(Token, Value)                                 \
 do                                                             \
   if (yychar == YYEMPTY && yylen == 1)                         \
 do                                                             \
   if (yychar == YYEMPTY && yylen == 1)                         \
-    { yychar = (token), yylval = (value);                      \
+    {                                                          \
+      yychar = (Token);                                                \
+      yylval = (Value);                                        \
       yychar1 = YYTRANSLATE (yychar);                          \
       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
       yychar1 = YYTRANSLATE (yychar);                          \
       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
-    { yyerror ("syntax error: cannot back up"); YYERROR; }     \
+    {                                                          \
+      yyerror ("syntax error: cannot back up");                \
+      YYERROR;                                                 \
+    }                                                          \
 while (0)
 
 #define YYTERROR       1
 #define YYERRCODE      256
 
 while (0)
 
 #define YYTERROR       1
 #define YYERRCODE      256
 
-#ifndef YYPURE
-# define YYLEX         yylex()
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+   are run).
+
+   When YYLLOC_DEFAULT is run, CURRENT is set the location of the
+   first token.  By default, to implement support for ranges, extend
+   its range to the last symbol.  */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)               \
+   Current.last_line   = Rhs[N].last_line;     \
+   Current.last_column = Rhs[N].last_column;
 #endif
 
 #endif
 
-#ifdef YYPURE
-# ifdef YYLSP_NEEDED
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
+#if YYPURE
+# if YYLSP_NEEDED
 #  ifdef YYLEX_PARAM
 #  ifdef YYLEX_PARAM
-#   define YYLEX               yylex(&yylval, &yylloc, YYLEX_PARAM)
+#   define YYLEX               yylex (&yylval, &yylloc, YYLEX_PARAM)
 #  else
 #  else
-#   define YYLEX               yylex(&yylval, &yylloc)
+#   define YYLEX               yylex (&yylval, &yylloc)
 #  endif
 #  endif
-# else /* not YYLSP_NEEDED */
+# else /* !YYLSP_NEEDED */
 #  ifdef YYLEX_PARAM
 #  ifdef YYLEX_PARAM
-#   define YYLEX               yylex(&yylval, YYLEX_PARAM)
+#   define YYLEX               yylex (&yylval, YYLEX_PARAM)
 #  else
 #  else
-#   define YYLEX               yylex(&yylval)
+#   define YYLEX               yylex (&yylval)
 #  endif
 #  endif
-# endif /* not YYLSP_NEEDED */
-#endif
-
-/* If nonreentrant, generate the variables here. */
-
-#ifndef YYPURE
-/* The lookahead symbol.  */
-int    yychar;
-
-/* The semantic value of the lookahead symbol. */
-YYSTYPE        yylval;
-
-# ifdef YYLSP_NEEDED
-/* Location data for the lookahead symbol.  */
-YYLTYPE yylloc;
-# endif
-
-/* Number of parse errors so far.  */
-int yynerrs;
-#endif  /* not YYPURE */
-
+# endif /* !YYLSP_NEEDED */
+#else /* !YYPURE */
+# define YYLEX                 yylex ()
+#endif /* !YYPURE */
 
 
+/* Enable debugging if requested.  */
 #if YYDEBUG
 #if YYDEBUG
-int yydebug;                   /*  nonzero means print parse trace     */
-
-  /* [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      */
-
+# include <stdio.h>
+# define YYDPRINTF(Args)                       \
+do {                                           \
+  if (yydebug)                                 \
+    fprintf Args;                              \
+} while (0)
+/* Nonzero means print parse trace. [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.
+   */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+#endif /* !YYDEBUG */
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
 #ifndef        YYINITDEPTH
-# define YYINITDEPTH 200
+# define YYINITDEPTH %%initdepth
 #endif
 
 #endif
 
-/*  YYMAXDEPTH is the maximum size the stacks can grow to
-    (effective only if the built-in stack extension method is used).  */
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   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
 
 #ifndef YYMAXDEPTH
 
 #if YYMAXDEPTH == 0
 # undef YYMAXDEPTH
 #endif
 
 #ifndef YYMAXDEPTH
-# define YYMAXDEPTH 10000
+# define YYMAXDEPTH %%maxdepth
 #endif
 #endif
+
 \f
 \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 */
+#if 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 *
+#   ifndef __cplusplus
+yystpcpy (yydest, yysrc)
+     char *yydest;
+     const char *yysrc;
+#   else
+yystpcpy (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
-#endif
+
+#endif /* !YYERROR_VERBOSE */
+
 \f
 \f
-#line
+
+#line %%line "%%skeleton"
 
 /* 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 *.
@@ -236,14 +501,14 @@ __yy_memcpy (char *to, char *from, unsigned int count)
 # ifdef __cplusplus
 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL
 # ifdef __cplusplus
 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL
-# else /* not __cplusplus */
+# else /* !__cplusplus */
 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-# endif /* not __cplusplus */
-#else /* not YYPARSE_PARAM */
+# endif /* !__cplusplus */
+#else /* !YYPARSE_PARAM */
 # define YYPARSE_PARAM_ARG
 # define YYPARSE_PARAM_DECL
 # define YYPARSE_PARAM_ARG
 # define YYPARSE_PARAM_DECL
-#endif /* not YYPARSE_PARAM */
+#endif /* !YYPARSE_PARAM */
 
 /* Prevent warning if -Wstrict-prototypes.  */
 #ifdef __GNUC__
 
 /* Prevent warning if -Wstrict-prototypes.  */
 #ifdef __GNUC__
@@ -254,12 +519,48 @@ int yyparse (void);
 # endif
 #endif
 
 # endif
 #endif
 
+/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
+   variables are global, or local to YYPARSE.  */
+
+#define YY_DECL_NON_LSP_VARIABLES                      \
+/* The lookahead symbol.  */                           \
+int yychar;                                            \
+                                                       \
+/* The semantic value of the lookahead symbol.  */     \
+YYSTYPE yylval;                                                \
+                                                       \
+/* Number of parse errors so far.  */                  \
+int yynerrs;
+
+#if YYLSP_NEEDED
+# define YY_DECL_VARIABLES                     \
+YY_DECL_NON_LSP_VARIABLES                      \
+                                               \
+/* Location data for the lookahead symbol.  */ \
+YYLTYPE yylloc;
+#else
+# define YY_DECL_VARIABLES                     \
+YY_DECL_NON_LSP_VARIABLES
+#endif
+
+/* If nonreentrant, generate the variables here.  */
+
+#if !YYPURE
+YY_DECL_VARIABLES
+#endif  /* !YYPURE */
+
 int
 int
-yyparse(YYPARSE_PARAM_ARG)
+yyparse (YYPARSE_PARAM_ARG)
      YYPARSE_PARAM_DECL
 {
      YYPARSE_PARAM_DECL
 {
+  /* If reentrant, generate the variables here.  */
+#if YYPURE
+  YY_DECL_VARIABLES
+#endif  /* !YYPURE */
+
   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.  */
@@ -267,13 +568,13 @@ 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
      to reallocate them elsewhere.  */
 
      `yyls': related to locations.
 
      Refer to the stacks thru separate pointers, to allow yyoverflow
      to reallocate them elsewhere.  */
 
-  /* The state stack. */
+  /* The state stack.  */
   short        yyssa[YYINITDEPTH];
   short *yyss = yyssa;
   register short *yyssp;
   short        yyssa[YYINITDEPTH];
   short *yyss = yyssa;
   register short *yyssp;
@@ -283,45 +584,33 @@ yyparse(YYPARSE_PARAM_ARG)
   YYSTYPE *yyvs = yyvsa;
   register YYSTYPE *yyvsp;
 
   YYSTYPE *yyvs = yyvsa;
   register YYSTYPE *yyvsp;
 
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   /* The location stack.  */
   YYLTYPE yylsa[YYINITDEPTH];
   YYLTYPE *yyls = yylsa;
   YYLTYPE *yylsp;
 #endif
 
   /* The location stack.  */
   YYLTYPE yylsa[YYINITDEPTH];
   YYLTYPE *yyls = yylsa;
   YYLTYPE *yylsp;
 #endif
 
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 #else
 # define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif
 
 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 #else
 # define YYPOPSTACK   (yyvsp--, yyssp--)
 #endif
 
-  int yystacksize = YYINITDEPTH;
-  int yyfree_stacks = 0;
-
-#ifdef YYPURE
-  int yychar;
-  YYSTYPE yylval;
-  int yynerrs;
-# ifdef YYLSP_NEEDED
-  YYLTYPE yylloc;
-# endif
-#endif
-
+  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;
-# ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   YYLTYPE yyloc;
   YYLTYPE yyloc;
-# endif
+#endif
 
   /* When reducing, the number of symbols on the RHS of the reduced
 
   /* When reducing, the number of symbols on the RHS of the reduced
-     rule. */
+     rule.  */
   int yylen;
 
   int yylen;
 
-  if (yydebug)
-    fprintf (stderr, "Starting parse\n");
+  YYDPRINTF ((stderr, "Starting parse\n"));
 
   yystate = 0;
   yyerrstatus = 0;
 
   yystate = 0;
   yyerrstatus = 0;
@@ -333,106 +622,104 @@ 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;
   yyvsp = yyvs;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   yylsp = yyls;
 #endif
   yylsp = yyls;
 #endif
+  goto yysetstate;
 
 
-/* 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:
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ 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.
+     */
+  yyssp++;
 
 
-  *++yyssp = yystate;
+ 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;
-#ifdef 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.  */
-# 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);
+      {
+       /* 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
+       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;
-# ifdef 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);
-# ifdef 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));
-# ifdef YYLSP_NEEDED
-      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
-      __yy_memcpy ((char *)yyls, (char *)yyls1,
-                  size * (unsigned int) sizeof (*yylsp));
+
+      {
+       short *yyss1 = yyss;
+       char *yyptr = (char *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+       if (! yyptr)
+         goto yyoverflowlab;
+       YYSTACK_RELOCATE (short, yyss);
+       YYSTACK_RELOCATE (YYSTYPE, yyvs);
+# if YYLSP_NEEDED
+       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;
-#ifdef YYLSP_NEEDED
-      yylsp = yyls + size - 1;
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+#if YYLSP_NEEDED
+      yylsp = yyls + yysize - 1;
 #endif
 
 #endif
 
-      if (yydebug)
-       fprintf (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;
     }
 
-  if (yydebug)
-    fprintf (stderr, "Entering state %d\n", yystate);
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
 
   goto yybackup;
 
   goto yybackup;
- yybackup:
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
 
 /* Do appropriate processing given the current state.  */
 /* Read a lookahead token if we need one and don't already have one.  */
 
 /* Do appropriate processing given the current state.  */
 /* Read a lookahead token if we need one and don't already have one.  */
@@ -451,24 +738,22 @@ yynewstate:
 
   if (yychar == YYEMPTY)
     {
 
   if (yychar == YYEMPTY)
     {
-      if (yydebug)
-       fprintf (stderr, "Reading a token: ");
+      YYDPRINTF ((stderr, "Reading a token: "));
       yychar = YYLEX;
     }
 
       yychar = YYLEX;
     }
 
-  /* Convert token to internal form (in yychar1) for indexing tables with */
+  /* Convert token to internal form (in yychar1) for indexing tables with */
 
 
-  if (yychar <= 0)             /* This means end of input. */
+  if (yychar <= 0)             /* This means end of input.  */
     {
       yychar1 = 0;
     {
       yychar1 = 0;
-      yychar = YYEOF;          /* Don't call YYLEX any more */
+      yychar = YYEOF;          /* Don't call YYLEX any more */
 
 
-      if (yydebug)
-       fprintf (stderr, "Now at end of input.\n");
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
   else
     {
     }
   else
     {
-      yychar1 = YYTRANSLATE(yychar);
+      yychar1 = YYTRANSLATE (yychar);
 
 #if YYDEBUG
      /* We have to keep this `#if YYDEBUG', since we use variables
 
 #if YYDEBUG
      /* We have to keep this `#if YYDEBUG', since we use variables
@@ -513,56 +798,58 @@ yynewstate:
     YYACCEPT;
 
   /* Shift the lookahead token.  */
     YYACCEPT;
 
   /* Shift the lookahead token.  */
-#if YYDEBUG
-  if (yydebug)
-    fprintf (stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
-#endif
+  YYDPRINTF ((stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]));
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
     yychar = YYEMPTY;
 
   *++yyvsp = yylval;
 
   /* Discard the token being shifted unless it is eof.  */
   if (yychar != YYEOF)
     yychar = YYEMPTY;
 
   *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   *++yylsp = yylloc;
 #endif
 
   *++yylsp = yylloc;
 #endif
 
-  /* count tokens shifted since error; after three, turn off error status.  */
-  if (yyerrstatus) yyerrstatus--;
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
 
   yystate = yyn;
   goto yynewstate;
 
 
   yystate = yyn;
   goto yynewstate;
 
-/* Do the default action for the current state.  */
-yydefault:
 
 
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
   yyn = yydefact[yystate];
   if (yyn == 0)
     goto yyerrlab;
   yyn = yydefact[yystate];
   if (yyn == 0)
     goto yyerrlab;
+  goto yyreduce;
+
 
 
-/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
 yyreduce:
 yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
   yylen = yyr2[yyn];
   yylen = yyr2[yyn];
-  /* Implement default value of the action:
-     `{dollar}{dollar} = {dollar}1'. */
-  if (yylen > 0)
-      yyval = yyvsp[1-yylen];
-#ifdef YYLSP_NEEDED
-  /* Implement default location.  If the rhs is empty, extend YYLOC to
-     YYLLOC, which corresponds to the current token, otherwise
-     implement `@{dollar} = Starts at @1, ends at @YYLEN'.  */
-  if (yylen > 0)
-    {
-      yyloc = yylsp[1-yylen];
-      yyloc.last_line = yylsp[0].last_line;
-      yyloc.last_column = yylsp[0].last_column;
-    }
-  else
-    {
-      yyloc.last_line = yylsp[0].last_line;
-      yyloc.last_column = yylsp[0].last_column;
-      yyloc.text = 0;
-    }
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to the semantic value of
+     the lookahead token.  This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+#if YYLSP_NEEDED
+  /* 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 - yylen), yylen);
 #endif
 
 #if YYDEBUG
 #endif
 
 #if YYDEBUG
@@ -570,37 +857,42 @@ 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]);
 
       /* Print the symbols being reduced, and their result.  */
 
       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]]);
+      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
+       fprintf (stderr, "%s ", yytname[yyrhs[yyi]]);
       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 */
-#line
+  switch (yyn)
+    {
+      %%action
+    }
+#line %%line "%%skeleton"
 \f
   yyvsp -= yylen;
   yyssp -= yylen;
 \f
   yyvsp -= yylen;
   yyssp -= yylen;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   yylsp -= yylen;
 #endif
 
   yylsp -= yylen;
 #endif
 
+#if YYDEBUG
   if (yydebug)
     {
   if (yydebug)
     {
-      short *ssp1 = yyss - 1;
+      short *yyssp1 = yyss - 1;
       fprintf (stderr, "state stack now");
       fprintf (stderr, "state stack now");
-      while (ssp1 != yyssp)
-       fprintf (stderr, " %d", *++ssp1);
+      while (yyssp1 != yyssp)
+       fprintf (stderr, " %d", *++yyssp1);
       fprintf (stderr, "\n");
     }
       fprintf (stderr, "\n");
     }
+#endif
 
   *++yyvsp = yyval;
 
   *++yyvsp = yyval;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   *++yylsp = yyloc;
 #endif
 
   *++yylsp = yyloc;
 #endif
 
@@ -618,115 +910,136 @@ $   /* the action file gets copied in in place of this dollarsign */
 
   goto yynewstate;
 
 
   goto yynewstate;
 
-yyerrlab:   /* here on detecting error */
 
 
-  if (! yyerrstatus)
-    /* If not already recovering from an error, report this error.  */
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
     {
       ++yynerrs;
 
     {
       ++yynerrs;
 
-#ifdef YYERROR_VERBOSE
+#if YYERROR_VERBOSE
       yyn = yypact[yystate];
 
       if (yyn > YYFLAG && yyn < YYLAST)
        {
       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++;
-         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);
-           }
-         else
-           yyerror ("parse error; also virtual memory exceeded");
-       }
+             yyerror (yymsg);
+             YYSTACK_FREE (yymsg);
+           }
+         else
+           yyerror ("parse error; also virtual memory exhausted");
+        }
       else
 #endif /* YYERROR_VERBOSE */
       else
 #endif /* YYERROR_VERBOSE */
-       yyerror ("parse error");
+        yyerror ("parse error");
     }
     }
-
   goto yyerrlab1;
   goto yyerrlab1;
-yyerrlab1:   /* here on error raised explicitly by an action */
 
 
+
+/*----------------------------------------------------.
+| yyerrlab1 -- error raised explicitly by an action.  |
+`----------------------------------------------------*/
+yyerrlab1:
   if (yyerrstatus == 3)
     {
   if (yyerrstatus == 3)
     {
-      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+      /* If just tried and failed to reuse lookahead token after an
+        error, discard it.  */
 
 
-      /* return failure if at end of input */
+      /* Return failure if at end of input.  */
       if (yychar == YYEOF)
        YYABORT;
       if (yychar == YYEOF)
        YYABORT;
-#if YYDEBUG
-      if (yydebug)
-       fprintf (stderr, "Discarding token %d (%s).\n",
-                yychar, yytname[yychar1]);
-#endif
+      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+                 yychar, yytname[yychar1]));
       yychar = YYEMPTY;
     }
 
       yychar = YYEMPTY;
     }
 
-  /* Else will try to reuse lookahead token
-     after shifting the error token.  */
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
 
 
-  yyerrstatus = 3;             /* Each real token shifted decrements this */
+  yyerrstatus = 3;             /* Each real token shifted decrements this */
 
   goto yyerrhandle;
 
 
   goto yyerrhandle;
 
-yyerrdefault:  /* current state does not do anything special for the error token. */
 
 
+/*-------------------------------------------------------------------.
+| yyerrdefault -- current state does not do anything special for the |
+| error token.                                                       |
+`-------------------------------------------------------------------*/
+yyerrdefault:
 #if 0
   /* This is wrong; only states that explicitly want error tokens
      should shift them.  */
 #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;
+
+  /* If its default is to accept any token, ok.  Otherwise pop it.  */
+  yyn = yydefact[yystate];
+  if (yyn)
+    goto yydefault;
 #endif
 
 #endif
 
-yyerrpop:   /* pop the current state because it cannot handle the error token */
 
 
-  if (yyssp == yyss) YYABORT;
+/*---------------------------------------------------------------.
+| yyerrpop -- pop the current state because it cannot handle the |
+| error token.                                                   |
+`---------------------------------------------------------------*/
+yyerrpop:
+  if (yyssp == yyss)
+    YYABORT;
   yyvsp--;
   yystate = *--yyssp;
   yyvsp--;
   yystate = *--yyssp;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   yylsp--;
 #endif
 
   yylsp--;
 #endif
 
+#if YYDEBUG
   if (yydebug)
     {
   if (yydebug)
     {
-      short *ssp1 = yyss - 1;
+      short *yyssp1 = yyss - 1;
       fprintf (stderr, "Error: state stack now");
       fprintf (stderr, "Error: state stack now");
-      while (ssp1 != yyssp)
-       fprintf (stderr, " %d", *++ssp1);
+      while (yyssp1 != yyssp)
+       fprintf (stderr, " %d", *++yyssp1);
       fprintf (stderr, "\n");
     }
       fprintf (stderr, "\n");
     }
+#endif
 
 
+/*--------------.
+| yyerrhandle.  |
+`--------------*/
 yyerrhandle:
 yyerrhandle:
-
   yyn = yypact[yystate];
   if (yyn == YYFLAG)
     goto yyerrdefault;
   yyn = yypact[yystate];
   if (yyn == YYFLAG)
     goto yyerrdefault;
@@ -749,38 +1062,46 @@ yyerrhandle:
   if (yyn == YYFINAL)
     YYACCEPT;
 
   if (yyn == YYFINAL)
     YYACCEPT;
 
-  if (yydebug)
-    fprintf (stderr, "Shifting error token, ");
+  YYDPRINTF ((stderr, "Shifting error token, "));
 
   *++yyvsp = yylval;
 
   *++yyvsp = yylval;
-#ifdef YYLSP_NEEDED
+#if YYLSP_NEEDED
   *++yylsp = yylloc;
 #endif
 
   yystate = yyn;
   goto yynewstate;
 
   *++yylsp = yylloc;
 #endif
 
   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);
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  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;
 }
 }
+
+#line %%input-line "%%filename"
+%%epilogue