From fileutils.

[bison.git] / data / yacc.c

diff --git a/data/yacc.c b/data/yacc.c
index e69311c33522b698a2e539e2bbb1994d4e613733..5b5da3c5a3ffa4ae718a8366addb97ee04f9f9ea 100644 (file)
--- a/data/yacc.c
+++ b/data/yacc.c
@@ -2,7 +2,8 @@ m4_divert(-1)                                                       -*- C -*-
 m4_include([c.m4])
 
 # Yacc compatible skeleton for Bison
 m4_include([c.m4])
 
 # Yacc compatible skeleton for Bison

-# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 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


@@ -303,7 +304,6 @@ b4_location_if(
 
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  b4_final_state_number
 
 /* YYFINAL -- State number of the termination state. */
 #define YYFINAL  b4_final_state_number

-#define YYFLAG  b4_flag

 #define YYLAST   b4_last
 
 /* YYNTOKENS -- Number of terminals. */
 #define YYLAST   b4_last
 
 /* YYNTOKENS -- Number of terminals. */


@@ -323,7 +323,7 @@ b4_location_if(
   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
 
 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */
   ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
 
 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX.  */

-static const b4_uint_type(b4_translate_max) yytranslate[[]] =
+static const b4_int_type_for([b4_translate]) yytranslate[[]] =

 {
   b4_translate
 };
 {
   b4_translate
 };


@@ -331,19 +331,19 @@ static const b4_uint_type(b4_translate_max) yytranslate[[]] =
 #if YYDEBUG
 /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */
 #if YYDEBUG
 /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
    YYRHS.  */

-static const b4_uint_type(b4_prhs_max) yyprhs[[]] =
+static const b4_int_type_for([b4_prhs]) yyprhs[[]] =

 {
   b4_prhs
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
 {
   b4_prhs
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS. */

-static const b4_sint_type(b4_rhs_max) yyrhs[[]] =
+static const b4_int_type_for([b4_rhs]) yyrhs[[]] =

 {
   b4_rhs
 };
 
 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */
 {
   b4_rhs
 };
 
 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined.  */

-static const b4_uint_type(b4_rline_max) yyrline[[]] =
+static const b4_int_type_for([b4_rline]) yyrline[[]] =

 {
   b4_rline
 };
 {
   b4_rline
 };


@@ -360,19 +360,19 @@ static const char *const yytname[[]] =
 
 /* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
    token YYLEX-NUM.  */
 
 /* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
    token YYLEX-NUM.  */

-static const short yytoknum[[]] =
+static const b4_int_type_for([b4_toknum]) yytoknum[[]] =

 {
   b4_toknum
 };
 
 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
 {
   b4_toknum
 };
 
 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */

-static const b4_uint_type(b4_r1_max) yyr1[[]] =
+static const b4_int_type_for([b4_r1]) yyr1[[]] =

 {
   b4_r1
 };
 
 /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */
 {
   b4_r1
 };
 
 /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN.  */

-static const b4_uint_type(b4_r2_max) yyr2[[]] =
+static const b4_int_type_for([b4_r2]) yyr2[[]] =

 {
   b4_r2
 };
 {
   b4_r2
 };


@@ -380,26 +380,27 @@ static const b4_uint_type(b4_r2_max) yyr2[[]] =
 /* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
 /* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */

-static const short yydefact[[]] =
+static const b4_int_type_for([b4_defact]) yydefact[[]] =

 {
   b4_defact
 };
 
 {
   b4_defact
 };
 

-/* YYPGOTO[[NTERM-NUM]]. */
-static const short yydefgoto[[]] =
+/* YYDEFGOTO[[NTERM-NUM]]. */
+static const b4_int_type_for([b4_defgoto]) yydefgoto[[]] =

 {
   b4_defgoto
 };
 
 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
 {
   b4_defgoto
 };
 
 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */

-static const short yypact[[]] =
+#define YYPACT_NINF b4_pact_ninf
+static const b4_int_type_for([b4_pact]) yypact[[]] =

 {
   b4_pact
 };
 
 /* YYPGOTO[[NTERM-NUM]].  */
 {
   b4_pact
 };
 
 /* YYPGOTO[[NTERM-NUM]].  */

-static const short yypgoto[[]] =
+static const b4_int_type_for([b4_pgoto]) yypgoto[[]] =

 {
   b4_pgoto
 };
 {
   b4_pgoto
 };


@@ -407,19 +408,20 @@ static const short yypgoto[[]] =
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
    number is the opposite.  If zero, do what YYDEFACT says.  */

-static const short yytable[[]] =
+#define YYTABLE_NINF b4_table_ninf
+static const b4_int_type_for([b4_table]) yytable[[]] =

 {
   b4_table
 };
 
 {
   b4_table
 };
 

-static const short yycheck[[]] =
+static const b4_int_type_for([b4_check]) yycheck[[]] =

 {
   b4_check
 };
 
 /* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 {
   b4_check
 };
 
 /* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */

-static const b4_uint_type(b4_stos_max) yystos[[]] =
+static const b4_int_type_for([b4_stos]) yystos[[]] =

 {
   b4_stos
 };
 {
   b4_stos
 };


@@ -601,6 +603,137 @@ yystpcpy (yydest, yysrc)
 
 \f
 
 
 \f
 

+#if YYDEBUG
+/*-----------------------------.
+| Print this symbol on YYOUT.  |
+`-----------------------------*/
+
+b4_c_function([yysymprint],
+             [static void],
+             [[FILE*],   [yyout]],
+             [[int],     [yytype]],
+             [[YYSTYPE], [yyvalue]]b4_location_if([,
+             [[YYLTYPE], [yylocation]]]))
+{
+  /* Pacify ``unused variable'' warnings.  */
+  (void) yyvalue;
+b4_location_if([  (void) yylocation;
+])dnl
+
+  if (yytype < YYNTOKENS)
+    {
+      YYFPRINTF (yyout, "token %s (", yytname[[yytype]]);
+# ifdef YYPRINT
+      YYPRINT (yyout, yytoknum[[yytype]], yyvalue);
+# endif
+    }
+  else
+    YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]);
+
+  switch (yytype)
+    {
+m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
+      default:
+        break;
+    }
+  YYFPRINTF (yyout, ")");
+}
+#endif /* YYDEBUG. */
+
+
+/*----------------------------------------------------------.
+| yyreport_parse_error -- report a parse error in YYSTATE.  |
+`----------------------------------------------------------*/
+
+b4_c_function([yyreport_parse_error],
+             [static void],
+             [[int],     [yystate]],
+             [[int],     [yychar]],
+             [[YYSTYPE], [yyvalue]]b4_location_if([,
+             [[YYLTYPE], [yylloc]]]))
+[{
+#if YYERROR_VERBOSE
+  int yyn = yypact[yystate];
+
+  if (YYPACT_NINF < yyn && yyn < YYLAST)
+    {
+      YYSIZE_T yysize = 0;
+      int yytype = YYTRANSLATE (yychar);
+      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 && yyx != YYTERROR)
+         yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+      yysize += yystrlen ("parse error, unexpected ") + 1;
+      yysize += yystrlen (yytname[yytype]);
+      yymsg = (char *) YYSTACK_ALLOC (yysize);
+      if (yymsg != 0)
+       {
+         char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+         yyp = yystpcpy (yyp, yytname[yytype]);
+
+         if (yycount < 5)
+           {
+             yycount = 0;
+             for (yyx = yyn < 0 ? -yyn : 0;
+                  yyx < (int) (sizeof (yytname) / sizeof (char *));
+                  yyx++)
+               if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+                 {
+                   const char *yyq = ! yycount ? ", expecting " : " or ";
+                   yyp = yystpcpy (yyp, yyq);
+                   yyp = yystpcpy (yyp, yytname[yyx]);
+                   yycount++;
+                 }
+           }
+         yyerror (yymsg);
+         YYSTACK_FREE (yymsg);
+       }
+      else
+       yyerror ("parse error; also virtual memory exhausted");
+    }
+  else
+#endif /* YYERROR_VERBOSE */
+    yyerror ("parse error");
+
+  /* Pacify ``unused variable'' warnings.  */
+  (void) yystate;
+  (void) yychar;
+  (void) yyvalue;
+  ]b4_location_if([(void) yylloc;])[
+}]
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+b4_c_function([yydestruct],
+             [static void],
+             [[int],     [yytype]],
+             [[YYSTYPE], [yyvalue]]b4_location_if([,
+             [[YYLTYPE], [yylocation]]]))
+{
+  /* Pacify ``unused variable'' warnings.  */
+  (void) yyvalue;
+b4_location_if([  (void) yylocation;
+])dnl
+
+  switch (yytype)
+    {
+m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
+      default:
+        break;
+    }
+}
+
+\f
+

 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
    into yyparse.  The argument should have type void *.
    It should actually point to an object.
 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
    into yyparse.  The argument should have type void *.
    It should actually point to an object.


@@ -629,15 +762,6 @@ int yyparse (void);
 # endif
 #endif
 
 # endif
 #endif
 

-#if defined (__STDC__) || defined (__cplusplus)
-static void yydestruct (int yytype,
-                       YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]));
-# if YYDEBUG
-static void yysymprint (FILE* out, int yytype,
-                       YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]));
-# endif
-#endif
-

 m4_divert_push([KILL])# ======================== M4 code.
 # b4_declare_parser_variables
 # ---------------------------
 m4_divert_push([KILL])# ======================== M4 code.
 # b4_declare_parser_variables
 # ---------------------------


