* tests/calc.at (_AT_DATA_CALC_Y): Define VAL, LOC, LEX_FORMALS,

[bison.git] / data / yacc.c

diff --git a/data/yacc.c b/data/yacc.c
index fff62912ea9ac7c18962d5f859a6622fc34cc0d3..35e8da4f5cdcf05089b7459bd8cf4e20918e34e5 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


@@ -129,6 +130,11 @@ m4_divert(0)dnl
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 
 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
              [1984, 1989, 1990, 2000, 2001, 2002])
 

+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+

 /* Written by Richard Stallman by simplifying the original so called
    ``semantic'' parser.  */
 
 /* Written by Richard Stallman by simplifying the original so called
    ``semantic'' parser.  */
 


@@ -160,11 +166,11 @@ m4_if(b4_prefix[], [yy], [],
 #define yynerrs b4_prefix[]nerrs
 b4_location_if([#define yylloc b4_prefix[]lloc])])
 
 #define yynerrs b4_prefix[]nerrs
 b4_location_if([#define yylloc b4_prefix[]lloc])])
 

+b4_token_defines(b4_tokens)
+

 /* Copy the first part of user declarations.  */
 b4_pre_prologue
 
 /* Copy the first part of user declarations.  */
 b4_pre_prologue
 

-b4_token_defines(b4_tokens)
-

 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG b4_debug
 /* Enabling traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG b4_debug


@@ -301,9 +307,14 @@ b4_location_if(
 
 #endif
 
 
 #endif
 

+#if defined (__STDC__) || defined (__cplusplus)
+   typedef signed char yysigned_char;
+#else
+   typedef short yysigned_char;
+#endif
+

 /* 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 +334,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 +342,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
 };


@@ -358,21 +369,23 @@ static const char *const yytname[[]] =
 };
 #endif
 
 };
 #endif
 

+# ifdef YYPRINT

 /* 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
 };
 {
   b4_toknum
 };

+# endif

 
 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives.  */
 
 /* 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,46 +393,49 @@ 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
 };
 
 /* YYTABLE[[YYPACT[STATE-NUM]]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
 {
   b4_pgoto
 };
 
 /* 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[[]] =
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, parse error.  */
+#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
 };


@@ -490,13 +506,14 @@ while (0)
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 
 
 /* YYLEX -- calling `yylex' with the right arguments.  */
 

-b4_pure_if(
-[#ifdef YYLEX_PARAM
-# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]), YYLEX_PARAM)
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])YYLEX_PARAM)

 #else
 #else

-# define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]))
-#endif],
-[#define YYLEX yylex ()])
+# define YYLEX b4_c_function_call([yylex], [int],
+                   b4_pure_if([[[[]], [[&yylval]]],
+                               b4_location_if([[[], [&yylloc]],])])
+                   m4_fst(b4_lex_param))
+#endif

 
 /* Enable debugging if requested.  */
 #if YYDEBUG
 
 /* Enable debugging if requested.  */
 #if YYDEBUG


@@ -601,6 +618,69 @@ 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. */
+
+
+/*-----------------------------------------------.
+| 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 +709,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 +891,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.  */


@@ -854,28 +925,19 @@ yybackup:
       YYDPRINTF ((stderr, "\n"));
     }
 
       YYDPRINTF ((stderr, "\n"));
     }
 

+  /* If the proper action on seeing token YYCHAR1 is to reduce or to
+     detect an error, take that action.  */

   yyn += yychar1;
   yyn += yychar1;

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

     goto yydefault;
     goto yydefault;

-

   yyn = yytable[yyn];
   yyn = yytable[yyn];

-
-  /* yyn is what to do for this token type in this state.
-     Negative => reduce, -yyn is rule number.
-     Positive => shift, yyn is new state.
-       New state is final state => don't bother to shift,
-       just return success.
-     0, or most negative number => error.  */
-
-  if (yyn < 0)
+  if (yyn <= 0)

     {
     {

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

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

-  else if (yyn == 0)
-    goto yyerrlab;

 
   if (yyn == YYFINAL)
     YYACCEPT;
 
   if (yyn == YYFINAL)
     YYACCEPT;


@@ -920,8 +982,8 @@ yyreduce:
   /* If YYLEN is nonzero, implement the default value of the action:
      `$$ = $1'.
 
   /* 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
+     Otherwise, the following line sets YYVAL to garbage.
+     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.  */
      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.  */


@@ -980,7 +1042,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,13 +1058,13 @@ yyerrlab:
   if (!yyerrstatus)
     {
       ++yynerrs;
   if (!yyerrstatus)
     {
       ++yynerrs;

-

 #if YYERROR_VERBOSE
       yyn = yypact[yystate];
 
 #if YYERROR_VERBOSE
       yyn = yypact[yystate];
 

-      if (yyn > YYFLAG && yyn < YYLAST)
+      if (YYPACT_NINF < yyn && yyn < YYLAST)

        {
          YYSIZE_T yysize = 0;
        {
          YYSIZE_T yysize = 0;

+         int yytype = YYTRANSLATE (yychar);

          char *yymsg;
          int yyx, yycount;
 
          char *yymsg;
          int yyx, yycount;
 


@@ -1011,15 +1073,15 @@ yyerrlab:
             YYCHECK.  */
          for (yyx = yyn < 0 ? -yyn : 0;
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
             YYCHECK.  */
          for (yyx = yyn < 0 ? -yyn : 0;
               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)

-           if (yycheck[yyx + yyn] == yyx)
+           if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
          yysize += yystrlen ("parse error, unexpected ") + 1;
              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
          yysize += yystrlen ("parse error, unexpected ") + 1;

-         yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
+         yysize += yystrlen (yytname[yytype]);

          yymsg = (char *) YYSTACK_ALLOC (yysize);
          if (yymsg != 0)
            {
              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
          yymsg = (char *) YYSTACK_ALLOC (yysize);
          if (yymsg != 0)
            {
              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");

-             yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
+             yyp = yystpcpy (yyp, yytname[yytype]);

 
              if (yycount < 5)
                {
 
              if (yycount < 5)
                {


@@ -1027,7 +1089,7 @@ yyerrlab:
                  for (yyx = yyn < 0 ? -yyn : 0;
                       yyx < (int) (sizeof (yytname) / sizeof (char *));
                       yyx++)
                  for (yyx = yyn < 0 ? -yyn : 0;
                       yyx < (int) (sizeof (yytname) / sizeof (char *));
                       yyx++)

-                   if (yycheck[yyx + yyn] == yyx)
+                   if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)

                      {
                        const char *yyq = ! yycount ? ", expecting " : " or ";
                        yyp = yystpcpy (yyp, yyq);
                      {
                        const char *yyq = ! yycount ? ", expecting " : " or ";
                        yyp = yystpcpy (yyp, yyq);


@@ -1037,13 +1099,13 @@ yyerrlab:
                }
              yyerror (yymsg);
              YYSTACK_FREE (yymsg);
                }
              yyerror (yymsg);
              YYSTACK_FREE (yymsg);

-           }
-         else
-           yyerror ("parse error; also virtual memory exhausted");
-        }
+           }
+         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;
 


@@ -1090,7 +1152,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,67 +1234,17 @@ 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, [],
 b4_epilogue
 m4_if(b4_defines_flag, 0, [],

-[b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
-              [1984, 1989, 1990, 2000, 2001, 2002])
-#output "b4_output_header_name"
+[#output "b4_output_header_name"
+b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
+             [1984, 1989, 1990, 2000, 2001, 2002])
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+

 #ifndef b4_header_guard
 # define b4_header_guard
 
 #ifndef b4_header_guard
 # define b4_header_guard