Revert doc patch.

[bison.git] / src / bison.simple

diff --git a/src/bison.simple b/src/bison.simple
index b830d95ff58ffc20d443ca69d8b7a677d40a43c1..9b627b1c5fe55cf7d2b259ca556d0ea8b46672e3 100644 (file)
--- a/src/bison.simple
+++ b/src/bison.simple
@@ -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 1984, 1989, 1990, 2000 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


@@ -30,16 +31,39 @@
    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.  */
 

+#include <stdio.h>
+
+/* 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
+
+/* Copy the user declarations.  */
+#line %%input_line "%%filename"
+%%prologue
+
+#line %%line "%%skeleton"
+#ifndef __cplusplus
+# ifndef __STDC__
+#  define const
+# endif
+#endif
+

 #ifndef YYSTACK_USE_ALLOCA
 # ifdef alloca
 #ifndef YYSTACK_USE_ALLOCA
 # ifdef alloca

-#  define YYSTACK_USE_ALLOCA
+#  define YYSTACK_USE_ALLOCA 1

 # else /* alloca not defined */
 #  ifdef __GNUC__
 # else /* alloca not defined */
 #  ifdef __GNUC__

-#   define YYSTACK_USE_ALLOCA
+#   define YYSTACK_USE_ALLOCA 1

 #   define alloca __builtin_alloca
 #  else /* not GNU C.  */
 #   if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 #   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
+#    define YYSTACK_USE_ALLOCA 1

 #    include <alloca.h>
 #   else /* not sparc */
      /* We think this test detects Watcom and Microsoft C.  */
 #    include <alloca.h>
 #   else /* not sparc */
      /* We think this test detects Watcom and Microsoft C.  */


@@ -57,13 +81,13 @@
          namespace.  So I turned it off.  rms, 2 May 1997.  */
        /* #include <malloc.h>  */
  #pragma alloca
          namespace.  So I turned it off.  rms, 2 May 1997.  */
        /* #include <malloc.h>  */
  #pragma alloca

-#      define YYSTACK_USE_ALLOCA
+#      define YYSTACK_USE_ALLOCA 1

 #     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
 #     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 YYSTACK_USE_ALLOCA 1

 #        define alloca __builtin_alloca
 #      endif /* __hpux */
 #      endif
 #        define alloca __builtin_alloca
 #      endif /* __hpux */
 #      endif


@@ -74,41 +98,194 @@
 # endif /* alloca not defined */
 #endif /* YYSTACK_USE_ALLOCA not defined */
 
 # endif /* alloca not defined */
 #endif /* YYSTACK_USE_ALLOCA not defined */
 

-#ifdef YYSTACK_USE_ALLOCA
-# define YYSTACK_ALLOC alloca
+#ifndef YYSTACK_USE_ALLOCA
+# define YYSTACK_USE_ALLOCA 0
+#endif
+
+/* Realloc WHAT from SIZE to YYSTACKSIZE elements of TYPE.
+   If WHAT was malloc'ed (not the original automatic ARRAY), free it. */
+#if YYSTACK_USE_ALLOCA
+# define YYSTACK_REALLOC(Type, What, Array)                            \
+do {                                                                   \
+  Type *old = What;                                                    \
+  What = (Type *) malloc (yystacksize * sizeof (Type));                        \
+  __yy_memcpy ((char *) What, (char *) old,                            \
+              (size) * (unsigned int) sizeof (Type));                  \
+  yyfree_stacks = 1;                                                   \
+  if (old != Array)                                                    \
+    free (old);                                                                \
+} while (0)

 #else
 #else

