s/return (foo)/return foo/

[bison.git] / src / lex.c

diff --git a/src/lex.c b/src/lex.c
index 20d89a1ec6467ec34d0a8d468c3d78b5fa901aff..b59793bcc18f72ca6f69e09536b9360a4ae0cf0a 100644 (file)
--- a/src/lex.c
+++ b/src/lex.c
@@ -1,52 +1,72 @@
 /* Token-reader for Bison's input parser,
 /* Token-reader for Bison's input parser,

-   Copyright (C) 1984, 1986, 1989 Free Software Foundation, Inc.
+   Copyright (C) 1984, 1986, 1989, 1992, 2000 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.
+/*
+   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>
    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 <ctype.h>

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

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

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

-#include "new.h"
+#include "alloc.h"
+#include "complain.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;
 
 extern int translations;
 

-int parse_percent_token();
+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));

 
 

-extern void fatals();
-extern void fatal();
+/* functions from main.c */
+extern char *printable_version PARAMS((int));

 
 /* Buffer for storing the current token.  */
 char *token_buffer;
 
 /* Allocated size of token_buffer, not including space for terminator.  */
 
 /* Buffer for storing the current token.  */
 char *token_buffer;
 
 /* Allocated size of token_buffer, not including space for terminator.  */

-static int maxtoken;
+int maxtoken;

 
 bucket *symval;
 int numval;
 
 bucket *symval;
 int numval;


@@ -56,7 +76,7 @@ static bucket *unlexed_symval;        /* by the next call to lex */
 
 
 void
 
 
 void

-init_lex()
+init_lex (void)

 {
   maxtoken = 100;
   token_buffer = NEW2 (maxtoken + 1, char);
 {
   maxtoken = 100;
   token_buffer = NEW2 (maxtoken + 1, char);


@@ -64,9 +84,8 @@ init_lex()
 }
 
 
 }
 
 

-static char *
-grow_token_buffer (p)
-     char *p;
+char *
+grow_token_buffer (char *p)

 {
   int offset = p - token_buffer;
   maxtoken *= 2;
 {
   int offset = p - token_buffer;
   maxtoken *= 2;


@@ -76,7 +95,7 @@ grow_token_buffer (p)
 
 
 int
 
 
 int

-skip_white_space()
+skip_white_space (void)

 {
   register int c;
   register int inside;
 {
   register int c;
   register int inside;


@@ -92,7 +111,10 @@ skip_white_space()
        case '/':
          c = getc(finput);
          if (c != '*' && c != '/')
        case '/':
          c = getc(finput);
          if (c != '*' && c != '/')

-           fatals("unexpected `/%c' found",c);
+           {
+             complain (_("unexpected `/' found and ignored"));
+             break;
+           }

          cplus_comment = (c == '/');
 
          c = getc(finput);
          cplus_comment = (c == '/');
 
          c = getc(finput);


@@ -119,7 +141,7 @@ skip_white_space()
                  c = getc(finput);
                }
              else if (c == EOF)
                  c = getc(finput);
                }
              else if (c == EOF)

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

              else
                c = getc(finput);
            }
              else
                c = getc(finput);
            }


@@ -136,42 +158,174 @@ skip_white_space()
          break;
 
        default:
          break;
 
        default:

-         return (c);
+         return c;

        }
     }
 }
 
        }
     }
 }
 

