X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/a70083a3ed3fc3f69e0bed00220614f9d8263994..131e2fef683836d45262423bbdf004a014335aba:/src/reader.c diff --git a/src/reader.c b/src/reader.c index 2263458a..cdacc071 100644 --- a/src/reader.c +++ b/src/reader.c @@ -23,49 +23,19 @@ #include "system.h" #include "getargs.h" #include "files.h" -#include "alloc.h" +#include "xalloc.h" #include "symtab.h" #include "lex.h" #include "gram.h" #include "complain.h" #include "output.h" - -#define LTYPESTR "\ -\n\ -#ifndef YYLTYPE\n\ -typedef\n\ - struct yyltype\n\ -\ - {\n\ - int timestamp;\n\ - int first_line;\n\ - int first_column;\ -\n\ - int last_line;\n\ - int last_column;\n\ - char *text;\n\ - }\n\ -\ - yyltype;\n\ -\n\ -#define YYLTYPE yyltype\n\ -#endif\n\ -\n" +#include "reader.h" +#include "conflicts.h" +#include "quote.h" /* Number of slots allocated (but not necessarily used yet) in `rline' */ static int rline_allocated; -extern bucket *symval; -extern int numval; -extern int expected_conflicts; -extern char *token_buffer; -extern int maxtoken; - -extern void tabinit PARAMS ((void)); -extern void free_symtab PARAMS ((void)); -extern void open_extra_files PARAMS ((void)); -extern char *printable_version PARAMS ((int)); - typedef struct symbol_list { struct symbol_list *next; @@ -74,10 +44,6 @@ typedef struct symbol_list } symbol_list; - -extern void reader PARAMS ((void)); -extern void reader_output_yylsp PARAMS ((FILE *)); - int lineno; char **tags; short *user_toknums; @@ -89,17 +55,17 @@ static bucket *startval; they must be unions. */ static int value_components_used; -static int typed; /* nonzero if %union has been seen. */ +/* Nonzero if %union has been seen. */ +static int typed; -static int lastprec; /* incremented for each %left, %right or %nonassoc seen */ +/* Incremented for each %left, %right or %nonassoc seen */ +static int lastprec; -static int gensym_count; /* incremented for each generated symbol */ +/* Incremented for each generated symbol */ +static int gensym_count; static bucket *errtoken; static bucket *undeftoken; - -/* Nonzero if any action or guard uses the @n construct. */ -static int yylsp_needed; /*===================\ @@ -151,6 +117,40 @@ read_signed_integer (FILE *stream) return sign * n; } +/*--------------------------------------------------------------. +| Get the data type (alternative in the union) of the value for | +| symbol N in rule RULE. | +`--------------------------------------------------------------*/ + +static char * +get_type_name (int n, symbol_list * rule) +{ + int i; + symbol_list *rp; + + if (n < 0) + { + complain (_("invalid $ value")); + return NULL; + } + + rp = rule; + i = 0; + + while (i < n) + { + rp = rp->next; + if (rp == NULL || rp->sym == NULL) + { + complain (_("invalid $ value")); + return NULL; + } + i++; + } + + return rp->sym->type_name; +} + /*-------------------------------------------------------------------. | Dump the string from FINPUT to FOUTPUT. MATCH is the delimiter of | | the string (either ' or "). | @@ -286,7 +286,7 @@ copy_at (FILE *fin, FILE *fout, int stack_offset) if (c == '$') { fprintf (fout, "yyloc"); - yylsp_needed = 1; + locations_flag = 1; } else if (isdigit (c) || c == '-') { @@ -296,10 +296,86 @@ copy_at (FILE *fin, FILE *fout, int stack_offset) n = read_signed_integer (fin); fprintf (fout, "yylsp[%d]", n - stack_offset); - yylsp_needed = 1; + locations_flag = 1; + } + else + { + char buf[] = "@c"; + buf[1] = c; + complain (_("%s is invalid"), quote (buf)); + } +} + + +/*-------------------------------------------------------------------. +| FIN is pointing to a wannabee semantic value (i.e., a `$'). | +| | +| Possible inputs: $[]($|integer) | +| | +| Output to FOUT a reference to this semantic value. STACK_OFFSET is | +| the number of values in the current rule so far, which says where | +| to find `$0' with respect to the top of the stack. | +`-------------------------------------------------------------------*/ + +static inline void +copy_dollar (FILE *fin, FILE *fout, + symbol_list *rule, int stack_offset) +{ + int c = getc (fin); + char *type_name = NULL; + + /* Get the typename if explicit. */ + if (c == '<') + { + char *cp = token_buffer; + + while ((c = getc (fin)) != '>' && c > 0) + { + if (cp == token_buffer + maxtoken) + cp = grow_token_buffer (cp); + + *cp++ = c; + } + *cp = 0; + type_name = token_buffer; + value_components_used = 1; + + c = getc (fin); + } + + if (c == '$') + { + fprintf (fout, "yyval"); + if (!type_name) + type_name = get_type_name (0, rule); + if (type_name) + fprintf (fout, ".%s", type_name); + if (!type_name && typed) + complain (_("$$ of `%s' has no declared type"), + rule->sym->tag); + } + else if (isdigit (c) || c == '-') + { + int n; + ungetc (c, fin); + n = read_signed_integer (fin); + + if (!type_name && n > 0) + type_name = get_type_name (n, rule); + + fprintf (fout, "yyvsp[%d]", n - stack_offset); + if (type_name) + fprintf (fout, ".%s", type_name); + if (!type_name && typed) + complain (_("$%d of `%s' has no declared type"), + n, rule->sym->tag); } else - complain (_("@%s is invalid"), printable_version (c)); + { + char buf[] = "$c"; + buf[1] = c; + complain (_("%s is invalid"), quote (buf)); + } } /*-------------------------------------------------------------------. @@ -314,7 +390,7 @@ copy_definition (void) /* -1 while reading a character if prev char was %. */ int after_percent; - if (!nolinesflag) + if (!no_lines_flag) fprintf (fattrs, "#line %d \"%s\"\n", lineno, infile); after_percent = 0; @@ -369,19 +445,18 @@ copy_definition (void) } -/*-----------------------------------------------------------------. -| Parse what comes after %token or %nterm. For %token, what_is is | -| STOKEN and what_is_not is SNTERM. For %nterm, the arguments are | -| reversed. | -`-----------------------------------------------------------------*/ +/*-------------------------------------------------------------------. +| Parse what comes after %token or %nterm. For %token, WHAT_IS is | +| token_sym and WHAT_IS_NOT is nterm_sym. For %nterm, the arguments | +| are reversed. | +`-------------------------------------------------------------------*/ static void -parse_token_decl (int what_is, int what_is_not) +parse_token_decl (symbol_class what_is, symbol_class what_is_not) { int token = 0; char *typename = 0; struct bucket *symbol = NULL; /* pts to symbol being defined */ - int k; for (;;) { @@ -400,25 +475,31 @@ parse_token_decl (int what_is, int what_is_not) } if (token == TYPENAME) { - k = strlen (token_buffer); - typename = NEW2 (k + 1, char); - strcpy (typename, token_buffer); + typename = xstrdup (token_buffer); value_components_used = 1; symbol = NULL; } else if (token == IDENTIFIER && *symval->tag == '\"' && symbol) { + if (symval->alias) + warn (_("symbol `%s' used more than once as a literal string"), + symval->tag); + else if (symbol->alias) + warn (_("symbol `%s' given more than one literal string"), + symbol->tag); + else + { + symval->class = token_sym; + symval->type_name = typename; + symval->user_token_number = symbol->user_token_number; + symbol->user_token_number = SALIAS; + symval->alias = symbol; + symbol->alias = symval; + /* symbol and symval combined are only one symbol */ + nsyms--; + } translations = 1; - symval->class = STOKEN; - symval->type_name = typename; - symval->user_token_number = symbol->user_token_number; - symbol->user_token_number = SALIAS; - - symval->alias = symbol; - symbol->alias = symval; - symbol = NULL; - - nsyms--; /* symbol and symval combined are only one symbol */ + symbol = NULL; } else if (token == IDENTIFIER) { @@ -428,7 +509,7 @@ parse_token_decl (int what_is, int what_is_not) if (symbol->class == what_is_not) complain (_("symbol %s redefined"), symbol->tag); symbol->class = what_is; - if (what_is == SNTERM && oldclass != SNTERM) + if (what_is == nterm_sym && oldclass != nterm_sym) symbol->value = nvars++; if (typename) @@ -447,7 +528,7 @@ parse_token_decl (int what_is, int what_is_not) else { complain (_("`%s' is invalid in %s"), - token_buffer, (what_is == STOKEN) ? "%token" : "%nterm"); + token_buffer, (what_is == token_sym) ? "%token" : "%nterm"); skip_to_char ('%'); } } @@ -455,7 +536,9 @@ parse_token_decl (int what_is, int what_is_not) } -/* Parse what comes after %start */ +/*------------------------------. +| Parse what comes after %start | +`------------------------------*/ static void parse_start_decl (void) @@ -471,43 +554,6 @@ parse_start_decl (void) } } - - -/*--------------------------------------------------------------. -| Get the data type (alternative in the union) of the value for | -| symbol n in rule rule. | -`--------------------------------------------------------------*/ - -static char * -get_type_name (int n, symbol_list * rule) -{ - int i; - symbol_list *rp; - - if (n < 0) - { - complain (_("invalid $ value")); - return NULL; - } - - rp = rule; - i = 0; - - while (i < n) - { - rp = rp->next; - if (rp == NULL || rp->sym == NULL) - { - complain (_("invalid $ value")); - return NULL; - } - i++; - } - - return rp->sym->type_name; -} - - /*-----------------------------------------------------------. | read in a %type declaration and record its information for | | get_type_name to access | @@ -516,7 +562,6 @@ get_type_name (int n, symbol_list * rule) static void parse_type_decl (void) { - int k; char *name; if (lex () != TYPENAME) @@ -526,9 +571,7 @@ parse_type_decl (void) return; } - k = strlen (token_buffer); - name = NEW2 (k + 1, char); - strcpy (name, token_buffer); + name = xstrdup (token_buffer); for (;;) { @@ -567,13 +610,14 @@ parse_type_decl (void) -/* read in a %left, %right or %nonassoc declaration and record its information. */ -/* assoc is either LEFT_ASSOC, RIGHT_ASSOC or NON_ASSOC. */ +/*----------------------------------------------------------------. +| Read in a %left, %right or %nonassoc declaration and record its | +| information. | +`----------------------------------------------------------------*/ static void -parse_assoc_decl (int assoc) +parse_assoc_decl (associativity assoc) { - int k; char *name = NULL; int prev = 0; @@ -593,11 +637,8 @@ parse_assoc_decl (int assoc) switch (t) { - case TYPENAME: - k = strlen (token_buffer); - name = NEW2 (k + 1, char); - strcpy (name, token_buffer); + name = xstrdup (token_buffer); break; case COMMA: @@ -608,9 +649,9 @@ parse_assoc_decl (int assoc) complain (_("redefining precedence of %s"), symval->tag); symval->prec = lastprec; symval->assoc = assoc; - if (symval->class == SNTERM) + if (symval->class == nterm_sym) complain (_("symbol %s redefined"), symval->tag); - symval->class = STOKEN; + symval->class = token_sym; if (name) { /* record the type, if one is specified */ if (symval->type_name == NULL) @@ -650,9 +691,11 @@ token_buffer); -/* copy the union declaration into fattrs (and fdefines), - where it is made into the - definition of YYSTYPE, the type of elements of the parser value stack. */ +/*-------------------------------------------------------------------. +| Copy the union declaration into fattrs (and fdefines), where it is | +| made into the definition of YYSTYPE, the type of elements of the | +| parser value stack. | +`-------------------------------------------------------------------*/ static void parse_union_decl (void) @@ -665,7 +708,7 @@ parse_union_decl (void) typed = 1; - if (!nolinesflag) + if (!no_lines_flag) fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile); else fprintf (fattrs, "\n"); @@ -721,34 +764,22 @@ parse_union_decl (void) } } -/* parse the declaration %expect N which says to expect N - shift-reduce conflicts. */ + +/*-------------------------------------------------------. +| Parse the declaration %expect N which says to expect N | +| shift-reduce conflicts. | +`-------------------------------------------------------*/ static void parse_expect_decl (void) { - int c; - int count; - char buffer[20]; - - c = getc (finput); - while (c == ' ' || c == '\t') - c = getc (finput); - - count = 0; - while (c >= '0' && c <= '9') - { - if (count < 20) - buffer[count++] = c; - c = getc (finput); - } - buffer[count] = 0; - + int c = skip_white_space (); ungetc (c, finput); - if (count <= 0 || count > 10) - complain ("%s", _("argument of %expect is not an integer")); - expected_conflicts = atoi (buffer); + if (!isdigit (c)) + complain (_("argument of %%expect is not an integer")); + else + expected_conflicts = read_signed_integer (finput); } @@ -778,15 +809,13 @@ parse_thong_decl (void) int token; struct bucket *symbol; char *typename = 0; - int k, usrtoknum; + int usrtoknum; translations = 1; token = lex (); /* fetch typename or first token */ if (token == TYPENAME) { - k = strlen (token_buffer); - typename = NEW2 (k + 1, char); - strcpy (typename, token_buffer); + typename = xstrdup (token_buffer); value_components_used = 1; token = lex (); /* fetch first token */ } @@ -800,7 +829,7 @@ parse_thong_decl (void) skip_to_char ('%'); return; } - symval->class = STOKEN; + symval->class = token_sym; symval->type_name = typename; symval->user_token_number = SALIAS; symbol = symval; @@ -823,16 +852,18 @@ parse_thong_decl (void) skip_to_char ('%'); return; } - symval->class = STOKEN; + symval->class = token_sym; symval->type_name = typename; symval->user_token_number = usrtoknum; symval->alias = symbol; symbol->alias = symval; - nsyms--; /* symbol and symval combined are only one symbol */ + /* symbol and symval combined are only one symbol. */ + nsyms--; } + /*----------------------------------------------------------------. | Read from finput until `%%' is seen. Discard the `%%'. Handle | | any `%' declarations, and copy the contents of any `%{ ... %}' | @@ -863,11 +894,11 @@ read_declarations (void) break; case TOKEN: - parse_token_decl (STOKEN, SNTERM); + parse_token_decl (token_sym, nterm_sym); break; case NTERM: - parse_token_decl (SNTERM, STOKEN); + parse_token_decl (nterm_sym, token_sym); break; case TYPE: @@ -888,16 +919,17 @@ read_declarations (void) case THONG: parse_thong_decl (); break; + case LEFT: - parse_assoc_decl (LEFT_ASSOC); + parse_assoc_decl (left_assoc); break; case RIGHT: - parse_assoc_decl (RIGHT_ASSOC); + parse_assoc_decl (right_assoc); break; case NONASSOC: - parse_assoc_decl (NON_ASSOC); + parse_assoc_decl (non_assoc); break; case SEMANTIC_PARSER: @@ -924,7 +956,9 @@ read_declarations (void) fatal (_("no input grammar")); else { - complain (_("unknown character: %s"), printable_version (c)); + char buf[] = "c"; + buf[0] = c; + complain (_("unknown character: %s"), quote (buf)); skip_to_char ('%'); } } @@ -938,19 +972,17 @@ read_declarations (void) `-------------------------------------------------------------------*/ static void -copy_action (symbol_list * rule, int stack_offset) +copy_action (symbol_list *rule, int stack_offset) { int c; - int n; int count; - char *type_name; /* offset is always 0 if parser has already popped the stack pointer */ if (semantic_parser) stack_offset = 0; fprintf (faction, "\ncase %d:\n", nrules); - if (!nolinesflag) + if (!no_lines_flag) fprintf (faction, "#line %d \"%s\"\n", lineno, infile); putc ('{', faction); @@ -987,57 +1019,7 @@ copy_action (symbol_list * rule, int stack_offset) break; case '$': - c = getc (finput); - type_name = NULL; - - if (c == '<') - { - char *cp = token_buffer; - - while ((c = getc (finput)) != '>' && c > 0) - { - if (cp == token_buffer + maxtoken) - cp = grow_token_buffer (cp); - - *cp++ = c; - } - *cp = 0; - type_name = token_buffer; - value_components_used = 1; - - c = getc (finput); - } - if (c == '$') - { - fprintf (faction, "yyval"); - if (!type_name) - type_name = get_type_name (0, rule); - if (type_name) - fprintf (faction, ".%s", type_name); - if (!type_name && typed) - complain (_("$$ of `%s' has no declared type"), - rule->sym->tag); - } - else if (isdigit (c) || c == '-') - { - ungetc (c, finput); - n = read_signed_integer (finput); - c = getc (finput); - - if (!type_name && n > 0) - type_name = get_type_name (n, rule); - - fprintf (faction, "yyvsp[%d]", n - stack_offset); - if (type_name) - fprintf (faction, ".%s", type_name); - if (!type_name && typed) - complain (_("$%d of `%s' has no declared type"), - n, rule->sym->tag); - continue; - } - else - complain (_("$%s is invalid"), printable_version (c)); - + copy_dollar (finput, faction, rule, stack_offset); break; case '@': @@ -1076,12 +1058,10 @@ copy_action (symbol_list * rule, int stack_offset) `-------------------------------------------------------------------*/ static void -copy_guard (symbol_list * rule, int stack_offset) +copy_guard (symbol_list *rule, int stack_offset) { int c; - int n; int count; - char *type_name; int brace_flag = 0; /* offset is always 0 if parser has already popped the stack pointer */ @@ -1089,7 +1069,7 @@ copy_guard (symbol_list * rule, int stack_offset) stack_offset = 0; fprintf (fguard, "\ncase %d:\n", nrules); - if (!nolinesflag) + if (!no_lines_flag) fprintf (fguard, "#line %d \"%s\"\n", lineno, infile); putc ('{', fguard); @@ -1136,56 +1116,7 @@ copy_guard (symbol_list * rule, int stack_offset) break; case '$': - c = getc (finput); - type_name = NULL; - - if (c == '<') - { - char *cp = token_buffer; - - while ((c = getc (finput)) != '>' && c > 0) - { - if (cp == token_buffer + maxtoken) - cp = grow_token_buffer (cp); - - *cp++ = c; - } - *cp = 0; - type_name = token_buffer; - - c = getc (finput); - } - - if (c == '$') - { - fprintf (fguard, "yyval"); - if (!type_name) - type_name = rule->sym->type_name; - if (type_name) - fprintf (fguard, ".%s", type_name); - if (!type_name && typed) - complain (_("$$ of `%s' has no declared type"), - rule->sym->tag); - } - else if (isdigit (c) || c == '-') - { - ungetc (c, finput); - n = read_signed_integer (finput); - c = getc (finput); - - if (!type_name && n > 0) - type_name = get_type_name (n, rule); - - fprintf (fguard, "yyvsp[%d]", n - stack_offset); - if (type_name) - fprintf (fguard, ".%s", type_name); - if (!type_name && typed) - complain (_("$%d of `%s' has no declared type"), - n, rule->sym->tag); - continue; - } - else - complain (_("$%s is invalid"), printable_version (c)); + copy_dollar (finput, fguard, rule, stack_offset); break; case '@': @@ -1227,8 +1158,7 @@ record_rule_line (void) if (nrules >= rline_allocated) { rline_allocated = nrules * 2; - rline = (short *) xrealloc ((char *) rline, - rline_allocated * sizeof (short)); + rline = XREALLOC (rline, short, rline_allocated); } rline[nrules] = lineno; } @@ -1246,7 +1176,7 @@ gensym (void) sprintf (token_buffer, "@%d", ++gensym_count); sym = getsym (token_buffer); - sym->class = SNTERM; + sym->class = nterm_sym; sym->value = nvars++; return sym; } @@ -1273,9 +1203,7 @@ get_type (void) return t; } - k = strlen (token_buffer); - name = NEW2 (k + 1, char); - strcpy (name, token_buffer); + name = xstrdup (token_buffer); for (;;) { @@ -1325,9 +1253,11 @@ readgram (void) symbol_list *p1; bucket *bp; - symbol_list *crule; /* points to first symbol_list of current rule. */ - /* its symbol is the lhs of the rule. */ - symbol_list *crule1; /* points to the symbol_list preceding crule. */ + /* Points to first symbol_list of current rule. its symbol is the + lhs of the rule. */ + symbol_list *crule; + /* Points to the symbol_list preceding crule. */ + symbol_list *crule1; p1 = NULL; @@ -1337,8 +1267,9 @@ readgram (void) { if (t == IDENTIFIER || t == BAR) { - int actionflag = 0; - int rulelength = 0; /* number of symbols in rhs of this rule so far */ + int action_flag = 0; + /* Number of symbols in rhs of this rule so far */ + int rulelength = 0; int xactions = 0; /* JF for error checking */ bucket *first_rhs = 0; @@ -1372,7 +1303,7 @@ readgram (void) record_rule_line (); - p = NEW (symbol_list); + p = XCALLOC (symbol_list, 1); p->sym = lhs; crule1 = p1; @@ -1386,13 +1317,13 @@ readgram (void) /* mark the rule's lhs as a nonterminal if not already so. */ - if (lhs->class == SUNKNOWN) + if (lhs->class == unknown_sym) { - lhs->class = SNTERM; + lhs->class = nterm_sym; lhs->value = nvars; nvars++; } - else if (lhs->class == STOKEN) + else if (lhs->class == token_sym) complain (_("rule given for %s, which is a token"), lhs->tag); /* read the rhs of the rule. */ @@ -1433,7 +1364,7 @@ readgram (void) /* If we just passed an action, that action was in the middle of a rule, so make a dummy rule to reduce it to a non-terminal. */ - if (actionflag) + if (action_flag) { bucket *sdummy; @@ -1450,30 +1381,30 @@ readgram (void) nrules++; nitems++; record_rule_line (); - p = NEW (symbol_list); + p = XCALLOC (symbol_list, 1); if (crule1) crule1->next = p; else grammar = p; p->sym = sdummy; - crule1 = NEW (symbol_list); + crule1 = XCALLOC (symbol_list, 1); p->next = crule1; crule1->next = crule; /* insert the dummy generated by that rule into this rule. */ nitems++; - p = NEW (symbol_list); + p = XCALLOC (symbol_list, 1); p->sym = sdummy; p1->next = p; p1 = p; - actionflag = 0; + action_flag = 0; } if (t == IDENTIFIER) { nitems++; - p = NEW (symbol_list); + p = XCALLOC (symbol_list, 1); p->sym = symval; p1->next = p; p1 = p; @@ -1481,14 +1412,14 @@ readgram (void) else /* handle an action. */ { copy_action (crule, rulelength); - actionflag = 1; + action_flag = 1; xactions++; /* JF */ } rulelength++; } /* end of read rhs of rule */ /* Put an empty link in the list to mark the end of this rule */ - p = NEW (symbol_list); + p = XCALLOC (symbol_list, 1); p1->next = p; p1 = p; @@ -1502,9 +1433,7 @@ readgram (void) if (t == GUARD) { if (!semantic_parser) - complain ("%s", - _ - ("%guard present but %semantic_parser not specified")); + complain (_("%%guard present but %%semantic_parser not specified")); copy_guard (crule, rulelength); t = lex (); @@ -1512,10 +1441,10 @@ readgram (void) else if (t == LEFT_CURLY) { /* This case never occurs -wjh */ - if (actionflag) + if (action_flag) complain (_("two actions at end of one rule")); copy_action (crule, rulelength); - actionflag = 1; + action_flag = 1; xactions++; /* -wjh */ t = lex (); } @@ -1546,12 +1475,12 @@ readgram (void) */ else if (t == TOKEN) { - parse_token_decl (STOKEN, SNTERM); + parse_token_decl (token_sym, nterm_sym); t = lex (); } else if (t == NTERM) { - parse_token_decl (SNTERM, STOKEN); + parse_token_decl (nterm_sym, token_sym); t = lex (); } else if (t == TYPE) @@ -1590,7 +1519,8 @@ readgram (void) if (nrules == 0) fatal (_("no rules in the input grammar")); - if (typed == 0 /* JF put out same default YYSTYPE as YACC does */ + /* JF put out same default YYSTYPE as YACC does */ + if (typed == 0 && !value_components_used) { /* We used to use `unsigned long' as YYSTYPE on MSDOS, @@ -1604,12 +1534,12 @@ readgram (void) /* Report any undefined symbols and consider them nonterminals. */ for (bp = firstsymbol; bp; bp = bp->next) - if (bp->class == SUNKNOWN) + if (bp->class == unknown_sym) { complain (_ ("symbol %s is used, but is not defined as a token and has no rules"), -bp->tag); - bp->class = SNTERM; + bp->tag); + bp->class = nterm_sym; bp->value = nvars++; } @@ -1656,7 +1586,7 @@ output_token_defines (FILE *file) continue; fprintf (file, "#define\t%s\t%d\n", symbol, - ((translations && !rawtoknumflag) + ((translations && !raw_flag) ? bp->user_token_number : bp->value)); if (semantic_parser) fprintf (file, "#define\tT%s\t%d\n", symbol, bp->value); @@ -1668,7 +1598,7 @@ output_token_defines (FILE *file) /*------------------------------------------------------------------. | Assign symbol numbers, and write definition of token names into | -| fdefines. Set up vectors tags and sprec of names and precedences | +| FDEFINES. Set up vectors TAGS and SPREC of names and precedences | | of symbols. | `------------------------------------------------------------------*/ @@ -1683,20 +1613,20 @@ packsymbols (void) /* int lossage = 0; JF set but not used */ - tags = NEW2 (nsyms + 1, char *); + tags = XCALLOC (char *, nsyms + 1); tags[0] = DOLLAR; - user_toknums = NEW2 (nsyms + 1, short); + user_toknums = XCALLOC (short, nsyms + 1); user_toknums[0] = 0; - sprec = NEW2 (nsyms, short); - sassoc = NEW2 (nsyms, short); + sprec = XCALLOC (short, nsyms); + sassoc = XCALLOC (short, nsyms); max_user_token_number = 256; last_user_token_number = 256; for (bp = firstsymbol; bp; bp = bp->next) { - if (bp->class == SNTERM) + if (bp->class == nterm_sym) { bp->value += ntokens; } @@ -1736,12 +1666,12 @@ packsymbols (void) continue; /* do not do processing below for SALIASs */ } - else /* bp->class == STOKEN */ + else /* bp->class == token_sym */ { bp->value = tokno++; } - if (bp->class == STOKEN) + if (bp->class == token_sym) { if (translations && !(bp->user_token_number)) bp->user_token_number = ++last_user_token_number; @@ -1760,7 +1690,7 @@ packsymbols (void) { int j; - token_translations = NEW2 (max_user_token_number + 1, short); + token_translations = XCALLOC (short, max_user_token_number + 1); /* initialize all entries for literal tokens to 2, the internal token number for $undefined., which represents all invalid @@ -1784,17 +1714,17 @@ packsymbols (void) error_token_number = errtoken->value; - if (!noparserflag) + if (!no_parser_flag) output_token_defines (ftable); - if (startval->class == SUNKNOWN) + if (startval->class == unknown_sym) fatal (_("the start symbol %s is undefined"), startval->tag); - else if (startval->class == STOKEN) + else if (startval->class == token_sym) fatal (_("the start symbol %s is a token"), startval->tag); start_symbol = startval->value; - if (definesflag) + if (defines_flag) { output_token_defines (fdefines); @@ -1838,12 +1768,12 @@ packgram (void) bucket *ruleprec; - ritem = NEW2 (nitems + 1, short); - rlhs = NEW2 (nrules, short) - 1; - rrhs = NEW2 (nrules, short) - 1; - rprec = NEW2 (nrules, short) - 1; - rprecsym = NEW2 (nrules, short) - 1; - rassoc = NEW2 (nrules, short) - 1; + ritem = XCALLOC (short, nitems + 1); + rlhs = XCALLOC (short, nrules) - 1; + rrhs = XCALLOC (short, nrules) - 1; + rprec = XCALLOC (short, nrules) - 1; + rprecsym = XCALLOC (short, nrules) - 1; + rassoc = XCALLOC (short, nrules) - 1; itemno = 0; ruleno = 1; @@ -1861,7 +1791,7 @@ packgram (void) ritem[itemno++] = p->sym->value; /* A rule gets by default the precedence and associativity of the last token in it. */ - if (p->sym->class == STOKEN) + if (p->sym->class == token_sym) { rprec[ruleno] = p->sym->prec; rassoc[ruleno] = p->sym->assoc; @@ -1917,7 +1847,7 @@ reader (void) nrules = 0; nitems = 0; rline_allocated = 10; - rline = NEW2 (rline_allocated, short); + rline = XCALLOC (short, rline_allocated); typed = 0; lastprec = 0; @@ -1926,7 +1856,6 @@ reader (void) semantic_parser = 0; pure_parser = 0; - yylsp_needed = 0; grammar = NULL; @@ -1937,12 +1866,12 @@ reader (void) tabinit (); /* Construct the error token */ errtoken = getsym ("error"); - errtoken->class = STOKEN; + errtoken->class = token_sym; errtoken->user_token_number = 256; /* Value specified by POSIX. */ /* Construct a token that represents all undefined literal tokens. It is always token number 2. */ undeftoken = getsym ("$undefined."); - undeftoken->class = STOKEN; + undeftoken->class = token_sym; undeftoken->user_token_number = 2; /* Read the declaration section. Copy %{ ... %} groups to FTABLE @@ -1952,7 +1881,7 @@ reader (void) fprintf (ftable, "\ /* %s, made from %s\n\ by GNU bison %s. */\n\ -\n", noparserflag ? "Bison-generated parse tables" : "A Bison parser", infile, VERSION); +\n", no_parser_flag ? "Bison-generated parse tables" : "A Bison parser", infile, VERSION); fputs ("#define YYBISON 1 /* Identify Bison output. */\n\n", ftable); read_declarations (); @@ -1967,7 +1896,7 @@ reader (void) reader_output_yylsp (fdefines); /* Write closing delimiters for actions and guards. */ output_trailers (); - if (yylsp_needed) + if (locations_flag) fputs ("#define YYLSP_NEEDED\n\n", ftable); /* Assign the symbols their symbol numbers. Write #defines for the token symbols into FDEFINES if requested. */ @@ -1979,9 +1908,27 @@ reader (void) free_symtab (); } + void reader_output_yylsp (FILE *f) { - if (yylsp_needed) - fprintf (f, LTYPESTR); + if (locations_flag) + fputs ("\ +\n\ +#ifndef YYLTYPE\n\ +typedef struct yyltype\n\ +{\n\ + int timestamp;\n\ + int first_line;\n\ + int first_column;\ +\n\ + int last_line;\n\ + int last_column;\n\ + char *text;\n\ +} yyltype;\n\ +\n\ +# define YYLTYPE yyltype\n\ +#endif\n\ +\n", + f); }