#include "system.h"
#include "getargs.h"
#include "files.h"
-#include "getopt.h" /* for optarg */
#include "symtab.h"
#include "options.h"
#include "lex.h"
-#include "xalloc.h"
#include "complain.h"
#include "gram.h"
#include "quote.h"
/* Buffer for storing the current token. */
-struct obstack token_obstack;
+static struct obstack token_obstack;
const char *token_buffer = NULL;
-bucket *symval;
+symbol_t *symval = NULL;
int numval;
-static int unlexed; /* these two describe a token to be reread */
-static bucket *unlexed_symval; /* by the next call to lex */
-
+/* A token to be reread, see unlex and lex. */
+static token_t unlexed = tok_undef;
+static symbol_t *unlexed_symval = NULL;
+static const char *unlexed_token_buffer = NULL;
void
-init_lex (void)
+lex_init (void)
{
obstack_init (&token_obstack);
- unlexed = -1;
+ unlexed = tok_undef;
+}
+
+
+void
+lex_free (void)
+{
+ obstack_free (&token_obstack, NULL);
}
| Do a getc, but give error message if EOF encountered |
`-----------------------------------------------------*/
-static int
+int
xgetc (FILE *f)
{
int c = getc (f);
}
-/*------------------------------------------------------------------.
-| Read one literal character from finput. Process \ escapes. |
-| Append the normalized string version of the char to OUT. Assign |
-| the character code to *PCODE. Return 1 unless the character is an |
-| unescaped `term' or \n report error for \n. |
-`------------------------------------------------------------------*/
-
-/* FIXME: We could directly work in the obstack, but that would make
- it more difficult to move to quotearg some day. So for the time
- being, I prefer have literalchar behave like quotearg, and change
- my mind later if I was wrong. */
+/*---------------------------------------------------------------.
+| Read one literal character from FINPUT, process \-escapes, and |
+| return the character. |
+`---------------------------------------------------------------*/
-static int
-literalchar (struct obstack *out, int *pcode, char term)
+char
+literalchar (void)
{
int c;
- char buf[4096];
- char *cp;
- int code;
- int wasquote = 0;
+ int res;
c = xgetc (finput);
if (c == '\n')
{
complain (_("unescaped newline in constant"));
ungetc (c, finput);
- code = '?';
- wasquote = 1;
+ res = '?';
}
else if (c != '\\')
{
- code = c;
- if (c == term)
- wasquote = 1;
+ res = c;
}
else
{
c = xgetc (finput);
if (c == 't')
- code = '\t';
+ res = '\t';
else if (c == 'n')
- code = '\n';
+ res = '\n';
else if (c == 'a')
- code = '\007';
+ res = '\007';
else if (c == 'r')
- code = '\r';
+ res = '\r';
else if (c == 'f')
- code = '\f';
+ res = '\f';
else if (c == 'b')
- code = '\b';
+ res = '\b';
else if (c == 'v')
- code = '\013';
+ res = '\013';
else if (c == '\\')
- code = '\\';
+ res = '\\';
else if (c == '\'')
- code = '\'';
+ res = '\'';
else if (c == '\"')
- code = '\"';
+ res = '\"';
else if (c <= '7' && c >= '0')
{
- code = 0;
+ res = 0;
while (c <= '7' && c >= '0')
{
- code = (code * 8) + (c - '0');
- if (code >= 256 || code < 0)
+ res = (res * 8) + (c - '0');
+ if (res >= 256 || res < 0)
{
complain (_("octal value outside range 0...255: `\\%o'"),
- code);
- code &= 0xFF;
+ res);
+ res &= 0xFF;
break;
}
c = xgetc (finput);
else if (c == 'x')
{
c = xgetc (finput);
- code = 0;
+ res = 0;
while (1)
{
if (c >= '0' && c <= '9')
- code *= 16, code += c - '0';
+ res *= 16, res += c - '0';
else if (c >= 'a' && c <= 'f')
- code *= 16, code += c - 'a' + 10;
+ res *= 16, res += c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
- code *= 16, code += c - 'A' + 10;
+ res *= 16, res += c - 'A' + 10;
else
break;
- if (code >= 256 || code < 0)
+ if (res >= 256 || res < 0)
{
- complain (_("hexadecimal value above 255: `\\x%x'"), code);
- code &= 0xFF;
+ complain (_("hexadecimal value above 255: `\\x%x'"), res);
+ res &= 0xFF;
break;
}
c = xgetc (finput);
badchar[0] = c;
complain (_("unknown escape sequence: `\\' followed by `%s'"),
quote (badchar));
- code = '?';
+ res = '?';
}
} /* has \ */
- /* now fill BUF with the canonical name for this character as a
- literal token. Do not use what the user typed, so that `\012'
- and `\n' can be interchangeable. */
-
- cp = buf;
- if (code == term && wasquote)
- *cp++ = code;
- else if (code == '\\')
- {
- *cp++ = '\\';
- *cp++ = '\\';
- }
- else if (code == '\'')
- {
- *cp++ = '\\';
- *cp++ = '\'';
- }
- else if (code == '\"')
- {
- *cp++ = '\\';
- *cp++ = '\"';
- }
- else if (code >= 040 && code < 0177)
- *cp++ = code;
- else if (code == '\t')
- {
- *cp++ = '\\';
- *cp++ = 't';
- }
- else if (code == '\n')
- {
- *cp++ = '\\';
- *cp++ = 'n';
- }
- else if (code == '\r')
- {
- *cp++ = '\\';
- *cp++ = 'r';
- }
- else if (code == '\v')
- {
- *cp++ = '\\';
- *cp++ = 'v';
- }
- else if (code == '\b')
- {
- *cp++ = '\\';
- *cp++ = 'b';
- }
- else if (code == '\f')
- {
- *cp++ = '\\';
- *cp++ = 'f';
- }
- else
- {
- *cp++ = '\\';
- *cp++ = code / 0100 + '0';
- *cp++ = ((code / 010) & 07) + '0';
- *cp++ = (code & 07) + '0';
- }
- *cp = '\0';
-
- if (out)
- obstack_sgrow (out, buf);
- *pcode = code;
- return !wasquote;
+ return res;
}
void
-unlex (int token)
+unlex (token_t token)
{
unlexed = token;
+ unlexed_token_buffer = token_buffer;
unlexed_symval = symval;
}
/* Just to make sure. */
token_buffer = NULL;
- if (unlexed >= 0)
+ if (unlexed != tok_undef)
{
+ token_t res = unlexed;
symval = unlexed_symval;
- c = unlexed;
- unlexed = -1;
- return c;
+ token_buffer = unlexed_token_buffer;
+ unlexed = tok_undef;
+ return res;
}
c = skip_white_space ();
case '\'':
/* parse the literal token and compute character code in code */
- translations = -1;
{
- int code, discode;
+ int code = literalchar ();
obstack_1grow (&token_obstack, '\'');
- literalchar (&token_obstack, &code, '\'');
+ obstack_1grow (&token_obstack, code);
c = getc (finput);
if (c != '\'')
{
complain (_("use \"...\" for multi-character literal tokens"));
- while (1)
- if (!literalchar (0, &discode, '\''))
- break;
+ while (literalchar () != '\'')
+ /* Skip. */;
}
obstack_1grow (&token_obstack, '\'');
obstack_1grow (&token_obstack, '\0');
token_buffer = obstack_finish (&token_obstack);
symval = getsym (token_buffer);
- symval->class = token_sym;
- if (!symval->user_token_number)
- symval->user_token_number = code;
+ if (symval->number == NUMBER_UNDEFINED)
+ {
+ symval->number = ntokens++;
+ symval->class = token_sym;
+ if (symval->user_token_number == SUNDEF)
+ symval->user_token_number = code;
+ }
return tok_identifier;
}
case '\"':
/* parse the literal string token and treat as an identifier */
- translations = -1;
{
int code; /* ignored here */
obstack_1grow (&token_obstack, '\"');
/* Read up to and including ". */
- while (literalchar (&token_obstack, &code, '\"'))
- /* nothing */;
+ do
+ {
+ code = literalchar ();
+ obstack_1grow (&token_obstack, code);
+ }
+ while (code != '\"');
obstack_1grow (&token_obstack, '\0');
token_buffer = obstack_finish (&token_obstack);
symval = getsym (token_buffer);
- symval->class = token_sym;
+ if (symval->number == NUMBER_UNDEFINED)
+ {
+ symval->number = ntokens++;
+ symval->class = token_sym;
+ }
return tok_identifier;
}
case ',':
+ token_buffer = ",";
return tok_comma;
case ':':
+ token_buffer = ":";
return tok_colon;
case ';':
+ token_buffer = ";";
return tok_semicolon;
case '|':
+ token_buffer = "|";
return tok_bar;
case '{':
+ token_buffer = "{";
return tok_left_curly;
case '=':
+ obstack_1grow (&token_obstack, c);
do
{
c = getc (finput);
+ obstack_1grow (&token_obstack, c);
if (c == '\n')
lineno++;
}
while (c == ' ' || c == '\n' || c == '\t');
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
if (c == '{')
{
- token_buffer = "={";
return tok_left_curly;
}
else
return parse_percent_token ();
default:
+ obstack_1grow (&token_obstack, c);
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
return tok_illegal;
}
}
static int
option_strcmp (const char *left, const char *right)
{
- const unsigned char *l, *r;
- int c;
-
- assert(left != NULL && right != NULL);
- l = (const unsigned char *)left;
- r = (const unsigned char *)right;
- while (((c = *l - *r++) == 0 && *l != '\0')
- || ((*l == '-' || *l == '_') && (*r == '_' || *r == '-')))
- l++;
- return c;
+ const unsigned char *l, *r;
+ int c;
+
+ assert (left);
+ assert (right);
+ l = (const unsigned char *)left;
+ r = (const unsigned char *)right;
+ while (((c = *l - *r++) == 0 && *l != '\0')
+ || ((*l == '-' || *l == '_') && (*r == '_' || *r == '-')))
+ l++;
+ return c;
}
/* Parse a token which starts with %.
Assumes the % has already been read and discarded. */
-int
+token_t
parse_percent_token (void)
{
- int c;
- const struct option_table_struct *tx;
+ const struct option_table_struct *tx = NULL;
+ const char *arg = NULL;
+ /* Where the ARG was found in token_buffer. */
+ size_t arg_offset = 0;
- c = getc (finput);
+ int c = getc (finput);
+ obstack_1grow (&token_obstack, '%');
+ obstack_1grow (&token_obstack, c);
- switch (c)
+ if (!isalpha (c))
{
- case '%':
- return tok_two_percents;
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
- case '{':
- return tok_percent_left_curly;
+ switch (c)
+ {
+ case '%':
+ return tok_two_percents;
- case '<':
- return tok_left;
+ case '{':
+ return tok_percent_left_curly;
- case '>':
- return tok_right;
+ /* The following guys are here for backward compatibility with
+ very ancient Yacc versions. The paper of Johnson mentions
+ them (as ancient :). */
+ case '<':
+ return tok_left;
- case '2':
- return tok_nonassoc;
+ case '>':
+ return tok_right;
- case '0':
- return tok_token;
+ case '2':
+ return tok_nonassoc;
- case '=':
- return tok_prec;
- }
+ case '0':
+ return tok_token;
- if (!isalpha (c))
- return tok_illegal;
+ case '=':
+ return tok_prec;
- obstack_1grow (&token_obstack, '%');
- while (isalpha (c) || c == '_' || c == '-')
+ default:
+ return tok_illegal;
+ }
+ }
+
+ while (c = getc (finput), isalpha (c) || c == '_' || c == '-')
{
if (c == '_')
c = '-';
obstack_1grow (&token_obstack, c);
+ }
+
+ /* %DIRECTIVE="ARG". Separate into
+ TOKEN_BUFFER = `%DIRECTIVE\0ARG\0'.
+ This is a bit hackish, but once we move to a Bison parser,
+ things will be cleaned up. */
+ if (c == '=')
+ {
+ /* End of the directive. We skip the `='. */
+ obstack_1grow (&token_obstack, '\0');
+ /* Fetch the ARG if present. */
c = getc (finput);
+ if (c == '"')
+ {
+ int code;
+ arg_offset = obstack_object_size (&token_obstack);
+ /* Read up to and including `"'. Do not append the closing
+ `"' in the output: it's not part of the ARG. */
+ while ((code = literalchar ()) != '"')
+ obstack_1grow (&token_obstack, code);
+ }
+ /* else: should be an error. */
}
+ else
+ ungetc (c, finput);
- ungetc (c, finput);
obstack_1grow (&token_obstack, '\0');
token_buffer = obstack_finish (&token_obstack);
+ if (arg_offset)
+ arg = token_buffer + arg_offset;
/* table lookup % directive */
for (tx = option_table; tx->name; tx++)
&& option_strcmp (token_buffer + 1, tx->name) == 0)
break;
- if (tx->set_flag)
- {
- *((int *) (tx->set_flag)) = 1;
- return tok_noop;
- }
+ if (arg && tx->ret_val != tok_stropt)
+ fatal (_("`%s' supports no argument: %s"), token_buffer, quote (arg));
+
switch (tx->ret_val)
{
- case tok_setopt:
- *((char **) (tx->set_flag)) = optarg;
+ case tok_stropt:
+ assert (tx->set_flag);
+ if (arg)
+ {
+ /* Keep only the first assignment: command line options have
+ already been processed, and we want them to have
+ precedence. Side effect: if this %-option is used
+ several times, only the first is honored. Bah. */
+ if (!*((char **) (tx->set_flag)))
+ *((char **) (tx->set_flag)) = xstrdup (arg);
+ }
+ else
+ fatal (_("`%s' requires an argument"), token_buffer);
+ return tok_noop;
+ break;
+
+ case tok_intopt:
+ assert (tx->set_flag);
+ *((int *) (tx->set_flag)) = 1;
return tok_noop;
break;
case tok_obsolete:
fatal (_("`%s' is no longer supported"), token_buffer);
+ return tok_noop;
break;
- }
- return tx->ret_val;
+ default:
+ return tx->ret_val;
+ break;
+ }
+ abort ();
}
projects / bison.git / blobdiff