-# define YYSTACK_ALLOC malloc
+# define YYSTACK_REALLOC(Type, What, Array)                            \
+do {                                                                   \
+  Type *old = What;                                                    \
+  What = (Type *) alloca (yystacksize * sizeof (Type));                        \
+  __yy_memcpy ((char *) What, (char *) old,                            \
+              (size) * (unsigned int) sizeof (Type));                  \
+} while (0)
+#endif
+
+#define YYBISON        1       /* Identify Bison output.  */
+#define YYPURE %%pure  /* Identify pure parsers.  */
+
+#ifndef YYDEBUG
+# define YYDEBUG %%debug
+#endif
+
+#line %%input_line "%%filename"
+#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
+
+#ifndef YYERROR_VERBOSE
+# define YYERROR_VERBOSE %%verbose
+#else
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#endif
+
+/* 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
+
+#if YYDEBUG || YYERROR_VERBOSE
+/* YYTNME[TOKEN_NUM] -- String name of the token TOKEN_NUM.  */
+static const char *const yytname[] =
+{
+  %%tname
+};

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

 
 #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.
    Once GCC version 2 has supplanted version 1, this can go.  */
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
    Once GCC version 2 has supplanted version 1, this can go.  */

+

 #define YYFAIL         goto yyerrlab
 #define YYFAIL         goto yyerrlab

+

 #define YYRECOVERING()  (!!yyerrstatus)
 #define YYRECOVERING()  (!!yyerrstatus)

-#define YYBACKUP(Token, Value) \
+
+#define YYBACKUP(Token, Value)                                 \

 do                                                             \
   if (yychar == YYEMPTY && yylen == 1)                         \
     {                                                          \
       yychar = (Token);                                                \
 do                                                             \
   if (yychar == YYEMPTY && yylen == 1)                         \
     {                                                          \
       yychar = (Token);                                                \

-      yylval = (Value);                                                \
+      yylval = (Value);                                        \

       yychar1 = YYTRANSLATE (yychar);                          \
       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
     {                                                          \
       yychar1 = YYTRANSLATE (yychar);                          \
       YYPOPSTACK;                                              \
       goto yybackup;                                           \
     }                                                          \
   else                                                         \
     {                                                          \

-      yyerror ("syntax error: cannot back up");                        \
+      yyerror ("syntax error: cannot back up");                \

       YYERROR;                                                 \
     }                                                          \
 while (0)
       YYERROR;                                                 \
     }                                                          \
 while (0)


@@ -116,7 +293,6 @@ while (0)
 #define YYTERROR       1
 #define YYERRCODE      256
 
 #define YYTERROR       1
 #define YYERRCODE      256
 

-

 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
    are run).
 
 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
    are run).
 


@@ -125,11 +301,13 @@ 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
 

+/* Definition of YYLSP_NEEDED.  */
+#define YYLSP_NEEDED %%locations_flag

 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 


@@ -151,7 +329,6 @@ while (0)
 # define YYLEX                 yylex ()
 #endif /* !YYPURE */
 
 # define YYLEX                 yylex ()
 #endif /* !YYPURE */
 

-

 /* Enable debugging if requested.  */
 #if YYDEBUG
 # define YYDPRINTF(Args)                       \
 /* Enable debugging if requested.  */
 #if YYDEBUG
 # define YYDPRINTF(Args)                       \


@@ -170,7 +347,7 @@ int yydebug;
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH
 
 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 #ifndef        YYINITDEPTH

-# define YYINITDEPTH 200
+# define YYINITDEPTH %%initdepth

 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 #endif
 
 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only


@@ -180,9 +357,11 @@ int yydebug;
 #endif
 
 #ifndef 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
 /* 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


@@ -191,43 +370,31 @@ int yydebug;
 #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++ */
 #if __GNUC__ > 1               /* GNU C and GNU C++ define this.  */
 # define __yy_memcpy(To, From, Count)  __builtin_memcpy (To, From, Count)
 #else                          /* not GNU C or C++ */

-# ifndef __cplusplus

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

+# ifndef __cplusplus

 __yy_memcpy (to, from, count)
      char *to;
 __yy_memcpy (to, from, count)
      char *to;

-     char *from;
+     const char *from;

      unsigned int count;
      unsigned int count;

