X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/408476bca98e78ea0c398f36ef58f4466edb277a..827aca04ebd852b63087d80d8e420bb325bb9bd5:/src/gram.c?ds=sidebyside diff --git a/src/gram.c b/src/gram.c index 6b9eda13..f6cc3c5d 100644 --- a/src/gram.c +++ b/src/gram.c @@ -1,7 +1,7 @@ /* Allocate input grammar variables for Bison. - Copyright (C) 1984, 1986, 1989, 2001, 2002, 2003, 2005, 2006 - 2007 Free Software Foundation, Inc. + Copyright (C) 1984, 1986, 1989, 2001-2003, 2005-2013 Free Software + Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. @@ -21,13 +21,13 @@ #include #include "system.h" -#include - +#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. */ @@ -47,50 +47,43 @@ symbol_number *token_translations = NULL; 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, "%s", r->lhs->tag); } -int -rule_rhs_length (rule *r) +size_t +rule_rhs_length (rule const *r) { - int res = 0; + size_t res = 0; item_number *rhsp; for (rhsp = r->rhs; *rhsp >= 0; ++rhsp) ++res; @@ -98,31 +91,28 @@ rule_rhs_length (rule *r) } 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, ""); for (rp = r->rhs; *rp >= 0; rp++) - xml_printf (out, level + 1, "%s", - xml_escape (symbols[*rp]->tag)); + xml_printf (out, level + 1, "%s", + xml_escape (symbols[*rp]->tag)); xml_puts (out, level, ""); } else @@ -133,13 +123,6 @@ rule_rhs_print_xml (rule *r, FILE *out, int level) } } -void -rule_print (rule *r, FILE *out) -{ - fprintf (out, "%s:", r->lhs->tag); - rule_rhs_print (r, out); -} - void ritem_print (FILE *out) { @@ -163,7 +146,7 @@ ritem_longest_rhs (void) { int length = rule_rhs_length (&rules[r]); if (length > max) - max = length; + max = length; } return max; @@ -171,7 +154,7 @@ ritem_longest_rhs (void) void grammar_rules_partial_print (FILE *out, const char *title, - rule_filter filter) + rule_filter filter) { rule_number r; bool first = true; @@ -181,14 +164,15 @@ grammar_rules_partial_print (FILE *out, const char *title, 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) @@ -210,7 +194,7 @@ grammar_rules_print_xml (FILE *out, int level) for (r = 0; r < nrules + nuseless_productions; r++) { if (first) - xml_puts (out, level + 1, ""); + xml_puts (out, level + 1, ""); first = false; { char const *usefulness; @@ -224,7 +208,8 @@ grammar_rules_print_xml (FILE *out, int level) fprintf (out, "tag); + fprintf (out, " percent_prec=\"%s\"", + xml_escape (rules[r].precsym->tag)); fputs (">\n", out); } rule_lhs_print_xml (&rules[r], out, level + 3); @@ -242,8 +227,8 @@ grammar_dump (FILE *out, const char *title) { 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"); @@ -253,37 +238,39 @@ grammar_dump (FILE *out, const char *title) 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"); @@ -293,8 +280,9 @@ grammar_dump (FILE *out, const char *title) 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"); @@ -306,11 +294,7 @@ grammar_rules_useless_report (const char *message) 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