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 65082a8141f95358eb359bd6d4e675adaf8a8590..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 "system.h"
 #include "getargs.h"
 #include "files.h"

-#include "getopt.h"            /* for optarg */

 #include "symtab.h"
 #include "options.h"
 #include "lex.h"
 #include "symtab.h"
 #include "options.h"
 #include "lex.h"


@@ -33,14 +32,13 @@
 static struct obstack token_obstack;
 const char *token_buffer = NULL;
 
 static struct obstack token_obstack;
 const char *token_buffer = NULL;
 

-bucket *symval;
+bucket *symval = NULL;

 int numval;
 
 int numval;
 

-/* these two describe a token to be reread */
+/* A token to be reread, see unlex and lex. */

 static token_t unlexed = tok_undef;
 static token_t unlexed = tok_undef;

-/* by the next call to lex */

 static bucket *unlexed_symval = NULL;
 static bucket *unlexed_symval = NULL;

-
+static const char *unlexed_token_buffer = NULL;

 
 void
 lex_init (void)
 
 void
 lex_init (void)


@@ -154,7 +152,7 @@ xgetc (FILE *f)
    being, I prefer have literalchar behave like quotearg, and change
    my mind later if I was wrong.  */
 
    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;
 literalchar (struct obstack *out, int *pcode, char term)
 {
   int c;


@@ -325,6 +323,7 @@ void
 unlex (token_t token)
 {
   unlexed = token;
 unlex (token_t token)
 {
   unlexed = token;

+  unlexed_token_buffer = token_buffer;

   unlexed_symval = symval;
 }
 
   unlexed_symval = symval;
 }
 


@@ -369,6 +368,7 @@ lex (void)
     {
       token_t res = unlexed;
       symval = unlexed_symval;
     {
       token_t res = unlexed;
       symval = unlexed_symval;

+      token_buffer = unlexed_token_buffer;

       unlexed = tok_undef;
       return res;
     }
       unlexed = tok_undef;
       return res;
     }


@@ -427,7 +427,7 @@ lex (void)
       /* parse the literal token and compute character code in  code  */
 
       {
       /* parse the literal token and compute character code in  code  */
 
       {

-       int code, discode;
+       int code;

 
        obstack_1grow (&token_obstack, '\'');
        literalchar (&token_obstack, &code, '\'');
 
        obstack_1grow (&token_obstack, '\'');
        literalchar (&token_obstack, &code, '\'');


@@ -435,6 +435,7 @@ lex (void)
        c = getc (finput);
        if (c != '\'')
          {
        c = getc (finput);
        if (c != '\'')
          {

+           int discode;

            complain (_("use \"...\" for multi-character literal tokens"));
            while (1)
              if (!literalchar (0, &discode, '\''))
            complain (_("use \"...\" for multi-character literal tokens"));
            while (1)
              if (!literalchar (0, &discode, '\''))


@@ -445,7 +446,7 @@ lex (void)
        token_buffer = obstack_finish (&token_obstack);
        symval = getsym (token_buffer);
        symval->class = token_sym;
        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;
       }
          symval->user_token_number = code;
        return tok_identifier;
       }


@@ -552,7 +553,10 @@ option_strcmp (const char *left, const char *right)
 token_t
 parse_percent_token (void)
 {
 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);
 
 
   int c = getc (finput);
 


@@ -564,6 +568,8 @@ parse_percent_token (void)
     case '{':
       return tok_percent_left_curly;
 
     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;
 
     case '<':
       return tok_left;
 


@@ -592,9 +598,34 @@ parse_percent_token (void)
       c = getc (finput);
     }
 
       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);
   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++)
 
   /* table lookup % directive */
   for (tx = option_table; tx->name; tx++)


@@ -602,27 +633,42 @@ parse_percent_token (void)
        && option_strcmp (token_buffer + 1, tx->name) == 0)
       break;
 
        && 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)
     {
 
   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;
 
     case tok_obsolete:
       fatal (_("`%s' is no longer supported"), token_buffer);

+      return tok_noop;

       break;
 
     default:
       break;
 
     default:

-      /* Other cases do not apply here. */
+      return tx->ret_val;

       break;
     }
       break;
     }

-
-  return tx->ret_val;
+  abort ();

 }
 }