Revert doc patch.

[bison.git] / src / bison.simple

diff --git a/src/bison.simple b/src/bison.simple
index eb94f301b29121b7a4717ec580eb7884f7ead5aa..9b627b1c5fe55cf7d2b259ca556d0ea8b46672e3 100644 (file)
--- a/src/bison.simple
+++ b/src/bison.simple
@@ -102,10 +102,27 @@
 # define YYSTACK_USE_ALLOCA 0
 #endif
 
 # 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
 #if YYSTACK_USE_ALLOCA

-# define YYSTACK_ALLOC 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.  */
 #endif
 
 #define YYBISON        1       /* Identify Bison output.  */


@@ -134,6 +151,9 @@ typedef struct yyltype
 
 #ifndef YYERROR_VERBOSE
 # define YYERROR_VERBOSE %%verbose
 
 #ifndef YYERROR_VERBOSE
 # define YYERROR_VERBOSE %%verbose

+#else
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1

 #endif
 
 /* Tokens.  */
 #endif
 
 /* Tokens.  */


@@ -452,7 +472,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


@@ -528,40 +548,38 @@ yyparse (YYPARSE_PARAM_ARG)
 
   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)


@@ -580,19 +598,11 @@ yyparse (YYPARSE_PARAM_ARG)
       yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)
        yystacksize = YYMAXDEPTH;
       yystacksize *= 2;
       if (yystacksize > YYMAXDEPTH)
        yystacksize = YYMAXDEPTH;

-# if !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 */
 


@@ -826,30 +836,29 @@ 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);
+         /* 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++;
               x < (int) (sizeof (yytname) / sizeof (char *)); x++)
            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);
+                 for (x = yyn < 0 ? -yyn : 0;

                         x < (int) (sizeof (yytname) / sizeof (char *)); x++)
                    if (yycheck[x + yyn] == x)
                      {
                         x < (int) (sizeof (yytname) / sizeof (char *)); x++)
                    if (yycheck[x + yyn] == x)
                      {

-                       strcat (msg, count == 0 ? ", expecting `" : " or `");
+                       strcat (msg, count == 0 ? ", expecting " : " or ");

                        strcat (msg, yytname[x]);
                        strcat (msg, yytname[x]);

-                       strcat (msg, "'");

                        count++;
                      }
                }
                        count++;
                      }
                }


@@ -857,7 +866,7 @@ yyerrlab:
              free (msg);
            }
           else
              free (msg);
            }
           else

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

         }
       else
 #endif /* YYERROR_VERBOSE */
         }
       else
 #endif /* YYERROR_VERBOSE */