X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/6d0ef4ec2078687dc9217ae51eea397ce7443a3d..e0c653e7e660c353c59b054de571474450aa4c92:/src/reader.c?ds=inline diff --git a/src/reader.c b/src/reader.c index 5084618f..7758c772 100644 --- a/src/reader.c +++ b/src/reader.c @@ -1,28 +1,25 @@ /* Input parser for Bison Copyright (C) 1984, 1986, 1989, 1992, 1998, 2000, 2001, 2002, 2003, - 2005, 2006 Free Software Foundation, Inc. + 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of Bison, the GNU Compiler Compiler. - Bison is free software; you can redistribute it and/or modify + 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 - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. - Bison is distributed in the hope that it will be useful, + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with Bison; see the file COPYING. If not, write to - the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ + along with this program. If not, see . */ #include #include "system.h" -#include #include @@ -70,27 +67,6 @@ grammar_start_symbol_set (symbol *sym, location loc) } } - -/*---------------------------------------------------------------------. -| There are two prologues: one before the first %union and one after. | -| Augment the one specified by POST. | -`---------------------------------------------------------------------*/ - -void -prologue_augment (const char *prologue, location loc, bool post) -{ - struct obstack *oout = - !post ? &pre_prologue_obstack : &post_prologue_obstack; - - obstack_fgrow1 (oout, "]b4_syncline(%d, [[", loc.start.line); - /* FIXME: Protection of M4 characters missing here. See - output.c:escaped_output. */ - MUSCLE_OBSTACK_SGROW (oout, - quotearg_style (c_quoting_style, loc.start.file)); - obstack_sgrow (oout, "]])[\n"); - obstack_sgrow (oout, prologue); -} - /*------------------------------------------------------------------------. @@ -148,7 +124,7 @@ record_merge_function_type (int merger, uniqstr type, location declaration_loc) merge_function != NULL && merger_find != merger; merge_function = merge_function->next) merger_find += 1; - assert (merge_function != NULL && merger_find == merger); + aver (merge_function != NULL && merger_find == merger); if (merge_function->type != NULL && !UNIQSTR_EQ (merge_function->type, type)) { complain_at (declaration_loc, @@ -196,7 +172,7 @@ static symbol_list *grammar_end = NULL; static void grammar_symbol_append (symbol *sym, location loc) { - symbol_list *p = symbol_list_new (sym, loc); + symbol_list *p = symbol_list_sym_new (sym, loc); if (grammar_end) grammar_end->next = p; @@ -225,13 +201,6 @@ static symbol_list *previous_rule_end = NULL; void grammar_current_rule_begin (symbol *lhs, location loc) { - if (!start_flag) - { - startsymbol = lhs; - startsymbol_location = loc; - start_flag = true; - } - /* Start a new rule and record its lhs. */ ++nrules; previous_rule_end = grammar_end; @@ -251,16 +220,25 @@ grammar_current_rule_begin (symbol *lhs, location loc) /*----------------------------------------------------------------------. -| A symbol should be used if it has a destructor, or if it is a | -| mid-rule symbol (i.e., the generated LHS replacing a mid-rule | -| action) that was assigned to, as in "exp: { $$ = 1; } { $$ = $1; }". | +| A symbol should be used if either: | +| 1. It has a destructor. | +| 2. --warnings=midrule-values and the symbol is a mid-rule symbol | +| (i.e., the generated LHS replacing a mid-rule action) that was | +| assigned to or used, as in "exp: { $$ = 1; } { $$ = $1; }". | `----------------------------------------------------------------------*/ static bool symbol_should_be_used (symbol_list const *s) { - return (symbol_destructor_get (s->sym) - || (s->midrule && s->midrule->used)); + if (symbol_destructor_get (s->content.sym)->code) + return true; + if (warnings_flag & warnings_midrule_values) + return ((s->midrule && s->midrule->action_props.is_value_used) + || (s->midrule_parent_rule + && symbol_list_n_get (s->midrule_parent_rule, + s->midrule_parent_rhs_index) + ->action_props.is_value_used)); + return false; } /*----------------------------------------------------------------. @@ -278,13 +256,13 @@ grammar_rule_check (const symbol_list *r) Don't worry about the default action if $$ is untyped, since $$'s value can't be used. */ - if (!r->action && r->sym->type_name) + if (!r->action_props.code && r->content.sym->type_name) { - symbol *first_rhs = r->next->sym; + symbol *first_rhs = r->next->content.sym; /* If $$ is being set in default way, report if any type mismatch. */ if (first_rhs) { - char const *lhs_type = r->sym->type_name; + char const *lhs_type = r->content.sym->type_name; const char *rhs_type = first_rhs->type_name ? first_rhs->type_name : ""; if (!UNIQSTR_EQ (lhs_type, rhs_type)) @@ -302,11 +280,11 @@ grammar_rule_check (const symbol_list *r) { symbol_list const *l = r; int n = 0; - for (; l && l->sym; l = l->next, ++n) - if (! (l->used + for (; l && l->content.sym; l = l->next, ++n) + if (! (l->action_props.is_value_used || !symbol_should_be_used (l) /* The default action, $$ = $1, `uses' both. */ - || (!r->action && (n == 0 || n == 1)))) + || (!r->action_props.code && (n == 0 || n == 1)))) { if (n) warn_at (r->location, _("unused value: $%d"), n); @@ -346,9 +324,9 @@ grammar_midrule_action (void) /* Make a DUMMY nonterminal, whose location is that of the midrule action. Create the MIDRULE. */ - location dummy_location = current_rule->action_location; + location dummy_location = current_rule->action_props.location; symbol *dummy = dummy_symbol_get (dummy_location); - symbol_list *midrule = symbol_list_new (dummy, dummy_location); + symbol_list *midrule = symbol_list_sym_new (dummy, dummy_location); /* Make a new rule, whose body is empty, before the current one, so that the action just read can belong to it. */ @@ -356,12 +334,11 @@ grammar_midrule_action (void) ++nritems; /* Attach its location and actions to that of the DUMMY. */ midrule->location = dummy_location; - midrule->action = current_rule->action; - midrule->action_location = dummy_location; - current_rule->action = NULL; - /* The action has not been translated yet, so $$ use hasn't been - detected yet. */ - midrule->used = false; + code_props_rule_action_init (&midrule->action_props, + current_rule->action_props.code, + current_rule->action_props.location, + midrule); + code_props_none_init (¤t_rule->action_props); if (previous_rule_end) previous_rule_end->next = midrule; @@ -369,7 +346,7 @@ grammar_midrule_action (void) grammar = midrule; /* End the dummy's rule. */ - midrule->next = symbol_list_new (NULL, dummy_location); + midrule->next = symbol_list_sym_new (NULL, dummy_location); midrule->next->next = current_rule; previous_rule_end = midrule->next; @@ -387,6 +364,7 @@ grammar_midrule_action (void) void grammar_current_rule_prec_set (symbol *precsym, location loc) { + symbol_class_set (precsym, token_sym, loc, false); if (current_rule->ruleprec) complain_at (loc, _("only one %s allowed per rule"), "%prec"); current_rule->ruleprec = precsym; @@ -426,7 +404,7 @@ grammar_current_rule_merge_set (uniqstr name, location loc) void grammar_current_rule_symbol_append (symbol *sym, location loc) { - if (current_rule->action) + if (current_rule->action_props.code) grammar_midrule_action (); grammar_symbol_append (sym, loc); } @@ -436,12 +414,12 @@ grammar_current_rule_symbol_append (symbol *sym, location loc) void grammar_current_rule_action_append (const char *action, location loc) { - if (current_rule->action) + if (current_rule->action_props.code) grammar_midrule_action (); /* After all symbol declarations have been parsed, packgram invokes - translate_rule_action. */ - current_rule->action = action; - current_rule->action_location = loc; + code_props_translate_code. */ + code_props_rule_action_init (¤t_rule->action_props, action, loc, + current_rule); } @@ -468,11 +446,11 @@ packgram (void) { int rule_length = 0; symbol *ruleprec = p->ruleprec; - record_merge_function_type (p->merger, p->sym->type_name, + record_merge_function_type (p->merger, p->content.sym->type_name, p->merger_declaration_location); rules[ruleno].user_number = ruleno; rules[ruleno].number = ruleno; - rules[ruleno].lhs = p->sym; + rules[ruleno].lhs = p->content.sym; rules[ruleno].rhs = ritem + itemno; rules[ruleno].prec = NULL; rules[ruleno].dprec = p->dprec; @@ -480,21 +458,26 @@ packgram (void) rules[ruleno].precsym = NULL; rules[ruleno].location = p->location; rules[ruleno].useful = true; - rules[ruleno].action = p->action ? translate_rule_action (p) : NULL; - rules[ruleno].action_location = p->action_location; - - /* If this rule contains midrules, rest assured that - grammar_midrule_action inserted the midrules into grammar before this - rule. Thus, the midrule actions have already been scanned in order to - set `used' flags for this rule's rhs, so grammar_rule_check will work - properly. */ + rules[ruleno].action = p->action_props.code; + rules[ruleno].action_location = p->action_props.location; + + /* If the midrule's $$ is set or its $n is used, remove the `$' from the + symbol name so that it's a user-defined symbol so that the default + %destructor and %printer apply. */ + if (p->midrule_parent_rule + && (p->action_props.is_value_used + || symbol_list_n_get (p->midrule_parent_rule, + p->midrule_parent_rhs_index) + ->action_props.is_value_used)) + p->content.sym->tag += 1; + /* Don't check the generated rule 0. It has no action, so some rhs symbols may appear unused, but the parsing algorithm ensures that %destructor's are invoked appropriately. */ if (p != grammar) grammar_rule_check (p); - for (p = p->next; p && p->sym; p = p->next) + for (p = p->next; p && p->content.sym; p = p->next) { ++rule_length; @@ -505,11 +488,12 @@ packgram (void) /* item_number = symbol_number. But the former needs to contain more: negative rule numbers. */ - ritem[itemno++] = symbol_number_as_item_number (p->sym->number); + ritem[itemno++] = + symbol_number_as_item_number (p->content.sym->number); /* A rule gets by default the precedence and associativity of its last token. */ - if (p->sym->class == token_sym && default_prec) - rules[ruleno].prec = p->sym; + if (p->content.sym->class == token_sym && default_prec) + rules[ruleno].prec = p->content.sym; } /* If this rule has a %prec, @@ -521,15 +505,15 @@ packgram (void) } /* An item ends by the rule number (negated). */ ritem[itemno++] = rule_number_as_item_number (ruleno); - assert (itemno < ITEM_NUMBER_MAX); + aver (itemno < ITEM_NUMBER_MAX); ++ruleno; - assert (ruleno < RULE_NUMBER_MAX); + aver (ruleno < RULE_NUMBER_MAX); if (p) p = p->next; } - assert (itemno == nritems); + aver (itemno == nritems); if (trace_flag & trace_sets) ritem_print (stderr); @@ -564,10 +548,6 @@ reader (void) undeftoken->class = token_sym; undeftoken->number = ntokens++; - /* Initialize the obstacks. */ - obstack_init (&pre_prologue_obstack); - obstack_init (&post_prologue_obstack); - gram_in = xfopen (grammar_file, "r"); gram__flex_debug = trace_flag & trace_scan; @@ -607,31 +587,66 @@ check_and_convert_grammar (void) endtoken->user_token_number = 0; } + /* Find the start symbol if no %start. */ + if (!start_flag) + { + symbol_list *node; + for (node = grammar; + node != NULL && symbol_is_dummy (node->content.sym); + node = node->next) + { + for (node = node->next; + node != NULL && node->content.sym != NULL; + node = node->next) + ; + } + aver (node != NULL); + grammar_start_symbol_set (node->content.sym, + node->content.sym->location); + } + /* Insert the initial rule, whose line is that of the first rule (not that of the start symbol): accept: %start EOF. */ { - symbol_list *p = symbol_list_new (accept, empty_location); + symbol_list *p = symbol_list_sym_new (accept, empty_location); p->location = grammar->location; - p->next = symbol_list_new (startsymbol, empty_location); - p->next->next = symbol_list_new (endtoken, empty_location); - p->next->next->next = symbol_list_new (NULL, empty_location); + p->next = symbol_list_sym_new (startsymbol, empty_location); + p->next->next = symbol_list_sym_new (endtoken, empty_location); + p->next->next->next = symbol_list_sym_new (NULL, empty_location); p->next->next->next->next = grammar; nrules += 1; nritems += 3; grammar = p; } - assert (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars); + aver (nsyms <= SYMBOL_NUMBER_MAXIMUM && nsyms == ntokens + nvars); /* Assign the symbols their symbol numbers. Write #defines for the token symbols into FDEFINES if requested. */ symbols_pack (); + /* Scan rule actions after invoking symbol_check_alias_consistency (in + symbols_pack above) so that token types are set correctly before the rule + action type checking. + + Before invoking grammar_rule_check (in packgram below) on any rule, make + sure all actions have already been scanned in order to set `used' flags. + Otherwise, checking that a midrule's $$ should be set will not always work + properly because the check must forward-reference the midrule's parent + rule. For the same reason, all the `used' flags must be set before + checking whether to remove `$' from any midrule symbol name (also in + packgram). */ + { + symbol_list *sym; + for (sym = grammar; sym; sym = sym->next) + code_props_translate_code (&sym->action_props); + } + /* Convert the grammar into the format described in gram.h. */ packgram (); /* The grammar as a symbol_list is no longer needed. */ - LIST_FREE (symbol_list, grammar); + symbol_list_free (grammar); }