Really add m4sugar to the repo.

[bison.git] / src / lex.c

diff --git a/src/lex.c b/src/lex.c
index f0fbf4851d408f11b470745b87d3635a71dfcedf..489fdf9c3b62cdec7b11f41f46c441f85f6d06ff 100644 (file)
--- a/src/lex.c
+++ b/src/lex.c
@@ -1,109 +1,67 @@
 /* Token-reader for Bison's input parser,
 /* Token-reader for Bison's input parser,

-   Copyright (C) 1984, 1986, 1989, 1992 Free Software Foundation, Inc.
+   Copyright 1984, 1986, 1989, 1992, 2000, 2001 Free Software Foundation, Inc.

 
 

-This file is part of Bison, the GNU Compiler Compiler.
+   This file is part of Bison, the GNU Compiler Compiler.

 
 

-Bison is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+   Bison is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.

 
 

-Bison is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   Bison is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.

 
 

-You should have received a copy of the GNU General Public License
-along with Bison; see the file COPYING.  If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with Bison; see the file COPYING.  If not, write to
+   the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */

 
 

-
-/*
-   lex is the entry point.  It is called from reader.c.
-   It returns one of the token-type codes defined in lex.h.
-   When an identifier is seen, the code IDENTIFIER is returned
-   and the name is looked up in the symbol table using symtab.c;
-   symval is set to a pointer to the entry found.  */
-
-#include <stdio.h>

 #include "system.h"
 #include "system.h"

+#include "getargs.h"

 #include "files.h"
 #include "files.h"

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

 #include "symtab.h"
 #include "symtab.h"

+#include "options.h"

 #include "lex.h"
 #include "lex.h"

-#include "alloc.h"
-
-/* flags set by % directives */
-extern int definesflag;        /* for -d */
-extern int toknumflag;         /* for -k */
-extern int noparserflag;       /* for -n */
-extern int fixed_outfiles;     /* for -y */
-extern int nolinesflag;        /* for -l */
-extern int rawtoknumflag;      /* for -r */
-extern int verboseflag;        /* for -v */
-extern int debugflag;                  /* for -t */
-extern char *spec_name_prefix;         /* for -p */
-extern char *spec_file_prefix; /* for -b */
-/*spec_outfile is declared in files.h, for -o */
-
-extern int lineno;
-extern int translations;
-
-void init_lex PARAMS((void));
-char *grow_token_buffer PARAMS((char *));
-int skip_white_space PARAMS((void));
-int safegetc PARAMS((FILE *));
-int literalchar PARAMS((char **, int *, char));
-void unlex PARAMS((int));
-int lex PARAMS((void));
-int parse_percent_token PARAMS((void));
-
-/* functions from main.c */
-extern char *printable_version PARAMS((int));
-extern void fatal PARAMS((char *));
-extern void warn PARAMS((char *));
-extern void warni PARAMS((char *, int));
-extern void warns PARAMS((char *, char *));
+#include "complain.h"
+#include "gram.h"
+#include "quote.h"

 
 /* Buffer for storing the current token.  */
 
 /* Buffer for storing the current token.  */

-char *token_buffer;
-
-/* Allocated size of token_buffer, not including space for terminator.  */
-int maxtoken;
+static struct obstack token_obstack;
+const char *token_buffer = NULL;

 
 

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

 int numval;
 
 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
 
 void

-init_lex (void)
+lex_init (void)

 {
 {

-  maxtoken = 100;
-  token_buffer = NEW2 (maxtoken + 1, char);
-  unlexed = -1;
+  obstack_init (&token_obstack);
+  unlexed = tok_undef;

 }
 
 
 }
 
 