@@ -820,7 +944,7 @@ yybackup:
   /* First try to decide what to do without reference to lookahead token.  */
 
   yyn = yypact[yystate];
   /* First try to decide what to do without reference to lookahead token.  */
 
   yyn = yypact[yystate];

-  if (yyn == YYFLAG)
+  if (yyn == YYPACT_NINF)

     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */
     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */


@@ -855,7 +979,7 @@ yybackup:
     }
 
   yyn += yychar1;
     }
 
   yyn += yychar1;

-  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)

     goto yydefault;
 
   yyn = yytable[yyn];
     goto yydefault;
 
   yyn = yytable[yyn];


@@ -869,7 +993,7 @@ yybackup:
 
   if (yyn < 0)
     {
 
   if (yyn < 0)
     {

-      if (yyn == YYFLAG)
+      if (yyn == YYTABLE_NINF)

        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
        goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;


@@ -980,7 +1104,7 @@ yyreduce:
   yyn = yyr1[yyn];
 
   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
   yyn = yyr1[yyn];
 
   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;

-  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)

     yystate = yytable[yystate];
   else
     yystate = yydefgoto[yyn - YYNTOKENS];
     yystate = yytable[yystate];
   else
     yystate = yydefgoto[yyn - YYNTOKENS];


@@ -996,54 +1120,7 @@ yyerrlab:
   if (!yyerrstatus)
     {
       ++yynerrs;
   if (!yyerrstatus)
     {
       ++yynerrs;

-
-#if YYERROR_VERBOSE
-      yyn = yypact[yystate];
-
-      if (yyn > YYFLAG && yyn < YYLAST)
-       {
-         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)
-           {
-             char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
-             yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
-
-             if (yycount < 5)
-               {
-                 yycount = 0;
-                 for (yyx = yyn < 0 ? -yyn : 0;
-                      yyx < (int) (sizeof (yytname) / sizeof (char *));
-                      yyx++)
-                   if (yycheck[yyx + yyn] == yyx)
-                     {
-                       const char *yyq = ! yycount ? ", expecting " : " or ";
-                       yyp = yystpcpy (yyp, yyq);
-                       yyp = yystpcpy (yyp, yytname[yyx]);
-                       yycount++;
-                     }
-               }
-             yyerror (yymsg);
-             YYSTACK_FREE (yymsg);
-           }
-         else
-           yyerror ("parse error; also virtual memory exhausted");
-        }
-      else
-#endif /* YYERROR_VERBOSE */
-        yyerror ("parse error");
+      yyreport_parse_error (yystate, yychar, yylval]b4_location_if([, yylloc])[);

     }
   goto yyerrlab1;
 
     }
   goto yyerrlab1;
 


