/* Token-reader for Bison's input parser,
- Copyright (C) 1984, 1986, 1989, 1992, 2000 Free Software Foundation, Inc.
+ Copyright 1984, 1986, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
-/*
- lex is the entry point. It is called from reader.c.
- It returns one of the token-type codes defined in lex.h.
- When an identifier is seen, the code IDENTIFIER is returned
- and the name is looked up in the symbol table using symtab.c;
- symval is set to a pointer to the entry found. */
-
-#include <stdio.h>
#include "system.h"
+#include "getargs.h"
#include "files.h"
-#include "getopt.h" /* for optarg */
#include "symtab.h"
+#include "options.h"
#include "lex.h"
-#include "alloc.h"
#include "complain.h"
-
-/* flags set by % directives */
-extern int definesflag; /* for -d */
-extern int toknumflag; /* for -k */
-extern int noparserflag; /* for -n */
-extern int fixed_outfiles; /* for -y */
-extern int nolinesflag; /* for -l */
-extern int rawtoknumflag; /* for -r */
-extern int verboseflag; /* for -v */
-extern int debugflag; /* for -t */
-extern char *spec_name_prefix; /* for -p */
-extern char *spec_file_prefix; /* for -b */
-/*spec_outfile is declared in files.h, for -o */
-
-extern int translations;
-
-void init_lex PARAMS((void));
-char *grow_token_buffer PARAMS((char *));
-int skip_white_space PARAMS((void));
-int safegetc PARAMS((FILE *));
-int literalchar PARAMS((char **, int *, char));
-void unlex PARAMS((int));
-int lex PARAMS((void));
-int parse_percent_token PARAMS((void));
-
-/* functions from main.c */
-extern char *printable_version PARAMS((int));
+#include "gram.h"
+#include "quote.h"
/* Buffer for storing the current token. */
-char *token_buffer;
+static struct obstack token_obstack;
+const char *token_buffer = NULL;
-/* Allocated size of token_buffer, not including space for terminator. */
-int maxtoken;
-
-bucket *symval;
+bucket *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 bucket *unlexed_symval = NULL;
+static const char *unlexed_token_buffer = NULL;
void
-init_lex (void)
+lex_init (void)
{
- maxtoken = 100;
- token_buffer = NEW2 (maxtoken + 1, char);
- unlexed = -1;
+ obstack_init (&token_obstack);
+ unlexed = tok_undef;
}
-char *
-grow_token_buffer (char *p)
+void
+lex_free (void)
{
- int offset = p - token_buffer;
- maxtoken *= 2;
- token_buffer = (char *) xrealloc(token_buffer, maxtoken + 1);
- return token_buffer + offset;
+ obstack_free (&token_obstack, NULL);
}
int
skip_white_space (void)
{
- register int c;
- register int inside;
+ int c;
+ int inside;
- c = getc(finput);
+ c = getc (finput);
for (;;)
{
switch (c)
{
case '/':
- c = getc(finput);
+ /* FIXME: Should probably be merged with copy_comment. */
+ c = getc (finput);
if (c != '*' && c != '/')
{
complain (_("unexpected `/' found and ignored"));
}
cplus_comment = (c == '/');
- c = getc(finput);
+ c = getc (finput);
inside = 1;
while (inside)
if (!cplus_comment && c == '*')
{
while (c == '*')
- c = getc(finput);
+ c = getc (finput);
if (c == '/')
{
inside = 0;
- c = getc(finput);
+ c = getc (finput);
}
}
else if (c == '\n')
lineno++;
if (cplus_comment)
inside = 0;
- c = getc(finput);
+ c = getc (finput);
}
else if (c == EOF)
fatal (_("unterminated comment"));
else
- c = getc(finput);
+ c = getc (finput);
}
break;
case ' ':
case '\t':
case '\f':
- c = getc(finput);
+ c = getc (finput);
break;
default:
}
}
-/* do a getc, but give error message if EOF encountered */
+
+/*-----------------------------------------------------.
+| Do a getc, but give error message if EOF encountered |
+`-----------------------------------------------------*/
+
int
-safegetc (FILE *f)
+xgetc (FILE *f)
{
- register int c = getc(f);
+ int c = getc (f);
if (c == EOF)
fatal (_("unexpected end of file"));
return c;
}
-/* read one literal character from finput. process \ escapes.
- append the normalized string version of the char to *pp.
- assign the character code to *pcode
- return 1 unless the character is an unescaped `term' or \n
- report error for \n
-*/
-int
-literalchar (char **pp, int *pcode, char term)
+
+/*---------------------------------------------------------------.
+| Read one literal character from FINPUT, process \-escapes, and |
+| return the character. |
+`---------------------------------------------------------------*/
+
+char
+literalchar (void)
{
- register int c;
- register char *p;
- register int code;
- int wasquote = 0;
+ int c;
+ int res;
- c = safegetc(finput);
+ c = xgetc (finput);
if (c == '\n')
{
complain (_("unescaped newline in constant"));
- ungetc(c, finput);
- code = '?';
- wasquote = 1;
+ ungetc (c, finput);
+ res = '?';
}
else if (c != '\\')
{
- code = c;
- if (c == term)
- wasquote = 1;
+ res = c;
}
else
{
- c = safegetc(finput);
- if (c == 't') code = '\t';
- else if (c == 'n') code = '\n';
- else if (c == 'a') code = '\007';
- else if (c == 'r') code = '\r';
- else if (c == 'f') code = '\f';
- else if (c == 'b') code = '\b';
- else if (c == 'v') code = '\013';
- else if (c == '\\') code = '\\';
- else if (c == '\'') code = '\'';
- else if (c == '\"') code = '\"';
+ c = xgetc (finput);
+ if (c == 't')
+ res = '\t';
+ else if (c == 'n')
+ res = '\n';
+ else if (c == 'a')
+ res = '\007';
+ else if (c == 'r')
+ res = '\r';
+ else if (c == 'f')
+ res = '\f';
+ else if (c == 'b')
+ res = '\b';
+ else if (c == 'v')
+ res = '\013';
+ else if (c == '\\')
+ res = '\\';
+ else if (c == '\'')
+ res = '\'';
+ else if (c == '\"')
+ 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 = safegetc(finput);
+ c = xgetc (finput);
}
- ungetc(c, finput);
+ ungetc (c, finput);
}
else if (c == 'x')
{
- c = safegetc(finput);
- code = 0;
+ c = xgetc (finput);
+ 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 = safegetc(finput);
+ c = xgetc (finput);
}
- ungetc(c, finput);
+ ungetc (c, finput);
}
else
{
+ char badchar [] = "c";
+ badchar[0] = c;
complain (_("unknown escape sequence: `\\' followed by `%s'"),
- printable_version(c));
- code = '?';
+ quote (badchar));
+ res = '?';
}
- } /* has \ */
-
- /* now fill token_buffer 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. */
-
- p = *pp;
- if (code == term && wasquote)
- *p++ = code;
- else if (code == '\\') {*p++ = '\\'; *p++ = '\\';}
- else if (code == '\'') {*p++ = '\\'; *p++ = '\'';}
- else if (code == '\"') {*p++ = '\\'; *p++ = '\"';}
- else if (code >= 040 && code < 0177)
- *p++ = code;
- else if (code == '\t') {*p++ = '\\'; *p++ = 't';}
- else if (code == '\n') {*p++ = '\\'; *p++ = 'n';}
- else if (code == '\r') {*p++ = '\\'; *p++ = 'r';}
- else if (code == '\v') {*p++ = '\\'; *p++ = 'v';}
- else if (code == '\b') {*p++ = '\\'; *p++ = 'b';}
- else if (code == '\f') {*p++ = '\\'; *p++ = 'f';}
- else
- {
- *p++ = '\\';
- *p++ = code / 0100 + '0';
- *p++ = ((code / 010) & 07) + '0';
- *p++ = (code & 07) + '0';
- }
- *pp = p;
- *pcode = code;
- return ! wasquote;
+ } /* has \ */
+
+ return res;
}
void
-unlex (int token)
+unlex (token_t token)
{
unlexed = token;
+ unlexed_token_buffer = token_buffer;
unlexed_symval = symval;
}
+/*-----------------------------------------------------------------.
+| We just read `<' from FIN. Store in TOKEN_BUFFER, the type name |
+| specified between the `<...>'. |
+`-----------------------------------------------------------------*/
-int
+void
+read_type_name (FILE *fin)
+{
+ int c = getc (fin);
+
+ while (c != '>')
+ {
+ if (c == EOF)
+ fatal (_("unterminated type name at end of file"));
+ if (c == '\n')
+ {
+ complain (_("unterminated type name"));
+ ungetc (c, fin);
+ break;
+ }
+
+ obstack_1grow (&token_obstack, c);
+ c = getc (fin);
+ }
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
+}
+
+
+token_t
lex (void)
{
- register int c;
- char *p;
+ int c;
+
+ /* 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();
- *token_buffer = c; /* for error messages (token buffer always valid) */
- token_buffer[1] = 0;
+ c = skip_white_space ();
switch (c)
{
case EOF:
- strcpy(token_buffer, "EOF");
- return ENDFILE;
-
- case 'A': case 'B': case 'C': case 'D': case 'E':
- case 'F': case 'G': case 'H': case 'I': case 'J':
- case 'K': case 'L': case 'M': case 'N': case 'O':
- case 'P': case 'Q': case 'R': case 'S': case 'T':
- case 'U': case 'V': case 'W': case 'X': case 'Y':
+ token_buffer = "EOF";
+ return tok_eof;
+
+ case 'A': case 'B': case 'C': case 'D': case 'E':
+ case 'F': case 'G': case 'H': case 'I': case 'J':
+ case 'K': case 'L': case 'M': case 'N': case 'O':
+ case 'P': case 'Q': case 'R': case 'S': case 'T':
+ case 'U': case 'V': case 'W': case 'X': case 'Y':
case 'Z':
- case 'a': case 'b': case 'c': case 'd': case 'e':
- case 'f': case 'g': case 'h': case 'i': case 'j':
- case 'k': case 'l': case 'm': case 'n': case 'o':
- case 'p': case 'q': case 'r': case 's': case 't':
- case 'u': case 'v': case 'w': case 'x': case 'y':
+ case 'a': case 'b': case 'c': case 'd': case 'e':
+ case 'f': case 'g': case 'h': case 'i': case 'j':
+ case 'k': case 'l': case 'm': case 'n': case 'o':
+ case 'p': case 'q': case 'r': case 's': case 't':
+ case 'u': case 'v': case 'w': case 'x': case 'y':
case 'z':
- case '.': case '_':
- p = token_buffer;
- while (isalnum(c) || c == '_' || c == '.')
- {
- if (p == token_buffer + maxtoken)
- p = grow_token_buffer(p);
+ case '.': case '_':
- *p++ = c;
- c = getc(finput);
+ while (isalnum (c) || c == '_' || c == '.')
+ {
+ obstack_1grow (&token_obstack, c);
+ c = getc (finput);
}
-
- *p = 0;
- ungetc(c, finput);
- symval = getsym(token_buffer);
- return IDENTIFIER;
-
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
+ ungetc (c, finput);
+ symval = getsym (token_buffer);
+ return tok_identifier;
+
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
{
numval = 0;
- p = token_buffer;
- while (isdigit(c))
+ while (isdigit (c))
{
- if (p == token_buffer + maxtoken)
- p = grow_token_buffer(p);
-
- *p++ = c;
- numval = numval*10 + c - '0';
- c = getc(finput);
+ obstack_1grow (&token_obstack, c);
+ numval = numval * 10 + c - '0';
+ c = getc (finput);
}
- *p = 0;
- ungetc(c, finput);
- return NUMBER;
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
+ ungetc (c, finput);
+ return tok_number;
}
case '\'':
-
/* parse the literal token and compute character code in code */
- translations = -1;
{
- int code, discode;
- char discard[10], *dp;
+ int code = literalchar ();
- p = token_buffer;
- *p++ = '\'';
- literalchar(&p, &code, '\'');
+ obstack_1grow (&token_obstack, '\'');
+ obstack_1grow (&token_obstack, code);
- c = getc(finput);
+ c = getc (finput);
if (c != '\'')
{
complain (_("use \"...\" for multi-character literal tokens"));
- while (1)
- {
- dp = discard;
- if (! literalchar(&dp, &discode, '\''))
- break;
- }
+ while (literalchar () != '\'')
+ /* Skip. */;
}
- *p++ = '\'';
- *p = 0;
- symval = getsym(token_buffer);
- symval->class = STOKEN;
- if (! symval->user_token_number)
+ 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 == SUNDEF)
symval->user_token_number = code;
- return IDENTIFIER;
+ return tok_identifier;
}
case '\"':
-
/* parse the literal string token and treat as an identifier */
- translations = -1;
{
- int code; /* ignored here */
- p = token_buffer;
- *p++ = '\"';
- while (literalchar(&p, &code, '\"')) /* read up to and including " */
+ int code; /* ignored here */
+
+ obstack_1grow (&token_obstack, '\"');
+ /* Read up to and including ". */
+ do
{
- if (p >= token_buffer + maxtoken - 4)
- p = grow_token_buffer(p);
+ code = literalchar ();
+ obstack_1grow (&token_obstack, code);
}
- *p = 0;
+ while (code != '\"');
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
- symval = getsym(token_buffer);
- symval->class = STOKEN;
+ symval = getsym (token_buffer);
+ symval->class = token_sym;
- return IDENTIFIER;
+ return tok_identifier;
}
case ',':
- return COMMA;
+ token_buffer = ",";
+ return tok_comma;
case ':':
- return COLON;
+ token_buffer = ":";
+ return tok_colon;
case ';':
- return SEMICOLON;
+ token_buffer = ";";
+ return tok_semicolon;
case '|':
- return BAR;
+ token_buffer = "|";
+ return tok_bar;
case '{':
- return LEFT_CURLY;
+ token_buffer = "{";
+ return tok_left_curly;
case '=':
+ obstack_1grow (&token_obstack, c);
do
{
- c = getc(finput);
- if (c == '\n') lineno++;
+ c = getc (finput);
+ obstack_1grow (&token_obstack, c);
+ if (c == '\n')
+ lineno++;
}
- while(c==' ' || c=='\n' || c=='\t');
+ while (c == ' ' || c == '\n' || c == '\t');
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
if (c == '{')
{
- strcpy(token_buffer, "={");
- return LEFT_CURLY;
+ return tok_left_curly;
}
else
{
- ungetc(c, finput);
- return ILLEGAL;
+ ungetc (c, finput);
+ return tok_illegal;
}
case '<':
- p = token_buffer;
- c = getc(finput);
- while (c != '>')
- {
- if (c == EOF)
- fatal (_("unterminated type name at end of file"));
- if (c == '\n')
- {
- complain (_("unterminated type name"));
- ungetc(c, finput);
- break;
- }
-
- if (p == token_buffer + maxtoken)
- p = grow_token_buffer(p);
-
- *p++ = c;
- c = getc(finput);
- }
- *p = 0;
- return TYPENAME;
-
+ read_type_name (finput);
+ return tok_typename;
case '%':
- return parse_percent_token();
+ return parse_percent_token ();
default:
- return ILLEGAL;
+ obstack_1grow (&token_obstack, c);
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_illegal;
}
}
-/* the following table dictates the action taken for the various
- % directives. A setflag value causes the named flag to be
- set. A retval action returns the code.
-*/
-struct percent_table_struct {
- char *name;
- void *setflag;
- int retval;
-} percent_table[] =
+/* This function is a strcmp, which doesn't differentiate `-' and `_'
+ chars. */
+
+static int
+option_strcmp (const char *left, const char *right)
{
- {"token", NULL, TOKEN},
- {"term", NULL, TOKEN},
- {"nterm", NULL, NTERM},
- {"type", NULL, TYPE},
- {"guard", NULL, GUARD},
- {"union", NULL, UNION},
- {"expect", NULL, EXPECT},
- {"thong", NULL, THONG},
- {"start", NULL, START},
- {"left", NULL, LEFT},
- {"right", NULL, RIGHT},
- {"nonassoc", NULL, NONASSOC},
- {"binary", NULL, NONASSOC},
- {"semantic_parser", NULL, SEMANTIC_PARSER},
- {"pure_parser", NULL, PURE_PARSER},
- {"prec", NULL, PREC},
-
- {"no_lines", &nolinesflag, NOOP}, /* -l */
- {"raw", &rawtoknumflag, NOOP}, /* -r */
- {"token_table", &toknumflag, NOOP}, /* -k */
-
-#if 0
- /* These can be utilized after main is reoganized so
- open_files() is deferred 'til after read_declarations().
- But %{ and %union both put information into files
- that have to be opened before read_declarations().
- */
- {"yacc", &fixed_outfiles, NOOP}, /* -y */
- {"fixed_output_files", &fixed_outfiles, NOOP}, /* -y */
- {"defines", &definesflag, NOOP}, /* -d */
- {"no_parser", &noparserflag, NOOP}, /* -n */
- {"output_file", &spec_outfile, SETOPT}, /* -o */
- {"file_prefix", &spec_file_prefix, SETOPT}, /* -b */
- {"name_prefix", &spec_name_prefix, SETOPT}, /* -p */
-
- /* These would be acceptable, but they do not affect processing */
- {"verbose", &verboseflag, NOOP}, /* -v */
- {"debug", &debugflag, NOOP}, /* -t */
- /* {"help", <print usage stmt>, NOOP},*/ /* -h */
- /* {"version", <print version number> , NOOP},*/ /* -V */
-#endif
-
- {NULL, NULL, ILLEGAL}
-};
+ 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)
{
- register int c;
- register char *p;
- register struct percent_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;
- p = token_buffer;
- c = getc(finput);
- *p++ = '%';
- *p++ = c; /* for error msg */
- *p = 0;
+ int c = getc (finput);
+ obstack_1grow (&token_obstack, '%');
+ obstack_1grow (&token_obstack, c);
switch (c)
{
case '%':
- return TWO_PERCENTS;
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_two_percents;
case '{':
- return PERCENT_LEFT_CURLY;
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_percent_left_curly;
+ /* The following guys are here for backward compatibility with
+ very ancient Yacc versions. The paper of Johnson mentions
+ them (as ancient :). */
case '<':
- return LEFT;
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_left;
case '>':
- return RIGHT;
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_right;
case '2':
- return NONASSOC;
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_nonassoc;
case '0':
- return TOKEN;
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_token;
case '=':
- return PREC;
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_prec;
}
- if (!isalpha(c))
- return ILLEGAL;
- p = token_buffer;
- *p++ = '%';
- while (isalpha(c) || c == '_' || c == '-')
+ if (!isalpha (c))
{
- if (p == token_buffer + maxtoken)
- p = grow_token_buffer(p);
+ token_buffer = obstack_finish (&token_obstack);
+ return tok_illegal;
+ }
- if (c == '-') c = '_';
- *p++ = c;
- c = getc(finput);
+ while (c = getc (finput), isalpha (c) || c == '_' || c == '-')
+ {
+ if (c == '_')
+ c = '-';
+ obstack_1grow (&token_obstack, c);
}
- ungetc(c, finput);
+ /* %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);
- *p = 0;
+ obstack_1grow (&token_obstack, '\0');
+ token_buffer = obstack_finish (&token_obstack);
+ if (arg_offset)
+ arg = token_buffer + arg_offset;
/* table lookup % directive */
- for (tx = percent_table; tx->name; tx++)
- if (strcmp(token_buffer+1, tx->name) == 0)
+ for (tx = option_table; tx->name; tx++)
+ if ((tx->access == opt_percent || tx->access == opt_both)
+ && option_strcmp (token_buffer + 1, tx->name) == 0)
break;
- if (tx->retval == SETOPT)
- {
- *((char **)(tx->setflag)) = optarg;
- return NOOP;
- }
- if (tx->setflag)
+
+ if (arg && tx->ret_val != tok_stropt)
+ fatal (_("`%s' supports no argument: %s"), token_buffer, quote (arg));
+
+
+ switch (tx->ret_val)
{
- *((int *)(tx->setflag)) = 1;
- return NOOP;
+ 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;
+
+ default:
+ return tx->ret_val;
+ break;
}
- return tx->retval;
+ abort ();
}
projects / bison.git / blobdiff