mirror of
https://git.savannah.gnu.org/git/bison.git
synced 2026-03-09 12:23:04 +00:00
Insert `_' macro around many string constants.
This commit is contained in:
@@ -19,6 +19,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include "system.h"
|
||||
|
||||
extern char *calloc ();
|
||||
extern char *realloc ();
|
||||
@@ -38,7 +39,7 @@ xmalloc (n)
|
||||
block = calloc (n, 1);
|
||||
if (block == NULL)
|
||||
{
|
||||
fprintf (stderr, "%s: memory exhausted\n", program_name);
|
||||
fprintf (stderr, _("%s: memory exhausted\n"), program_name);
|
||||
done (1);
|
||||
}
|
||||
|
||||
@@ -56,7 +57,7 @@ xrealloc (block, n)
|
||||
block = realloc (block, n);
|
||||
if (block == NULL)
|
||||
{
|
||||
fprintf (stderr, "%s: memory exhausted\n", program_name);
|
||||
fprintf (stderr, _("%s: memory exhausted\n"), program_name);
|
||||
done (1);
|
||||
}
|
||||
|
||||
|
||||
@@ -311,11 +311,11 @@ print_firsts()
|
||||
register int j;
|
||||
register unsigned *rowp;
|
||||
|
||||
printf("\n\n\nFIRSTS\n\n");
|
||||
printf(_("\n\n\nFIRSTS\n\n"));
|
||||
|
||||
for (i = ntokens; i < nsyms; i++)
|
||||
{
|
||||
printf("\n\n%s firsts\n\n", tags[i]);
|
||||
printf(_("\n\n%s firsts\n\n"), tags[i]);
|
||||
|
||||
rowp = firsts + ((i - ntokens) * varsetsize);
|
||||
|
||||
@@ -333,11 +333,11 @@ print_fderives()
|
||||
register int j;
|
||||
register unsigned *rp;
|
||||
|
||||
printf("\n\n\nFDERIVES\n");
|
||||
printf(_("\n\n\nFDERIVES\n"));
|
||||
|
||||
for (i = ntokens; i < nsyms; i++)
|
||||
{
|
||||
printf("\n\n%s derives\n\n", tags[i]);
|
||||
printf(_("\n\n%s derives\n\n"), tags[i]);
|
||||
rp = fderives + i * rulesetsize;
|
||||
|
||||
for (j = 0; j <= nrules; j++)
|
||||
|
||||
@@ -192,13 +192,13 @@ int lookaheadnum;
|
||||
{
|
||||
if (sprec[i] < redprec)
|
||||
{
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, "reduce");
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, _("reduce"));
|
||||
*fp2 &= ~mask; /* flush the shift for this token */
|
||||
flush_shift(state, i);
|
||||
}
|
||||
else if (sprec[i] > redprec)
|
||||
{
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, "shift");
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, _("shift"));
|
||||
*fp1 &= ~mask; /* flush the reduce for this token */
|
||||
}
|
||||
else
|
||||
@@ -212,15 +212,15 @@ int lookaheadnum;
|
||||
{
|
||||
|
||||
case RIGHT_ASSOC:
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, "shift");
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, _("shift"));
|
||||
break;
|
||||
|
||||
case LEFT_ASSOC:
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, "reduce");
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, _("reduce"));
|
||||
break;
|
||||
|
||||
case NON_ASSOC:
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, "an error");
|
||||
if (verboseflag) log_resolution(state, lookaheadnum, i, _("an error"));
|
||||
break;
|
||||
}
|
||||
|
||||
@@ -296,7 +296,7 @@ int state, LAno, token;
|
||||
char *resolution;
|
||||
{
|
||||
fprintf(foutput,
|
||||
"Conflict in state %d between rule %d and token %s resolved as %s.\n",
|
||||
_("Conflict in state %d between rule %d and token %s resolved as %s.\n"),
|
||||
state, LAruleno[LAno], tags[token], resolution);
|
||||
}
|
||||
|
||||
@@ -341,20 +341,20 @@ verbose_conflict_log()
|
||||
src_total += src_count;
|
||||
rrc_total += rrc_count;
|
||||
|
||||
fprintf(foutput, "State %d contains", i);
|
||||
fprintf(foutput, _("State %d contains"), i);
|
||||
|
||||
if (src_count == 1)
|
||||
fprintf(foutput, " 1 shift/reduce conflict");
|
||||
fprintf(foutput, _(" 1 shift/reduce conflict"));
|
||||
else if (src_count > 1)
|
||||
fprintf(foutput, " %d shift/reduce conflicts", src_count);
|
||||
fprintf(foutput, _(" %d shift/reduce conflicts"), src_count);
|
||||
|
||||
if (src_count > 0 && rrc_count > 0)
|
||||
fprintf(foutput, " and");
|
||||
fprintf(foutput, _(" and"));
|
||||
|
||||
if (rrc_count == 1)
|
||||
fprintf(foutput, " 1 reduce/reduce conflict");
|
||||
fprintf(foutput, _(" 1 reduce/reduce conflict"));
|
||||
else if (rrc_count > 1)
|
||||
fprintf(foutput, " %d reduce/reduce conflicts", rrc_count);
|
||||
fprintf(foutput, _(" %d reduce/reduce conflicts"), rrc_count);
|
||||
|
||||
putc('.', foutput);
|
||||
putc('\n', foutput);
|
||||
@@ -377,31 +377,31 @@ total_conflicts()
|
||||
{
|
||||
/* If invoked under the name `yacc', use the output format
|
||||
specified by POSIX. */
|
||||
fprintf(stderr, "conflicts: ");
|
||||
fprintf(stderr, _("conflicts: "));
|
||||
if (src_total > 0)
|
||||
fprintf(stderr, " %d shift/reduce", src_total);
|
||||
fprintf(stderr, _(" %d shift/reduce"), src_total);
|
||||
if (src_total > 0 && rrc_total > 0)
|
||||
fprintf(stderr, ",");
|
||||
if (rrc_total > 0)
|
||||
fprintf(stderr, " %d reduce/reduce", rrc_total);
|
||||
fprintf(stderr, _(" %d reduce/reduce"), rrc_total);
|
||||
putc('\n', stderr);
|
||||
}
|
||||
else
|
||||
{
|
||||
fprintf(stderr, "%s contains", infile);
|
||||
fprintf(stderr, _("%s contains"), infile);
|
||||
|
||||
if (src_total == 1)
|
||||
fprintf(stderr, " 1 shift/reduce conflict");
|
||||
fprintf(stderr, _(" 1 shift/reduce conflict"));
|
||||
else if (src_total > 1)
|
||||
fprintf(stderr, " %d shift/reduce conflicts", src_total);
|
||||
fprintf(stderr, _(" %d shift/reduce conflicts"), src_total);
|
||||
|
||||
if (src_total > 0 && rrc_total > 0)
|
||||
fprintf(stderr, " and");
|
||||
fprintf(stderr, _(" and"));
|
||||
|
||||
if (rrc_total == 1)
|
||||
fprintf(stderr, " 1 reduce/reduce conflict");
|
||||
fprintf(stderr, _(" 1 reduce/reduce conflict"));
|
||||
else if (rrc_total > 1)
|
||||
fprintf(stderr, " %d reduce/reduce conflicts", rrc_total);
|
||||
fprintf(stderr, _(" %d reduce/reduce conflicts"), rrc_total);
|
||||
|
||||
putc('.', stderr);
|
||||
putc('\n', stderr);
|
||||
@@ -600,7 +600,7 @@ int state;
|
||||
for (i = 0; i < ntokens; i++)
|
||||
{
|
||||
if (mask & *fp3)
|
||||
fprintf(foutput, " %-4s\t[reduce using rule %d (%s)]\n",
|
||||
fprintf(foutput, _(" %-4s\t[reduce using rule %d (%s)]\n"),
|
||||
tags[i], default_rule, tags[rlhs[default_rule]]);
|
||||
|
||||
mask <<= 1;
|
||||
@@ -611,7 +611,7 @@ int state;
|
||||
}
|
||||
}
|
||||
|
||||
fprintf(foutput, " $default\treduce using rule %d (%s)\n\n",
|
||||
fprintf(foutput, _(" $default\treduce using rule %d (%s)\n\n"),
|
||||
default_rule, tags[rlhs[default_rule]]);
|
||||
}
|
||||
else if (n - m >= 1)
|
||||
@@ -697,7 +697,7 @@ int state;
|
||||
if (j != default_LA)
|
||||
{
|
||||
rule = LAruleno[j];
|
||||
fprintf(foutput, " %-4s\treduce using rule %d (%s)\n",
|
||||
fprintf(foutput, _(" %-4s\treduce using rule %d (%s)\n"),
|
||||
tags[i], rule, tags[rlhs[rule]]);
|
||||
}
|
||||
else defaulted = 1;
|
||||
@@ -709,12 +709,12 @@ int state;
|
||||
if (defaulted)
|
||||
{
|
||||
rule = LAruleno[default_LA];
|
||||
fprintf(foutput, " %-4s\treduce using rule %d (%s)\n",
|
||||
fprintf(foutput, _(" %-4s\treduce using rule %d (%s)\n"),
|
||||
tags[i], rule, tags[rlhs[rule]]);
|
||||
defaulted = 0;
|
||||
}
|
||||
rule = LAruleno[j];
|
||||
fprintf(foutput, " %-4s\t[reduce using rule %d (%s)]\n",
|
||||
fprintf(foutput, _(" %-4s\t[reduce using rule %d (%s)]\n"),
|
||||
tags[i], rule, tags[rlhs[rule]]);
|
||||
}
|
||||
}
|
||||
@@ -735,7 +735,7 @@ int state;
|
||||
|
||||
if (default_LA >= 0)
|
||||
{
|
||||
fprintf(foutput, " $default\treduce using rule %d (%s)\n",
|
||||
fprintf(foutput, _(" $default\treduce using rule %d (%s)\n"),
|
||||
default_rule, tags[rlhs[default_rule]]);
|
||||
}
|
||||
|
||||
|
||||
@@ -99,11 +99,11 @@ print_derives()
|
||||
|
||||
extern char **tags;
|
||||
|
||||
printf("\n\n\nDERIVES\n\n");
|
||||
printf(_("\n\n\nDERIVES\n\n"));
|
||||
|
||||
for (i = ntokens; i < nsyms; i++)
|
||||
{
|
||||
printf("%s derives", tags[i]);
|
||||
printf(_("%s derives"), tags[i]);
|
||||
for (sp = derives[i]; *sp > 0; sp++)
|
||||
{
|
||||
printf(" %d", *sp);
|
||||
|
||||
@@ -63,13 +63,13 @@ void
|
||||
usage (stream)
|
||||
FILE *stream;
|
||||
{
|
||||
fprintf (stream, "\
|
||||
fprintf (stream, _("\
|
||||
Usage: %s [-dhklntvyV] [-b file-prefix] [-o outfile] [-p name-prefix]\n\
|
||||
[--debug] [--defines] [--fixed-output-files] [--no-lines]\n\
|
||||
[--verbose] [--version] [--help] [--yacc]\n\
|
||||
[--no-parser] [--token-table]\n\
|
||||
[--file-prefix=prefix] [--name-prefix=prefix]\n\
|
||||
[--output=outfile] grammar-file\n",
|
||||
[--output=outfile] grammar-file\n"),
|
||||
program_name);
|
||||
}
|
||||
|
||||
@@ -157,11 +157,11 @@ getargs(argc, argv)
|
||||
|
||||
if (optind == argc)
|
||||
{
|
||||
fprintf(stderr, "%s: no grammar file given\n", program_name);
|
||||
fprintf(stderr, _("%s: no grammar file given\n"), program_name);
|
||||
exit(1);
|
||||
}
|
||||
if (optind < argc - 1)
|
||||
fprintf(stderr, "%s: extra arguments ignored after '%s'\n",
|
||||
fprintf(stderr, _("%s: extra arguments ignored after '%s'\n"),
|
||||
program_name, argv[optind]);
|
||||
|
||||
infile = argv[optind];
|
||||
|
||||
@@ -288,7 +288,7 @@ set_goto_map()
|
||||
if (ISTOKEN(symbol)) break;
|
||||
|
||||
if (ngotos == MAXSHORT)
|
||||
toomany("gotos");
|
||||
toomany(_("gotos"));
|
||||
|
||||
ngotos++;
|
||||
goto_map[symbol]++;
|
||||
|
||||
40
src/lex.c
40
src/lex.c
@@ -18,7 +18,7 @@ along with Bison; see the file COPYING. If not, write to
|
||||
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
|
||||
/*
|
||||
/*
|
||||
lex is the entry point. It is called from reader.c.
|
||||
It returns one of the token-type codes defined in lex.h.
|
||||
When an identifier is seen, the code IDENTIFIER is returned
|
||||
@@ -107,9 +107,9 @@ skip_white_space()
|
||||
{
|
||||
case '/':
|
||||
c = getc(finput);
|
||||
if (c != '*' && c != '/')
|
||||
if (c != '*' && c != '/')
|
||||
{
|
||||
warn("unexpected `/' found and ignored");
|
||||
warn(_("unexpected `/' found and ignored"));
|
||||
break;
|
||||
}
|
||||
cplus_comment = (c == '/');
|
||||
@@ -138,7 +138,7 @@ skip_white_space()
|
||||
c = getc(finput);
|
||||
}
|
||||
else if (c == EOF)
|
||||
fatal("unterminated comment");
|
||||
fatal(_("unterminated comment"));
|
||||
else
|
||||
c = getc(finput);
|
||||
}
|
||||
@@ -167,7 +167,7 @@ safegetc(f)
|
||||
{
|
||||
register int c = getc(f);
|
||||
if (c == EOF)
|
||||
fatal("Unexpected end of file");
|
||||
fatal(_("Unexpected end of file"));
|
||||
return c;
|
||||
}
|
||||
|
||||
@@ -189,9 +189,9 @@ literalchar(pp, pcode, term)
|
||||
int wasquote = 0;
|
||||
|
||||
c = safegetc(finput);
|
||||
if (c == '\n')
|
||||
if (c == '\n')
|
||||
{
|
||||
warn("unescaped newline in constant");
|
||||
warn(_("unescaped newline in constant"));
|
||||
ungetc(c, finput);
|
||||
code = '?';
|
||||
wasquote = 1;
|
||||
@@ -199,7 +199,7 @@ literalchar(pp, pcode, term)
|
||||
else if (c != '\\')
|
||||
{
|
||||
code = c;
|
||||
if (c == term)
|
||||
if (c == term)
|
||||
wasquote = 1;
|
||||
}
|
||||
else
|
||||
@@ -223,7 +223,7 @@ literalchar(pp, pcode, term)
|
||||
code = (code * 8) + (c - '0');
|
||||
if (code >= 256 || code < 0)
|
||||
{
|
||||
warni("octal value outside range 0...255: `\\%o'", code);
|
||||
warni(_("octal value outside range 0...255: `\\%o'"), code);
|
||||
code &= 0xFF;
|
||||
break;
|
||||
}
|
||||
@@ -243,11 +243,11 @@ literalchar(pp, pcode, term)
|
||||
code *= 16, code += c - 'a' + 10;
|
||||
else if (c >= 'A' && c <= 'F')
|
||||
code *= 16, code += c - 'A' + 10;
|
||||
else
|
||||
else
|
||||
break;
|
||||
if (code >= 256 || code<0)
|
||||
{
|
||||
warni("hexadecimal value above 255: `\\x%x'", code);
|
||||
warni(_("hexadecimal value above 255: `\\x%x'"), code);
|
||||
code &= 0xFF;
|
||||
break;
|
||||
}
|
||||
@@ -257,7 +257,7 @@ literalchar(pp, pcode, term)
|
||||
}
|
||||
else
|
||||
{
|
||||
warni ("unknown escape sequence: `\\' followed by `%s'",
|
||||
warni (_("unknown escape sequence: `\\' followed by `%s'"),
|
||||
printable_version(c));
|
||||
code = '?';
|
||||
}
|
||||
@@ -388,7 +388,7 @@ lex()
|
||||
c = getc(finput);
|
||||
if (c != '\'')
|
||||
{
|
||||
warn("use \"...\" for multi-character literal tokens");
|
||||
warn(_("use \"...\" for multi-character literal tokens"));
|
||||
dp = discard;
|
||||
while (literalchar(&dp, &discode, '\'')) {}
|
||||
}
|
||||
@@ -463,10 +463,10 @@ lex()
|
||||
while (c != '>')
|
||||
{
|
||||
if (c == EOF)
|
||||
fatal("unterminated type name at end of file");
|
||||
if (c == '\n')
|
||||
fatal(_("unterminated type name at end of file"));
|
||||
if (c == '\n')
|
||||
{
|
||||
warn("unterminated type name");
|
||||
warn(_("unterminated type name"));
|
||||
ungetc(c, finput);
|
||||
break;
|
||||
}
|
||||
@@ -479,7 +479,7 @@ lex()
|
||||
}
|
||||
*p = 0;
|
||||
return (TYPENAME);
|
||||
|
||||
|
||||
|
||||
case '%':
|
||||
return (parse_percent_token());
|
||||
@@ -489,13 +489,13 @@ lex()
|
||||
}
|
||||
}
|
||||
|
||||
/* the following table dictates the action taken for the various
|
||||
/* the following table dictates the action taken for the various
|
||||
% directives. A setflag value causes the named flag to be
|
||||
set. A retval action returns the code.
|
||||
*/
|
||||
struct percent_table_struct {
|
||||
char *name;
|
||||
void *setflag;
|
||||
void *setflag;
|
||||
int retval;
|
||||
} percent_table[] =
|
||||
{
|
||||
@@ -583,7 +583,7 @@ parse_percent_token ()
|
||||
case '=':
|
||||
return (PREC);
|
||||
}
|
||||
if (!isalpha(c))
|
||||
if (!isalpha(c))
|
||||
return (ILLEGAL);
|
||||
|
||||
p = token_buffer;
|
||||
|
||||
@@ -49,7 +49,7 @@ set_nullable()
|
||||
short *r1;
|
||||
|
||||
#ifdef TRACE
|
||||
fprintf(stderr, "Entering set_nullable");
|
||||
fprintf(stderr, _("Entering set_nullable"));
|
||||
#endif
|
||||
|
||||
nullable = NEW2(nvars, char) - ntokens;
|
||||
|
||||
@@ -1190,7 +1190,7 @@ int vector;
|
||||
{
|
||||
loc = j + from[k];
|
||||
if (loc > MAXTABLE)
|
||||
fatals("maximum table size (%s) exceeded", int_to_string(MAXTABLE));
|
||||
fatals(_("maximum table size (%s) exceeded"), int_to_string(MAXTABLE));
|
||||
|
||||
if (table[loc] != 0)
|
||||
ok = 0;
|
||||
|
||||
34
src/print.c
34
src/print.c
@@ -80,7 +80,7 @@ void
|
||||
print_token(extnum, token)
|
||||
int extnum, token;
|
||||
{
|
||||
fprintf(foutput, " type %d is %s\n", extnum, tags[token]);
|
||||
fprintf(foutput, _(" type %d is %s\n"), extnum, tags[token]);
|
||||
}
|
||||
|
||||
|
||||
@@ -88,7 +88,7 @@ void
|
||||
print_state(state)
|
||||
int state;
|
||||
{
|
||||
fprintf(foutput, "\n\nstate %d\n\n", state);
|
||||
fprintf(foutput, _("\n\nstate %d\n\n"), state);
|
||||
print_core(state);
|
||||
print_actions(state);
|
||||
}
|
||||
@@ -133,7 +133,7 @@ int state;
|
||||
sp++;
|
||||
}
|
||||
|
||||
fprintf (foutput, " (rule %d)", rule);
|
||||
fprintf (foutput, _(" (rule %d)"), rule);
|
||||
putc('\n', foutput);
|
||||
}
|
||||
|
||||
@@ -161,9 +161,9 @@ int state;
|
||||
if (!shiftp && !redp)
|
||||
{
|
||||
if (final_state == state)
|
||||
fprintf(foutput, " $default\taccept\n");
|
||||
fprintf(foutput, _(" $default\taccept\n"));
|
||||
else
|
||||
fprintf(foutput, " NO ACTIONS\n");
|
||||
fprintf(foutput, _(" NO ACTIONS\n"));
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -179,9 +179,9 @@ int state;
|
||||
/* The following line used to be turned off. */
|
||||
if (ISVAR(symbol)) break;
|
||||
if (symbol==0) /* I.e. strcmp(tags[symbol],"$")==0 */
|
||||
fprintf(foutput, " $ \tgo to state %d\n", state1);
|
||||
fprintf(foutput, _(" $ \tgo to state %d\n"), state1);
|
||||
else
|
||||
fprintf(foutput, " %-4s\tshift, and go to state %d\n",
|
||||
fprintf(foutput, _(" %-4s\tshift, and go to state %d\n"),
|
||||
tags[symbol], state1);
|
||||
}
|
||||
|
||||
@@ -204,7 +204,7 @@ int state;
|
||||
{
|
||||
if (! errp->errs[j]) continue;
|
||||
symbol = errp->errs[j];
|
||||
fprintf(foutput, " %-4s\terror (nonassociative)\n", tags[symbol]);
|
||||
fprintf(foutput, _(" %-4s\terror (nonassociative)\n"), tags[symbol]);
|
||||
}
|
||||
|
||||
if (j > 0)
|
||||
@@ -215,7 +215,7 @@ int state;
|
||||
{
|
||||
rule = redp->rules[0];
|
||||
symbol = rlhs[rule];
|
||||
fprintf(foutput, " $default\treduce using rule %d (%s)\n\n",
|
||||
fprintf(foutput, _(" $default\treduce using rule %d (%s)\n\n"),
|
||||
rule, tags[symbol]);
|
||||
}
|
||||
else if (redp)
|
||||
@@ -230,7 +230,7 @@ int state;
|
||||
if (! shiftp->shifts[i]) continue;
|
||||
state1 = shiftp->shifts[i];
|
||||
symbol = accessing_symbol[state1];
|
||||
fprintf(foutput, " %-4s\tgo to state %d\n", tags[symbol], state1);
|
||||
fprintf(foutput, _(" %-4s\tgo to state %d\n"), tags[symbol], state1);
|
||||
}
|
||||
|
||||
putc('\n', foutput);
|
||||
@@ -251,23 +251,23 @@ print_grammar()
|
||||
int column = 0;
|
||||
|
||||
/* rule # : LHS -> RHS */
|
||||
fputs("\nGrammar\n", foutput);
|
||||
fputs(_("\nGrammar\n"), foutput);
|
||||
for (i = 1; i <= nrules; i++)
|
||||
/* Don't print rules disabled in reduce_grammar_tables. */
|
||||
if (rlhs[i] >= 0)
|
||||
{
|
||||
fprintf(foutput, "rule %-4d %s ->", i, tags[rlhs[i]]);
|
||||
fprintf(foutput, _("rule %-4d %s ->"), i, tags[rlhs[i]]);
|
||||
rule = &ritem[rrhs[i]];
|
||||
if (*rule > 0)
|
||||
while (*rule > 0)
|
||||
fprintf(foutput, " %s", tags[*rule++]);
|
||||
else
|
||||
fputs (" /* empty */", foutput);
|
||||
fputs (_(" /* empty */"), foutput);
|
||||
putc('\n', foutput);
|
||||
}
|
||||
|
||||
/* TERMINAL (type #) : rule #s terminal is on RHS */
|
||||
fputs("\nTerminals, with rules where they appear\n\n", foutput);
|
||||
fputs(_("\nTerminals, with rules where they appear\n\n"), foutput);
|
||||
fprintf(foutput, "%s (-1)\n", tags[0]);
|
||||
if (translations)
|
||||
{
|
||||
@@ -315,7 +315,7 @@ print_grammar()
|
||||
fprintf (foutput, "%s\n", buffer);
|
||||
}
|
||||
|
||||
fputs("\nNonterminals, with rules where they appear\n\n", foutput);
|
||||
fputs(_("\nNonterminals, with rules where they appear\n\n"), foutput);
|
||||
for (i = ntokens; i <= nsyms - 1; i++)
|
||||
{
|
||||
int left_count = 0, right_count = 0;
|
||||
@@ -341,7 +341,7 @@ print_grammar()
|
||||
if (left_count > 0)
|
||||
{
|
||||
END_TEST (50);
|
||||
sprintf (buffer + strlen(buffer), " on left:");
|
||||
sprintf (buffer + strlen(buffer), _(" on left:"));
|
||||
|
||||
for (j = 1; j <= nrules; j++)
|
||||
{
|
||||
@@ -356,7 +356,7 @@ print_grammar()
|
||||
if (left_count > 0)
|
||||
sprintf (buffer + strlen(buffer), ",");
|
||||
END_TEST (50);
|
||||
sprintf (buffer + strlen(buffer), " on right:");
|
||||
sprintf (buffer + strlen(buffer), _(" on right:"));
|
||||
for (j = 1; j <= nrules; j++)
|
||||
{
|
||||
for (rule = &ritem[rrhs[j]]; *rule > 0; rule++)
|
||||
|
||||
216
src/reader.c
216
src/reader.c
@@ -135,14 +135,14 @@ skip_to_char(target)
|
||||
{
|
||||
int c;
|
||||
if (target == '\n')
|
||||
warn(" Skipping to next \\n");
|
||||
warn(_(" Skipping to next \\n"));
|
||||
else
|
||||
warni(" Skipping to next %c", target);
|
||||
warni(_(" Skipping to next %c"), target);
|
||||
|
||||
do
|
||||
c = skip_white_space();
|
||||
while (c != target && c != EOF);
|
||||
if (c != EOF)
|
||||
if (c != EOF)
|
||||
ungetc(c, finput);
|
||||
}
|
||||
|
||||
@@ -193,7 +193,7 @@ reader()
|
||||
getsym("$undefined.")->class = STOKEN;
|
||||
/* Read the declaration section. Copy %{ ... %} groups to ftable and fdefines file.
|
||||
Also notice any %token, %left, etc. found there. */
|
||||
if (noparserflag)
|
||||
if (noparserflag)
|
||||
fprintf(ftable, "\n/* Bison-generated parse tables, made from %s\n",
|
||||
infile);
|
||||
else
|
||||
@@ -261,23 +261,23 @@ read_declarations ()
|
||||
case TOKEN:
|
||||
parse_token_decl (STOKEN, SNTERM);
|
||||
break;
|
||||
|
||||
|
||||
case NTERM:
|
||||
parse_token_decl (SNTERM, STOKEN);
|
||||
break;
|
||||
|
||||
|
||||
case TYPE:
|
||||
parse_type_decl();
|
||||
break;
|
||||
|
||||
|
||||
case START:
|
||||
parse_start_decl();
|
||||
break;
|
||||
|
||||
|
||||
case UNION:
|
||||
parse_union_decl();
|
||||
break;
|
||||
|
||||
|
||||
case EXPECT:
|
||||
parse_expect_decl();
|
||||
break;
|
||||
@@ -312,16 +312,16 @@ read_declarations ()
|
||||
break;
|
||||
|
||||
default:
|
||||
warns("unrecognized: %s", token_buffer);
|
||||
warns(_("unrecognized: %s"), token_buffer);
|
||||
skip_to_char('%');
|
||||
}
|
||||
}
|
||||
else if (c == EOF)
|
||||
fatal("no input grammar");
|
||||
fatal(_("no input grammar"));
|
||||
else
|
||||
{
|
||||
char buff[100];
|
||||
sprintf(buff, "unknown character: %s", printable_version(c));
|
||||
sprintf(buff, _("unknown character: %s"), printable_version(c));
|
||||
warn(buff);
|
||||
skip_to_char('%');
|
||||
}
|
||||
@@ -360,7 +360,7 @@ copy_definition ()
|
||||
case '%':
|
||||
after_percent = -1;
|
||||
break;
|
||||
|
||||
|
||||
case '\'':
|
||||
case '"':
|
||||
match = c;
|
||||
@@ -370,22 +370,22 @@ copy_definition ()
|
||||
while (c != match)
|
||||
{
|
||||
if (c == EOF)
|
||||
fatal("unterminated string at end of file");
|
||||
fatal(_("unterminated string at end of file"));
|
||||
if (c == '\n')
|
||||
{
|
||||
warn("unterminated string");
|
||||
warn(_("unterminated string"));
|
||||
ungetc(c, finput);
|
||||
c = match;
|
||||
continue;
|
||||
}
|
||||
|
||||
putc(c, fattrs);
|
||||
|
||||
|
||||
if (c == '\\')
|
||||
{
|
||||
c = getc(finput);
|
||||
if (c == EOF)
|
||||
fatal("unterminated string at end of file");
|
||||
fatal(_("unterminated string at end of file"));
|
||||
putc(c, fattrs);
|
||||
if (c == '\n')
|
||||
lineno++;
|
||||
@@ -434,7 +434,7 @@ copy_definition ()
|
||||
c = getc(finput);
|
||||
}
|
||||
else if (c == EOF)
|
||||
fatal("unterminated comment in `%{' definition");
|
||||
fatal(_("unterminated comment in `%{' definition"));
|
||||
else
|
||||
{
|
||||
putc(c, fattrs);
|
||||
@@ -445,7 +445,7 @@ copy_definition ()
|
||||
break;
|
||||
|
||||
case EOF:
|
||||
fatal("unterminated `%{' definition");
|
||||
fatal(_("unterminated `%{' definition"));
|
||||
|
||||
default:
|
||||
putc(c, fattrs);
|
||||
@@ -499,7 +499,7 @@ parse_token_decl (what_is, what_is_not)
|
||||
symbol = NULL;
|
||||
}
|
||||
else if (token == IDENTIFIER && *symval->tag == '\"'
|
||||
&& symbol)
|
||||
&& symbol)
|
||||
{
|
||||
translations = 1;
|
||||
symval->class = STOKEN;
|
||||
@@ -507,8 +507,8 @@ parse_token_decl (what_is, what_is_not)
|
||||
symval->user_token_number = symbol->user_token_number;
|
||||
symbol->user_token_number = SALIAS;
|
||||
|
||||
symval->alias = symbol;
|
||||
symbol->alias = symval;
|
||||
symval->alias = symbol;
|
||||
symbol->alias = symval;
|
||||
symbol = NULL;
|
||||
|
||||
nsyms--; /* symbol and symval combined are only one symbol */
|
||||
@@ -519,7 +519,7 @@ parse_token_decl (what_is, what_is_not)
|
||||
symbol = symval;
|
||||
|
||||
if (symbol->class == what_is_not)
|
||||
warns("symbol %s redefined", symbol->tag);
|
||||
warns(_("symbol %s redefined"), symbol->tag);
|
||||
symbol->class = what_is;
|
||||
if (what_is == SNTERM && oldclass != SNTERM)
|
||||
symbol->value = nvars++;
|
||||
@@ -529,7 +529,7 @@ parse_token_decl (what_is, what_is_not)
|
||||
if (symbol->type_name == NULL)
|
||||
symbol->type_name = typename;
|
||||
else if (strcmp(typename, symbol->type_name) != 0)
|
||||
warns("type redeclaration for %s", symbol->tag);
|
||||
warns(_("type redeclaration for %s"), symbol->tag);
|
||||
}
|
||||
}
|
||||
else if (symbol && token == NUMBER)
|
||||
@@ -539,8 +539,8 @@ parse_token_decl (what_is, what_is_not)
|
||||
}
|
||||
else
|
||||
{
|
||||
warnss("`%s' is invalid in %s",
|
||||
token_buffer,
|
||||
warnss(_("`%s' is invalid in %s"),
|
||||
token_buffer,
|
||||
(what_is == STOKEN) ? "%token" : "%nterm");
|
||||
skip_to_char('%');
|
||||
}
|
||||
@@ -548,7 +548,7 @@ parse_token_decl (what_is, what_is_not)
|
||||
|
||||
}
|
||||
|
||||
/* parse what comes after %thong
|
||||
/* parse what comes after %thong
|
||||
the full syntax is
|
||||
%thong <type> token number literal
|
||||
the <type> or number may be omitted. The number specifies the
|
||||
@@ -559,7 +559,7 @@ parse_token_decl (what_is, what_is_not)
|
||||
The ->user_token_number of the first is SALIAS and the ->user_token_number
|
||||
of the second is set to the number, if any, from the declaration.
|
||||
The two symbols are linked via pointers in their ->alias fields.
|
||||
|
||||
|
||||
during output_defines_table, the symbol is reported
|
||||
thereafter, only the literal string is retained
|
||||
it is the literal string that is output to yytname
|
||||
@@ -585,9 +585,9 @@ parse_thong_decl ()
|
||||
|
||||
/* process first token */
|
||||
|
||||
if (token != IDENTIFIER)
|
||||
if (token != IDENTIFIER)
|
||||
{
|
||||
warns("unrecognized item %s, expected an identifier",
|
||||
warns(_("unrecognized item %s, expected an identifier"),
|
||||
token_buffer);
|
||||
skip_to_char('%');
|
||||
return;
|
||||
@@ -598,7 +598,7 @@ parse_thong_decl ()
|
||||
symbol = symval;
|
||||
|
||||
token = lex(); /* get number or literal string */
|
||||
|
||||
|
||||
if (token == NUMBER) {
|
||||
usrtoknum = numval;
|
||||
token = lex(); /* okay, did number, now get literal */
|
||||
@@ -607,9 +607,9 @@ parse_thong_decl ()
|
||||
|
||||
/* process literal string token */
|
||||
|
||||
if (token != IDENTIFIER || *symval->tag != '\"')
|
||||
if (token != IDENTIFIER || *symval->tag != '\"')
|
||||
{
|
||||
warns("expected string constant instead of %s",
|
||||
warns(_("expected string constant instead of %s"),
|
||||
token_buffer);
|
||||
skip_to_char('%');
|
||||
return;
|
||||
@@ -618,8 +618,8 @@ parse_thong_decl ()
|
||||
symval->type_name = typename;
|
||||
symval->user_token_number = usrtoknum;
|
||||
|
||||
symval->alias = symbol;
|
||||
symbol->alias = symval;
|
||||
symval->alias = symbol;
|
||||
symbol->alias = symval;
|
||||
|
||||
nsyms--; /* symbol and symval combined are only one symbol */
|
||||
}
|
||||
@@ -631,9 +631,9 @@ void
|
||||
parse_start_decl ()
|
||||
{
|
||||
if (start_flag)
|
||||
warn("multiple %start declarations");
|
||||
warn(_("multiple %start declarations"));
|
||||
if (lex() != IDENTIFIER)
|
||||
warn("invalid %start declaration");
|
||||
warn(_("invalid %start declaration"));
|
||||
else
|
||||
{
|
||||
start_flag = 1;
|
||||
@@ -653,7 +653,7 @@ parse_type_decl ()
|
||||
|
||||
if (lex() != TYPENAME)
|
||||
{
|
||||
warn("%type declaration has no <typename>");
|
||||
warn(_("%type declaration has no <typename>"));
|
||||
skip_to_char('%');
|
||||
return;
|
||||
}
|
||||
@@ -682,12 +682,12 @@ parse_type_decl ()
|
||||
if (symval->type_name == NULL)
|
||||
symval->type_name = name;
|
||||
else if (strcmp(name, symval->type_name) != 0)
|
||||
warns("type redeclaration for %s", symval->tag);
|
||||
warns(_("type redeclaration for %s"), symval->tag);
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
warns("invalid %%type declaration due to item: `%s'", token_buffer);
|
||||
warns(_("invalid %%type declaration due to item: `%s'"), token_buffer);
|
||||
skip_to_char('%');
|
||||
}
|
||||
}
|
||||
@@ -731,18 +731,18 @@ int assoc;
|
||||
|
||||
case IDENTIFIER:
|
||||
if (symval->prec != 0)
|
||||
warns("redefining precedence of %s", symval->tag);
|
||||
warns(_("redefining precedence of %s"), symval->tag);
|
||||
symval->prec = lastprec;
|
||||
symval->assoc = assoc;
|
||||
if (symval->class == SNTERM)
|
||||
warns("symbol %s redefined", symval->tag);
|
||||
warns(_("symbol %s redefined"), symval->tag);
|
||||
symval->class = STOKEN;
|
||||
if (name)
|
||||
{ /* record the type, if one is specified */
|
||||
if (symval->type_name == NULL)
|
||||
symval->type_name = name;
|
||||
else if (strcmp(name, symval->type_name) != 0)
|
||||
warns("type redeclaration for %s", symval->tag);
|
||||
warns(_("type redeclaration for %s"), symval->tag);
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -752,9 +752,9 @@ int assoc;
|
||||
symval->user_token_number = numval;
|
||||
translations = 1;
|
||||
}
|
||||
else
|
||||
else
|
||||
{
|
||||
warns("invalid text (%s) - number should be after identifier",
|
||||
warns(_("invalid text (%s) - number should be after identifier"),
|
||||
token_buffer);
|
||||
skip_to_char('%');
|
||||
}
|
||||
@@ -764,7 +764,7 @@ int assoc;
|
||||
return;
|
||||
|
||||
default:
|
||||
warns("unexpected item: %s", token_buffer);
|
||||
warns(_("unexpected item: %s"), token_buffer);
|
||||
skip_to_char('%');
|
||||
}
|
||||
|
||||
@@ -788,7 +788,7 @@ parse_union_decl()
|
||||
int cplus_comment;
|
||||
|
||||
if (typed)
|
||||
warn("multiple %union declarations");
|
||||
warn(_("multiple %union declarations"));
|
||||
|
||||
typed = 1;
|
||||
|
||||
@@ -846,7 +846,7 @@ parse_union_decl()
|
||||
}
|
||||
}
|
||||
if (c == EOF)
|
||||
fatal("unterminated comment at end of file");
|
||||
fatal(_("unterminated comment at end of file"));
|
||||
|
||||
if (!cplus_comment && c == '*')
|
||||
{
|
||||
@@ -872,7 +872,7 @@ parse_union_decl()
|
||||
|
||||
case '}':
|
||||
if (count == 0)
|
||||
warn ("unmatched close-brace (`}')");
|
||||
warn (_("unmatched close-brace (`}')"));
|
||||
count--;
|
||||
if (count <= 0)
|
||||
{
|
||||
@@ -916,7 +916,7 @@ parse_expect_decl()
|
||||
ungetc (c, finput);
|
||||
|
||||
if (count <= 0 || count > 10)
|
||||
warn("argument of %expect is not an integer");
|
||||
warn(_("argument of %expect is not an integer"));
|
||||
expected_conflicts = atoi (buffer);
|
||||
}
|
||||
|
||||
@@ -929,14 +929,14 @@ get_type_name(n, rule)
|
||||
int n;
|
||||
symbol_list *rule;
|
||||
{
|
||||
static char *msg = "invalid $ value";
|
||||
static char *msg = N_("invalid $ value");
|
||||
|
||||
register int i;
|
||||
register symbol_list *rp;
|
||||
|
||||
if (n < 0)
|
||||
{
|
||||
warn(msg);
|
||||
warn(_(msg));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@@ -948,7 +948,7 @@ symbol_list *rule;
|
||||
rp = rp->next;
|
||||
if (rp == NULL || rp->sym == NULL)
|
||||
{
|
||||
warn(msg);
|
||||
warn(_(msg));
|
||||
return NULL;
|
||||
}
|
||||
i++;
|
||||
@@ -1009,9 +1009,9 @@ int stack_offset;
|
||||
putc(c, fguard);
|
||||
if (count > 0)
|
||||
count--;
|
||||
else
|
||||
else
|
||||
{
|
||||
warn("unmatched right brace (`}')");
|
||||
warn(_("unmatched right brace (`}')"));
|
||||
c = getc(finput); /* skip it */
|
||||
}
|
||||
break;
|
||||
@@ -1025,22 +1025,22 @@ int stack_offset;
|
||||
while (c != match)
|
||||
{
|
||||
if (c == EOF)
|
||||
fatal("unterminated string at end of file");
|
||||
if (c == '\n')
|
||||
fatal(_("unterminated string at end of file"));
|
||||
if (c == '\n')
|
||||
{
|
||||
warn("unterminated string");
|
||||
warn(_("unterminated string"));
|
||||
ungetc(c, finput);
|
||||
c = match; /* invent terminator */
|
||||
continue;
|
||||
}
|
||||
|
||||
putc(c, fguard);
|
||||
|
||||
|
||||
if (c == '\\')
|
||||
{
|
||||
c = getc(finput);
|
||||
if (c == EOF)
|
||||
fatal("unterminated string");
|
||||
fatal(_("unterminated string"));
|
||||
putc(c, fguard);
|
||||
if (c == '\n')
|
||||
lineno++;
|
||||
@@ -1089,7 +1089,7 @@ int stack_offset;
|
||||
c = getc(finput);
|
||||
}
|
||||
else if (c == EOF)
|
||||
fatal("unterminated comment");
|
||||
fatal(_("unterminated comment"));
|
||||
else
|
||||
{
|
||||
putc(c, fguard);
|
||||
@@ -1122,7 +1122,7 @@ int stack_offset;
|
||||
if (type_name)
|
||||
fprintf(fguard, ".%s", type_name);
|
||||
if(!type_name && typed)
|
||||
warns("$$ of `%s' has no declared type", rule->sym->tag);
|
||||
warns(_("$$ of `%s' has no declared type"), rule->sym->tag);
|
||||
}
|
||||
|
||||
else if (isdigit(c) || c == '-')
|
||||
@@ -1138,11 +1138,11 @@ int stack_offset;
|
||||
if (type_name)
|
||||
fprintf(fguard, ".%s", type_name);
|
||||
if(!type_name && typed)
|
||||
warnss("$%s of `%s' has no declared type", int_to_string(n), rule->sym->tag);
|
||||
warnss(_("$%s of `%s' has no declared type"), int_to_string(n), rule->sym->tag);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
warni("$%s is invalid", printable_version(c));
|
||||
warni(_("$%s is invalid"), printable_version(c));
|
||||
|
||||
break;
|
||||
|
||||
@@ -1156,7 +1156,7 @@ int stack_offset;
|
||||
}
|
||||
else
|
||||
{
|
||||
warni("@%s is invalid", printable_version(c));
|
||||
warni(_("@%s is invalid"), printable_version(c));
|
||||
n = 1;
|
||||
}
|
||||
|
||||
@@ -1166,7 +1166,7 @@ int stack_offset;
|
||||
continue;
|
||||
|
||||
case EOF:
|
||||
fatal("unterminated %%guard clause");
|
||||
fatal(_("unterminated %%guard clause"));
|
||||
|
||||
default:
|
||||
putc(c, fguard);
|
||||
@@ -1248,13 +1248,13 @@ int stack_offset;
|
||||
{
|
||||
if (c == '\n')
|
||||
{
|
||||
warn("unterminated string");
|
||||
warn(_("unterminated string"));
|
||||
ungetc(c, finput);
|
||||
c = match;
|
||||
continue;
|
||||
}
|
||||
else if (c == EOF)
|
||||
fatal("unterminated string at end of file");
|
||||
fatal(_("unterminated string at end of file"));
|
||||
|
||||
putc(c, faction);
|
||||
|
||||
@@ -1262,7 +1262,7 @@ int stack_offset;
|
||||
{
|
||||
c = getc(finput);
|
||||
if (c == EOF)
|
||||
fatal("unterminated string");
|
||||
fatal(_("unterminated string"));
|
||||
putc(c, faction);
|
||||
if (c == '\n')
|
||||
lineno++;
|
||||
@@ -1311,7 +1311,7 @@ int stack_offset;
|
||||
c = getc(finput);
|
||||
}
|
||||
else if (c == EOF)
|
||||
fatal("unterminated comment");
|
||||
fatal(_("unterminated comment"));
|
||||
else
|
||||
{
|
||||
putc(c, faction);
|
||||
@@ -1343,8 +1343,8 @@ int stack_offset;
|
||||
if (!type_name) type_name = get_type_name(0, rule);
|
||||
if (type_name)
|
||||
fprintf(faction, ".%s", type_name);
|
||||
if(!type_name && typed)
|
||||
warns("$$ of `%s' has no declared type", rule->sym->tag);
|
||||
if(!type_name && typed)
|
||||
warns(_("$$ of `%s' has no declared type"), rule->sym->tag);
|
||||
}
|
||||
else if (isdigit(c) || c == '-')
|
||||
{
|
||||
@@ -1358,13 +1358,13 @@ int stack_offset;
|
||||
fprintf(faction, "yyvsp[%d]", n - stack_offset);
|
||||
if (type_name)
|
||||
fprintf(faction, ".%s", type_name);
|
||||
if(!type_name && typed)
|
||||
warnss("$%s of `%s' has no declared type",
|
||||
if(!type_name && typed)
|
||||
warnss(_("$%s of `%s' has no declared type"),
|
||||
int_to_string(n), rule->sym->tag);
|
||||
continue;
|
||||
}
|
||||
else
|
||||
warni("$%s is invalid", printable_version(c));
|
||||
warni(_("$%s is invalid"), printable_version(c));
|
||||
|
||||
break;
|
||||
|
||||
@@ -1378,7 +1378,7 @@ int stack_offset;
|
||||
}
|
||||
else
|
||||
{
|
||||
warn("invalid @-construct");
|
||||
warn(_("invalid @-construct"));
|
||||
n = 1;
|
||||
}
|
||||
|
||||
@@ -1388,7 +1388,7 @@ int stack_offset;
|
||||
continue;
|
||||
|
||||
case EOF:
|
||||
fatal("unmatched `{'");
|
||||
fatal(_("unmatched `{'"));
|
||||
|
||||
default:
|
||||
putc(c, faction);
|
||||
@@ -1470,18 +1470,18 @@ readgram()
|
||||
startval = lhs;
|
||||
start_flag = 1;
|
||||
}
|
||||
|
||||
|
||||
t = lex();
|
||||
if (t != COLON)
|
||||
{
|
||||
warn("ill-formed rule: initial symbol not followed by colon");
|
||||
warn(_("ill-formed rule: initial symbol not followed by colon"));
|
||||
unlex(t);
|
||||
}
|
||||
}
|
||||
|
||||
if (nrules == 0 && t == BAR)
|
||||
{
|
||||
warn("grammar starts with vertical bar");
|
||||
warn(_("grammar starts with vertical bar"));
|
||||
lhs = symval; /* BOGUS: use a random symval */
|
||||
}
|
||||
/* start a new rule and record its lhs. */
|
||||
@@ -1512,7 +1512,7 @@ readgram()
|
||||
nvars++;
|
||||
}
|
||||
else if (lhs->class == STOKEN)
|
||||
warns("rule given for %s, which is a token", lhs->tag);
|
||||
warns(_("rule given for %s, which is a token"), lhs->tag);
|
||||
|
||||
/* read the rhs of the rule. */
|
||||
|
||||
@@ -1610,7 +1610,7 @@ readgram()
|
||||
|
||||
if (t == PREC)
|
||||
{
|
||||
warn("two @prec's in a row");
|
||||
warn(_("two @prec's in a row"));
|
||||
t = lex();
|
||||
crule->ruleprec = symval;
|
||||
t = lex();
|
||||
@@ -1618,7 +1618,7 @@ readgram()
|
||||
if (t == GUARD)
|
||||
{
|
||||
if (! semantic_parser)
|
||||
warn("%%guard present but %%semantic_parser not specified");
|
||||
warn(_("%%guard present but %%semantic_parser not specified"));
|
||||
|
||||
copy_guard(crule, rulelength);
|
||||
t = lex();
|
||||
@@ -1626,7 +1626,7 @@ readgram()
|
||||
else if (t == LEFT_CURLY)
|
||||
{
|
||||
/* This case never occurs -wjh */
|
||||
if (actionflag) warn("two actions at end of one rule");
|
||||
if (actionflag) warn(_("two actions at end of one rule"));
|
||||
copy_action(crule, rulelength);
|
||||
actionflag = 1;
|
||||
xactions++; /* -wjh */
|
||||
@@ -1638,16 +1638,16 @@ readgram()
|
||||
{
|
||||
if (lhs->type_name == 0 || first_rhs->type_name == 0
|
||||
|| strcmp(lhs->type_name,first_rhs->type_name))
|
||||
warnss("type clash (`%s' `%s') on default action",
|
||||
warnss(_("type clash (`%s' `%s') on default action"),
|
||||
lhs->type_name ? lhs->type_name : "",
|
||||
first_rhs->type_name ? first_rhs->type_name : "");
|
||||
}
|
||||
/* Warn if there is no default for $$ but we need one. */
|
||||
else if (!xactions && !first_rhs && lhs->type_name != 0)
|
||||
warn("empty rule for typed nonterminal, and no action");
|
||||
warn(_("empty rule for typed nonterminal, and no action"));
|
||||
if (t == SEMICOLON)
|
||||
t = lex();
|
||||
}
|
||||
}
|
||||
#if 0
|
||||
/* these things can appear as alternatives to rules. */
|
||||
/* NO, they cannot.
|
||||
@@ -1688,7 +1688,7 @@ readgram()
|
||||
|
||||
else
|
||||
{
|
||||
warns("invalid input: %s", token_buffer);
|
||||
warns(_("invalid input: %s"), token_buffer);
|
||||
t = lex();
|
||||
}
|
||||
}
|
||||
@@ -1696,10 +1696,10 @@ readgram()
|
||||
/* grammar has been read. Do some checking */
|
||||
|
||||
if (nsyms > MAXSHORT)
|
||||
fatals("too many symbols (tokens plus nonterminals); maximum %s",
|
||||
fatals(_("too many symbols (tokens plus nonterminals); maximum %s"),
|
||||
int_to_string(MAXSHORT));
|
||||
if (nrules == 0)
|
||||
fatal("no rules in the input grammar");
|
||||
fatal(_("no rules in the input grammar"));
|
||||
|
||||
if (typed == 0 /* JF put out same default YYSTYPE as YACC does */
|
||||
&& !value_components_used)
|
||||
@@ -1717,7 +1717,7 @@ readgram()
|
||||
for (bp = firstsymbol; bp; bp = bp->next)
|
||||
if (bp->class == SUNKNOWN)
|
||||
{
|
||||
warns("symbol %s is used, but is not defined as a token and has no rules",
|
||||
warns(_("symbol %s is used, but is not defined as a token and has no rules"),
|
||||
bp->tag);
|
||||
bp->class = SNTERM;
|
||||
bp->value = nvars++;
|
||||
@@ -1753,9 +1753,9 @@ get_type()
|
||||
|
||||
t = lex();
|
||||
|
||||
if (t != TYPENAME)
|
||||
if (t != TYPENAME)
|
||||
{
|
||||
warn("ill-formed %type declaration");
|
||||
warn(_("ill-formed %type declaration"));
|
||||
return t;
|
||||
}
|
||||
|
||||
@@ -1779,7 +1779,7 @@ get_type()
|
||||
if (symval->type_name == NULL)
|
||||
symval->type_name = name;
|
||||
else if (strcmp(name, symval->type_name) != 0)
|
||||
warns("type redeclaration for %s", symval->tag);
|
||||
warns(_("type redeclaration for %s"), symval->tag);
|
||||
|
||||
break;
|
||||
|
||||
@@ -1825,7 +1825,7 @@ packsymbols()
|
||||
{
|
||||
/* this symbol and its alias are a single token defn.
|
||||
allocate a tokno, and assign to both
|
||||
check agreement of ->prec and ->assoc fields
|
||||
check agreement of ->prec and ->assoc fields
|
||||
and make both the same
|
||||
*/
|
||||
if (bp->value == 0)
|
||||
@@ -1834,7 +1834,7 @@ packsymbols()
|
||||
if (bp->prec != bp->alias->prec) {
|
||||
if (bp->prec != 0 && bp->alias->prec != 0
|
||||
&& bp->user_token_number == SALIAS)
|
||||
warnss("conflicting precedences for %s and %s",
|
||||
warnss(_("conflicting precedences for %s and %s"),
|
||||
bp->tag, bp->alias->tag);
|
||||
if (bp->prec != 0) bp->alias->prec = bp->prec;
|
||||
else bp->prec = bp->alias->prec;
|
||||
@@ -1843,7 +1843,7 @@ packsymbols()
|
||||
if (bp->assoc != bp->alias->assoc) {
|
||||
if (bp->assoc != 0 && bp->alias->assoc != 0
|
||||
&& bp->user_token_number == SALIAS)
|
||||
warnss("conflicting assoc values for %s and %s",
|
||||
warnss(_("conflicting assoc values for %s and %s"),
|
||||
bp->tag, bp->alias->tag);
|
||||
if (bp->assoc != 0) bp->alias->assoc = bp->assoc;
|
||||
else bp->assoc = bp->alias->assoc;
|
||||
@@ -1883,14 +1883,14 @@ packsymbols()
|
||||
the internal token number for $undefined.,
|
||||
which represents all invalid inputs. */
|
||||
for (i = 0; i <= max_user_token_number; i++)
|
||||
token_translations[i] = 2;
|
||||
token_translations[i] = 2;
|
||||
|
||||
for (bp = firstsymbol; bp; bp = bp->next)
|
||||
{
|
||||
if (bp->value >= ntokens) continue; /* non-terminal */
|
||||
if (bp->user_token_number == SALIAS) continue;
|
||||
if (bp->user_token_number == SALIAS) continue;
|
||||
if (token_translations[bp->user_token_number] != 2)
|
||||
warnsss("tokens %s and %s both assigned number %s",
|
||||
warnsss(_("tokens %s and %s both assigned number %s"),
|
||||
tags[token_translations[bp->user_token_number]],
|
||||
bp->tag,
|
||||
int_to_string(bp->user_token_number));
|
||||
@@ -1904,9 +1904,9 @@ packsymbols()
|
||||
output_token_defines(ftable);
|
||||
|
||||
if (startval->class == SUNKNOWN)
|
||||
fatals("the start symbol %s is undefined", startval->tag);
|
||||
fatals(_("the start symbol %s is undefined"), startval->tag);
|
||||
else if (startval->class == STOKEN)
|
||||
fatals("the start symbol %s is a token", startval->tag);
|
||||
fatals(_("the start symbol %s is a token"), startval->tag);
|
||||
|
||||
start_symbol = startval->value;
|
||||
|
||||
@@ -1937,9 +1937,9 @@ packsymbols()
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
/* For named tokens, but not literal ones, define the name.
|
||||
The value is the user token number.
|
||||
|
||||
/* For named tokens, but not literal ones, define the name.
|
||||
The value is the user token number.
|
||||
*/
|
||||
void
|
||||
output_token_defines(file)
|
||||
@@ -1957,7 +1957,7 @@ FILE *file;
|
||||
if (bp->user_token_number == SALIAS) continue;
|
||||
if ('\'' == *symbol) continue; /* skip literal character */
|
||||
if (bp == errtoken) continue; /* skip error token */
|
||||
if ('\"' == *symbol)
|
||||
if ('\"' == *symbol)
|
||||
{
|
||||
/* use literal string only if given a symbol with an alias */
|
||||
if (bp->alias)
|
||||
@@ -1972,8 +1972,8 @@ FILE *file;
|
||||
if (c != '\0') continue;
|
||||
|
||||
fprintf(file, "#define\t%s\t%d\n", symbol,
|
||||
((translations && ! rawtoknumflag)
|
||||
? bp->user_token_number
|
||||
((translations && ! rawtoknumflag)
|
||||
? bp->user_token_number
|
||||
: bp->value));
|
||||
if (semantic_parser)
|
||||
fprintf(file, "#define\tT%s\t%d\n", symbol, bp->value);
|
||||
|
||||
56
src/reduce.c
56
src/reduce.c
@@ -138,7 +138,7 @@ reduce_grammar ()
|
||||
print_notices();
|
||||
|
||||
if (!BITISSET(N, start_symbol - ntokens))
|
||||
fatals("Start symbol %s does not derive any sentence",
|
||||
fatals(_("Start symbol %s does not derive any sentence"),
|
||||
tags[start_symbol]);
|
||||
|
||||
reduce_grammar_tables();
|
||||
@@ -151,8 +151,8 @@ reduce_grammar ()
|
||||
/**/ statisticsflag = FALSE; /* someday getopts should handle this */
|
||||
if (statisticsflag == TRUE)
|
||||
fprintf(stderr,
|
||||
"reduced %s defines %d terminal%s, %d nonterminal%s\
|
||||
, and %d production%s.\n", infile,
|
||||
_("reduced %s defines %d terminal%s, %d nonterminal%s\
|
||||
, and %d production%s.\n"), infile,
|
||||
ntokens, (ntokens == 1 ? "" : "s"),
|
||||
nvars, (nvars == 1 ? "" : "s"),
|
||||
nrules, (nrules == 1 ? "" : "s"));
|
||||
@@ -173,7 +173,7 @@ reduce_grammar ()
|
||||
* process takes only 2 seconds on my 8Mhz AT.
|
||||
*/
|
||||
|
||||
static bool
|
||||
static bool
|
||||
useful_production (i, N)
|
||||
int i;
|
||||
BSet N;
|
||||
@@ -196,7 +196,7 @@ BSet N;
|
||||
|
||||
/* Remember that rules are 1-origin, symbols are 0-origin. */
|
||||
|
||||
static void
|
||||
static void
|
||||
useless_nonterminals ()
|
||||
{
|
||||
BSet Np, Ns;
|
||||
@@ -218,7 +218,7 @@ useless_nonterminals ()
|
||||
* set being computed remains unchanged. Any nonterminals not in the
|
||||
* set at that point are useless in that they will never be used in
|
||||
* deriving a sentence of the language.
|
||||
*
|
||||
*
|
||||
* This iteration doesn't use any special traversal over the
|
||||
* productions. A set is kept of all productions for which all the
|
||||
* nonterminals in the RHS are in useful. Only productions not in
|
||||
@@ -253,7 +253,7 @@ useless_nonterminals ()
|
||||
N = Np;
|
||||
}
|
||||
|
||||
static void
|
||||
static void
|
||||
inaccessable_symbols ()
|
||||
{
|
||||
BSet Vp, Vs, Pp;
|
||||
@@ -270,13 +270,13 @@ inaccessable_symbols ()
|
||||
* reachable symbols, add the production to the set of reachable
|
||||
* productions, and add all of the nonterminals in the RHS of the
|
||||
* production to the set of reachable symbols.
|
||||
*
|
||||
*
|
||||
* Consider only the (partially) reduced grammar which has only
|
||||
* nonterminals in N and productions in P.
|
||||
*
|
||||
*
|
||||
* The result is the set P of productions in the reduced grammar, and
|
||||
* the set V of symbols in the reduced grammar.
|
||||
*
|
||||
*
|
||||
* Although this algorithm also computes the set of terminals which are
|
||||
* reachable, no terminal will be deleted from the grammar. Some
|
||||
* terminals might not be in the grammar but might be generated by
|
||||
@@ -302,7 +302,7 @@ inaccessable_symbols ()
|
||||
Vp[i] = V[i];
|
||||
for (i = 1; i <= nrules; i++)
|
||||
{
|
||||
if (!BITISSET(Pp, i) && BITISSET(P, i) &&
|
||||
if (!BITISSET(Pp, i) && BITISSET(P, i) &&
|
||||
BITISSET(V, rlhs[i]))
|
||||
{
|
||||
for (r = &ritem[rrhs[i]]; *r >= 0; r++)
|
||||
@@ -352,7 +352,7 @@ inaccessable_symbols ()
|
||||
SETBIT(V1, rprecsym[i]);
|
||||
}
|
||||
|
||||
static void
|
||||
static void
|
||||
reduce_grammar_tables ()
|
||||
{
|
||||
/* This is turned off because we would need to change the numbers
|
||||
@@ -481,7 +481,7 @@ reduce_grammar_tables ()
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
static void
|
||||
print_results ()
|
||||
{
|
||||
int i;
|
||||
@@ -491,7 +491,7 @@ print_results ()
|
||||
|
||||
if (nuseless_nonterminals > 0)
|
||||
{
|
||||
fprintf(foutput, "Useless nonterminals:\n\n");
|
||||
fprintf(foutput, _("Useless nonterminals:\n\n"));
|
||||
for (i = ntokens; i < nsyms; i++)
|
||||
if (!BITISSET(V, i))
|
||||
fprintf(foutput, " %s\n", tags[i]);
|
||||
@@ -503,7 +503,7 @@ print_results ()
|
||||
{
|
||||
if (!b)
|
||||
{
|
||||
fprintf(foutput, "\n\nTerminals which are not used:\n\n");
|
||||
fprintf(foutput, _("\n\nTerminals which are not used:\n\n"));
|
||||
b = TRUE;
|
||||
}
|
||||
fprintf(foutput, " %s\n", tags[i]);
|
||||
@@ -512,7 +512,7 @@ print_results ()
|
||||
|
||||
if (nuseless_productions > 0)
|
||||
{
|
||||
fprintf(foutput, "\n\nUseless rules:\n\n");
|
||||
fprintf(foutput, _("\n\nUseless rules:\n\n"));
|
||||
for (i = 1; i <= nrules; i++)
|
||||
{
|
||||
if (!BITISSET(P, i))
|
||||
@@ -531,7 +531,7 @@ print_results ()
|
||||
fprintf(foutput, "\n\n");
|
||||
}
|
||||
|
||||
void
|
||||
void
|
||||
dump_grammar ()
|
||||
{
|
||||
int i;
|
||||
@@ -540,23 +540,23 @@ dump_grammar ()
|
||||
fprintf(foutput,
|
||||
"ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d\n\n",
|
||||
ntokens, nvars, nsyms, nrules, nitems);
|
||||
fprintf(foutput, "Variables\n---------\n\n");
|
||||
fprintf(foutput, "Value Sprec Sassoc Tag\n");
|
||||
fprintf(foutput, _("Variables\n---------\n\n"));
|
||||
fprintf(foutput, _("Value Sprec Sassoc Tag\n"));
|
||||
for (i = ntokens; i < nsyms; i++)
|
||||
fprintf(foutput, "%5d %5d %5d %s\n",
|
||||
i, sprec[i], sassoc[i], tags[i]);
|
||||
fprintf(foutput, "\n\n");
|
||||
fprintf(foutput, "Rules\n-----\n\n");
|
||||
fprintf(foutput, _("Rules\n-----\n\n"));
|
||||
for (i = 1; i <= nrules; i++)
|
||||
{
|
||||
fprintf(foutput, "%-5d(%5d%5d)%5d : (@%-5d)",
|
||||
fprintf(foutput, "%-5d(%5d%5d)%5d : (@%-5d)",
|
||||
i, rprec[i], rassoc[i], rlhs[i], rrhs[i]);
|
||||
for (r = &ritem[rrhs[i]]; *r > 0; r++)
|
||||
fprintf(foutput, "%5d", *r);
|
||||
fprintf(foutput, " [%d]\n", -(*r));
|
||||
}
|
||||
fprintf(foutput, "\n\n");
|
||||
fprintf(foutput, "Rules interpreted\n-----------------\n\n");
|
||||
fprintf(foutput, _("Rules interpreted\n-----------------\n\n"));
|
||||
for (i = 1; i <= nrules; i++)
|
||||
{
|
||||
fprintf(foutput, "%-5d %s :", i, tags[rlhs[i]]);
|
||||
@@ -568,28 +568,28 @@ dump_grammar ()
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
static void
|
||||
print_notices ()
|
||||
{
|
||||
extern int fixed_outfiles;
|
||||
|
||||
if (fixed_outfiles && nuseless_productions)
|
||||
fprintf(stderr, "%d rules never reduced\n", nuseless_productions);
|
||||
fprintf(stderr, _("%d rules never reduced\n"), nuseless_productions);
|
||||
|
||||
fprintf(stderr, "%s contains ", infile);
|
||||
fprintf(stderr, _("%s contains "), infile);
|
||||
|
||||
if (nuseless_nonterminals > 0)
|
||||
{
|
||||
fprintf(stderr, "%d useless nonterminal%s",
|
||||
fprintf(stderr, _("%d useless nonterminal%s"),
|
||||
nuseless_nonterminals,
|
||||
(nuseless_nonterminals == 1 ? "" : "s"));
|
||||
}
|
||||
if (nuseless_nonterminals > 0 && nuseless_productions > 0)
|
||||
fprintf(stderr, " and ");
|
||||
fprintf(stderr, _(" and "));
|
||||
|
||||
if (nuseless_productions > 0)
|
||||
{
|
||||
fprintf(stderr, "%d useless rule%s",
|
||||
fprintf(stderr, _("%d useless rule%s"),
|
||||
nuseless_productions,
|
||||
(nuseless_productions == 1 ? "" : "s"));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user