/* Allocate input grammar variables for Bison.
- Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003, 2005, 2006
- 2007, 2008 Free Software Foundation, Inc.
+ Copyright (C) 1984, 1986, 1989, 2001-2003, 2005-2015 Free Software
+ Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
#include <config.h>
#include "system.h"
-#include <quotearg.h>
-
+#include "complain.h"
+#include "getargs.h"
#include "gram.h"
+#include "print-xml.h"
#include "reader.h"
#include "reduce.h"
#include "symtab.h"
-#include "print-xml.h"
/* Comments for these variables are in gram.h. */
int max_user_token_number = 256;
bool
-rule_useful_in_grammar_p (rule *r)
+rule_useful_in_grammar_p (rule const *r)
{
return r->number < nrules;
}
bool
-rule_useless_in_grammar_p (rule *r)
+rule_useless_in_grammar_p (rule const *r)
{
return !rule_useful_in_grammar_p (r);
}
bool
-rule_useless_in_parser_p (rule *r)
+rule_useless_in_parser_p (rule const *r)
{
return !r->useful && rule_useful_in_grammar_p (r);
}
void
-rule_lhs_print (rule *r, symbol *previous_lhs, FILE *out)
+rule_lhs_print (rule const *r, symbol const *previous_lhs, FILE *out)
{
fprintf (out, " %3d ", r->number);
if (previous_lhs != r->lhs)
- {
- fprintf (out, "%s:", r->lhs->tag);
- }
+ fprintf (out, "%s:", r->lhs->tag);
else
- {
- int n;
- for (n = strlen (previous_lhs->tag); n > 0; --n)
- fputc (' ', out);
- fputc ('|', out);
- }
+ fprintf (out, "%*s|", (int) strlen (previous_lhs->tag), "");
}
void
-rule_lhs_print_xml (rule *r, FILE *out, int level)
+rule_lhs_print_xml (rule const *r, FILE *out, int level)
{
xml_printf (out, level, "<lhs>%s</lhs>", r->lhs->tag);
}
size_t
-rule_rhs_length (rule *r)
+rule_rhs_length (rule const *r)
{
size_t res = 0;
item_number *rhsp;
}
void
-rule_rhs_print (rule *r, FILE *out)
+rule_rhs_print (rule const *r, FILE *out)
{
- if (*r->rhs >= 0)
+ if (0 <= *r->rhs)
{
item_number *rp;
for (rp = r->rhs; *rp >= 0; rp++)
- fprintf (out, " %s", symbols[*rp]->tag);
- fputc ('\n', out);
+ fprintf (out, " %s", symbols[*rp]->tag);
}
else
- {
- fprintf (out, " /* %s */\n", _("empty"));
- }
+ fputs (" %empty", out);
}
static void
-rule_rhs_print_xml (rule *r, FILE *out, int level)
+rule_rhs_print_xml (rule const *r, FILE *out, int level)
{
if (*r->rhs >= 0)
{
item_number *rp;
xml_puts (out, level, "<rhs>");
for (rp = r->rhs; *rp >= 0; rp++)
- xml_printf (out, level + 1, "<symbol>%s</symbol>",
- xml_escape (symbols[*rp]->tag));
+ xml_printf (out, level + 1, "<symbol>%s</symbol>",
+ xml_escape (symbols[*rp]->tag));
xml_puts (out, level, "</rhs>");
}
else
}
}
-void
-rule_print (rule *r, FILE *out)
-{
- fprintf (out, "%s:", r->lhs->tag);
- rule_rhs_print (r, out);
-}
-
void
ritem_print (FILE *out)
{
{
int length = rule_rhs_length (&rules[r]);
if (length > max)
- max = length;
+ max = length;
}
return max;
void
grammar_rules_partial_print (FILE *out, const char *title,
- rule_filter filter)
+ rule_filter filter)
{
rule_number r;
bool first = true;
for (r = 0; r < nrules + nuseless_productions; r++)
{
if (filter && !filter (&rules[r]))
- continue;
+ continue;
if (first)
- fprintf (out, "%s\n\n", title);
+ fprintf (out, "%s\n\n", title);
else if (previous_lhs && previous_lhs != rules[r].lhs)
- fputc ('\n', out);
+ fputc ('\n', out);
first = false;
rule_lhs_print (&rules[r], previous_lhs, out);
rule_rhs_print (&rules[r], out);
+ fprintf (out, "\n");
previous_lhs = rules[r].lhs;
}
if (!first)
for (r = 0; r < nrules + nuseless_productions; r++)
{
if (first)
- xml_puts (out, level + 1, "<rules>");
+ xml_puts (out, level + 1, "<rules>");
first = false;
{
char const *usefulness;
fprintf (out, "<rule number=\"%d\" usefulness=\"%s\"",
rules[r].number, usefulness);
if (rules[r].precsym)
- fprintf (out, " percent_prec=\"%s\"", rules[r].precsym->tag);
+ fprintf (out, " percent_prec=\"%s\"",
+ xml_escape (rules[r].precsym->tag));
fputs (">\n", out);
}
rule_lhs_print_xml (&rules[r], out, level + 3);
{
fprintf (out, "%s\n\n", title);
fprintf (out,
- "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
- ntokens, nvars, nsyms, nrules, nritems);
+ "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
+ ntokens, nvars, nsyms, nrules, nritems);
fprintf (out, "Variables\n---------\n\n");
for (i = ntokens; i < nsyms; i++)
fprintf (out, "%5d %5d %5d %s\n",
- i,
- symbols[i]->prec, symbols[i]->assoc,
- symbols[i]->tag);
+ i,
+ symbols[i]->prec, symbols[i]->assoc,
+ symbols[i]->tag);
fprintf (out, "\n\n");
}
fprintf (out, "Rules\n-----\n\n");
{
rule_number i;
- fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
+ 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];
- item_number *rp = NULL;
- unsigned int rhs_itemno = rule_i->rhs - ritem;
- unsigned int rhs_count = 0;
- /* Find the last RHS index in ritems. */
- for (rp = rule_i->rhs; *rp >= 0; ++rp)
- ++rhs_count;
- fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u) %2d ->",
- i,
- rule_i->prec ? rule_i->prec->prec : 0,
- rule_i->prec ? rule_i->prec->assoc : 0,
- rule_i->useful,
- rhs_itemno,
- rhs_itemno + rhs_count - 1,
- rule_i->lhs->number);
- /* Dumped the RHS. */
- for (rp = rule_i->rhs; *rp >= 0; rp++)
- fprintf (out, " %3d", *rp);
- fprintf (out, " [%d]\n", item_number_as_rule_number (*rp));
+ rule const *rule_i = &rules[i];
+ item_number *rp = NULL;
+ unsigned int rhs_itemno = rule_i->rhs - ritem;
+ unsigned int rhs_count = 0;
+ /* Find the last RHS index in ritems. */
+ for (rp = rule_i->rhs; *rp >= 0; ++rp)
+ ++rhs_count;
+ fprintf (out, "%3d (%2d, %2d, %2d, %2u-%2u) %2d ->",
+ i,
+ rule_i->prec ? rule_i->prec->prec : 0,
+ rule_i->prec ? rule_i->prec->assoc : 0,
+ rule_i->useful,
+ rhs_itemno,
+ rhs_itemno + rhs_count - 1,
+ rule_i->lhs->number);
+ /* Dumped the RHS. */
+ for (rp = rule_i->rhs; *rp >= 0; rp++)
+ fprintf (out, " %3d", *rp);
+ fprintf (out, " [%d]\n", item_number_as_rule_number (*rp));
}
}
fprintf (out, "\n\n");
rule_number r;
for (r = 0; r < nrules + nuseless_productions; r++)
{
- fprintf (out, "%-5d ", r);
- rule_print (&rules[r], out);
+ fprintf (out, "%-5d %s:", r, rules[r].lhs->tag);
+ rule_rhs_print (&rules[r], out);
+ fprintf (out, "\n");
}
}
fprintf (out, "\n\n");
rule_number r;
for (r = 0; r < nrules ; ++r)
if (!rules[r].useful)
- {
- location_print (stderr, rules[r].location);
- fprintf (stderr, ": %s: %s: ", _("warning"), message);
- rule_print (&rules[r], stderr);
- }
+ complain (&rules[r].location, Wother, "%s", message);
}
void
projects / bison.git / blobdiff