+/* do a getc, but give error message if EOF encountered */
+int
+safegetc (FILE *f)
+{
+  register int c = getc(f);
+  if (c == EOF)
+    fatal (_("unexpected end of file"));
+  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)
+{
+  register int c;
+  register char *p;
+  register int code;
+  int wasquote = 0;
+
+  c = safegetc(finput);
+  if (c == '\n')
+    {
+      complain (_("unescaped newline in constant"));
+      ungetc(c, finput);
+      code = '?';
+      wasquote = 1;
+    }
+  else if (c != '\\')
+    {
+      code = c;
+      if (c == term)
+       wasquote = 1;
+    }
+  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 = '\"';
+      else if (c <= '7' && c >= '0')
+       {
+         code = 0;
+         while (c <= '7' && c >= '0')
+           {
+             code = (code * 8) + (c - '0');
+             if (code >= 256 || code < 0)
+               {
+                 complain (_("octal value outside range 0...255: `\\%o'"),
+                           code);
+                 code &= 0xFF;
+                 break;
+               }
+             c = safegetc(finput);
+           }
+         ungetc(c, finput);
+       }
+      else if (c == 'x')
+       {
+         c = safegetc(finput);
+         code = 0;
+         while (1)
+           {
+             if (c >= '0' && c <= '9')
+               code *= 16,  code += c - '0';
+             else if (c >= 'a' && c <= 'f')
+               code *= 16,  code += c - 'a' + 10;
+             else if (c >= 'A' && c <= 'F')
+               code *= 16,  code += c - 'A' + 10;
+             else
+               break;
+             if (code >= 256 || code<0)
+               {
+                 complain (_("hexadecimal value above 255: `\\x%x'"),
+                           code);
+                 code &= 0xFF;
+                 break;
+               }
+             c = safegetc(finput);
+           }
+         ungetc(c, finput);
+       }
+      else
+       {
+         complain (_("unknown escape sequence: `\\' followed by `%s'"),
+                   printable_version(c));
+         code = '?';
+       }
+    } /* 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 == term && wasquote)
+    *p++ = code;
+  else 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;
+}
+

 
 void
 
 void

-unlex(token)
-int token;
+unlex (int token)

 {
   unlexed = token;
   unlexed_symval = symval;
 }
 
 
 {
   unlexed = token;
   unlexed_symval = symval;
 }
 
 

-

 int
 int

-lex()
+lex (void)

 {
   register int c;
 {
   register int c;

-  register char *p;
+  char *p;

 
   if (unlexed >= 0)
     {
       symval = unlexed_symval;
       c = unlexed;
       unlexed = -1;
 
   if (unlexed >= 0)
     {
       symval = unlexed_symval;
       c = unlexed;
       unlexed = -1;

-      return (c);
+      return c;

     }
 
   c = skip_white_space();
     }
 
   c = skip_white_space();

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

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

-      return (ENDFILE);
+      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 'A':  case 'B':  case 'C':  case 'D':  case 'E':
     case 'F':  case 'G':  case 'H':  case 'I':  case 'J':


@@ -199,183 +353,97 @@ lex()
       *p = 0;
       ungetc(c, finput);
       symval = getsym(token_buffer);
       *p = 0;
       ungetc(c, finput);
       symval = getsym(token_buffer);

-      return (IDENTIFIER);
+      return IDENTIFIER;

 
     case '0':  case '1':  case '2':  case '3':  case '4':
     case '5':  case '6':  case '7':  case '8':  case '9':
       {
        numval = 0;
 
 
     case '0':  case '1':  case '2':  case '3':  case '4':
     case '5':  case '6':  case '7':  case '8':  case '9':
       {
        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);
          }
            numval = numval*10 + c - '0';
            c = getc(finput);
          }

+       *p = 0;

        ungetc(c, finput);
        ungetc(c, finput);

-       return (NUMBER);
+       return NUMBER;

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

-      translations = -1;

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

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

       {
       {

-       register int code = 0;
+       int code, discode;
+       char discard[10], *dp;

 
 

-       if (c == '\\')
-         {
-           c = getc(finput);
+       p = token_buffer;
+       *p++ = '\'';
+       literalchar(&p, &code, '\'');

 
 

-           if (c <= '7' && c >= '0')
-             {
-               while (c <= '7' && c >= '0')
-                 {
-                   code = (code * 8) + (c - '0');
-                   c = getc(finput);
-                   if (code >= 256 || code < 0)
-                     fatals("malformatted literal token `\\%03o'", code);
-                 }
-             }
-           else
+       c = getc(finput);
+       if (c != '\'')
+         {
+           complain (_("use \"...\" for multi-character literal tokens"));
+           while (1)

              {
              {

-               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 == 'x')
-                 {
-                   c = getc(finput);
-                   while ((c <= '9' && c >= '0')
-                          || (c >= 'a' && c <= 'z')
-                          || (c >= 'A' && c <= 'Z'))
-                     {
-                       code *= 16;
-                       if (c <= '9' && c >= '0')
-                         code += c - '0';
-                       else if (c >= 'a' && c <= 'z')
-                         code += c - 'a' + 10;
-                       else if (c >= 'A' && c <= 'Z')
-                         code += c - 'A' + 10;
-                       if (code >= 256 || code<0)/* JF this said if(c>=128) */
-                         fatals("malformatted literal token `\\x%x'",code);
-                       c = getc(finput);
-                     }
-                   ungetc(c, finput);
-                 }
-               else if (c == '\\')
-                 code = '\\';
-               else if (c == '\'')
-                 code = '\'';
-               else if (c == '\"')     /* JF this is a good idea */
-                 code = '\"';
-               else
-                 {
-                   if (c >= 040 && c <= 0177)
-                     fatals ("unknown escape sequence `\\%c'", c);
-                   else
-                     fatals ("unknown escape sequence: `\\' followed by char code 0x%x", c);
-                 }
-
-               c = getc(finput);
+               dp = discard;
+               if (! literalchar(&dp, &discode, '\''))
+                 break;

              }
          }
              }
          }

