#include "lex.h"
#include "gram.h"
#include "machine.h"
+#include "complain.h"
#define LTYPESTR "\
\n\
\n"
/* Number of slots allocated (but not necessarily used yet) in `rline' */
-int rline_allocated;
+static int rline_allocated;
-extern char *program_name;
extern int definesflag;
extern int nolinesflag;
extern int noparserflag;
extern void output_trailers PARAMS((void));
extern void free_symtab PARAMS((void));
extern void open_extra_files PARAMS((void));
-extern char *int_to_string PARAMS((int));
extern char *printable_version PARAMS((int));
-extern void fatal PARAMS((char *));
-extern void fatals PARAMS((char *, char *));
-extern void warn PARAMS((char *));
-extern void warni PARAMS((char *, int));
-extern void warns PARAMS((char *, char *));
-extern void warnss PARAMS((char *, char *, char *));
-extern void warnsss PARAMS((char *, char *, char *, char *));
extern void unlex PARAMS((int));
-extern void done PARAMS((int));
extern int skip_white_space PARAMS((void));
extern int parse_percent_token PARAMS((void));
symbol_list;
-void reader PARAMS((void));
-void reader_output_yylsp PARAMS((FILE *));
-void read_declarations PARAMS((void));
-void copy_definition PARAMS((void));
-void parse_token_decl PARAMS((int, int));
-void parse_start_decl PARAMS((void));
-void parse_type_decl PARAMS((void));
-void parse_assoc_decl PARAMS((int));
-void parse_union_decl PARAMS((void));
-void parse_expect_decl PARAMS((void));
-char *get_type_name PARAMS((int, symbol_list *));
-void copy_guard PARAMS((symbol_list *, int));
-void parse_thong_decl PARAMS((void));
-void copy_action PARAMS((symbol_list *, int));
-bucket *gensym PARAMS((void));
-void readgram PARAMS((void));
-void record_rule_line PARAMS((void));
-void packsymbols PARAMS((void));
-void output_token_defines PARAMS((FILE *));
-void packgram PARAMS((void));
-int read_signed_integer PARAMS((FILE *));
+extern void reader PARAMS((void));
+extern void reader_output_yylsp PARAMS((FILE *));
+
+static void read_declarations PARAMS((void));
+static void copy_definition PARAMS((void));
+static void parse_token_decl PARAMS((int, int));
+static void parse_start_decl PARAMS((void));
+static void parse_type_decl PARAMS((void));
+static void parse_assoc_decl PARAMS((int));
+static void parse_union_decl PARAMS((void));
+static void parse_expect_decl PARAMS((void));
+static char *get_type_name PARAMS((int, symbol_list *));
+static void copy_guard PARAMS((symbol_list *, int));
+static void parse_thong_decl PARAMS((void));
+static void copy_action PARAMS((symbol_list *, int));
+static bucket *gensym PARAMS((void));
+static void readgram PARAMS((void));
+static void record_rule_line PARAMS((void));
+static void packsymbols PARAMS((void));
+static void output_token_defines PARAMS((FILE *));
+static void packgram PARAMS((void));
#if 0
static int get_type PARAMS((void));
#endif
int lineno;
-symbol_list *grammar;
-int start_flag;
-bucket *startval;
char **tags;
int *user_toknums;
+static symbol_list *grammar;
+static int start_flag;
+static bucket *startval;
/* Nonzero if components of semantic values are used, implying
they must be unions. */
/* Nonzero if any action or guard uses the @n construct. */
static int yylsp_needed;
+\f
+/*===================\
+| Low level lexing. |
+\===================*/
static void
skip_to_char (int target)
{
int c;
if (target == '\n')
- warn(_(" Skipping to next \\n"));
+ complain (_(" Skipping to next \\n"));
else
- warni(_(" Skipping to next %c"), target);
+ complain (_(" Skipping to next %c"), target);
do
- c = skip_white_space();
+ c = skip_white_space ();
while (c != target && c != EOF);
if (c != EOF)
- ungetc(c, finput);
+ ungetc (c, finput);
+}
+
+
+/*---------------------------------------------------------.
+| Read a signed integer from STREAM and return its value. |
+`---------------------------------------------------------*/
+
+static inline int
+read_signed_integer (FILE *stream)
+{
+ register int c = getc (stream);
+ register int sign = 1;
+ register int n = 0;
+
+ if (c == '-')
+ {
+ c = getc (stream);
+ sign = -1;
+ }
+
+ while (isdigit (c))
+ {
+ n = 10 * n + (c - '0');
+ c = getc (stream);
+ }
+
+ ungetc (c, stream);
+
+ return sign * n;
+}
+\f
+/*-------------------------------------------------------------------.
+| Dump the string from FINPUT to FOUTPUT. MATCH is the delimiter of |
+| the string (either ' or "). |
+`-------------------------------------------------------------------*/
+
+static inline void
+copy_string (FILE *fin, FILE *fout, int match)
+{
+ int c;
+
+ putc (match, fout);
+ c = getc (fin);
+
+ while (c != match)
+ {
+ if (c == EOF)
+ fatal (_("unterminated string at end of file"));
+ if (c == '\n')
+ {
+ complain (_("unterminated string"));
+ ungetc (c, fin);
+ c = match; /* invent terminator */
+ continue;
+ }
+
+ putc(c, fout);
+
+ if (c == '\\')
+ {
+ c = getc (fin);
+ if (c == EOF)
+ fatal (_("unterminated string at end of file"));
+ putc (c, fout);
+ if (c == '\n')
+ lineno++;
+ }
+
+ c = getc(fin);
+ }
+
+ putc(c, fout);
+}
+
+
+/* Dump the comment from IN to OUT1 and OUT2. C is either `*' or `/',
+ depending upon the type of comments used. OUT2 might be NULL. */
+
+static inline void
+copy_comment2 (FILE *in, FILE *out1, FILE* out2, int c)
+{
+ int cplus_comment;
+ register int ended;
+
+ cplus_comment = (c == '/');
+ putc (c, out1);
+ if (out2)
+ putc (c, out2);
+ c = getc (in);
+
+ ended = 0;
+ while (!ended)
+ {
+ if (!cplus_comment && c == '*')
+ {
+ while (c == '*')
+ {
+ putc (c, out1);
+ if (out2)
+ putc (c, out2);
+ c = getc (in);
+ }
+
+ if (c == '/')
+ {
+ putc(c, out1);
+ if (out2)
+ putc(c, out2);
+ ended = 1;
+ }
+ }
+ else if (c == '\n')
+ {
+ lineno++;
+ putc (c, out1);
+ if (out2)
+ putc (c, out2);
+ if (cplus_comment)
+ ended = 1;
+ else
+ c = getc (in);
+ }
+ else if (c == EOF)
+ fatal (_("unterminated comment"));
+ else
+ {
+ putc (c, out1);
+ if (out2)
+ putc (c, out2);
+ c = getc (in);
+ }
+ }
+}
+
+
+/* Dump the comment from FIN to FOUT. C is either `*' or `/',
+ depending upon the type of comments used. */
+
+static inline void
+copy_comment (FILE *fin, FILE *fout, int c)
+{
+ copy_comment2 (fin, fout, NULL, c);
}
startval = NULL; /* start symbol not specified yet. */
#if 0
- translations = 0; /* initially assume token number translation not needed. */
+ /* initially assume token number translation not needed. */
+ translations = 0;
#endif
- /* Nowadays translations is always set to 1,
- since we give `error' a user-token-number
- to satisfy the Posix demand for YYERRCODE==256. */
+ /* Nowadays translations is always set to 1, since we give `error' a
+ user-token-number to satisfy the Posix demand for YYERRCODE==256.
+ */
translations = 1;
nsyms = 1;
nrules = 0;
nitems = 0;
rline_allocated = 10;
- rline = NEW2(rline_allocated, short);
+ rline = NEW2 (rline_allocated, short);
typed = 0;
lastprec = 0;
grammar = NULL;
- init_lex();
+ init_lex ();
lineno = 1;
- /* initialize the symbol table. */
- tabinit();
- /* construct the error token */
- errtoken = getsym("error");
+ /* Initialize the symbol table. */
+ tabinit ();
+ /* Construct the error token */
+ errtoken = getsym ("error");
errtoken->class = STOKEN;
- 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.");
+ 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->user_token_number = 2;
- /* Read the declaration section. Copy %{ ... %} groups to ftable and fdefines file.
- Also notice any %token, %left, etc. found there. */
- if (noparserflag)
- fprintf(ftable, "\n/* Bison-generated parse tables, made from %s\n",
- infile);
- else
- fprintf(ftable, "\n/* A Bison parser, made from %s\n", infile);
- fprintf(ftable, " by %s */\n\n", VERSION_STRING);
- fprintf(ftable, "#define YYBISON 1 /* Identify Bison output. */\n\n");
- read_declarations();
- /* start writing the guard and action files, if they are needed. */
- output_headers();
- /* read in the grammar, build grammar in list form. write out guards and actions. */
- readgram();
- /* Now we know whether we need the line-number stack.
- If we do, write its type into the .tab.h file. */
+
+ /* Read the declaration section. Copy %{ ... %} groups to FTABLE
+ and FDEFINES file. Also notice any %token, %left, etc. found
+ there. */
+ putc ('\n', ftable);
+ fprintf (ftable, "\
+/* %s, made from %s\n\
+ by GNU bison %s. */\n\
+\n",
+ noparserflag ? "Bison-generated parse tables" : "A Bison parser",
+ infile,
+ VERSION);
+
+ fputs ("#define YYBISON 1 /* Identify Bison output. */\n\n", ftable);
+ read_declarations ();
+ /* Start writing the guard and action files, if they are needed. */
+ output_headers ();
+ /* Read in the grammar, build grammar in list form. Write out
+ guards and actions. */
+ readgram ();
+ /* Now we know whether we need the line-number stack. If we do,
+ write its type into the .tab.h file. */
if (fdefines)
- reader_output_yylsp(fdefines);
- /* write closing delimiters for actions and guards. */
- output_trailers();
+ reader_output_yylsp (fdefines);
+ /* Write closing delimiters for actions and guards. */
+ output_trailers ();
if (yylsp_needed)
- fprintf(ftable, "#define YYLSP_NEEDED\n\n");
- /* assign the symbols their symbol numbers.
- Write #defines for the token symbols into fdefines if requested. */
- packsymbols();
- /* convert the grammar into the format described in gram.h. */
- packgram();
- /* free the symbol table data structure
- since symbols are now all referred to by symbol number. */
- free_symtab();
+ fputs ("#define YYLSP_NEEDED\n\n", ftable);
+ /* Assign the symbols their symbol numbers. Write #defines for the
+ token symbols into FDEFINES if requested. */
+ packsymbols ();
+ /* Convert the grammar into the format described in gram.h. */
+ packgram ();
+ /* Free the symbol table data structure since symbols are now all
+ referred to by symbol number. */
+ free_symtab ();
}
void
`%' declarations, and copy the contents of any `%{ ... %}' groups
to fattrs. */
-void
+static void
read_declarations (void)
{
register int c;
break;
case UNION:
- parse_union_decl();
+ parse_union_decl ();
break;
case EXPECT:
break;
default:
- warns(_("unrecognized: %s"), token_buffer);
+ complain (_("unrecognized: %s"), token_buffer);
skip_to_char('%');
}
}
else if (c == EOF)
- fatal(_("no input grammar"));
+ fatal (_("no input grammar"));
else
{
- warns (_("unknown character: %s"), printable_version(c));
+ complain (_("unknown character: %s"), printable_version(c));
skip_to_char('%');
}
}
}
-/* copy the contents of a %{ ... %} into the definitions file.
-The %{ has already been read. Return after reading the %}. */
+/* Copy the contents of a `%{ ... %}' into the definitions file. The
+ `%{' has already been read. Return after reading the `%}'. */
-void
+static void
copy_definition (void)
{
register int c;
- register int match;
- register int ended;
- register int after_percent; /* -1 while reading a character if prev char was % */
- int cplus_comment;
+ /* -1 while reading a character if prev char was %. */
+ register int after_percent;
if (!nolinesflag)
fprintf(fattrs, "#line %d \"%s\"\n", lineno, infile);
after_percent = 0;
- c = getc(finput);
+ c = getc (finput);
for (;;)
{
case '\'':
case '"':
- match = c;
- putc(c, fattrs);
- c = getc(finput);
-
- while (c != match)
- {
- if (c == EOF)
- fatal(_("unterminated string at end of file"));
- if (c == '\n')
- {
- warn(_("unterminated string"));
- ungetc(c, finput);
- c = match;
- continue;
- }
-
- putc(c, fattrs);
-
- if (c == '\\')
- {
- c = getc(finput);
- if (c == EOF)
- fatal(_("unterminated string at end of file"));
- putc(c, fattrs);
- if (c == '\n')
- lineno++;
- }
-
- c = getc(finput);
- }
-
- putc(c, fattrs);
+ copy_string (finput, fattrs, c);
break;
case '/':
- putc(c, fattrs);
- c = getc(finput);
+ putc (c, fattrs);
+ c = getc (finput);
if (c != '*' && c != '/')
continue;
-
- cplus_comment = (c == '/');
- putc(c, fattrs);
- c = getc(finput);
-
- ended = 0;
- while (!ended)
- {
- if (!cplus_comment && c == '*')
- {
- while (c == '*')
- {
- putc(c, fattrs);
- c = getc(finput);
- }
-
- if (c == '/')
- {
- putc(c, fattrs);
- ended = 1;
- }
- }
- else if (c == '\n')
- {
- lineno++;
- putc(c, fattrs);
- if (cplus_comment)
- ended = 1;
- else
- c = getc(finput);
- }
- else if (c == EOF)
- fatal(_("unterminated comment in `%{' definition"));
- else
- {
- putc(c, fattrs);
- c = getc(finput);
- }
- }
-
+ copy_comment (finput, fattrs, c);
break;
case EOF:
- fatal(_("unterminated `%{' definition"));
+ fatal ("%s",
+ _("unterminated `%{' definition"));
default:
putc(c, fattrs);
For %token, what_is is STOKEN and what_is_not is SNTERM.
For %nterm, the arguments are reversed. */
-void
+static void
parse_token_decl (int what_is, int what_is_not)
{
register int token = 0;
if (tmp_char == '%')
return;
if (tmp_char == EOF)
- fatals ("Premature EOF after %s", token_buffer);
+ fatal (_("Premature EOF after %s"), token_buffer);
token = lex();
if (token == COMMA)
symbol = symval;
if (symbol->class == what_is_not)
- warns(_("symbol %s redefined"), symbol->tag);
+ complain (_("symbol %s redefined"), symbol->tag);
symbol->class = what_is;
if (what_is == SNTERM && oldclass != SNTERM)
symbol->value = nvars++;
if (symbol->type_name == NULL)
symbol->type_name = typename;
else if (strcmp(typename, symbol->type_name) != 0)
- warns(_("type redeclaration for %s"), symbol->tag);
+ complain (_("type redeclaration for %s"), symbol->tag);
}
}
else if (symbol && token == NUMBER)
}
else
{
- warnss(_("`%s' is invalid in %s"),
- token_buffer,
+ complain (_("`%s' is invalid in %s"),
+ token_buffer,
(what_is == STOKEN) ? "%token" : "%nterm");
skip_to_char('%');
}
it is the literal string that is output to yytname
*/
-void
+static void
parse_thong_decl (void)
{
register int token;
if (token != IDENTIFIER)
{
- warns(_("unrecognized item %s, expected an identifier"),
- token_buffer);
+ complain (_("unrecognized item %s, expected an identifier"),
+ token_buffer);
skip_to_char('%');
return;
}
if (token != IDENTIFIER || *symval->tag != '\"')
{
- warns(_("expected string constant instead of %s"),
- token_buffer);
+ complain (_("expected string constant instead of %s"),
+ token_buffer);
skip_to_char('%');
return;
}
}
-/* parse what comes after %start */
+/* Parse what comes after %start */
-void
+static void
parse_start_decl (void)
{
if (start_flag)
- warn(_("multiple %start declarations"));
- if (lex() != IDENTIFIER)
- warn(_("invalid %start declaration"));
+ complain (_("multiple %s declarations"), "%start");
+ if (lex () != IDENTIFIER)
+ complain (_("invalid %s declaration"), "%start");
else
{
start_flag = 1;
/* read in a %type declaration and record its information for get_type_name to access */
-void
+static void
parse_type_decl (void)
{
register int k;
if (lex() != TYPENAME)
{
- warn(_("%type declaration has no <typename>"));
+ complain ("%s", _("%type declaration has no <typename>"));
skip_to_char('%');
return;
}
if (tmp_char == '%')
return;
if (tmp_char == EOF)
- fatals ("Premature EOF after %s", token_buffer);
+ fatal (_("Premature EOF after %s"), token_buffer);
t = lex();
if (symval->type_name == NULL)
symval->type_name = name;
else if (strcmp(name, symval->type_name) != 0)
- warns(_("type redeclaration for %s"), symval->tag);
+ complain (_("type redeclaration for %s"), symval->tag);
break;
default:
- warns(_("invalid %%type declaration due to item: `%s'"), token_buffer);
+ complain (_("invalid %%type declaration due to item: %s"),
+ token_buffer);
skip_to_char('%');
}
}
/* read in a %left, %right or %nonassoc declaration and record its information. */
/* assoc is either LEFT_ASSOC, RIGHT_ASSOC or NON_ASSOC. */
-void
+static void
parse_assoc_decl (int assoc)
{
register int k;
if (tmp_char == '%')
return;
if (tmp_char == EOF)
- fatals ("Premature EOF after %s", token_buffer);
+ fatal (_("Premature EOF after %s"), token_buffer);
t = lex();
case IDENTIFIER:
if (symval->prec != 0)
- warns(_("redefining precedence of %s"), symval->tag);
+ complain (_("redefining precedence of %s"), symval->tag);
symval->prec = lastprec;
symval->assoc = assoc;
if (symval->class == SNTERM)
- warns(_("symbol %s redefined"), symval->tag);
+ complain (_("symbol %s redefined"), symval->tag);
symval->class = STOKEN;
if (name)
{ /* record the type, if one is specified */
if (symval->type_name == NULL)
symval->type_name = name;
else if (strcmp(name, symval->type_name) != 0)
- warns(_("type redeclaration for %s"), symval->tag);
+ complain (_("type redeclaration for %s"), symval->tag);
}
break;
}
else
{
- warns(_("invalid text (%s) - number should be after identifier"),
+ complain (_("invalid text (%s) - number should be after identifier"),
token_buffer);
skip_to_char('%');
}
return;
default:
- warns(_("unexpected item: %s"), token_buffer);
+ complain (_("unexpected item: %s"), token_buffer);
skip_to_char('%');
}
where it is made into the
definition of YYSTYPE, the type of elements of the parser value stack. */
-void
+static void
parse_union_decl (void)
{
register int c;
- register int count;
- register int in_comment;
- int cplus_comment;
+ register int count = 0;
if (typed)
- warn(_("multiple %union declarations"));
+ complain (_("multiple %s declarations"), "%union");
typed = 1;
if (!nolinesflag)
- fprintf(fattrs, "\n#line %d \"%s\"\n", lineno, infile);
+ fprintf (fattrs, "\n#line %d \"%s\"\n", lineno, infile);
else
- fprintf(fattrs, "\n");
+ fprintf (fattrs, "\n");
- fprintf(fattrs, "typedef union");
+ fprintf (fattrs, "typedef union");
if (fdefines)
- fprintf(fdefines, "typedef union");
-
- count = 0;
- in_comment = 0;
+ fprintf (fdefines, "typedef union");
- c = getc(finput);
+ c = getc (finput);
while (c != EOF)
{
- putc(c, fattrs);
+ putc (c, fattrs);
if (fdefines)
- putc(c, fdefines);
+ putc (c, fdefines);
switch (c)
{
break;
case '/':
- c = getc(finput);
+ c = getc (finput);
if (c != '*' && c != '/')
- ungetc(c, finput);
- else
- {
- putc(c, fattrs);
- if (fdefines)
- putc(c, fdefines);
- cplus_comment = (c == '/');
- in_comment = 1;
- c = getc(finput);
- while (in_comment)
- {
- putc(c, fattrs);
- if (fdefines)
- putc(c, fdefines);
-
- if (c == '\n')
- {
- lineno++;
- if (cplus_comment)
- {
- in_comment = 0;
- break;
- }
- }
- if (c == EOF)
- fatal(_("unterminated comment at end of file"));
-
- if (!cplus_comment && c == '*')
- {
- c = getc(finput);
- if (c == '/')
- {
- putc('/', fattrs);
- if (fdefines)
- putc('/', fdefines);
- in_comment = 0;
- }
- }
- else
- c = getc(finput);
- }
- }
+ continue;
+ copy_comment2 (finput, fattrs, fdefines, c);
break;
case '}':
if (count == 0)
- warn (_("unmatched close-brace (`}')"));
+ complain (_("unmatched %s"), "`}'");
count--;
if (count <= 0)
{
- fprintf(fattrs, " YYSTYPE;\n");
+ fprintf (fattrs, " YYSTYPE;\n");
if (fdefines)
- fprintf(fdefines, " YYSTYPE;\n");
+ fprintf (fdefines, " YYSTYPE;\n");
/* JF don't choke on trailing semi */
- c=skip_white_space();
- if(c!=';') ungetc(c,finput);
+ c = skip_white_space ();
+ if (c != ';')
+ ungetc (c,finput);
return;
}
}
- c = getc(finput);
+ c = getc (finput);
}
}
/* parse the declaration %expect N which says to expect N
shift-reduce conflicts. */
-void
+static void
parse_expect_decl (void)
{
register int c;
ungetc (c, finput);
if (count <= 0 || count > 10)
- warn(_("argument of %expect is not an integer"));
+ complain ("%s", _("argument of %expect is not an integer"));
expected_conflicts = atoi (buffer);
}
/* that's all of parsing the declaration section */
\f
-/* Get the data type (alternative in the union) of the value for symbol n in rule rule. */
+/* FIN is pointing to a location (i.e., a `@'). Output to FOUT
+ a reference to this location. 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_at (FILE *fin, FILE *fout, int stack_offset)
+{
+ int c;
+
+ c = getc (fin);
+ if (c == '$')
+ {
+ fprintf (fout, "yyloc");
+ yylsp_needed = 1;
+ }
+ else if (isdigit(c) || c == '-')
+ {
+ int n;
-char *
+ ungetc (c, fin);
+ n = read_signed_integer (fin);
+
+ fprintf (fout, "yylsp[%d]", n - stack_offset);
+ yylsp_needed = 1;
+ }
+ else
+ complain (_("@%s is invalid"), printable_version (c));
+}
+
+
+/* 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)
{
- static char *msg = N_("invalid $ value");
-
register int i;
register symbol_list *rp;
if (n < 0)
{
- warn(_(msg));
+ complain (_("invalid $ value"));
return NULL;
}
rp = rp->next;
if (rp == NULL || rp->sym == NULL)
{
- warn(_(msg));
+ 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 "). */
-
-void
-copy_string (FILE *finput, FILE *foutput, int match)
-{
- int c;
-
- putc (match, foutput);
- c = getc (finput);
-
- while (c != match)
- {
- if (c == EOF)
- fatal(_("unterminated string at end of file"));
- if (c == '\n')
- {
- warn (_("unterminated string"));
- ungetc (c, finput);
- c = match; /* invent terminator */
- continue;
- }
-
- putc(c, foutput);
-
- if (c == '\\')
- {
- c = getc (finput);
- if (c == EOF)
- fatal (_("unterminated string"));
- putc (c, foutput);
- if (c == '\n')
- lineno++;
- }
-
- c = getc(finput);
- }
-
- putc(c, foutput);
+ return rp->sym->type_name;
}
-/* Dump the comment from FINPUT to FOUTPUT. C is either `*' or `/',
- depending upon the type of comments used. */
-
-void
-copy_comment (FILE *finput, FILE *foutput, int c)
-{
- int cplus_comment;
- register int match;
- register int ended;
-
- cplus_comment = (c == '/');
- putc (c, foutput);
- c = getc (finput);
-
- ended = 0;
- while (!ended)
- {
- if (!cplus_comment && c == '*')
- {
- while (c == '*')
- {
- putc(c, foutput);
- c = getc(finput);
- }
-
- if (c == '/')
- {
- putc(c, foutput);
- ended = 1;
- }
- }
- else if (c == '\n')
- {
- lineno++;
- putc (c, foutput);
- if (cplus_comment)
- ended = 1;
- else
- c = getc(finput);
- }
- else if (c == EOF)
- fatal (_("unterminated comment"));
- else
- {
- putc (c, foutput);
- c = getc (finput);
- }
- }
-}
/* After `%guard' is seen in the input file, copy the actual guard
into the guards file. If the guard is followed by an action, copy
respect to the top of the stack, for the simple parser in which the
stack is not popped until after the guard is run. */
-void
+static void
copy_guard (symbol_list *rule, int stack_offset)
{
register int c;
count--;
else
{
- warn(_("unmatched right brace (`}')"));
+ complain (_("unmatched %s"), "`}'");
c = getc(finput); /* skip it */
}
break;
if (type_name)
fprintf(fguard, ".%s", type_name);
if(!type_name && typed)
- warns(_("$$ of `%s' has no declared type"), rule->sym->tag);
+ complain (_("$$ of `%s' has no declared type"),
+ rule->sym->tag);
}
else if (isdigit(c) || c == '-')
{
if (type_name)
fprintf(fguard, ".%s", type_name);
if (!type_name && typed)
- warnss (_("$%s of `%s' has no declared type"),
- int_to_string(n), rule->sym->tag);
+ complain (_("$%d of `%s' has no declared type"),
+ n, rule->sym->tag);
continue;
}
else
- warns(_("$%s is invalid"), printable_version(c));
+ complain (_("$%s is invalid"), printable_version (c));
break;
case '@':
- c = getc (finput);
- if (c == '$')
- {
- fprintf (fguard, "yyloc");
- yylsp_needed = 1;
- }
- else if (isdigit(c) || c == '-')
- {
- ungetc (c, finput);
- n = read_signed_integer (finput);
- c = getc (finput);
- fprintf (fguard, "yylsp[%d]", n - stack_offset);
- yylsp_needed = 1;
- continue;
- }
- else
- {
- warns (_("@%s is invalid"), printable_version (c));
- n = 1;
- }
+ copy_at (finput, fguard, stack_offset);
break;
case EOF:
- fatal (_("unterminated %%guard clause"));
+ fatal ("%s",
+ _("unterminated %guard clause"));
default:
putc (c, fguard);
fprintf(fguard, ";\n break;}");
if (c == '{')
- copy_action(rule, stack_offset);
+ copy_action (rule, stack_offset);
else if (c == '=')
{
c = getc(finput); /* why not skip_white_space -wjh */
if (c == '{')
- copy_action(rule, stack_offset);
+ copy_action (rule, stack_offset);
}
else
ungetc(c, finput);
values in the current rule so far, which says where to find `$0'
with respect to the top of the stack. */
-void
+static void
copy_action (symbol_list *rule, int stack_offset)
{
register int c;
break;
case '/':
- putc(c, faction);
- c = getc(finput);
+ putc (c, faction);
+ c = getc (finput);
if (c != '*' && c != '/')
continue;
copy_comment (finput, faction, c);
if (type_name)
fprintf(faction, ".%s", type_name);
if(!type_name && typed)
- warns(_("$$ of `%s' has no declared type"),
- rule->sym->tag);
+ complain (_("$$ of `%s' has no declared type"),
+ rule->sym->tag);
}
else if (isdigit(c) || c == '-')
{
if (type_name)
fprintf(faction, ".%s", type_name);
if(!type_name && typed)
- warnss(_("$%s of `%s' has no declared type"),
- int_to_string(n), rule->sym->tag);
+ complain (_("$%d of `%s' has no declared type"),
+ n, rule->sym->tag);
continue;
}
else
- warns(_("$%s is invalid"), printable_version(c));
+ complain (_("$%s is invalid"), printable_version (c));
break;
case '@':
- c = getc (finput);
- if (c == '$')
- {
- fprintf (faction, "yyloc");
- yylsp_needed = 1;
- }
- else if (isdigit(c) || c == '-')
- {
- ungetc (c, finput);
- n = read_signed_integer (finput);
- c = getc (finput);
- fprintf (faction, "yylsp[%d]", n - stack_offset);
- yylsp_needed = 1;
- continue;
- }
- else
- {
- warns (_("@%s is invalid"), printable_version (c));
- n = 1;
- }
+ copy_at (finput, faction, stack_offset);
break;
case EOF:
- fatal(_("unmatched `{'"));
+ fatal (_("unmatched %s"), "`{'");
default:
putc(c, faction);
/* generate a dummy symbol, a nonterminal,
whose name cannot conflict with the user's names. */
-bucket *
+static bucket *
gensym (void)
{
register bucket *sym;
sym = getsym(token_buffer);
sym->class = SNTERM;
sym->value = nvars++;
- return (sym);
+ return sym;
}
/* Parse the input grammar into a one symbol_list structure.
All guards and actions are copied out to the appropriate files,
labelled by the rule number they apply to. */
-void
+static void
readgram (void)
{
register int t;
t = lex();
if (t != COLON)
{
- warn(_("ill-formed rule: initial symbol not followed by colon"));
+ complain (_("ill-formed rule: initial symbol not followed by colon"));
unlex(t);
}
}
if (nrules == 0 && t == BAR)
{
- warn(_("grammar starts with vertical bar"));
+ complain (_("grammar starts with vertical bar"));
lhs = symval; /* BOGUS: use a random symval */
}
/* start a new rule and record its lhs. */
nvars++;
}
else if (lhs->class == STOKEN)
- warns(_("rule given for %s, which is a token"), lhs->tag);
+ complain (_("rule given for %s, which is a token"), lhs->tag);
/* read the rhs of the rule. */
if (t == PREC)
{
- warn(_("two @prec's in a row"));
+ complain (_("two @prec's in a row"));
t = lex();
crule->ruleprec = symval;
t = lex();
if (t == GUARD)
{
if (! semantic_parser)
- warn(_("%%guard present but %%semantic_parser not specified"));
+ complain ("%s",
+ _("%guard present but %semantic_parser not specified"));
copy_guard(crule, rulelength);
t = lex();
{
/* This case never occurs -wjh */
if (actionflag)
- warn(_("two actions at end of one rule"));
+ complain (_("two actions at end of one rule"));
copy_action(crule, rulelength);
actionflag = 1;
xactions++; /* -wjh */
t = lex();
}
- /* If $$ is being set in default way, warn if any type
+ /* If $$ is being set in default way, report if any type
mismatch. */
else if (!xactions
&& first_rhs
if (lhs->type_name == 0
|| first_rhs->type_name == 0
|| strcmp(lhs->type_name,first_rhs->type_name))
- warnss(_("type clash (`%s' `%s') on default action"),
- lhs->type_name ? lhs->type_name : "",
- first_rhs->type_name ? first_rhs->type_name : "");
+ complain (_("type clash (`%s' `%s') on default action"),
+ lhs->type_name ? lhs->type_name : "",
+ first_rhs->type_name ? first_rhs->type_name : "");
}
/* Warn if there is no default for $$ but we need one. */
else if (!xactions && !first_rhs && lhs->type_name != 0)
- warn(_("empty rule for typed nonterminal, and no action"));
+ complain (_("empty rule for typed nonterminal, and no action"));
if (t == SEMICOLON)
t = lex();
}
else
{
- warns(_("invalid input: %s"), token_buffer);
+ complain (_("invalid input: %s"), token_buffer);
t = lex();
}
}
/* grammar has been read. Do some checking */
if (nsyms > MAXSHORT)
- fatals(_("too many symbols (tokens plus nonterminals); maximum %s"),
- int_to_string(MAXSHORT));
+ fatal (_("too many symbols (tokens plus nonterminals); maximum %d"),
+ MAXSHORT);
if (nrules == 0)
- fatal(_("no rules in the input grammar"));
+ fatal (_("no rules in the input grammar"));
if (typed == 0 /* JF put out same default YYSTYPE as YACC does */
&& !value_components_used)
for (bp = firstsymbol; bp; bp = bp->next)
if (bp->class == SUNKNOWN)
{
- warns(_("symbol %s is used, but is not defined as a token and has no rules"),
- bp->tag);
+ complain (_("symbol %s is used, but is not defined as a token and has no rules"),
+ bp->tag);
bp->class = SNTERM;
bp->value = nvars++;
}
}
-void
+static void
record_rule_line (void)
{
/* Record each rule's source line number in rline table. */
if (t != TYPENAME)
{
- warn(_("ill-formed %type declaration"));
+ complain (_("invalid %s declaration"), "%type");
return t;
}
switch (t)
{
case SEMICOLON:
- return (lex());
+ return lex();
case COMMA:
break;
if (symval->type_name == NULL)
symval->type_name = name;
else if (strcmp(name, symval->type_name) != 0)
- warns(_("type redeclaration for %s"), symval->tag);
+ complain (_("type redeclaration for %s"), symval->tag);
break;
default:
- return (t);
+ return t;
}
}
}
fdefines. Set up vectors tags and sprec of names and precedences
of symbols. */
-void
+static void
packsymbols (void)
{
register bucket *bp;
register int tokno = 1;
register int i;
register int last_user_token_number;
+ static char DOLLAR[] = "$";
/* int lossage = 0; JF set but not used */
tags = NEW2(nsyms + 1, char *);
- tags[0] = "$";
+ tags[0] = DOLLAR;
user_toknums = NEW2(nsyms + 1, int);
user_toknums[0] = 0;
{
if (bp->prec != 0 && bp->alias->prec != 0
&& bp->user_token_number == SALIAS)
- warnss(_("conflicting precedences for %s and %s"),
- bp->tag, bp->alias->tag);
+ complain (_("conflicting precedences for %s and %s"),
+ bp->tag, bp->alias->tag);
if (bp->prec != 0)
bp->alias->prec = bp->prec;
else
if (bp->assoc != bp->alias->assoc)
{
- if (bp->assoc != 0 && bp->alias->assoc != 0
- && bp->user_token_number == SALIAS)
- warnss(_("conflicting assoc values for %s and %s"),
- bp->tag, bp->alias->tag);
- if (bp->assoc != 0)
- bp->alias->assoc = bp->assoc;
- else
- bp->assoc = bp->alias->assoc;
- }
+ if (bp->assoc != 0 && bp->alias->assoc != 0
+ && bp->user_token_number == SALIAS)
+ complain (_("conflicting assoc values for %s and %s"),
+ bp->tag, bp->alias->tag);
+ if (bp->assoc != 0)
+ bp->alias->assoc = bp->assoc;
+ else
+ bp->assoc = bp->alias->assoc;
+ }
if (bp->user_token_number == SALIAS)
continue; /* do not do processing below for SALIASs */
if (translations)
{
- register int i;
+ register int j;
token_translations = NEW2(max_user_token_number+1, short);
/* initialize all entries for literal tokens to 2, the internal
token number for $undefined., which represents all invalid
inputs. */
- for (i = 0; i <= max_user_token_number; i++)
- token_translations[i] = 2;
+ for (j = 0; j <= max_user_token_number; j++)
+ token_translations[j] = 2;
for (bp = firstsymbol; bp; bp = bp->next)
{
if (bp->user_token_number == SALIAS)
continue;
if (token_translations[bp->user_token_number] != 2)
- warnsss(_("tokens %s and %s both assigned number %s"),
- tags[token_translations[bp->user_token_number]],
- bp->tag,
- int_to_string(bp->user_token_number));
+ complain (_("tokens %s and %s both assigned number %d"),
+ tags[token_translations[bp->user_token_number]],
+ bp->tag,
+ bp->user_token_number);
token_translations[bp->user_token_number] = bp->value;
}
}
output_token_defines(ftable);
if (startval->class == SUNKNOWN)
- fatals(_("the start symbol %s is undefined"), startval->tag);
+ fatal (_("the start symbol %s is undefined"), startval->tag);
else if (startval->class == STOKEN)
- fatals(_("the start symbol %s is a token"), startval->tag);
+ fatal (_("the start symbol %s is a token"), startval->tag);
start_symbol = startval->value;
/* For named tokens, but not literal ones, define the name. The value
is the user token number. */
-void
+static void
output_token_defines (FILE *file)
{
bucket *bp;
while ((c = *cp++) && c != '.');
if (c != '\0') continue;
- fprintf(file, "#define\t%s\t%d\n", symbol,
- ((translations && ! rawtoknumflag)
- ? bp->user_token_number
- : bp->value));
+ fprintf (file, "#define\t%s\t%d\n", symbol,
+ ((translations && ! rawtoknumflag)
+ ? bp->user_token_number
+ : bp->value));
if (semantic_parser)
- fprintf(file, "#define\tT%s\t%d\n", symbol, bp->value);
+ fprintf (file, "#define\tT%s\t%d\n", symbol, bp->value);
}
putc('\n', file);
/* convert the rules into the representation using rrhs, rlhs and ritems. */
-void
+static void
packgram (void)
{
register int itemno;
ritem[itemno] = 0;
}
-\f
-/* Read a signed integer from STREAM and return its value. */
-
-int
-read_signed_integer (FILE *stream)
-{
- register int c = getc(stream);
- register int sign = 1;
- register int n;
-
- if (c == '-')
- {
- c = getc(stream);
- sign = -1;
- }
- n = 0;
- while (isdigit(c))
- {
- n = 10*n + (c - '0');
- c = getc(stream);
- }
-
- ungetc(c, stream);
-
- return n * sign;
-}
projects / bison.git / blobdiff