-char *
-grow_token_buffer (char *p)
+void
+lex_free (void)

 {
 {

-  int offset = p - token_buffer;
-  maxtoken *= 2;
-  token_buffer = (char *) xrealloc(token_buffer, maxtoken + 1);
-  return token_buffer + offset;
+  obstack_free (&token_obstack, NULL);

 }
 
 
 int
 skip_white_space (void)
 {
 }
 
 
 int
 skip_white_space (void)
 {

-  register int c;
-  register int inside;
+  int c;
+  int inside;

 
 

-  c = getc(finput);
+  c = getc (finput);

 
   for (;;)
     {
 
   for (;;)
     {


@@ -112,15 +70,16 @@ skip_white_space (void)
       switch (c)
        {
        case '/':
       switch (c)
        {
        case '/':

-         c = getc(finput);
+         /* FIXME: Should probably be merged with copy_comment.  */
+         c = getc (finput);

          if (c != '*' && c != '/')
            {
          if (c != '*' && c != '/')
            {

-             warn(_("unexpected `/' found and ignored"));
+             complain (_("unexpected `/' found and ignored"));

              break;
            }
          cplus_comment = (c == '/');
 
              break;
            }
          cplus_comment = (c == '/');
 

-         c = getc(finput);
+         c = getc (finput);

 
          inside = 1;
          while (inside)
 
          inside = 1;
          while (inside)


@@ -128,12 +87,12 @@ skip_white_space (void)
              if (!cplus_comment && c == '*')
                {
                  while (c == '*')
              if (!cplus_comment && c == '*')
                {
                  while (c == '*')

-                   c = getc(finput);
+                   c = getc (finput);

 
                  if (c == '/')
                    {
                      inside = 0;
 
                  if (c == '/')
                    {
                      inside = 0;

-                     c = getc(finput);
+                     c = getc (finput);

                    }
                }
              else if (c == '\n')
                    }
                }
              else if (c == '\n')


@@ -141,12 +100,12 @@ skip_white_space (void)
                  lineno++;
                  if (cplus_comment)
                    inside = 0;
                  lineno++;
                  if (cplus_comment)
                    inside = 0;

-                 c = getc(finput);
+                 c = getc (finput);

                }
              else if (c == EOF)
                }
              else if (c == EOF)

-               fatal(_("unterminated comment"));
+               fatal (_("unterminated comment"));

              else
              else

-               c = getc(finput);
+               c = getc (finput);

            }
 
          break;
            }
 
          break;


@@ -157,470 +116,493 @@ skip_white_space (void)
        case ' ':
        case '\t':
        case '\f':
        case ' ':
        case '\t':
        case '\f':

-         c = getc(finput);
+         c = getc (finput);

          break;
 
        default:
          break;
 
        default:

-         return (c);
+         return c;

        }
     }
 }
 
        }
     }
 }
 

-/* do a getc, but give error message if EOF encountered */
+
+/*-----------------------------------------------------.
+| Do a getc, but give error message if EOF encountered |
+`-----------------------------------------------------*/
+

 int
 int

-safegetc (FILE *f)
+xgetc (FILE *f)

 {
 {

-  register int c = getc(f);
+  int c = getc (f);

   if (c == EOF)
   if (c == EOF)

-    fatal(_("Unexpected end of file"));
+    fatal (_("unexpected end of file"));

   return c;
 }
 
   return c;
 }
 

