]> git.saurik.com Git - bison.git/blobdiff - src/lex.c
* src/bison.hairy: Formatting/comment changes.
[bison.git] / src / lex.c
index ec229a753fffd1d234567fcf926b588a05a79ff4..deb6eb7af47374fd303b83ac865b2c7fdb059d4f 100644 (file)
--- a/src/lex.c
+++ b/src/lex.c
 #include "system.h"
 #include "getargs.h"
 #include "files.h"
-#include "getopt.h"            /* for optarg */
 #include "symtab.h"
+#include "options.h"
 #include "lex.h"
-#include "xalloc.h"
 #include "complain.h"
 #include "gram.h"
 #include "quote.h"
 
 /* Buffer for storing the current token.  */
-struct obstack token_obstack;
-char *token_buffer = NULL;
+static struct obstack token_obstack;
+const char *token_buffer = NULL;
 
-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)
 {
   obstack_init (&token_obstack);
-  unlexed = -1;
+  unlexed = tok_undef;
+}
+
+
+void
+lex_free (void)
+{
+  obstack_free (&token_obstack, NULL);
 }
 
 
@@ -123,7 +130,7 @@ skip_white_space (void)
 | Do a getc, but give error message if EOF encountered |
 `-----------------------------------------------------*/
 
-static int
+int
 xgetc (FILE *f)
 {
   int c = getc (f);
@@ -133,75 +140,62 @@ 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.                       |
-`------------------------------------------------------------------*/
+/*---------------------------------------------------------------.
+| Read one literal character from FINPUT, process \-escapes, and |
+| return the character.                                          |
+`---------------------------------------------------------------*/
 
-/* 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.  */
-
-static int
-literalchar (struct obstack *out, int *pcode, char term)
+char
+literalchar (void)
 {
   int c;
-  char buf[4096];
-  char *cp;
-  int code;
-  int wasquote = 0;
+  int res;
 
   c = xgetc (finput);
   if (c == '\n')
     {
       complain (_("unescaped newline in constant"));
       ungetc (c, finput);
-      code = '?';
-      wasquote = 1;
+      res = '?';
     }
   else if (c != '\\')
     {
-      code = c;
-      if (c == term)
-       wasquote = 1;
+      res = c;
     }
   else
     {
       c = xgetc (finput);
       if (c == 't')
-       code = '\t';
+       res = '\t';
       else if (c == 'n')
-       code = '\n';
+       res = '\n';
       else if (c == 'a')
-       code = '\007';
+       res = '\007';
       else if (c == 'r')
-       code = '\r';
+       res = '\r';
       else if (c == 'f')
-       code = '\f';
+       res = '\f';
       else if (c == 'b')
-       code = '\b';
+       res = '\b';
       else if (c == 'v')
-       code = '\013';
+       res = '\013';
       else if (c == '\\')
-       code = '\\';
+       res = '\\';
       else if (c == '\'')
-       code = '\'';
+       res = '\'';
       else if (c == '\"')
-       code = '\"';
+       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 = xgetc (finput);
@@ -211,21 +205,21 @@ literalchar (struct obstack *out, int *pcode, char term)
       else if (c == 'x')
        {
          c = xgetc (finput);
-         code = 0;
+         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 = xgetc (finput);
@@ -234,88 +228,23 @@ literalchar (struct obstack *out, int *pcode, char term)
        }
       else
        {
-         char buf [] = "c";
-         buf[0] = c;
+         char badchar [] = "c";
+         badchar[0] = c;
          complain (_("unknown escape sequence: `\\' followed by `%s'"),
-                   quote (buf));
-         code = '?';
+                   quote (badchar));
+         res = '?';
        }
     }                          /* 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);
-  *pcode = code;
-  return !wasquote;
+  return res;
 }
 
 
 void
-unlex (int token)
+unlex (token_t token)
 {
   unlexed = token;
+  unlexed_token_buffer = token_buffer;
   unlexed_symval = symval;
 }
 
@@ -356,12 +285,13 @@ lex (void)
   /* 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 ();
@@ -417,27 +347,25 @@ lex (void)
     case '\'':
       /* parse the literal token and compute character code in  code  */
 
-      translations = -1;
       {
-       int code, discode;
+       int code = literalchar ();
 
        obstack_1grow (&token_obstack, '\'');
-       literalchar (&token_obstack, &code, '\'');
+       obstack_1grow (&token_obstack, code);
 
        c = getc (finput);
        if (c != '\'')
          {
            complain (_("use \"...\" for multi-character literal tokens"));
-           while (1)
-             if (!literalchar (0, &discode, '\''))
-               break;
+           while (literalchar () != '\'')
+             /* Skip. */;
          }
        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)
+       if (symval->user_token_number == SUNDEF)
          symval->user_token_number = code;
        return tok_identifier;
       }
@@ -445,14 +373,17 @@ lex (void)
     case '\"':
       /* parse the literal string token and treat as an identifier */
 
