* src/lex.c (literalchar): Don't escape the special characters,

[bison.git] / src / lex.c

diff --git a/src/lex.c b/src/lex.c
index 3888b21588e34f6c22495fa8d8f3e7c0cb4fd89b..b2458a4f2e8a2c1978ee9ecac7cd0c8f09aaa8ef 100644 (file)
--- a/src/lex.c
+++ b/src/lex.c
@@ -30,15 +30,15 @@
 
 /* Buffer for storing the current token.  */
 static struct obstack token_obstack;
-char *token_buffer = NULL;
+const char *token_buffer = NULL;
 
-bucket *symval;
+bucket *symval = NULL;
 int numval;
 
 /* A token to be reread, see unlex and lex. */
 static token_t unlexed = tok_undef;
 static bucket *unlexed_symval = NULL;
-static char *unlexed_token_buffer = NULL;
+static const char *unlexed_token_buffer = NULL;
 
 void
 lex_init (void)
@@ -140,24 +140,16 @@ xgetc (FILE *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.      |
+| Append the char to OUT and assign it *PCODE. Return 1 unless the |
+| character is an unescaped `term' or \n report error for \n.      |
+`-----------------------------------------------------------------*/
 
-static int
+int
 literalchar (struct obstack *out, int *pcode, char term)
 {
   int c;
-  char buf[4096];
-  char *cp;
   int code;
   int wasquote = 0;
 
@@ -249,71 +241,8 @@ literalchar (struct obstack *out, int *pcode, char term)
        }
     }                          /* 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);
+    obstack_1grow (out, code);
   *pcode = code;
   return !wasquote;
 }
@@ -554,9 +483,9 @@ token_t
 parse_percent_token (void)
 {
   const struct option_table_struct *tx = NULL;
-  /* Where `=' was found in token_buffer. */
-  size_t equal_offset = 0;
-  char *arg = NULL;
+  const char *arg = NULL;
+  /* Where the ARG was found in token_buffer. */
+  size_t arg_offset = 0;
 
   int c = getc (finput);
 
@@ -598,33 +527,34 @@ parse_percent_token (void)
       c = getc (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 == '=')
     {
-      equal_offset = obstack_object_size (&token_obstack);
-      obstack_1grow (&token_obstack, c);
+      /* End of the directive.  We skip the `='. */
+      obstack_1grow (&token_obstack, '\0');
+      /* Fetch the ARG if present. */
       c = getc (finput);
-      if (c = '"')
+      if (c == '"')
        {
-         int code;             /* ignored here */
-
-         obstack_1grow (&token_obstack, '"');
-         /* Read up to and including ".  */
-         while (literalchar (&token_obstack, &code, '"'))
-           /* nothing */;
+         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 (equal_offset)
-    {
-      /* %token_buffer="arg" */
-      arg = token_buffer + equal_offset + 2;
-      arg[strlen (arg) - 1] = '\0';
-      token_buffer[equal_offset] = '\0';
-    }
+  if (arg_offset)
+    arg = token_buffer + arg_offset;
 
   /* table lookup % directive */
   for (tx = option_table; tx->name; tx++)
@@ -647,7 +577,7 @@ parse_percent_token (void)
             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)) = arg;
+           *((char **) (tx->set_flag)) = xstrdup (arg);
        }
       else
        fatal (_("`%s' requires an argument"), token_buffer);