X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/b7c49edf135cea5dc2bd0942b42d28e6c84cf71f..e9f87b5b7df2e328d2e4196d276c0d96594c906b:/src/reader.c?ds=inline diff --git a/src/reader.c b/src/reader.c index c5f3b11e..cf3e18f3 100644 --- a/src/reader.c +++ b/src/reader.c @@ -52,8 +52,6 @@ typedef struct symbol_list } symbol_list; int lineno; -char **tags; -short *user_toknums; static symbol_list *grammar; static int start_flag; static bucket *startval; @@ -71,6 +69,7 @@ static int lastprec; static bucket *errtoken = NULL; static bucket *undeftoken = NULL; static bucket *eoftoken = NULL; +static bucket *axiom = NULL; static symbol_list * symbol_list_new (bucket *sym) @@ -1155,10 +1154,7 @@ parse_braces (symbol_list *rule, int stack_offset) /* Above loop exits when C is '}'. */ if (--count) - { - obstack_1grow (&action_obstack, c); - c = getc (finput); - } + obstack_1grow (&action_obstack, c); } obstack_1grow (&action_obstack, '\0'); @@ -1358,6 +1354,11 @@ readgram (void) p = symbol_list_new (sdummy); /* Attach its lineno to that of the host rule. */ p->line = crule->line; + /* Move the action from the host rule to this one. */ + p->action = crule->action; + p->action_line = crule->action_line; + crule->action = NULL; + if (crule1) crule1->next = p; else @@ -1450,12 +1451,8 @@ readgram (void) t = lex (); } - /* grammar has been read. Do some checking */ - if (nsyms > MAXSHORT) - fatal (_("too many symbols (tokens plus nonterminals); maximum %d"), - MAXSHORT); if (nrules == 0) fatal (_("no rules in the input grammar")); @@ -1471,6 +1468,25 @@ readgram (void) bp->value = nvars++; } + /* Insert the initial rule, which line is that of the first rule + (not that of the start symbol): + + axiom: %start EOF. */ + p = symbol_list_new (axiom); + p->line = grammar->line; + p->next = symbol_list_new (startval); + p->next->next = symbol_list_new (eoftoken); + p->next->next->next = symbol_list_new (NULL); + p->next->next->next->next = grammar; + nrules += 1; + nitems += 3; + grammar = p; + startval = axiom; + + if (nsyms > MAXSHORT) + fatal (_("too many symbols (tokens plus nonterminals); maximum %d"), + MAXSHORT); + ntokens = nsyms - nvars; } @@ -1533,18 +1549,17 @@ token_translations_init (void) /* A token which translation has already been set? */ if (token_translations[bp->user_token_number] != 2) complain (_("tokens %s and %s both assigned number %d"), - tags[token_translations[bp->user_token_number]], + symbols[token_translations[bp->user_token_number]]->tag, bp->tag, bp->user_token_number); token_translations[bp->user_token_number] = bp->value; } } -/*------------------------------------------------------------------. -| Assign symbol numbers, and write definition of token names into | -| FDEFINES. Set up vectors TAGS and SPREC of names and precedences | -| of symbols. | -`------------------------------------------------------------------*/ +/*----------------------------------------------------------------. +| Assign symbol numbers, and write definition of token names into | +| FDEFINES. Set up vectors SYMBOL_TABLE, TAGS of symbols. | +`----------------------------------------------------------------*/ static void packsymbols (void) @@ -1553,11 +1568,7 @@ packsymbols (void) int tokno = 1; int last_user_token_number; - tags = XCALLOC (char *, nsyms + 1); - user_toknums = XCALLOC (short, nsyms + 1); - - sprec = XCALLOC (short, nsyms); - sassoc = XCALLOC (short, nsyms); + symbols = XCALLOC (bucket *, nsyms); max_user_token_number = 256; last_user_token_number = 256; @@ -1628,10 +1639,7 @@ packsymbols (void) max_user_token_number = bp->user_token_number; } - tags[bp->value] = bp->tag; - user_toknums[bp->value] = bp->user_token_number; - sprec[bp->value] = bp->prec; - sassoc[bp->value] = bp->assoc; + symbols[bp->value] = bp; } token_translations_init (); @@ -1647,56 +1655,6 @@ packsymbols (void) } -/*---------------------------------------------------------------. -| Save the definition of token names in the `TOKENDEFS' muscle. | -`---------------------------------------------------------------*/ - -static void -symbols_save (void) -{ - struct obstack tokendefs; - bucket *bp; - obstack_init (&tokendefs); - - for (bp = firstsymbol; bp; bp = bp->next) - { - char *symbol = bp->tag; /* get symbol */ - - if (bp->value >= ntokens) - continue; - if (bp->user_token_number == SALIAS) - continue; - if ('\'' == *symbol) - continue; /* skip literal character */ - if (bp == errtoken) - continue; /* skip error token */ - if ('\"' == *symbol) - { - /* use literal string only if given a symbol with an alias */ - if (bp->alias) - symbol = bp->alias->tag; - else - continue; - } - - /* Don't #define nonliteral tokens whose names contain periods. */ - if (strchr (symbol, '.')) - continue; - - obstack_fgrow2 (&tokendefs, "# define %s\t%d\n", - symbol, bp->user_token_number); - if (semantic_parser) - /* FIXME: This is probably wrong, and should be just as - above. --akim. */ - obstack_fgrow2 (&tokendefs, "# define T%s\t%d\n", symbol, bp->value); - } - - obstack_1grow (&tokendefs, 0); - muscle_insert ("tokendef", xstrdup (obstack_finish (&tokendefs))); - obstack_free (&tokendefs, NULL); -} - - /*---------------------------------------------------------------. | Convert the rules into the representation using RRHS, RLHS and | | RITEMS. | @@ -1714,7 +1672,7 @@ packgram (void) fatal (_("too many items (max %d)"), MAXSHORT); ritem = XCALLOC (short, nitems + 1); - rule_table = XCALLOC (rule_t, nrules) - 1; + rules = XCALLOC (rule_t, nrules) - 1; itemno = 0; ruleno = 1; @@ -1723,14 +1681,14 @@ packgram (void) while (p) { bucket *ruleprec = p->ruleprec; - rule_table[ruleno].lhs = p->sym->value; - rule_table[ruleno].rhs = itemno; - rule_table[ruleno].line = p->line; - rule_table[ruleno].useful = TRUE; - rule_table[ruleno].action = p->action; - rule_table[ruleno].action_line = p->action_line; - rule_table[ruleno].guard = p->guard; - rule_table[ruleno].guard_line = p->guard_line; + rules[ruleno].lhs = p->sym->value; + rules[ruleno].rhs = itemno; + rules[ruleno].line = p->line; + rules[ruleno].useful = TRUE; + rules[ruleno].action = p->action; + rules[ruleno].action_line = p->action_line; + rules[ruleno].guard = p->guard; + rules[ruleno].guard_line = p->guard_line; p = p->next; while (p && p->sym) @@ -1740,8 +1698,8 @@ packgram (void) of the last token in it. */ if (p->sym->class == token_sym) { - rule_table[ruleno].prec = p->sym->prec; - rule_table[ruleno].assoc = p->sym->assoc; + rules[ruleno].prec = p->sym->prec; + rules[ruleno].assoc = p->sym->assoc; } if (p) p = p->next; @@ -1751,9 +1709,9 @@ packgram (void) the specified symbol's precedence replaces the default. */ if (ruleprec) { - rule_table[ruleno].prec = ruleprec->prec; - rule_table[ruleno].assoc = ruleprec->assoc; - rule_table[ruleno].precsym = ruleprec->value; + rules[ruleno].prec = ruleprec->prec; + rules[ruleno].assoc = ruleprec->assoc; + rules[ruleno].precsym = ruleprec->value; } ritem[itemno++] = -ruleno; @@ -1764,6 +1722,8 @@ packgram (void) } ritem[itemno] = 0; + nritems = itemno; + assert (nritems == nitems); if (trace_flag) ritem_print (stderr); @@ -1805,6 +1765,11 @@ reader (void) /* Initialize the symbol table. */ tabinit (); + /* Construct the axiom symbol. */ + axiom = getsym ("$axiom"); + axiom->class = nterm_sym; + axiom->value = nvars++; + /* Construct the error token */ errtoken = getsym ("error"); errtoken->class = token_sym; @@ -1849,9 +1814,10 @@ reader (void) /* Assign the symbols their symbol numbers. Write #defines for the token symbols into FDEFINES if requested. */ packsymbols (); - /* Save them. */ - symbols_save (); /* 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); }