-{
-  register char *f = from;
-  register char *t = to;
-  register int i = count;
-
-  while (i-- > 0)
-    *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
-__yy_memcpy (char *to, char *from, unsigned int count)
+__yy_memcpy (char *to, const char *from, unsigned int count)
+# endif

 {
 {

+  register const 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
 \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 *.


@@ -264,7 +431,7 @@ int yyparse (void);
 /* The lookahead symbol.  */                           \
 int yychar;                                            \
                                                        \
 /* The lookahead symbol.  */                           \
 int yychar;                                            \
                                                        \

-/* The semantic value of the lookahead symbol. */      \
+/* The semantic value of the lookahead symbol.  */     \

 YYSTYPE yylval;                                                \
                                                        \
 /* Number of parse errors so far.  */                  \
 YYSTYPE yylval;                                                \
                                                        \
 /* Number of parse errors so far.  */                  \


@@ -281,8 +448,7 @@ YYLTYPE yylloc;
 _YY_DECL_VARIABLES
 #endif
 
 _YY_DECL_VARIABLES
 #endif
 

-
-/* If nonreentrant, generate the variables here. */
+/* If nonreentrant, generate the variables here.  */

 
 #if !YYPURE
 YY_DECL_VARIABLES
 
 #if !YYPURE
 YY_DECL_VARIABLES


@@ -292,7 +458,7 @@ int
 yyparse (YYPARSE_PARAM_ARG)
      YYPARSE_PARAM_DECL
 {
 yyparse (YYPARSE_PARAM_ARG)
      YYPARSE_PARAM_DECL
 {

-  /* If reentrant, generate the variables here. */
+  /* If reentrant, generate the variables here.  */

 #if YYPURE
   YY_DECL_VARIABLES
 #endif  /* !YYPURE */
 #if YYPURE
   YY_DECL_VARIABLES
 #endif  /* !YYPURE */


@@ -306,13 +472,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;


@@ -338,7 +504,6 @@ yyparse (YYPARSE_PARAM_ARG)
   int yystacksize = YYINITDEPTH;
   int yyfree_stacks = 0;
 
   int yystacksize = YYINITDEPTH;
   int yyfree_stacks = 0;
 

-

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


@@ -347,7 +512,7 @@ yyparse (YYPARSE_PARAM_ARG)
 # endif
 
   /* When reducing, the number of symbols on the RHS of the reduced
 # endif
 
   /* When reducing, the number of symbols on the RHS of the reduced

-     rule. */
+     rule.  */

   int yylen;
 
   YYDPRINTF ((stderr, "Starting parse\n"));
   int yylen;
 
   YYDPRINTF ((stderr, "Starting parse\n"));


@@ -362,58 +527,59 @@ 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.  */
       int size = yyssp - yyss + 1;
 
 #ifdef yyoverflow
       /* Get the current used size of the three stacks, in elements.  */
       int size = yyssp - yyss + 1;
 
 #ifdef yyoverflow

-      /* Each stack pointer address is followed by the size of
-        the data in use in that stack, in bytes.  */
+      {
+       /* 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, size * sizeof (*yyssp),
+                   &yyvs1, size * sizeof (*yyvsp),
+                   &yyls1, size * 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, size * sizeof (*yyssp),
+                   &yyvs1, size * 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)


@@ -432,19 +598,11 @@ yynewstate:
       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));
+
+      YYSTACK_REALLOC (short, yyss, yyssa);
+      YYSTACK_REALLOC (YYSTYPE, yyvs, yyvsa);

 # 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_REALLOC (YYLTYPE, yyls, yylsa);

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


@@ -464,7 +622,6 @@ yynewstate:
 
   goto yybackup;
 
 
   goto yybackup;
 

-

 /*-----------.
 | yybackup.  |
 `-----------*/
 /*-----------.
 | yybackup.  |
 `-----------*/


@@ -491,12 +648,12 @@ yybackup:
       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.  */

 
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }
 
       YYDPRINTF ((stderr, "Now at end of input.\n"));
     }


@@ -585,7 +742,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 +755,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


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

-$ /* The action file replaces this line marked with this dollarsign. */
-#line
+  switch (yyn)
+    {
+      %%action
+    }
+#line %%line "%%skeleton"

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


@@ -666,7 +826,7 @@ yyerrlab:
     {
       ++yynerrs;
 
     {
       ++yynerrs;
 

-#ifdef YYERROR_VERBOSE
+#if YYERROR_VERBOSE

       yyn = yypact[yystate];
 
       if (yyn > YYFLAG && yyn < YYLAST)
       yyn = yypact[yystate];
 
       if (yyn > YYFLAG && yyn < YYLAST)


@@ -676,56 +836,55 @@ yyerrlab:
          int x, count;
 
          count = 0;
          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++)
+         /* Start X at -YYN if negative to avoid negative indexes in
+            YYCHECK.  */
+         for (x = yyn < 0 ? -yyn : 0;
+              x < (int) (sizeof (yytname) / sizeof (char *)); x++)

            if (yycheck[x + yyn] == x)
              size += strlen (yytname[x]) + 15, count++;
            if (yycheck[x + yyn] == x)
              size += strlen (yytname[x]) + 15, count++;

-         size += strlen ("parse error, unexpected `") + 1;
+         size += strlen ("parse error, unexpected ") + 1;

          size += strlen (yytname[YYTRANSLATE (yychar)]);
          msg = (char *) malloc (size);
          if (msg != 0)
            {
          size += strlen (yytname[YYTRANSLATE (yychar)]);
          msg = (char *) malloc (size);
          if (msg != 0)
            {

-             strcpy (msg, "parse error, unexpected `");
+             strcpy (msg, "parse error, unexpected ");

              strcat (msg, yytname[YYTRANSLATE (yychar)]);
              strcat (msg, yytname[YYTRANSLATE (yychar)]);

-             strcat (msg, "'");

 
              if (count < 5)
                {
                  count = 0;
 
              if (count < 5)
                {
                  count = 0;

-                 for (x = (yyn < 0 ? -yyn : 0);
-                      x < (sizeof (yytname) / sizeof (char *)); x++)
+                 for (x = yyn < 0 ? -yyn : 0;
+                        x < (int) (sizeof (yytname) / sizeof (char *)); x++)

                    if (yycheck[x + yyn] == x)
                      {
                    if (yycheck[x + yyn] == x)
                      {

-                       strcat (msg, count == 0 ? ", expecting `" : " or `");
-                       strcat (msg, yytname[x]);
-                       strcat (msg, "'");
+                       strcat (msg, count == 0 ? ", expecting " : " or ");
+                       strcat (msg, yytname[x]);

                        count++;
                      }
                }
              yyerror (msg);
              free (msg);
            }
                        count++;
                      }
                }
              yyerror (msg);
              free (msg);
            }

-         else
-           yyerror ("parse error; also virtual memory exceeded");
-       }
+          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 -- error raised explicitly by an action |
-`--------------------------------------------------*/
+/*----------------------------------------------------.
+| yyerrlab1 -- error raised explicitly by an action.  |
+`----------------------------------------------------*/

 yyerrlab1:
   if (yyerrstatus == 3)
     {
       /* If just tried and failed to reuse lookahead token after an
         error, discard it.  */
 
 yyerrlab1:
   if (yyerrstatus == 3)
     {
       /* 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;
       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
       if (yychar == YYEOF)
        YYABORT;
       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",


@@ -736,7 +895,7 @@ yyerrlab1:
   /* 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;
 


@@ -759,7 +918,7 @@ yyerrdefault:
 
 /*---------------------------------------------------------------.
 | yyerrpop -- pop the current state because it cannot handle the |
 
 /*---------------------------------------------------------------.
 | yyerrpop -- pop the current state because it cannot handle the |

-| error token                                                    |
+| error token.                                                   |

 `---------------------------------------------------------------*/
 yyerrpop:
   if (yyssp == yyss)
 `---------------------------------------------------------------*/
 yyerrpop:
   if (yyssp == yyss)


@@ -847,3 +1006,6 @@ yyabortlab:
     }
   return 1;
 }
     }
   return 1;
 }

+
+#line %%input_line "%%filename"
+%%epilogue