-      translations = -1;
       {
        int code;               /* ignored here */
 
        obstack_1grow (&token_obstack, '\"');
        /* Read up to and including ".  */
-       while (literalchar (&token_obstack, &code, '\"'))
-         /* nothing */;
+       do
+         {
+           code = literalchar ();
+           obstack_1grow (&token_obstack, code);
+         }
+       while (code != '\"');
        obstack_1grow (&token_obstack, '\0');
        token_buffer = obstack_finish (&token_obstack);
 
@@ -463,32 +394,40 @@ lex (void)
       }
 
     case ',':
+      token_buffer = ",";
       return tok_comma;
 
     case ':':
+      token_buffer = ":";
       return tok_colon;
 
     case ';':
+      token_buffer = ";";
       return tok_semicolon;
 
     case '|':
+      token_buffer = "|";
       return tok_bar;
 
     case '{':
+      token_buffer = "{";
       return tok_left_curly;
 
     case '=':
+      obstack_1grow (&token_obstack, c);
       do
        {
          c = getc (finput);
+         obstack_1grow (&token_obstack, c);
          if (c == '\n')
            lineno++;
        }
       while (c == ' ' || c == '\n' || c == '\t');
+      obstack_1grow (&token_obstack, '\0');
+      token_buffer = obstack_finish (&token_obstack);
 
       if (c == '{')
        {
-         token_buffer = "={";
          return tok_left_curly;
        }
       else
@@ -505,71 +444,44 @@ lex (void)
       return parse_percent_token ();
 
     default:
+      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 set_flag value causes the named flag to be set.  A
-   retval action returns the code.  */
-struct percent_table_struct
-{
-  const char *name;
-  void *set_flag;
-  int retval;
-};
+/* This function is a strcmp, which doesn't differentiate `-' and `_'
+   chars.  */
 
-struct percent_table_struct percent_table[] =
+static int
+option_strcmp (const char *left, const char *right)
 {
-  { "token",           NULL,                   tok_token },
-  { "term",            NULL,                   tok_token },
-  { "nterm",           NULL,                   tok_nterm },
-  { "type",            NULL,                   tok_type },
-  { "guard",           NULL,                   tok_guard },
-  { "union",           NULL,                   tok_union },
-  { "expect",          NULL,                   tok_expect },
-  { "thong",           NULL,                   tok_thong },
-  { "start",           NULL,                   tok_start },
-  { "left",            NULL,                   tok_left },
-  { "right",           NULL,                   tok_right },
-  { "nonassoc",                NULL,                   tok_nonassoc },
-  { "binary",          NULL,                   tok_nonassoc },
-  { "prec",            NULL,                   tok_prec },
-  { "locations",       &locations_flag,        tok_noop },     /* -l */
-  { "no_lines",                &no_lines_flag,         tok_noop },     /* -l */
-  { "raw",             NULL,                   tok_obsolete }, /* -r */
-  { "token_table",     &token_table_flag,      tok_noop },     /* -k */
-  { "yacc",            &yacc_flag,             tok_noop },     /* -y */
-  { "fixed_output_files",&yacc_flag,           tok_noop },     /* -y */
-  { "defines",         &defines_flag,          tok_noop },     /* -d */
-  { "no_parser",       &no_parser_flag,        tok_noop },     /* -n */
-#if 0
-  /* For the time being, this is not enabled yet, while it's possible
-     though, since we use obstacks.  The only risk is with semantic
-     parsers which will output an `include' of an output file: be sure
-     that the naem included is indeed the name of the output file.  */
-  { "output_file",     &spec_outfile,          tok_setopt },   /* -o */
-  { "file_prefix",     &spec_file_prefix,      tok_setopt },   /* -b */
-  { "name_prefix",     &spec_name_prefix,      tok_setopt },   /* -p */
-#endif
-  { "verbose",         &verbose_flag,          tok_noop },     /* -v */
-  { "debug",           &debug_flag,            tok_noop },     /* -t */
-  { "semantic_parser", &semantic_parser,       tok_noop },
-  { "pure_parser",     &pure_parser,           tok_noop },
-
-  { NULL, NULL, tok_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)
 {
-  int c;
-  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;
 
-  c = getc (finput);
+  int c = getc (finput);
 
   switch (c)
     {
@@ -579,6 +491,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;
 
@@ -601,38 +515,83 @@ parse_percent_token (void)
   obstack_1grow (&token_obstack, '%');
   while (isalpha (c) || c == '_' || c == '-')
     {
-      if (c == '-')
-       c = '_';
+      if (c == '_')
+       c = '-';
       obstack_1grow (&token_obstack, c);
       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 ((code = literalchar ()) != '"')
+           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 = 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->set_flag)
+  if (arg && tx->ret_val != tok_stropt)
+    fatal (_("`%s' supports no argument: %s"), token_buffer, quote (arg));
+
+
+  switch (tx->ret_val)
     {
-      *((int *) (tx->set_flag)) = 1;
+    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;
 
-  switch (tx->retval)
-    {
-    case tok_setopt:
-      *((char **) (tx->set_flag)) = optarg;
+    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;
-    }
 
-  return tx->retval;
+    default:
+      return tx->ret_val;
+      break;
+    }
+  abort ();
 }