-/* read one literal character from finput.  process \ escapes.
-   append the normalized string version of the char to *pp.
-   assign the character code to *pcode
-   return 1 unless the character is an unescaped `term' or \n
-       report error for \n
-*/
-int
-literalchar (char **pp, int *pcode, char term)
+
+/*---------------------------------------------------------------.
+| Read one literal character from FINPUT, process \-escapes, and |
+| return the character.                                          |
+`---------------------------------------------------------------*/
+
+char
+literalchar (void)

 {
 {

-  register int c;
-  register char *p;
-  register int code;
-  int wasquote = 0;
+  int c;
+  int res;

 
 

-  c = safegetc(finput);
+  c = xgetc (finput);

   if (c == '\n')
     {
   if (c == '\n')
     {

-      warn(_("unescaped newline in constant"));
-      ungetc(c, finput);
-      code = '?';
-      wasquote = 1;
+      complain (_("unescaped newline in constant"));
+      ungetc (c, finput);
+      res = '?';

     }
   else if (c != '\\')
     {
     }
   else if (c != '\\')
     {

-      code = c;
-      if (c == term)
-       wasquote = 1;
+      res = c;

     }
   else
     {
     }
   else
     {

-      c = safegetc(finput);
-      if (c == 't')  code = '\t';
-      else if (c == 'n')  code = '\n';
-      else if (c == 'a')  code = '\007';
-      else if (c == 'r')  code = '\r';
-      else if (c == 'f')  code = '\f';
-      else if (c == 'b')  code = '\b';
-      else if (c == 'v')  code = '\013';
-      else if (c == '\\')  code = '\\';
-      else if (c == '\'')  code = '\'';
-      else if (c == '\"')  code = '\"';
+      c = xgetc (finput);
+      if (c == 't')
+       res = '\t';
+      else if (c == 'n')
+       res = '\n';
+      else if (c == 'a')
+       res = '\007';
+      else if (c == 'r')
+       res = '\r';
+      else if (c == 'f')
+       res = '\f';
+      else if (c == 'b')
+       res = '\b';
+      else if (c == 'v')
+       res = '\013';
+      else if (c == '\\')
+       res = '\\';
+      else if (c == '\'')
+       res = '\'';
+      else if (c == '\"')
+       res = '\"';

       else if (c <= '7' && c >= '0')
        {
       else if (c <= '7' && c >= '0')
        {

-         code = 0;
+         res = 0;

          while (c <= '7' && c >= '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)

                {
                {

-                 warni(_("octal value outside range 0...255: `\\%o'"), code);
-                 code &= 0xFF;
+                 complain (_("octal value outside range 0...255: `\\%o'"),
+                           res);
+                 res &= 0xFF;

                  break;
                }
                  break;
                }

-             c = safegetc(finput);
+             c = xgetc (finput);

            }
            }

-         ungetc(c, finput);
+         ungetc (c, finput);

        }
       else if (c == 'x')
        {
        }
       else if (c == 'x')
        {

-         c = safegetc(finput);
-         code = 0;
+         c = xgetc (finput);
+         res = 0;

          while (1)
            {
              if (c >= '0' && c <= '9')
          while (1)
            {
              if (c >= '0' && c <= '9')

-               code *= 16,  code += c - '0';
+               res *= 16, res += c - '0';

              else if (c >= 'a' && c <= 'f')
              else if (c >= 'a' && c <= 'f')

-               code *= 16,  code += c - 'a' + 10;
+               res *= 16, res += c - 'a' + 10;

              else if (c >= 'A' && c <= 'F')
              else if (c >= 'A' && c <= 'F')

-               code *= 16,  code += c - 'A' + 10;
+               res *= 16, res += c - 'A' + 10;

              else
                break;
              else
                break;

-             if (code >= 256 || code<0)
+             if (res >= 256 || res < 0)

                {
                {

-                 warni(_("hexadecimal value above 255: `\\x%x'"), code);
-                 code &= 0xFF;
+                 complain (_("hexadecimal value above 255: `\\x%x'"), res);
+                 res &= 0xFF;

                  break;
                }
                  break;
                }

-             c = safegetc(finput);
+             c = xgetc (finput);

            }
            }

-         ungetc(c, finput);
+         ungetc (c, finput);

        }
       else
        {
        }
       else
        {

-         warns (_("unknown escape sequence: `\\' followed by `%s'"),
-                printable_version(c));
-         code = '?';
+         char badchar [] = "c";
+         badchar[0] = c;
+         complain (_("unknown escape sequence: `\\' followed by `%s'"),
+                   quote (badchar));
+         res = '?';

        }
        }

-    } /* has \ */
-
-  /* now fill token_buffer 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.  */
-
-  p = *pp;
-  if (code == '\\')  {*p++ = '\\'; *p++ = '\\';}
-  else if (code == '\'')  {*p++ = '\\'; *p++ = '\'';}
-  else if (code == '\"')  {*p++ = '\\'; *p++ = '\"';}
-  else if (code >= 040 && code < 0177)
-    *p++ = code;
-  else if (code == '\t')  {*p++ = '\\'; *p++ = 't';}
-  else if (code == '\n')  {*p++ = '\\'; *p++ = 'n';}
-  else if (code == '\r')  {*p++ = '\\'; *p++ = 'r';}
-  else if (code == '\v')  {*p++ = '\\'; *p++ = 'v';}
-  else if (code == '\b')  {*p++ = '\\'; *p++ = 'b';}
-  else if (code == '\f')  {*p++ = '\\'; *p++ = 'f';}
-  else
-    {
-      *p++ = '\\';
-      *p++ = code / 0100 + '0';
-      *p++ = ((code / 010) & 07) + '0';
-      *p++ = (code & 07) + '0';
-    }
-  *pp = p;
-  *pcode = code;
-  return  ! wasquote;
+    }                          /* has \ */
+
+  return res;

 }
 
 
 void
 }
 
 
 void