@@ -1090,7 +1167,7 @@ yyerrlab1:
   for (;;)
     {
       yyn = yypact[yystate];
   for (;;)
     {
       yyn = yypact[yystate];

-      if (yyn != YYFLAG)
+      if (yyn != YYPACT_NINF)

        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
        {
          yyn += YYTERROR;
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)


@@ -1172,62 +1249,6 @@ yyreturn:
 ]}
 
 
 ]}
 
 

-/*-----------------------------------------------.
-| Release the memory associated to this symbol.  |
-`-----------------------------------------------*/
-
-static void
-yydestruct (int yytype,
-           YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]))
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
-
-  switch (yytype)
-    {
-m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
-      default:
-        break;
-    }
-}
-
-
-#if YYDEBUG
-/*-----------------------------.
-| Print this symbol on YYOUT.  |
-`-----------------------------*/
-
-static void
-yysymprint (FILE* yyout, int yytype,
-           YYSTYPE yyvalue[]b4_location_if([, YYLTYPE yylocation]))
-{
-  /* Pacify ``unused variable'' warnings.  */
-  (void) yyvalue;
-b4_location_if([  (void) yylocation;
-])dnl
-
-  if (yytype < YYNTOKENS)
-    {
-      YYFPRINTF (yyout, "token %s (", yytname[[yytype]]);
-# ifdef YYPRINT
-      YYPRINT (yyout, yytoknum[[yytype]], yyvalue);
-# endif
-    }
-  else
-    YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]);
-
-  switch (yytype)
-    {
-m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
-      default:
-        break;
-    }
-  YYFPRINTF (yyout, ")");
-}
-#endif /* YYDEBUG. */
-

 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [#output "b4_output_header_name"
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],
 [#output "b4_output_header_name"