-       else
-         {
-           code = c;
-           c = getc(finput);
-         }
-       if (c != '\'')
-         fatal("multicharacter literal tokens not supported");
+       *p++ = '\'';
+       *p = 0;
+       symval = getsym(token_buffer);
+       symval->class = STOKEN;
+       if (! symval->user_token_number)
+         symval->user_token_number = code;
+       return IDENTIFIER;
+      }

 
 

-       /* 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.  */
+    case '\"':

 
 

+      /* parse the literal string token and treat as an identifier */
+
+      translations = -1;
+      {
+       int code;       /* ignored here */

        p = token_buffer;
        p = token_buffer;

-       *p++ = '\'';
-       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++ = '\"';
+       while (literalchar(&p, &code, '\"'))  /* read up to and including " */

          {
          {

-           *p++ = '\\';
-           *p++ = 'f';
+           if (p >= token_buffer + maxtoken - 4)
+             p = grow_token_buffer(p);

          }
          }

-        else
-         {
-           *p++ = code / 0100 + '0';
-           *p++ = ((code / 010) & 07) + '0';
-           *p++ = (code & 07) + '0';
-         }
-       *p++ = '\'';

        *p = 0;
        *p = 0;

+

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

-       if (! symval->user_token_number)
-         symval->user_token_number = code;
-       return (IDENTIFIER);
+
+       return IDENTIFIER;

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

-      return (COMMA);
+      return COMMA;

 
     case ':':
 
     case ':':

-      return (COLON);
+      return COLON;

 
     case ';':
 
     case ';':

-      return (SEMICOLON);
+      return SEMICOLON;

 
     case '|':
 
     case '|':

-      return (BAR);
+      return BAR;

 
     case '{':
 
     case '{':

-      return (LEFT_CURLY);
+      return LEFT_CURLY;

 
     case '=':
       do
 
     case '=':
       do


@@ -386,11 +454,14 @@ lex()
       while(c==' ' || c=='\n' || c=='\t');
 
       if (c == '{')
       while(c==' ' || c=='\n' || c=='\t');
 
       if (c == '{')

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

       else
        {
          ungetc(c, finput);
       else
        {
          ungetc(c, finput);

-         return(ILLEGAL);
+         return ILLEGAL;

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


@@ -398,8 +469,14 @@ lex()
       c = getc(finput);
       while (c != '>')
        {
       c = getc(finput);
       while (c != '>')
        {

-         if (c == '\n' || c == EOF)
-           fatal("unterminated type name");
+         if (c == EOF)
+           fatal (_("unterminated type name at end of file"));
+         if (c == '\n')
+           {
+             complain (_("unterminated type name"));
+             ungetc(c, finput);
+             break;
+           }

 
          if (p == token_buffer + maxtoken)
            p = grow_token_buffer(p);
 
          if (p == token_buffer + maxtoken)
            p = grow_token_buffer(p);


@@ -408,60 +485,122 @@ lex()
          c = getc(finput);
        }
       *p = 0;
          c = getc(finput);
        }
       *p = 0;

-      return (TYPENAME);
-           
+      return TYPENAME;
+

 
     case '%':
 
     case '%':

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

 
     default:
 
     default:

-      return (ILLEGAL);
+      return ILLEGAL;

     }
 }
 
     }
 }
 