-unlex (int token)
+unlex (token_t token)

 {
   unlexed = token;
 {
   unlexed = token;

+  unlexed_token_buffer = token_buffer;

   unlexed_symval = symval;
 }
 
   unlexed_symval = symval;
 }
 

+/*-----------------------------------------------------------------.
+| We just read `<' from FIN.  Store in TOKEN_BUFFER, the type name |
+| specified between the `<...>'.                                   |
+`-----------------------------------------------------------------*/

 
 

-int
+void
+read_type_name (FILE *fin)
+{
+  int c = getc (fin);
+
+  while (c != '>')
+    {
+      if (c == EOF)
+       fatal (_("unterminated type name at end of file"));
+      if (c == '\n')
+       {
+         complain (_("unterminated type name"));
+         ungetc (c, fin);
+         break;
+       }
+
+      obstack_1grow (&token_obstack, c);
+      c = getc (fin);
+    }
+  obstack_1grow (&token_obstack, '\0');
+  token_buffer = obstack_finish (&token_obstack);
+}
+
+
+token_t

 lex (void)
 {
 lex (void)
 {

-  register int c;
-  char *p;
+  int c;
+
+  /* Just to make sure. */
+  token_buffer = NULL;

 
 

-  if (unlexed >= 0)
+  if (unlexed != tok_undef)

     {
     {

+      token_t res = unlexed;

       symval = unlexed_symval;
       symval = unlexed_symval;

-      c = unlexed;
-      unlexed = -1;
-      return (c);
+      token_buffer = unlexed_token_buffer;
+      unlexed = tok_undef;
+      return res;

     }
 
     }
 

-  c = skip_white_space();
-  *token_buffer = c;   /* for error messages (token buffer always valid) */
-  token_buffer[1] = 0;
+  c = skip_white_space ();

 
   switch (c)
     {
     case EOF:
 
   switch (c)
     {
     case EOF:

-      strcpy(token_buffer, "EOF");
-      return (ENDFILE);
-
-    case 'A':  case 'B':  case 'C':  case 'D':  case 'E':
-    case 'F':  case 'G':  case 'H':  case 'I':  case 'J':
-    case 'K':  case 'L':  case 'M':  case 'N':  case 'O':
-    case 'P':  case 'Q':  case 'R':  case 'S':  case 'T':
-    case 'U':  case 'V':  case 'W':  case 'X':  case 'Y':
+      token_buffer = "EOF";
+      return tok_eof;
+
+    case 'A':    case 'B':    case 'C':    case 'D':    case 'E':
+    case 'F':    case 'G':    case 'H':    case 'I':    case 'J':
+    case 'K':    case 'L':    case 'M':    case 'N':    case 'O':
+    case 'P':    case 'Q':    case 'R':    case 'S':    case 'T':
+    case 'U':    case 'V':    case 'W':    case 'X':    case 'Y':

     case 'Z':
     case 'Z':

-    case 'a':  case 'b':  case 'c':  case 'd':  case 'e':
-    case 'f':  case 'g':  case 'h':  case 'i':  case 'j':
-    case 'k':  case 'l':  case 'm':  case 'n':  case 'o':
-    case 'p':  case 'q':  case 'r':  case 's':  case 't':
-    case 'u':  case 'v':  case 'w':  case 'x':  case 'y':
+    case 'a':    case 'b':    case 'c':    case 'd':    case 'e':
+    case 'f':    case 'g':    case 'h':    case 'i':    case 'j':
+    case 'k':    case 'l':    case 'm':    case 'n':    case 'o':
+    case 'p':    case 'q':    case 'r':    case 's':    case 't':
+    case 'u':    case 'v':    case 'w':    case 'x':    case 'y':

     case 'z':
     case 'z':

-    case '.':  case '_':
-      p = token_buffer;
-      while (isalnum(c) || c == '_' || c == '.')
-       {
-         if (p == token_buffer + maxtoken)
-           p = grow_token_buffer(p);
+    case '.':    case '_':

 
 

-         *p++ = c;
-         c = getc(finput);
+      while (isalnum (c) || c == '_' || c == '.')
+       {
+         obstack_1grow (&token_obstack, c);
+         c = getc (finput);

        }
        }

-
-      *p = 0;
-      ungetc(c, finput);
-      symval = getsym(token_buffer);
-      return (IDENTIFIER);
-
-    case '0':  case '1':  case '2':  case '3':  case '4':
-    case '5':  case '6':  case '7':  case '8':  case '9':
+      obstack_1grow (&token_obstack, '\0');
+      token_buffer = obstack_finish (&token_obstack);
+      ungetc (c, finput);
+      symval = getsym (token_buffer);
+      return tok_identifier;
+
+    case '0':    case '1':    case '2':    case '3':    case '4':
+    case '5':    case '6':    case '7':    case '8':    case '9':

       {
        numval = 0;
 
       {
        numval = 0;
 

-       p = token_buffer;
-       while (isdigit(c))
+       while (isdigit (c))

          {
          {

-           if (p == token_buffer + maxtoken)
-             p = grow_token_buffer(p);
-
-           *p++ = c;
-           numval = numval*10 + c - '0';
-           c = getc(finput);
+           obstack_1grow (&token_obstack, c);
+           numval = numval * 10 + c - '0';
+           c = getc (finput);

          }
          }

-       *p = 0;
-       ungetc(c, finput);
-       return (NUMBER);
+       obstack_1grow (&token_obstack, '\0');
+       token_buffer = obstack_finish (&token_obstack);
+       ungetc (c, finput);
+       return tok_number;

       }
 
     case '\'':
       }
 
     case '\'':

-

       /* parse the literal token and compute character code in  code  */
 
       /* parse the literal token and compute character code in  code  */
 

-      translations = -1;

       {
       {

-       int code, discode;
-       char discard[10], *dp;
+       int code = literalchar ();

 
 

-       p = token_buffer;
-       *p++ = '\'';
-       literalchar(&p, &code, '\'');
+       obstack_1grow (&token_obstack, '\'');
+       obstack_1grow (&token_obstack, code);

 
 

-       c = getc(finput);
+       c = getc (finput);

        if (c != '\'')
          {
        if (c != '\'')
          {

-           warn(_("use \"...\" for multi-character literal tokens"));
-           while (1)
-             {
-               dp = discard;
-               if (! literalchar(&dp, &discode, '\''))
-                 break;
-             }
+           complain (_("use \"...\" for multi-character literal tokens"));
+           while (literalchar () != '\'')
+             /* Skip. */;

          }
          }

-       *p++ = '\'';
-       *p = 0;
-       symval = getsym(token_buffer);
-       symval->class = STOKEN;
-       if (! symval->user_token_number)
+       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 == SUNDEF)

          symval->user_token_number = code;
          symval->user_token_number = code;

-       return (IDENTIFIER);
+       return tok_identifier;

       }
 
     case '\"':
       }
 
     case '\"':

-

       /* parse the literal string token and treat as an identifier */
 
       /* parse the literal string token and treat as an identifier */
 

-      translations = -1;

       {
       {

-       int code;       /* ignored here */
-       p = token_buffer;
-       *p++ = '\"';
-       while (literalchar(&p, &code, '\"'))  /* read up to and including " */
+       int code;               /* ignored here */
+
+       obstack_1grow (&token_obstack, '\"');
+       /* Read up to and including ".  */
+       do

          {
          {

-           if (p >= token_buffer + maxtoken - 4)
-             p = grow_token_buffer(p);
+           code = literalchar ();
+           obstack_1grow (&token_obstack, code);

          }
          }

-       *p = 0;
+       while (code != '\"');
+       obstack_1grow (&token_obstack, '\0');
+       token_buffer = obstack_finish (&token_obstack);

 
 

-       symval = getsym(token_buffer);
-       symval->class = STOKEN;
+       symval = getsym (token_buffer);
+       symval->class = token_sym;

 
 

-       return (IDENTIFIER);
+       return tok_identifier;

       }
 
     case ',':
       }
 
     case ',':

-      return (COMMA);
+      token_buffer = ",";
+      return tok_comma;

 
     case ':':
 
     case ':':

-      return (COLON);
+      token_buffer = ":";
+      return tok_colon;

 
     case ';':
 
     case ';':

-      return (SEMICOLON);
+      token_buffer = ";";
+      return tok_semicolon;

 
     case '|':
 
     case '|':

-      return (BAR);
+      token_buffer = "|";
+      return tok_bar;

 
     case '{':
 
     case '{':

-      return (LEFT_CURLY);
+      token_buffer = "{";
+      return tok_left_curly;

 
     case '=':
 
     case '=':

+      obstack_1grow (&token_obstack, c);

       do
        {
       do
        {

-         c = getc(finput);
-         if (c == '\n') lineno++;
+         c = getc (finput);
+         obstack_1grow (&token_obstack, c);
+         if (c == '\n')
+           lineno++;

        }
        }

-      while(c==' ' || c=='\n' || c=='\t');
+      while (c == ' ' || c == '\n' || c == '\t');
+      obstack_1grow (&token_obstack, '\0');
+      token_buffer = obstack_finish (&token_obstack);

 
       if (c == '{')
        {
 
       if (c == '{')
        {

-         strcpy(token_buffer, "={");
-         return(LEFT_CURLY);
+         return tok_left_curly;

        }
       else
        {
        }
       else
        {

-         ungetc(c, finput);
-         return(ILLEGAL);
+         ungetc (c, finput);
+         return tok_illegal;

        }
 
     case '<':
        }
 
     case '<':

-      p = token_buffer;
-      c = getc(finput);
-      while (c != '>')
-       {
-         if (c == EOF)
-           fatal(_("unterminated type name at end of file"));
-         if (c == '\n')
-           {
-             warn(_("unterminated type name"));
-             ungetc(c, finput);
-             break;
-           }
-
-         if (p == token_buffer + maxtoken)
-           p = grow_token_buffer(p);
-
-         *p++ = c;
-         c = getc(finput);
-       }
-      *p = 0;
-      return (TYPENAME);
-
+      read_type_name (finput);
+      return tok_typename;

 
     case '%':
 
     case '%':

-      return (parse_percent_token());
+      return parse_percent_token ();

 
     default:
 
     default:

-      return (ILLEGAL);
+      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 setflag value causes the named flag to be
-       set.  A retval action returns the code.
-*/
-struct percent_table_struct {
-       char *name;
-       void *setflag;
-       int retval;
-} percent_table[] =
+/* This function is a strcmp, which doesn't differentiate `-' and `_'
+   chars.  */
+
+static int
+option_strcmp (const char *left, const char *right)

 {
 {

-  {"token", NULL, TOKEN},
-  {"term", NULL, TOKEN},
-  {"nterm", NULL, NTERM},
-  {"type", NULL, TYPE},
-  {"guard", NULL, GUARD},
-  {"union", NULL, UNION},
-  {"expect", NULL, EXPECT},
-  {"thong", NULL, THONG},
-  {"start", NULL, START},
-  {"left", NULL, LEFT},
-  {"right", NULL, RIGHT},
-  {"nonassoc", NULL, NONASSOC},
-  {"binary", NULL, NONASSOC},
-  {"semantic_parser", NULL, SEMANTIC_PARSER},
-  {"pure_parser", NULL, PURE_PARSER},
-  {"prec", NULL, PREC},
-
-  {"no_lines", &nolinesflag, NOOP}, /* -l */
-  {"raw", &rawtoknumflag, NOOP}, /* -r */
-  {"token_table", &toknumflag, NOOP}, /* -k */
-
-#if 0
-  /* These can be utilized after main is reoganized so
-     open_files() is deferred 'til after read_declarations().
-     But %{ and %union both put information into files
-     that have to be opened before read_declarations().
-     */
-  {"yacc", &fixed_outfiles, NOOP}, /* -y */
-  {"fixed_output_files", &fixed_outfiles, NOOP}, /* -y */
-  {"defines", &definesflag, NOOP}, /* -d */
-  {"no_parser", &noparserflag, NOOP}, /* -n */
-  {"output_file", &spec_outfile, SETOPT}, /* -o */
-  {"file_prefix", &spec_file_prefix, SETOPT}, /* -b */
-  {"name_prefix", &spec_name_prefix, SETOPT}, /* -p */
-
-  /* These would be acceptable, but they do not affect processing */
-  {"verbose", &verboseflag, NOOP}, /* -v */
-  {"debug", &debugflag, NOOP}, /* -t */
-  /*   {"help", <print usage stmt>, NOOP},*/   /* -h */
-  /*   {"version", <print version number> ,  NOOP},*/  /* -V */
-#endif
-
-  {NULL, NULL, 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.  */
 
 
 /* Parse a token which starts with %.
    Assumes the % has already been read and discarded.  */
 

-int
+token_t

 parse_percent_token (void)
 {
 parse_percent_token (void)
 {

-  register int c;
-  register char *p;
-  register 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;

 
 

-  p = token_buffer;
-  c = getc(finput);
-  *p++ = '%';
-  *p++ = c;    /* for error msg */
-  *p = 0;
+  int c = getc (finput);
+  obstack_1grow (&token_obstack, '%');
+  obstack_1grow (&token_obstack, c);

 
   switch (c)
     {
     case '%':
 
   switch (c)
     {
     case '%':

-      return (TWO_PERCENTS);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_two_percents;

 
     case '{':
 
     case '{':

-      return (PERCENT_LEFT_CURLY);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_percent_left_curly;

 
 

+      /* The following guys are here for backward compatibility with
+        very ancient Yacc versions.  The paper of Johnson mentions
+        them (as ancient :).  */

     case '<':
     case '<':

-      return (LEFT);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_left;

 
     case '>':
 
     case '>':

-      return (RIGHT);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_right;

 
     case '2':
 
     case '2':

-      return (NONASSOC);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_nonassoc;

 
     case '0':
 
     case '0':

-      return (TOKEN);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_token;

 
     case '=':
 
     case '=':

-      return (PREC);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_prec;

     }
     }

-  if (!isalpha(c))
-    return (ILLEGAL);

 
 

-  p = token_buffer;
-  *p++ = '%';
-  while (isalpha(c) || c == '_' || c == '-')
+  if (!isalpha (c))

     {
     {

-      if (p == token_buffer + maxtoken)
-       p = grow_token_buffer(p);
+      token_buffer = obstack_finish (&token_obstack);
+      return tok_illegal;
+    }

 
 

-      if (c == '-') c = '_';
-      *p++ = c;
-      c = getc(finput);
+  while (c = getc (finput), isalpha (c) || c == '_' || c == '-')
+    {
+      if (c == '_')
+       c = '-';
+      obstack_1grow (&token_obstack, c);

     }
 
     }
 

-  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);

 
 

-  *p = 0;
+  obstack_1grow (&token_obstack, '\0');
+  token_buffer = obstack_finish (&token_obstack);
+  if (arg_offset)
+    arg = token_buffer + arg_offset;

 
   /* table lookup % directive */
 
   /* 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;
       break;

-  if (tx->retval == SETOPT)
-    {
-      *((char **)(tx->setflag)) = optarg;
-      return NOOP;
-    }
-  if (tx->setflag)
+
+  if (arg && tx->ret_val != tok_stropt)
+    fatal (_("`%s' supports no argument: %s"), token_buffer, quote (arg));
+
+
+  switch (tx->ret_val)

     {
     {

-      *((int *)(tx->setflag)) = 1;
-      return NOOP;
+    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:
+      return tx->ret_val;
+      break;

     }
     }

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

 }
 }