New experimental feature: if --verbose --trace output all the

[bison.git] / src / lex.c

diff --git a/src/lex.c b/src/lex.c
index ec40c14160644e590c205e01a0fd940501d3c4d8..78b8a8f391bf84f8db7981a39e008575f18dd8e4 100644 (file)
--- a/src/lex.c
+++ b/src/lex.c
@@ -21,7 +21,6 @@
 #include "system.h"
 #include "getargs.h"
 #include "files.h"
-#include "getopt.h"            /* for optarg */
 #include "symtab.h"
 #include "options.h"
 #include "lex.h"
@@ -33,7 +32,7 @@
 static struct obstack token_obstack;
 const char *token_buffer = NULL;
 
-bucket *symval;
+bucket *symval = NULL;
 int numval;
 
 /* A token to be reread, see unlex and lex. */
@@ -153,7 +152,7 @@ xgetc (FILE *f)
    being, I prefer have literalchar behave like quotearg, and change
    my mind later if I was wrong.  */
 
-static int
+int
 literalchar (struct obstack *out, int *pcode, char term)
 {
   int c;
@@ -428,7 +427,7 @@ lex (void)
       /* parse the literal token and compute character code in  code  */
 
       {
-       int code, discode;
+       int code;
 
        obstack_1grow (&token_obstack, '\'');
        literalchar (&token_obstack, &code, '\'');
@@ -436,6 +435,7 @@ lex (void)
        c = getc (finput);
        if (c != '\'')
          {
+           int discode;
            complain (_("use \"...\" for multi-character literal tokens"));
            while (1)
              if (!literalchar (0, &discode, '\''))
@@ -446,7 +446,7 @@ lex (void)
        token_buffer = obstack_finish (&token_obstack);
        symval = getsym (token_buffer);
        symval->class = token_sym;
-       if (!symval->user_token_number)
+       if (symval->user_token_number == SUNDEF)
          symval->user_token_number = code;
        return tok_identifier;
       }
@@ -553,7 +553,10 @@ option_strcmp (const char *left, const char *right)
 token_t
 parse_percent_token (void)
 {
-  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;
 
   int c = getc (finput);
 
@@ -565,6 +568,8 @@ parse_percent_token (void)
     case '{':
       return tok_percent_left_curly;
 
+      /* FIXME: Who the heck are those 5 guys!?! `%<' = `%left'!!!
+        Let's ask for there removal.  */
     case '<':
       return tok_left;
 
@@ -593,9 +598,34 @@ parse_percent_token (void)
       c = getc (finput);
     }
 
-  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 (literalchar (NULL, &code, '"'))
+           obstack_1grow (&token_obstack, code);
+       }
+      /* else: should be an error. */
+    }
+  else
+    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++)
@@ -603,27 +633,42 @@ parse_percent_token (void)
        && 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;
 
     default:
-      /* Other cases do not apply here. */
+      return tx->ret_val;
       break;
     }
-
-  return tx->ret_val;
+  abort ();
 }