#include "output.h"
#include "reader.h"
#include "conflicts.h"
-
-extern char *printable_version PARAMS ((int));
+#include "quote.h"
/* Number of slots allocated (but not necessarily used yet) in `rline' */
static int rline_allocated;
static bucket *errtoken;
static bucket *undeftoken;
-
-/* Nonzero if any action or guard uses the @n construct. */
-static int yylsp_needed;
\f
/*===================\
return sign * n;
}
\f
+/*--------------------------------------------------------------.
+| 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;
+}
+\f
/*-------------------------------------------------------------------.
| Dump the string from FINPUT to FOUTPUT. MATCH is the delimiter of |
| the string (either ' or "). |
}
-/*---------------------------------------------------------------.
-| Dump the comment from IN to OUT1 and OUT2. C is either `*' or |
-| `/', depending upon the type of comments used. OUT2 might be |
-| NULL. |
-`---------------------------------------------------------------*/
+/*----------------------------------------------------------------.
+| Dump the wannabee comment from IN to OUT1 and OUT2. In fact we |
+| just saw a `/', which might or might not be a comment. In any |
+| case, copy what we saw. |
+| |
+| OUT2 might be NULL. |
+`----------------------------------------------------------------*/
static inline void
-copy_comment2 (FILE *in, FILE *out1, FILE *out2, int c)
+copy_comment2 (FILE *fin, FILE *out1, FILE *out2)
{
int cplus_comment;
int ended;
+ int c;
+
+ /* We read a `/', output it. */
+ putc ('/', out1);
+ if (out2)
+ putc ('/', out2);
+
+ switch ((c = getc (fin)))
+ {
+ case '/':
+ cplus_comment = 1;
+ break;
+ case '*':
+ cplus_comment = 0;
+ break;
+ default:
+ ungetc (c, fin);
+ return;
+ }
- cplus_comment = (c == '/');
putc (c, out1);
if (out2)
putc (c, out2);
- c = getc (in);
+ c = getc (fin);
ended = 0;
while (!ended)
putc (c, out1);
if (out2)
putc (c, out2);
- c = getc (in);
+ c = getc (fin);
}
if (c == '/')
if (cplus_comment)
ended = 1;
else
- c = getc (in);
+ c = getc (fin);
}
else if (c == EOF)
fatal (_("unterminated comment"));
putc (c, out1);
if (out2)
putc (c, out2);
- c = getc (in);
+ c = getc (fin);
}
}
}
-/*------------------------------------------------------------.
-| Dump the comment from FIN to FOUT. C is either `*' or `/', |
-| depending upon the type of comments used. |
-`------------------------------------------------------------*/
+/*-------------------------------------------------------------------.
+| Dump the comment (actually the current string starting with a `/') |
+| from FIN to FOUT. |
+`-------------------------------------------------------------------*/
static inline void
-copy_comment (FILE *fin, FILE *fout, int c)
+copy_comment (FILE *fin, FILE *fout)
{
- copy_comment2 (fin, fout, NULL, c);
+ copy_comment2 (fin, fout, NULL);
}
if (c == '$')
{
fprintf (fout, "yyloc");
- yylsp_needed = 1;
+ locations_flag = 1;
}
else if (isdigit (c) || c == '-')
{
n = read_signed_integer (fin);
fprintf (fout, "yylsp[%d]", n - stack_offset);
- yylsp_needed = 1;
+ locations_flag = 1;
}
else
- complain (_("@%s is invalid"), printable_version (c));
+ {
+ 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: $[<TYPENAME>]($|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 type name if explicit. */
+ if (c == '<')
+ {
+ read_type_name (fin);
+ 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
+ {
+ char buf[] = "$c";
+ buf[1] = c;
+ complain (_("%s is invalid"), quote (buf));
+ }
}
\f
/*-------------------------------------------------------------------.
/* -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;
break;
case '/':
- putc (c, fattrs);
- c = getc (finput);
- if (c != '*' && c != '/')
- continue;
- copy_comment (finput, fattrs, c);
+ copy_comment (finput, fattrs);
break;
case EOF:
{
int token = 0;
char *typename = 0;
- struct bucket *symbol = NULL; /* pts to symbol being defined */
- int k;
+ /* The symbol being defined. */
+ struct bucket *symbol = NULL;
+
+ /* After `%token' and `%nterm', any number of symbols maybe be
+ defined. */
for (;;)
{
int tmp_char = ungetc (skip_white_space (), finput);
+ /* `%' (for instance from `%token', or from `%%' etc.) is the
+ only valid means to end this declaration. */
if (tmp_char == '%')
return;
if (tmp_char == EOF)
}
if (token == TYPENAME)
{
- k = strlen (token_buffer);
- typename = XCALLOC (char, k + 1);
- 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 = 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 = NULL;
-
- nsyms--; /* symbol and symval combined are only one symbol */
+ symbol = NULL;
}
else if (token == IDENTIFIER)
{
}
}
-
-
-/*--------------------------------------------------------------.
-| 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 |
static void
parse_type_decl (void)
{
- int k;
char *name;
if (lex () != TYPENAME)
return;
}
- k = strlen (token_buffer);
- name = XCALLOC (char, k + 1);
- strcpy (name, token_buffer);
+ name = xstrdup (token_buffer);
for (;;)
{
static void
parse_assoc_decl (associativity assoc)
{
- int k;
char *name = NULL;
int prev = 0;
switch (t)
{
-
case TYPENAME:
- k = strlen (token_buffer);
- name = XCALLOC (char, k + 1);
- strcpy (name, token_buffer);
+ name = xstrdup (token_buffer);
break;
case COMMA:
typed = 1;
- if (!nolinesflag)
+ if (!no_lines_flag)
fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile);
else
fprintf (fattrs, "\n");
break;
case '/':
- c = getc (finput);
- if (c != '*' && c != '/')
- continue;
- copy_comment2 (finput, fattrs, fdefines, c);
+ copy_comment2 (finput, fattrs, fdefines);
break;
-
case '{':
count++;
break;
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);
}
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 = XCALLOC (char, k + 1);
- strcpy (typename, token_buffer);
+ typename = xstrdup (token_buffer);
value_components_used = 1;
token = lex (); /* fetch first token */
}
symval->alias = symbol;
symbol->alias = symval;
- nsyms--; /* symbol and symval combined are only one symbol */
+ /* symbol and symval combined are only one symbol. */
+ nsyms--;
}
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 ('%');
}
}
`-------------------------------------------------------------------*/
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);
break;
case '/':
- putc (c, faction);
- c = getc (finput);
- if (c != '*' && c != '/')
- continue;
- copy_comment (finput, faction, c);
+ copy_comment (finput, faction);
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 '@':
`-------------------------------------------------------------------*/
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 */
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);
break;
case '/':
- putc (c, fguard);
- c = getc (finput);
- if (c != '*' && c != '/')
- continue;
- copy_comment (finput, fguard, c);
+ copy_comment (finput, fguard);
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 '@':
return t;
}
- k = strlen (token_buffer);
- name = XCALLOC (char, k + 1);
- strcpy (name, token_buffer);
+ name = xstrdup (token_buffer);
for (;;)
{
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;
{
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;
/* 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;
- /* Since the action was written out with this rule's */
- /* number, we must give the new rule this number */
- /* by inserting the new rule before it. */
+ /* Since the action was written out with this rule's
+ number, we must give the new rule this number by
+ inserting the new rule before it. */
/* Make a dummy nonterminal, a gensym. */
sdummy = gensym ();
p->next = crule1;
crule1->next = crule;
- /* insert the dummy generated by that rule into this rule. */
+ /* Insert the dummy generated by that rule into this
+ rule. */
nitems++;
p = XCALLOC (symbol_list, 1);
p->sym = sdummy;
p1->next = p;
p1 = p;
- actionflag = 0;
+ action_flag = 0;
}
if (t == IDENTIFIER)
else /* handle an action. */
{
copy_action (crule, rulelength);
- actionflag = 1;
+ action_flag = 1;
xactions++; /* JF */
}
rulelength++;
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 ();
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 ();
}
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,
{
complain (_
("symbol %s is used, but is not defined as a token and has no rules"),
-bp->tag);
+ bp->tag);
bp->class = nterm_sym;
bp->value = nvars++;
}
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);
error_token_number = errtoken->value;
- if (!noparserflag)
+ if (!no_parser_flag)
output_token_defines (ftable);
if (startval->class == unknown_sym)
start_symbol = startval->value;
- if (definesflag)
+ if (defines_flag)
{
output_token_defines (fdefines);
semantic_parser = 0;
pure_parser = 0;
- yylsp_needed = 0;
grammar = NULL;
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 ();
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. */
void
reader_output_yylsp (FILE *f)
{
- if (yylsp_needed)
+ if (locations_flag)
fputs ("\
\n\
#ifndef YYLTYPE\n\
-typedef\n\
- struct yyltype\n\
-\
- {\n\
- int timestamp;\n\
- int first_line;\n\
- int first_column;\
+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\
- }\n\
-\
- yyltype;\n\
+ int last_line;\n\
+ int last_column;\n\
+ char *text;\n\
+} yyltype;\n\
\n\
-#define YYLTYPE yyltype\n\
+# define YYLTYPE yyltype\n\
#endif\n\
\n",
f);
projects / bison.git / blobdiff