X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/0846f581e81ccd73ea43f2a1dc73fd79ffc86b75..43168960182a2537605d6a1262a39e4e43c57d98:/src/lex.c?ds=sidebyside

diff --git a/src/lex.c b/src/lex.c
index 65082a81..78b8a8f3 100644
--- 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,14 +32,13 @@
 static struct obstack token_obstack;
 const char *token_buffer = NULL;
 
-bucket *symval;
+bucket *symval = NULL;
 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;
-/* by the next call to lex */
 static bucket *unlexed_symval = NULL;
-
+static const char *unlexed_token_buffer = NULL;
 
 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.  */
 
-static int
+int
 literalchar (struct obstack *out, int *pcode, char term)
 {
   int c;
@@ -325,6 +323,7 @@ void
 unlex (token_t token)
 {
   unlexed = token;
+  unlexed_token_buffer = token_buffer;
   unlexed_symval = symval;
 }
 
@@ -369,6 +368,7 @@ lex (void)
     {
       token_t res = unlexed;
       symval = unlexed_symval;
+      token_buffer = unlexed_token_buffer;
       unlexed = tok_undef;
       return res;
     }
@@ -427,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, '\'');
@@ -435,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, '\''))
@@ -445,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;
       }
@@ -552,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);
 
@@ -564,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;
 
@@ -592,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++)
@@ -602,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 ();
 }