-
-/* parse a token which starts with %.  Assumes the % has already been read and discarded.  */
+/* 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[] =
+{
+  {"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}
+};
+
+/* Parse a token which starts with %.
+   Assumes the % has already been read and discarded.  */

 
 int
 
 int

-parse_percent_token ()
+parse_percent_token (void)

 {
   register int c;
   register char *p;
 {
   register int c;
   register char *p;

+  register struct percent_table_struct *tx;

 
   p = token_buffer;
   c = getc(finput);
 
   p = token_buffer;
   c = getc(finput);

+  *p++ = '%';
+  *p++ = c;    /* for error msg */
+  *p = 0;

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

-      return (TWO_PERCENTS);
+      return TWO_PERCENTS;

 
     case '{':
 
     case '{':

-      return (PERCENT_LEFT_CURLY);
+      return PERCENT_LEFT_CURLY;

 
     case '<':
 
     case '<':

-      return (LEFT);
+      return LEFT;

 
     case '>':
 
     case '>':

-      return (RIGHT);
+      return RIGHT;

 
     case '2':
 
     case '2':

-      return (NONASSOC);
+      return NONASSOC;

 
     case '0':
 
     case '0':

-      return (TOKEN);
+      return TOKEN;

 
     case '=':
 
     case '=':

-      return (PREC);
+      return PREC;

     }
   if (!isalpha(c))
     }
   if (!isalpha(c))

-    return (ILLEGAL);
+    return ILLEGAL;

 
 

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

     {
       if (p == token_buffer + maxtoken)
        p = grow_token_buffer(p);
 
     {
       if (p == token_buffer + maxtoken)
        p = grow_token_buffer(p);
 

+      if (c == '-') c = '_';

       *p++ = c;
       c = getc(finput);
     }
       *p++ = c;
       c = getc(finput);
     }


@@ -470,35 +609,19 @@ parse_percent_token ()
 
   *p = 0;
 
 
   *p = 0;
 

-  if (strcmp(token_buffer, "token") == 0
-      ||
-      strcmp(token_buffer, "term") == 0)
-    return (TOKEN);
-  else if (strcmp(token_buffer, "nterm") == 0)
-    return (NTERM);
-  else if (strcmp(token_buffer, "type") == 0)
-    return (TYPE);
-  else if (strcmp(token_buffer, "guard") == 0)
-    return (GUARD);
-  else if (strcmp(token_buffer, "union") == 0)
-    return (UNION);
-  else if (strcmp(token_buffer, "expect") == 0)
-    return (EXPECT);
-  else if (strcmp(token_buffer, "start") == 0)
-    return (START);
-  else if (strcmp(token_buffer, "left") == 0)
-    return (LEFT);
-  else if (strcmp(token_buffer, "right") == 0)
-    return (RIGHT);
-  else if (strcmp(token_buffer, "nonassoc") == 0
-          ||
-          strcmp(token_buffer, "binary") == 0)
-    return (NONASSOC);
-  else if (strcmp(token_buffer, "semantic_parser") == 0)
-    return (SEMANTIC_PARSER);
-  else if (strcmp(token_buffer, "pure_parser") == 0)
-    return (PURE_PARSER);
-  else if (strcmp(token_buffer, "prec") == 0)
-    return (PREC);
-  else return (ILLEGAL);
+  /* table lookup % directive */
+  for (tx = percent_table; tx->name; tx++)
+    if (strcmp(token_buffer+1, tx->name) == 0)
+      break;
+  if (tx->retval == SETOPT)
+    {
+      *((char **)(tx->setflag)) = optarg;
+      return NOOP;
+    }
+  if (tx->setflag)
+    {
+      *((int *)(tx->setflag)) = 1;
+      return NOOP;
+    }
+  return tx->retval;

 }
 }