2005-10-04 Paul Eggert <eggert@cs.ucla.edu>
+ Undo the parts of the unlocked-I/O change that substituted
+ putc or puts for printf. This might hurt performance a bit,
+ but some people prefer the printf style.
+ * data/c.m4 (yysymprint): Prefer printf to puts and putc.
+ * data/glr.c (YYFPUTC, YYFPUTS, YYDPUTS): Remove.
+ All uses replaced by YYFPRINTF and YYDPRINTF.
+ * data/yacc.c: Likewise.
+ * lib/bitset.c (bitset_print): Likewise.
+ * lib/bitsetv.c (bitsetv_dump, debug-bitsetv): Prefer printf to
+ putc and puts.
+ * lib/lbitset.c (debug_lbitset): Likewise.
+ * src/closure.c (print_firsts, print_fderives): Likewise.
+ * src/gram.c (grammar_dump): Likewise.
+ * src/lalr.c (look_ahead_tokens_print): Likewise.
+ * src/output.c (escaped_output): Likewise.
+ (user_actions_output): Break apart two printfs.
+ * src/parse-gram.y (%printer): Prefer printf to putc and puts.
+ * src/reduce.c (reduce_print): Likewise.
+ * src/state.c (state_rule_look_ahead_tokens_print): Likewise.
+ * src/system.h: Include unlocked-io.h rathe than stdio.h.
+
* data/glr.c (yyuserMerge, yyreportAmbiguity, yyreportSyntaxError):
Use assignments rather than casts-to-void to suppress
unused-variable warnings. This pacifies 'lint'.
* src/lalr.c (look_ahead_tokens_print): Likewise.
* src/output.c (escaped_output): Likewise.
(user_actions_output): Coalesce two printfs.
- * src/parse-gram.h (%printer): Prefer putc and puts to printf.
+ * src/parse-gram.y (%printer): Prefer putc and puts to printf.
* src/reduce.c (reduce_print): Likewise.
* src/state.c (state_rule_look_ahead_tokens_print): Likewise.
- * src/system.h: Include unlocked-io.h rathe than stdio.h.
+ * src/system.h: Include unlocked-io.h rather than stdio.h.
* data/lalr1.cc: Don't put an unmatched ' in a dnl comment, as
this confuses xgettext.
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
]b4_location_if([ YY_LOCATION_PRINT (yyoutput, *yylocationp);
- YYFPUTS (": ", yyoutput);
+ YYFPRINTF (yyoutput, ": ");
])dnl
[
# ifdef YYPRINT
[ default:
break;
}
- YYFPUTC (')', yyoutput);
+ YYFPRINTF (yyoutput, ")");
}
]])
#if YYDEBUG
-# ifdef YYFPRINTF
-# define YYFPUTC(Char, Stream) YYFPRINTF (Stream, "%c", Char)
-# define YYFPUTS(Char, Stream) YYFPRINTF (Stream, "%s", String)
-# else
+#if ! defined (YYFPRINTF)
# define YYFPRINTF fprintf
-# define YYFPUTC fputc
-# define YYFPUTS fputs
-# endif
+#endif
# define YYDPRINTF(Args) \
do { \
YYFPRINTF Args; \
} while (0)
-# define YYDPUTS(String, Stream) \
-do { \
- if (yydebug) \
- YYFPUTS (String, Stream); \
-} while (0)
-
]b4_yysymprint_generate([b4_c_ansi_function_def])[
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
YYFPRINTF (stderr, "%s ", Title); \
yysymprint (stderr, \
Type, Value]b4_location_if([, Location])[); \
- YYFPUTC ('\n', stderr); \
+ YYFPRINTF (stderr, "\n"); \
} \
} while (0)
#else /* !YYDEBUG */
-# define YYDPUTS(String, File)
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
YYFPRINTF (stderr, "%s unresolved ", yymsg);
yysymprint (stderr, yystos[yys->yylrState],
&yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
- YYFPUTC ('\n', stderr);
+ YYFPRINTF (stderr, "\n");
}
#endif
return;
yystack->yytops.yystates[0] = yystack->yylastDeleted;
yystack->yytops.yysize = 1;
- YYDPUTS ("Restoring last deleted stack as stack #0.\n", stderr);
+ YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
yystack->yylastDeleted = NULL;
}
{
if (yyi == yyj)
{
- YYDPUTS ("Removing dead stacks.\n", stderr);
+ YYDPRINTF ((stderr, "Removing dead stacks.\n"));
}
yystack->yytops.yysize -= 1;
}
yyx1 = yyx1;
#if YYDEBUG
- YYFPUTS ("Ambiguity detected.\nOption 1,\n", stderr);
+ YYFPRINTF (stderr, "Ambiguity detected.\n");
+ YYFPRINTF (stderr, "Option 1,\n");
yyreportTree (yyx0, 2);
- YYFPUTS ("\nOption 2,\n", stderr);
+ YYFPRINTF (stderr, "\nOption 2,\n");
yyreportTree (yyx1, 2);
- YYFPUTC ('\n', stderr);
+ YYFPRINTF (stderr, "\n");
#endif
yyFail (yystack][]b4_pure_args[, YY_("syntax is ambiguous"));
}
{
if (*yytokenp == YYEMPTY)
{
- YYDPUTS ("Reading a token: ", stderr);
+ YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
*yytokenp = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);
yydestruct ("Error: discarding",
*yytokenp, yylvalp]b4_location_if([, yyllocp])[);
}
- YYDPUTS ("Reading a token: ", stderr);
+ YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
*yytokenp = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", *yytokenp, yylvalp, yyllocp);
YYSTYPE* const yylvalp = &yylval;
YYLTYPE* const yyllocp = &yylloc;
- YYDPUTS ("Starting parse\n", stderr);
+ YYDPRINTF ((stderr, "Starting parse\n"));
yytoken = YYEMPTY;
yylval = yyval_default;
{
if (yytoken == YYEMPTY)
{
- YYDPUTS ("Reading a token: ", stderr);
+ YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
yytoken = YYTRANSLATE (yychar);
YY_SYMBOL_PRINT ("Next token is", yytoken, yylvalp, yyllocp);
if (yystack.yytops.yysize == 0)
yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
- YYDPUTS ("Returning to deterministic operation.\n", stderr);
+ YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
]b4_location_if([[ yystack.yyerror_range[1].yystate.yyloc = *yyllocp;]])[
yyreportSyntaxError (&yystack, yylvalp, yyllocp]b4_user_args[);
goto yyuser_error;
else if (yystack.yytops.yysize == 1)
{
YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
- YYDPUTS ("Returning to deterministic operation.\n", stderr);
+ YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
yycompressStack (&yystack);
break;
}
if (yys->yypred)
{
yy_yypstack (yys->yypred);
- fputs (" -> ", stderr);
+ fprintf (stderr, " -> ");
}
fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
}
yypstates (yyGLRState* yyst)
{
if (yyst == NULL)
- fputs ("<null>", stderr);
+ fprintf (stderr, "<null>");
else
yy_yypstack (yyst);
- fputc ('\n', stderr);
+ fprintf (stderr, "\n");
}
static void
(long int) YYINDEX (yyp->yyoption.yystate),
(long int) YYINDEX (yyp->yyoption.yynext));
}
- fputc ('\n', stderr);
+ fprintf (stderr, "\n");
}
- fputs ("Tops:", stderr);
+ fprintf (stderr, "Tops:");
for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
(long int) YYINDEX (yystack->yytops.yystates[yyi]));
- fputc ('\n', stderr);
+ fprintf (stderr, "\n");
}
#endif
]
/* Enable debugging if requested. */
#if YYDEBUG
-# ifdef YYFPRINTF
-# define YYFPUTC(Char, Stream) YYFPRINTF (Stream, "%c", Char)
-# define YYFPUTS(Char, Stream) YYFPRINTF (Stream, "%s", String)
-# else
+# ifndef YYFPRINTF
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
# define YYFPRINTF fprintf
-# define YYFPUTC fputc
-# define YYFPUTS fputs
# endif
# define YYDPRINTF(Args) \
YYFPRINTF Args; \
} while (0)
-# define YYDPUTS(String, Stream) \
-do { \
- if (yydebug) \
- YYFPUTS (String, Stream); \
-} while (0)
-
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
do { \
if (yydebug) \
YYFPRINTF (stderr, "%s ", Title); \
yysymprint (stderr, \
Type, Value]b4_location_if([, Location])[); \
- YYFPUTC ('\n', stderr); \
+ YYFPRINTF (stderr, "\n"); \
} \
} while (0)
[[short int *bottom], [bottom]],
[[short int *top], [top]])[
{
- YYFPUTS ("Stack now", stderr);
+ YYFPRINTF (stderr, "Stack now");
for (/* Nothing. */; bottom <= top; ++bottom)
YYFPRINTF (stderr, " %d", *bottom);
- YYFPUTC ('\n', stderr);
+ YYFPRINTF (stderr, "\n");
}
# define YY_STACK_PRINT(Bottom, Top) \
/* Nonzero means print parse trace. It is left uninitialized so that
multiple parsers can coexist. */
int yydebug;
-
#else /* !YYDEBUG */
-
-# define YYDPUTS(String, File)
# define YYDPRINTF(Args)
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
# define YY_STACK_PRINT(Bottom, Top)
# define YY_REDUCE_PRINT(Rule)
-
#endif /* !YYDEBUG */
rule. */
int yylen;
- YYDPUTS ("Starting parse\n", stderr);
+ YYDPRINTF ((stderr, "Starting parse\n"));
yystate = 0;
yyerrstatus = 0;
/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
if (yychar == YYEMPTY)
{
- YYDPUTS ("Reading a token: ", stderr);
+ YYDPRINTF ((stderr, "Reading a token: "));
yychar = YYLEX;
}
if (yychar <= YYEOF)
{
yychar = yytoken = YYEOF;
- YYDPUTS ("Now at end of input.\n", stderr);
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
}
else
{
{
if (pos > 70)
{
- fputc ('\n', file);
+ fprintf (file, "\n");
pos = 0;
}
};
if (verbose)
- fputs ("}\n", file);
+ fprintf (file, "}\n");
}
bitset_dump (file, bsetv[i]);
}
- fputc ('\n', file);
+ fprintf (file, "\n");
}
debug_bitset (bsetv[i]);
}
- fputc ('\n', stderr);
+ fprintf (stderr, "\n");
}
for (j = 0; j < LBITSET_WORD_BITS; j++)
if ((word & ((bitset_word) 1 << j)))
fprintf (stderr, " %u", j);
- fputc ('\n', stderr);
+ fprintf (stderr, "\n");
}
}
}
{
symbol_number i, j;
- fputs ("FIRSTS\n", stderr);
+ fprintf (stderr, "FIRSTS\n");
for (i = ntokens; i < nsyms; i++)
{
bitset_iterator iter;
symbols[j + ntokens]->tag);
}
}
- fputs ("\n\n", stderr);
+ fprintf (stderr, "\n\n");
}
int i;
rule_number r;
- fputs ("FDERIVES\n", stderr);
+ fprintf (stderr, "FDERIVES\n");
for (i = ntokens; i < nsyms; i++)
{
bitset_iterator iter;
rule_rhs_print (&rules[r], stderr);
}
}
- fputs ("\n\n", stderr);
+ fprintf (stderr, "\n\n");
}
\f
/*------------------------------------------------------------------.
ntokens, nvars, nsyms, nrules, nritems);
- fputs (("Variables\n---------\n\n"
- "Value Sprec Sassoc Tag\n"),
- out);
+ fprintf (out, "Variables\n---------\n\n");
{
symbol_number i;
+ fprintf (out, "Value Sprec Sassoc Tag\n");
+
for (i = ntokens; i < nsyms; i++)
fprintf (out, "%5d %5d %5d %s\n",
i,
symbols[i]->prec, symbols[i]->assoc,
symbols[i]->tag);
+ fprintf (out, "\n\n");
}
- fputs ("\n\n", out);
- fputs (("Rules\n-----\n\n"
- "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n"),
- out);
+ fprintf (out, "Rules\n-----\n\n");
{
rule_number i;
+ fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
for (i = 0; i < nrules + nuseless_productions; i++)
{
rule *rule_i = &rules[i];
fprintf (out, " [%d]\n", item_number_as_rule_number (*rp));
}
}
- fputs ("\n\n", out);
+ fprintf (out, "\n\n");
- fputs ("Rules interpreted\n-----------------\n\n", out);
+ fprintf (out, "Rules interpreted\n-----------------\n\n");
{
rule_number r;
for (r = 0; r < nrules + nuseless_productions; r++)
rule_print (&rules[r], out);
}
}
- fputs ("\n\n", out);
+ fprintf (out, "\n\n");
}
{
state_number i;
int j, k;
- fputs ("Look-ahead tokens: BEGIN\n", out);
+ fprintf (out, "Look-ahead tokens: BEGIN\n");
for (i = 0; i < nstates; ++i)
{
reductions *reds = states[i]->reductions;
reds->rules[j]->number);
};
}
- fputs ("Look-ahead tokens: END\n", out);
+ fprintf (out, "Look-ahead tokens: END\n");
}
void
escaped_output (FILE *out, char const *string)
{
char const *p;
- fputs ("[[", out);
+ fprintf (out, "[[");
for (p = quotearg_style (c_quoting_style, string); *p; p++)
switch (*p)
default: fputc (*p, out); break;
}
- fputs ("]]", out);
+ fprintf (out, "]]");
}
fprintf (out, "]b4_syncline(%d, ",
rules[r].action_location.start.line);
escaped_output (out, rules[r].action_location.start.file);
- fprintf (out, ")[\n %s\n break;\n\n",
+ fprintf (out, ")[\n");
+ fprintf (out, " %s\n break;\n\n",
rules[r].action);
}
fputs ("]])\n\n", out);
%type <integer> INT
%printer { fprintf (stderr, "%d", $$); } INT
%type <symbol> ID symbol string_as_id
-%printer { fputs ($$->tag, stderr); } ID symbol string_as_id
+%printer { fprintf (stderr, "%s", $$->tag); } ID symbol string_as_id
%type <symbol> ID_COLON
%printer { fprintf (stderr, "%s:", $$->tag); } ID_COLON
%type <assoc> precedence_declarator
"%d useless rules",
nuseless_productions),
nuseless_productions);
- fputc ('\n', stderr);
+ fprintf (stderr, "\n");
}
\f
void
bitset_iterator biter;
int k;
char const *sep = "";
- fputs (" [", out);
+ fprintf (out, " [");
BITSET_FOR_EACH (biter, reds->look_ahead_tokens[red], k, 0)
{
fprintf (out, "%s%s", sep, symbols[k]->tag);
sep = ", ";
}
- fputc (']', out);
+ fprintf (out, "]");
}
}
projects / bison.git / commitdiff
