X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/ddc8ede1abfd807faf5ddb0ee6c56cead0db84e3..c4bd5bf7c5b63334e8bb67af294800d4aec0fe06:/src/reader.c?ds=sidebyside diff --git a/src/reader.c b/src/reader.c index 800ecc22..e48afaf0 100644 --- a/src/reader.c +++ b/src/reader.c @@ -22,7 +22,6 @@ #include #include "system.h" -#include #include @@ -148,7 +147,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 +195,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 +224,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; @@ -259,7 +251,7 @@ grammar_current_rule_begin (symbol *lhs, location loc) static bool symbol_should_be_used (symbol_list const *s) { - return (s->sym->destructor + return (symbol_destructor_get (s->content.sym) || (s->midrule && s->midrule->used)); } @@ -278,13 +270,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 && 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,7 +294,7 @@ grammar_rule_check (const symbol_list *r) { symbol_list const *l = r; int n = 0; - for (; l && l->sym; l = l->next, ++n) + for (; l && l->content.sym; l = l->next, ++n) if (! (l->used || !symbol_should_be_used (l) /* The default action, $$ = $1, `uses' both. */ @@ -348,7 +340,7 @@ grammar_midrule_action (void) action. Create the MIDRULE. */ location dummy_location = current_rule->action_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. */ @@ -369,7 +361,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; @@ -468,11 +460,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; @@ -488,9 +480,13 @@ packgram (void) 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. */ - grammar_rule_check (p); + /* 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; @@ -501,11 +497,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, @@ -517,15 +514,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); @@ -603,23 +600,41 @@ 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. */