gcc/ch/hash.h

   1 /* C code produced by gperf version 2.7.1 (19981006 egcs) */
   2 /* Command-line: gperf -L C -F , 0, 0, 0 -D -E -S1 -p -j1 -i 1 -g -o -t -k* gperf.tmp  */
   3 struct resword {
   4   const char  *name;
   5   short        token;
   6   enum rid     rid;
   7   enum toktype { RESERVED, DIRECTIVE, PREDEF } flags;
   8 };
   9 extern tree ridpointers [];
  10 #ifdef __GNUC__
  11 __inline
  12 #endif
  13 static unsigned int hash        PARAMS ((const char *, unsigned int));
  14 #ifdef __GNUC__
  15 __inline
  16 #endif
  17 struct resword *in_word_set     PARAMS ((const char *, unsigned int));
  18 /* maximum key range = 2815, duplicates = 6 */
  19
  20 #ifdef __GNUC__
  21 __inline
  22 #endif
  23 static unsigned int
  24 hash (str, len)
  25      register const char *str;
  26      register unsigned int len;
  27 {
  28   static unsigned short asso_values[] =
  29     {
  30       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  31       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  32       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  33       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  34       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  35       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  36       2822, 2822, 2822, 2822, 2822,    4,   61,   80,   12,  350,
  37         91,   39,    3,    2, 2822,    4,  129,  155,   64,   46,
  38         65, 2822,   96,   13,    1,  135,    7,    2,    8,  124,
  39          7, 2822, 2822, 2822, 2822,    1, 2822,   94,   40,  127,
  40         21,    1,   81,    1,    1,    7, 2822,    3,   23,   74,
  41        255,  203,   70, 2822,  218,    1,   88,  124,    1,    6,
  42         10,   56,   40, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  43       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  44       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  45       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  46       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  47       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  48       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  49       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  50       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  51       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  52       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  53       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  54       2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822, 2822,
  55       2822, 2822, 2822, 2822, 2822, 2822
  56     };
  57   register int hval = len;
  58
  59   switch (hval)
  60     {
  61       default:
  62       case 30:
  63         hval += asso_values[(unsigned char)str[29]];
  64       case 29:
  65         hval += asso_values[(unsigned char)str[28]];
  66       case 28:
  67         hval += asso_values[(unsigned char)str[27]];
  68       case 27:
  69         hval += asso_values[(unsigned char)str[26]];
  70       case 26:
  71         hval += asso_values[(unsigned char)str[25]];
  72       case 25:
  73         hval += asso_values[(unsigned char)str[24]];
  74       case 24:
  75         hval += asso_values[(unsigned char)str[23]];
  76       case 23:
  77         hval += asso_values[(unsigned char)str[22]];
  78       case 22:
  79         hval += asso_values[(unsigned char)str[21]];
  80       case 21:
  81         hval += asso_values[(unsigned char)str[20]];
  82       case 20:
  83         hval += asso_values[(unsigned char)str[19]];
  84       case 19:
  85         hval += asso_values[(unsigned char)str[18]];
  86       case 18:
  87         hval += asso_values[(unsigned char)str[17]];
  88       case 17:
  89         hval += asso_values[(unsigned char)str[16]];
  90       case 16:
  91         hval += asso_values[(unsigned char)str[15]];
  92       case 15:
  93         hval += asso_values[(unsigned char)str[14]];
  94       case 14:
  95         hval += asso_values[(unsigned char)str[13]];
  96       case 13:
  97         hval += asso_values[(unsigned char)str[12]];
  98       case 12:
  99         hval += asso_values[(unsigned char)str[11]];
 100       case 11:
 101         hval += asso_values[(unsigned char)str[10]];
 102       case 10:
 103         hval += asso_values[(unsigned char)str[9]];
 104       case 9:
 105         hval += asso_values[(unsigned char)str[8]];
 106       case 8:
 107         hval += asso_values[(unsigned char)str[7]];
 108       case 7:
 109         hval += asso_values[(unsigned char)str[6]];
 110       case 6:
 111         hval += asso_values[(unsigned char)str[5]];
 112       case 5:
 113         hval += asso_values[(unsigned char)str[4]];
 114       case 4:
 115         hval += asso_values[(unsigned char)str[3]];
 116       case 3:
 117         hval += asso_values[(unsigned char)str[2]];
 118       case 2:
 119         hval += asso_values[(unsigned char)str[1]];
 120       case 1:
 121         hval += asso_values[(unsigned char)str[0]];
 122         break;
 123     }
 124   return hval;
 125 }
 126
 127 #ifdef __GNUC__
 128 __inline
 129 #endif
 130 struct resword *
 131 in_word_set (str, len)
 132      register const char *str;
 133      register unsigned int len;
 134 {
 135   enum
 136     {
 137       TOTAL_KEYWORDS = 300,
 138       MIN_WORD_LENGTH = 2,
 139       MAX_WORD_LENGTH = 30,
 140       MIN_HASH_VALUE = 7,
 141       MAX_HASH_VALUE = 2821
 142     };
 143
 144   static struct resword wordlist[] =
 145     {
 146       {"AT",                    AT,                     NORID,  RESERVED},
 147       {"WITH",                  WITH,                   NORID,  RESERVED},
 148       {"THIS",                  THIS,                   NORID,  RESERVED},
 149       {"else",                  ELSE,                   NORID,  RESERVED},
 150       {"while",                 WHILE,                  NORID,  RESERVED},
 151       {"TO",                    TO,                     NORID,  RESERVED},
 152       {"seize",                 SEIZE,                  NORID,  RESERVED},
 153       {"DO",                    DO,                     NORID,  RESERVED},
 154       {"OD",                    OD,                     NORID,  RESERVED},
 155       {"BIT",                   BOOLS,                  RID_BOOLS,      PREDEF},
 156       {"IN",                    IN,                     RID_IN, RESERVED},
 157       {"INIT",                  INIT,                   NORID,  RESERVED},
 158       {"AND",                   AND,                    NORID,  RESERVED},
 159       {"fi",                    FI,                     NORID,  RESERVED},
 160       {"if",                    IF,                     NORID,  RESERVED},
 161       {"set",                   SET,                    NORID,  RESERVED},
 162       {"FI",                    FI,                     NORID,  RESERVED},
 163       {"IF",                    IF,                     NORID,  RESERVED},
 164       {"by",                    BY,                     NORID,  RESERVED},
 165       {"this",                  THIS,                   NORID,  RESERVED},
 166       {"with",                  WITH,                   NORID,  RESERVED},
 167       {"STATIC",                        STATIC,                 NORID,  RESERVED},
 168       {"exit",                  EXIT,                   NORID,  RESERVED},
 169       {"ON",                    ON,                     NORID,  RESERVED},
 170       {"NOT",                   NOT,                    NORID,  RESERVED},
 171       {"elsif",                 ELSIF,                  NORID,  RESERVED},
 172       {"START",                 START,                  NORID,  RESERVED},
 173       {"list",                  IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 174       {"POS",                   POS,                    NORID,  RESERVED},
 175       {"DOWN",                  DOWN,                   NORID,  RESERVED},
 176       {"STOP",                  STOP,                   NORID,  RESERVED},
 177       {"BIN",                   BIN,                    NORID,  RESERVED},
 178       {"GOTO",                  GOTO,                   NORID,  RESERVED},
 179       {"bit",                   BOOLS,                  RID_BOOLS,      PREDEF},
 180       {"OF",                    OF,                     NORID,  RESERVED},
 181       {"all",                   ALL,                    NORID,  RESERVED},
 182       {"OR",                    OR,                     NORID,  RESERVED},
 183       {"ROW",                   ROW,                    NORID,  RESERVED},
 184       {"LIST",                  IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 185       {"XOR",                   XOR,                    NORID,  RESERVED},
 186       {"PACK",                  PACK,                   NORID,  RESERVED},
 187       {"based",                 BASED,                  NORID,  RESERVED},
 188       {"step",                  STEP,                   NORID,  RESERVED},
 189       {"page",                  IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 190       {"asm",                   ASM_KEYWORD,            NORID,  RESERVED},
 191       {"dcl",                   DCL,                    NORID,  RESERVED},
 192       {"ASM",                   ASM_KEYWORD,            NORID,  RESERVED},
 193       {"ANDIF",                 ANDIF,                  NORID,  RESERVED},
 194       {"simple",                        SIMPLE,                 NORID,  RESERVED},
 195       {"at",                    AT,                     NORID,  RESERVED},
 196       {"OUT",                   PARAMATTR,              RID_OUT,        RESERVED},
 197       {"BY",                    BY,                     NORID,  RESERVED},
 198       {"text",                  TEXT,                   NORID,  RESERVED},
 199       {"FAR",                   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 200       {"up",                    UP,                     NORID,  RESERVED},
 201       {"delay",                 DELAY,                  NORID,  RESERVED},
 202       {"CHARS",                 CHARS,                  NORID,  RESERVED},
 203       {"UP",                    UP,                     NORID,  RESERVED},
 204       {"spec",                  SPEC,                   NORID,  RESERVED},
 205       {"SYN",                   SYN,                    NORID,  RESERVED},
 206       {"GRANT",                 GRANT,                  NORID,  RESERVED},
 207       {"MOD",                   MOD,                    NORID,  RESERVED},
 208       {"small",                 IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 209       {"DCL",                   DCL,                    NORID,  RESERVED},
 210       {"ever",                  EVER,                   NORID,  RESERVED},
 211       {"do",                    DO,                     NORID,  RESERVED},
 212       {"od",                    OD,                     NORID,  RESERVED},
 213       {"case",                  CASE,                   NORID,  RESERVED},
 214       {"esac",                  ESAC,                   NORID,  RESERVED},
 215       {"CCITT_OS",              IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 216       {"FOR",                   FOR,                    NORID,  RESERVED},
 217       {"ORIF",                  ORIF,                   NORID,  RESERVED},
 218       {"BODY",                  BODY,                   NORID,  RESERVED},
 219       {"INOUT",                 PARAMATTR,              RID_INOUT,      RESERVED},
 220       {"SIGNAL",                        SIGNAL,                 NORID,  RESERVED},
 221       {"LOC",                   LOC,                    NORID,  RESERVED},
 222       {"NOLIST",                        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 223       {"even",                  IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 224       {"in",                    IN,                     RID_IN, RESERVED},
 225       {"ALL",                   ALL,                    NORID,  RESERVED},
 226       {"NOPACK",                        NOPACK,                 NORID,  RESERVED},
 227       {"call",                  CALL,                   NORID,  RESERVED},
 228       {"pos",                   POS,                    NORID,  RESERVED},
 229       {"end",                   END,                    NORID,  RESERVED},
 230       {"send",                  SEND,                   NORID,  RESERVED},
 231       {"of",                    OF,                     NORID,  RESERVED},
 232       {"PROC",                  PROC,                   NORID,  RESERVED},
 233       {"to",                    TO,                     NORID,  RESERVED},
 234       {"rem",                   REM,                    NORID,  RESERVED},
 235       {"pack",                  PACK,                   NORID,  RESERVED},
 236       {"BOOLS",                 BOOLS,                  RID_BOOLS,      RESERVED},
 237       {"mod",                   MOD,                    NORID,  RESERVED},
 238       {"ref",                   REF,                    NORID,  RESERVED},
 239       {"use_seize_file",                USE_SEIZE_FILE,         NORID,  DIRECTIVE},
 240       {"bin",                   BIN,                    NORID,  RESERVED},
 241       {"medium",                        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 242       {"begin",                 BEGINTOKEN,             NORID,  RESERVED},
 243       {"FORBID",                        FORBID,                 NORID,  RESERVED},
 244       {"syn",                   SYN,                    NORID,  RESERVED},
 245       {"body",                  BODY,                   NORID,  RESERVED},
 246       {"ARRAY",                 ARRAY,                  NORID,  RESERVED},
 247       {"STRUCT",                        STRUCT,                 NORID,  RESERVED},
 248       {"read",                  READ,                   RID_READ,       RESERVED},
 249       {"cycle",                 CYCLE,                  NORID,  RESERVED},
 250       {"large",                 IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 251       {"VARYING",               VARYING,                NORID,  RESERVED},
 252       {"CALL",                  CALL,                   NORID,  RESERVED},
 253       {"then",                  THEN,                   NORID,  RESERVED},
 254       {"event",                 EVENT,                  NORID,  RESERVED},
 255       {"cause",                 CAUSE,                  NORID,  RESERVED},
 256       {"loc",                   LOC,                    NORID,  RESERVED},
 257       {"access",                        ACCESS,                 NORID,  RESERVED},
 258       {"init",                  INIT,                   NORID,  RESERVED},
 259       {"receive",               RECEIVE,                NORID,  RESERVED},
 260       {"TEXT",                  TEXT,                   NORID,  RESERVED},
 261       {"EXIT",                  EXIT,                   NORID,  RESERVED},
 262       {"stop",                  STOP,                   NORID,  RESERVED},
 263       {"SET",                   SET,                    NORID,  RESERVED},
 264       {"and",                   AND,                    NORID,  RESERVED},
 265       {"signal",                        SIGNAL,                 NORID,  RESERVED},
 266       {"far",                   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 267       {"assert",                        ASSERT,                 NORID,  RESERVED},
 268       {"static",                        STATIC,                 NORID,  RESERVED},
 269       {"debug_types",           IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 270       {"prefixed",              PREFIXED,               NORID,  RESERVED},
 271       {"out",                   PARAMATTR,              RID_OUT,        RESERVED},
 272       {"THEN",                  THEN,                   NORID,  RESERVED},
 273       {"or",                    OR,                     NORID,  RESERVED},
 274       {"END",                   END,                    NORID,  RESERVED},
 275       {"row",                   ROW,                    NORID,  RESERVED},
 276       {"STEP",                  STEP,                   NORID,  RESERVED},
 277       {"xor",                   XOR,                    NORID,  RESERVED},
 278       {"SMALL",                 IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 279       {"PRIORITY",              PRIORITY,               NORID,  RESERVED},
 280       {"SEND",                  SEND,                   NORID,  RESERVED},
 281       {"BASED",                 BASED,                  NORID,  RESERVED},
 282       {"chars",                 CHARS,                  NORID,  RESERVED},
 283       {"DYNAMIC",               DYNAMIC,                RID_DYNAMIC,    RESERVED},
 284       {"CASE",                  CASE,                   NORID,  RESERVED},
 285       {"ESAC",                  ESAC,                   NORID,  RESERVED},
 286       {"module",                        MODULE,                 NORID,  RESERVED},
 287       {"on",                    ON,                     NORID,  RESERVED},
 288       {"result",                        RESULT,                 NORID,  RESERVED},
 289       {"PAGE",                  IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 290       {"andif",                 ANDIF,                  NORID,  RESERVED},
 291       {"READ",                  READ,                   RID_READ,       RESERVED},
 292       {"bools",                 BOOLS,                  RID_BOOLS,      RESERVED},
 293       {"ASSERT",                        ASSERT,                 NORID,  RESERVED},
 294       {"debug_lines",           IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 295       {"after",                 AFTER,                  NORID,  RESERVED},
 296       {"ALL_STATIC_ON",         ALL_STATIC_ON,          NORID,  DIRECTIVE},
 297       {"down",                  DOWN,                   NORID,  RESERVED},
 298       {"WHILE",                 WHILE,                  NORID,  RESERVED},
 299       {"start",                 START,                  NORID,  RESERVED},
 300       {"optimize",              IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 301       {"goto",                  GOTO,                   NORID,  RESERVED},
 302       {"for",                   FOR,                    NORID,  RESERVED},
 303       {"SPEC",                  SPEC,                   NORID,  RESERVED},
 304       {"orif",                  ORIF,                   NORID,  RESERVED},
 305       {"BEGIN",                 BEGINTOKEN,             NORID,  RESERVED},
 306       {"REF",                   REF,                    NORID,  RESERVED},
 307       {"OPTIMIZATION_WINDOW",   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 308       {"ACCESS",                        ACCESS,                 NORID,  RESERVED},
 309       {"AFTER",                 AFTER,                  NORID,  RESERVED},
 310       {"not",                   NOT,                    NORID,  RESERVED},
 311       {"buffer",                        BUFFER,                 NORID,  RESERVED},
 312       {"inline",                        INLINE,                 RID_INLINE,     RESERVED},
 313       {"CONTEXT",               CONTEXT,                NORID,  RESERVED},
 314       {"RANGE",                 RANGE,                  NORID,  RESERVED},
 315       {"newmode",               NEWMODE,                NORID,  RESERVED},
 316       {"range",                 RANGE,                  NORID,  RESERVED},
 317       {"forbid",                        FORBID,                 NORID,  RESERVED},
 318       {"nolist",                        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 319       {"CAUSE",                 CAUSE,                  NORID,  RESERVED},
 320       {"ELSIF",                 ELSIF,                  NORID,  RESERVED},
 321       {"remote",                        REMOTE,                 NORID,  RESERVED},
 322       {"timeout",               TIMEOUT,                NORID,  RESERVED},
 323       {"powerset",              POWERSET,               NORID,  RESERVED},
 324       {"debug_symbols",         IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 325       {"general",               GENERAL,                NORID,  RESERVED},
 326       {"REGION",                        REGION,                 NORID,  RESERVED},
 327       {"REM",                   REM,                    NORID,  RESERVED},
 328       {"ALL_STATIC_OFF",                ALL_STATIC_OFF,         NORID,  DIRECTIVE},
 329       {"INLINE",                        INLINE,                 RID_INLINE,     RESERVED},
 330       {"synmode",               SYNMODE,                NORID,  RESERVED},
 331       {"proc",                  PROC,                   NORID,  RESERVED},
 332       {"LARGE",                 IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 333       {"DELAY",                 DELAY,                  NORID,  RESERVED},
 334       {"process",               PROCESS,                NORID,  RESERVED},
 335       {"OPTIMIZE",              IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 336       {"varying",               VARYING,                NORID,  RESERVED},
 337       {"dynamic",               DYNAMIC,                RID_DYNAMIC,    RESERVED},
 338       {"ccitt_os",              IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 339       {"struct",                        STRUCT,                 NORID,  RESERVED},
 340       {"grant",                 GRANT,                  NORID,  RESERVED},
 341       {"empty_off",             EMPTY_OFF,              NORID,  DIRECTIVE},
 342       {"PROCESS",               PROCESS,                NORID,  RESERVED},
 343       {"RANGE_ON",              RANGE_ON,               NORID,  DIRECTIVE},
 344       {"inout",                 PARAMATTR,              RID_INOUT,      RESERVED},
 345       {"array",                 ARRAY,                  NORID,  RESERVED},
 346       {"region",                        REGION,                 NORID,  RESERVED},
 347       {"TIMEOUT",               TIMEOUT,                NORID,  RESERVED},
 348       {"recursive",             RECURSIVE,              NORID,  RESERVED},
 349       {"event_code",            IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 350       {"NONREF",                        NONREF,                 NORID,  RESERVED},
 351       {"SIMPLE",                        SIMPLE,                 NORID,  RESERVED},
 352       {"SEIZE",                 SEIZE,                  NORID,  RESERVED},
 353       {"RESULT",                        RESULT,                 NORID,  RESERVED},
 354       {"multiple_data_segs",    IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 355       {"signal_code",           SIGNAL_CODE,            NORID,  DIRECTIVE},
 356       {"RETURN",                        RETURN,                 NORID,  RESERVED},
 357       {"CONTINUE",              CONTINUE,               NORID,  RESERVED},
 358       {"SIGNAL_CODE",           SIGNAL_CODE,            NORID,  DIRECTIVE},
 359       {"empty_on",              EMPTY_ON,               NORID,  DIRECTIVE},
 360       {"nopack",                        NOPACK,                 NORID,  RESERVED},
 361       {"RETURNS",               RETURNS,                NORID,  RESERVED},
 362       {"CYCLE",                 CYCLE,                  NORID,  RESERVED},
 363       {"SYNMODE",               SYNMODE,                NORID,  RESERVED},
 364       {"exceptions",            EXCEPTIONS,             NORID,  RESERVED},
 365       {"EVEN",                  IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 366       {"PRINT_O_CODE",          IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 367       {"EVENT",                 EVENT,                  NORID,  RESERVED},
 368       {"context",               CONTEXT,                NORID,  RESERVED},
 369       {"RANGE_OFF",             RANGE_OFF,              NORID,  DIRECTIVE},
 370       {"EVER",                  EVER,                   NORID,  RESERVED},
 371       {"EMPTY_ON",              EMPTY_ON,               NORID,  DIRECTIVE},
 372       {"MEDIUM",                        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 373       {"BUFFER",                        BUFFER,                 NORID,  RESERVED},
 374       {"MODULE",                        MODULE,                 NORID,  RESERVED},
 375       {"grant_file_size",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 376       {"ELSE",                  ELSE,                   NORID,  RESERVED},
 377       {"process_type",          PROCESS_TYPE_TOKEN,     NORID,  DIRECTIVE},
 378       {"priority",              PRIORITY,               NORID,  RESERVED},
 379       {"buffer_code",           IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 380       {"return",                        RETURN,                 NORID,  RESERVED},
 381       {"returns",               RETURNS,                NORID,  RESERVED},
 382       {"all_static_off",                ALL_STATIC_OFF,         NORID,  DIRECTIVE},
 383       {"POWERSET",              POWERSET,               NORID,  RESERVED},
 384       {"EMPTY_OFF",             EMPTY_OFF,              NORID,  DIRECTIVE},
 385       {"range_off",             RANGE_OFF,              NORID,  DIRECTIVE},
 386       {"signal_max_length",     IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 387       {"PREFIXED",              PREFIXED,               NORID,  RESERVED},
 388       {"NEWMODE",               NEWMODE,                NORID,  RESERVED},
 389       {"EXCEPTIONS",            EXCEPTIONS,             NORID,  RESERVED},
 390       {"REMOTE",                        REMOTE,                 NORID,  RESERVED},
 391       {"SHORT_PRED_SUCC",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 392       {"all_static_on",         ALL_STATIC_ON,          NORID,  DIRECTIVE},
 393       {"nonref",                        NONREF,                 NORID,  RESERVED},
 394       {"SIGNAL_MAX_LENGTH",     IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 395       {"REENTRANT",             IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 396       {"range_on",              RANGE_ON,               NORID,  DIRECTIVE},
 397       {"GENERAL",               GENERAL,                NORID,  RESERVED},
 398       {"continue",              CONTINUE,               NORID,  RESERVED},
 399       {"STATE_ROUTINE",         IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 400       {"EXTRA_CONST_SEG",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 401       {"use_seize_file_restricted",     USE_SEIZE_FILE_RESTRICTED,      NORID,  DIRECTIVE},
 402       {"ONLY_FOR_TARGET",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 403       {"extra_const_seg",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 404       {"multiple_const_segs",   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 405       {"RECURSIVE",             RECURSIVE,              NORID,  RESERVED},
 406       {"DEBUG_SYMBOLS",         IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 407       {"DEBUG_TYPES",           IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 408       {"GRANT_FILE_SIZE",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 409       {"DEBUG_LINES",           IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 410       {"ONLY_FOR_SIMULATION",   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 411       {"state_routine",         IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 412       {"generate_set_names",    IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 413       {"print_o_code",          IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 414       {"PROCESS_TYPE",          PROCESS_TYPE_TOKEN,     NORID,  DIRECTIVE},
 415       {"short_pred_succ",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 416       {"reentrant",             IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 417       {"RECEIVE",               RECEIVE,                NORID,  RESERVED},
 418       {"EVENT_CODE",            IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 419       {"optimize_runtime",      IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 420       {"SUPPORT_CAUSING_ADDRESS",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 421       {"print_symbol_table",    IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 422       {"REENTRANT_ALL",         IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 423       {"PRINT_SYMBOL_TABLE",    IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 424       {"BUFFER_CODE",           IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 425       {"generate_all_set_names",        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 426       {"NO_OVERLAP_CHECK",      IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 427       {"no_overlap_check",      IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 428       {"reentrant_all",         IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 429       {"MULTIPLE_DATA_SEGS",    IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 430       {"OPTIMIZE_RUNTIME",      IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 431       {"only_for_target",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 432       {"MULTIPLE_CONST_SEGS",   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 433       {"optimization_window",   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 434       {"support_causing_address",       IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 435       {"USE_SEIZE_FILE",                USE_SEIZE_FILE,         NORID,  DIRECTIVE},
 436       {"SEND_SIGNAL_DEFAULT_PRIORITY",  SEND_SIGNAL_DEFAULT_PRIORITY,   NORID,  DIRECTIVE},
 437       {"make_publics_for_discrete_syns",        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 438       {"only_for_simulation",   IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 439       {"send_signal_default_priority",  SEND_SIGNAL_DEFAULT_PRIORITY,   NORID,  DIRECTIVE},
 440       {"send_buffer_default_priority",  SEND_BUFFER_DEFAULT_PRIORITY,   NORID,  DIRECTIVE},
 441       {"GENERATE_SET_NAMES",    IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 442       {"MAKE_PUBLICS_FOR_DISCRETE_SYNS",        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 443       {"SEND_BUFFER_DEFAULT_PRIORITY",  SEND_BUFFER_DEFAULT_PRIORITY,   NORID,  DIRECTIVE},
 444       {"GENERATE_ALL_SET_NAMES",        IGNORED_DIRECTIVE,      NORID,  DIRECTIVE},
 445       {"USE_SEIZE_FILE_RESTRICTED",     USE_SEIZE_FILE_RESTRICTED,      NORID,  DIRECTIVE}
 446     };
 447
 448   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
 449     {
 450       register int key = hash (str, len);
 451
 452       if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
 453         {
 454           register struct resword *wordptr;
 455           register struct resword *wordendptr;
 456           register struct resword *resword;
 457
 458           switch (key - 7)
 459             {
 460               case 0:
 461                 resword = &wordlist[0];
 462                 goto compare;
 463               case 5:
 464                 resword = &wordlist[1];
 465                 goto compare;
 466               case 16:
 467                 resword = &wordlist[2];
 468                 goto compare;
 469               case 23:
 470                 resword = &wordlist[3];
 471                 goto compare;
 472               case 36:
 473                 resword = &wordlist[4];
 474                 goto compare;
 475               case 42:
 476                 resword = &wordlist[5];
 477                 goto compare;
 478               case 48:
 479                 resword = &wordlist[6];
 480                 goto compare;
 481               case 53:
 482                 wordptr = &wordlist[7];
 483                 wordendptr = wordptr + 2;
 484                 goto multicompare;
 485               case 60:
 486                 resword = &wordlist[9];
 487                 goto compare;
 488               case 61:
 489                 resword = &wordlist[10];
 490                 goto compare;
 491               case 66:
 492                 resword = &wordlist[11];
 493                 goto compare;
 494               case 76:
 495                 resword = &wordlist[12];
 496                 goto compare;
 497               case 83:
 498                 wordptr = &wordlist[13];
 499                 wordendptr = wordptr + 2;
 500                 goto multicompare;
 501               case 86:
 502                 resword = &wordlist[15];
 503                 goto compare;
 504               case 88:
 505                 wordptr = &wordlist[16];
 506                 wordendptr = wordptr + 2;
 507                 goto multicompare;
 508               case 91:
 509                 resword = &wordlist[18];
 510                 goto compare;
 511               case 94:
 512                 resword = &wordlist[19];
 513                 goto compare;
 514               case 99:
 515                 resword = &wordlist[20];
 516                 goto compare;
 517               case 100:
 518                 resword = &wordlist[21];
 519                 goto compare;
 520               case 103:
 521                 resword = &wordlist[22];
 522                 goto compare;
 523               case 105:
 524                 resword = &wordlist[23];
 525                 goto compare;
 526               case 107:
 527                 resword = &wordlist[24];
 528                 goto compare;
 529               case 111:
 530                 resword = &wordlist[25];
 531                 goto compare;
 532               case 113:
 533                 resword = &wordlist[26];
 534                 goto compare;
 535               case 116:
 536                 resword = &wordlist[27];
 537                 goto compare;
 538               case 120:
 539                 resword = &wordlist[28];
 540                 goto compare;
 541               case 121:
 542                 resword = &wordlist[29];
 543                 goto compare;
 544               case 122:
 545                 resword = &wordlist[30];
 546                 goto compare;
 547               case 123:
 548                 resword = &wordlist[31];
 549                 goto compare;
 550               case 129:
 551                 resword = &wordlist[32];
 552                 goto compare;
 553               case 131:
 554                 resword = &wordlist[33];
 555                 goto compare;
 556               case 132:
 557                 resword = &wordlist[34];
 558                 goto compare;
 559               case 136:
 560                 resword = &wordlist[35];
 561                 goto compare;
 562               case 137:
 563                 resword = &wordlist[36];
 564                 goto compare;
 565               case 140:
 566                 resword = &wordlist[37];
 567                 goto compare;
 568               case 142:
 569                 resword = &wordlist[38];
 570                 goto compare;
 571               case 146:
 572                 resword = &wordlist[39];
 573                 goto compare;
 574               case 150:
 575                 resword = &wordlist[40];
 576                 goto compare;
 577               case 155:
 578                 resword = &wordlist[41];
 579                 goto compare;
 580               case 157:
 581                 resword = &wordlist[42];
 582                 goto compare;
 583               case 163:
 584                 resword = &wordlist[43];
 585                 goto compare;
 586               case 165:
 587                 resword = &wordlist[44];
 588                 goto compare;
 589               case 167:
 590                 resword = &wordlist[45];
 591                 goto compare;
 592               case 168:
 593                 resword = &wordlist[46];
 594                 goto compare;
 595               case 171:
 596                 resword = &wordlist[47];
 597                 goto compare;
 598               case 175:
 599                 resword = &wordlist[48];
 600                 goto compare;
 601               case 177:
 602                 resword = &wordlist[49];
 603                 goto compare;
 604               case 178:
 605                 resword = &wordlist[50];
 606                 goto compare;
 607               case 180:
 608                 resword = &wordlist[51];
 609                 goto compare;
 610               case 184:
 611                 resword = &wordlist[52];
 612                 goto compare;
 613               case 187:
 614                 resword = &wordlist[53];
 615                 goto compare;
 616               case 189:
 617                 resword = &wordlist[54];
 618                 goto compare;
 619               case 193:
 620                 resword = &wordlist[55];
 621                 goto compare;
 622               case 194:
 623                 resword = &wordlist[56];
 624                 goto compare;
 625               case 195:
 626                 resword = &wordlist[57];
 627                 goto compare;
 628               case 196:
 629                 resword = &wordlist[58];
 630                 goto compare;
 631               case 197:
 632                 resword = &wordlist[59];
 633                 goto compare;
 634               case 202:
 635                 resword = &wordlist[60];
 636                 goto compare;
 637               case 209:
 638                 resword = &wordlist[61];
 639                 goto compare;
 640               case 213:
 641                 resword = &wordlist[62];
 642                 goto compare;
 643               case 217:
 644                 resword = &wordlist[63];
 645                 goto compare;
 646               case 218:
 647                 resword = &wordlist[64];
 648                 goto compare;
 649               case 219:
 650                 wordptr = &wordlist[65];
 651                 wordendptr = wordptr + 2;
 652                 goto multicompare;
 653               case 220:
 654                 wordptr = &wordlist[67];
 655                 wordendptr = wordptr + 2;
 656                 goto multicompare;
 657               case 225:
 658                 resword = &wordlist[69];
 659                 goto compare;
 660               case 229:
 661                 resword = &wordlist[70];
 662                 goto compare;
 663               case 232:
 664                 resword = &wordlist[71];
 665                 goto compare;
 666               case 240:
 667                 resword = &wordlist[72];
 668                 goto compare;
 669               case 246:
 670                 resword = &wordlist[73];
 671                 goto compare;
 672               case 250:
 673                 resword = &wordlist[74];
 674                 goto compare;
 675               case 251:
 676                 resword = &wordlist[75];
 677                 goto compare;
 678               case 254:
 679                 resword = &wordlist[76];
 680                 goto compare;
 681               case 255:
 682                 resword = &wordlist[77];
 683                 goto compare;
 684               case 257:
 685                 resword = &wordlist[78];
 686                 goto compare;
 687               case 258:
 688                 resword = &wordlist[79];
 689                 goto compare;
 690               case 262:
 691                 resword = &wordlist[80];
 692                 goto compare;
 693               case 264:
 694                 resword = &wordlist[81];
 695                 goto compare;
 696               case 270:
 697                 resword = &wordlist[82];
 698                 goto compare;
 699               case 273:
 700                 resword = &wordlist[83];
 701                 goto compare;
 702               case 275:
 703                 resword = &wordlist[84];
 704                 goto compare;
 705               case 279:
 706                 resword = &wordlist[85];
 707                 goto compare;
 708               case 284:
 709                 resword = &wordlist[86];
 710                 goto compare;
 711               case 286:
 712                 resword = &wordlist[87];
 713                 goto compare;
 714               case 289:
 715                 resword = &wordlist[88];
 716                 goto compare;
 717               case 291:
 718                 resword = &wordlist[89];
 719                 goto compare;
 720               case 293:
 721                 resword = &wordlist[90];
 722                 goto compare;
 723               case 294:
 724                 resword = &wordlist[91];
 725                 goto compare;
 726               case 296:
 727                 resword = &wordlist[92];
 728                 goto compare;
 729               case 297:
 730                 resword = &wordlist[93];
 731                 goto compare;
 732               case 298:
 733                 resword = &wordlist[94];
 734                 goto compare;
 735               case 300:
 736                 resword = &wordlist[95];
 737                 goto compare;
 738               case 302:
 739                 resword = &wordlist[96];
 740                 goto compare;
 741               case 307:
 742                 resword = &wordlist[97];
 743                 goto compare;
 744               case 308:
 745                 resword = &wordlist[98];
 746                 goto compare;
 747               case 317:
 748                 resword = &wordlist[99];
 749                 goto compare;
 750               case 322:
 751                 resword = &wordlist[100];
 752                 goto compare;
 753               case 325:
 754                 resword = &wordlist[101];
 755                 goto compare;
 756               case 331:
 757                 resword = &wordlist[102];
 758                 goto compare;
 759               case 332:
 760                 resword = &wordlist[103];
 761                 goto compare;
 762               case 335:
 763                 resword = &wordlist[104];
 764                 goto compare;
 765               case 336:
 766                 resword = &wordlist[105];
 767                 goto compare;
 768               case 339:
 769                 resword = &wordlist[106];
 770                 goto compare;
 771               case 342:
 772                 resword = &wordlist[107];
 773                 goto compare;
 774               case 344:
 775                 resword = &wordlist[108];
 776                 goto compare;
 777               case 345:
 778                 resword = &wordlist[109];
 779                 goto compare;
 780               case 349:
 781                 resword = &wordlist[110];
 782                 goto compare;
 783               case 350:
 784                 resword = &wordlist[111];
 785                 goto compare;
 786               case 354:
 787                 resword = &wordlist[112];
 788                 goto compare;
 789               case 356:
 790                 resword = &wordlist[113];
 791                 goto compare;
 792               case 357:
 793                 resword = &wordlist[114];
 794                 goto compare;
 795               case 358:
 796                 resword = &wordlist[115];
 797                 goto compare;
 798               case 359:
 799                 resword = &wordlist[116];
 800                 goto compare;
 801               case 360:
 802                 resword = &wordlist[117];
 803                 goto compare;
 804               case 366:
 805                 resword = &wordlist[118];
 806                 goto compare;
 807               case 380:
 808                 resword = &wordlist[119];
 809                 goto compare;
 810               case 389:
 811                 resword = &wordlist[120];
 812                 goto compare;
 813               case 402:
 814                 resword = &wordlist[121];
 815                 goto compare;
 816               case 404:
 817                 resword = &wordlist[122];
 818                 goto compare;
 819               case 408:
 820                 resword = &wordlist[123];
 821                 goto compare;
 822               case 410:
 823                 resword = &wordlist[124];
 824                 goto compare;
 825               case 411:
 826                 resword = &wordlist[125];
 827                 goto compare;
 828               case 415:
 829                 resword = &wordlist[126];
 830                 goto compare;
 831               case 416:
 832                 resword = &wordlist[127];
 833                 goto compare;
 834               case 422:
 835                 resword = &wordlist[128];
 836                 goto compare;
 837               case 423:
 838                 resword = &wordlist[129];
 839                 goto compare;
 840               case 426:
 841                 resword = &wordlist[130];
 842                 goto compare;
 843               case 427:
 844                 resword = &wordlist[131];
 845                 goto compare;
 846               case 428:
 847                 resword = &wordlist[132];
 848                 goto compare;
 849               case 433:
 850                 resword = &wordlist[133];
 851                 goto compare;
 852               case 436:
 853                 resword = &wordlist[134];
 854                 goto compare;
 855               case 438:
 856                 resword = &wordlist[135];
 857                 goto compare;
 858               case 439:
 859                 resword = &wordlist[136];
 860                 goto compare;
 861               case 441:
 862                 resword = &wordlist[137];
 863                 goto compare;
 864               case 444:
 865                 wordptr = &wordlist[138];
 866                 wordendptr = wordptr + 2;
 867                 goto multicompare;
 868               case 445:
 869                 resword = &wordlist[140];
 870                 goto compare;
 871               case 453:
 872                 resword = &wordlist[141];
 873                 goto compare;
 874               case 454:
 875                 resword = &wordlist[142];
 876                 goto compare;
 877               case 455:
 878                 resword = &wordlist[143];
 879                 goto compare;
 880               case 456:
 881                 resword = &wordlist[144];
 882                 goto compare;
 883               case 459:
 884                 resword = &wordlist[145];
 885                 goto compare;
 886               case 468:
 887                 resword = &wordlist[146];
 888                 goto compare;
 889               case 476:
 890                 resword = &wordlist[147];
 891                 goto compare;
 892               case 479:
 893                 resword = &wordlist[148];
 894                 goto compare;
 895               case 480:
 896                 resword = &wordlist[149];
 897                 goto compare;
 898               case 481:
 899                 resword = &wordlist[150];
 900                 goto compare;
 901               case 482:
 902                 resword = &wordlist[151];
 903                 goto compare;
 904               case 484:
 905                 resword = &wordlist[152];
 906                 goto compare;
 907               case 487:
 908                 resword = &wordlist[153];
 909                 goto compare;
 910               case 491:
 911                 resword = &wordlist[154];
 912                 goto compare;
 913               case 492:
 914                 resword = &wordlist[155];
 915                 goto compare;
 916               case 498:
 917                 resword = &wordlist[156];
 918                 goto compare;
 919               case 505:
 920                 resword = &wordlist[157];
 921                 goto compare;
 922               case 506:
 923                 resword = &wordlist[158];
 924                 goto compare;
 925               case 514:
 926                 resword = &wordlist[159];
 927                 goto compare;
 928               case 533:
 929                 resword = &wordlist[160];
 930                 goto compare;
 931               case 536:
 932                 resword = &wordlist[161];
 933                 goto compare;
 934               case 539:
 935                 resword = &wordlist[162];
 936                 goto compare;
 937               case 540:
 938                 resword = &wordlist[163];
 939                 goto compare;
 940               case 542:
 941                 resword = &wordlist[164];
 942                 goto compare;
 943               case 544:
 944                 resword = &wordlist[165];
 945                 goto compare;
 946               case 547:
 947                 resword = &wordlist[166];
 948                 goto compare;
 949               case 550:
 950                 resword = &wordlist[167];
 951                 goto compare;
 952               case 551:
 953                 resword = &wordlist[168];
 954                 goto compare;
 955               case 561:
 956                 resword = &wordlist[169];
 957                 goto compare;
 958               case 567:
 959                 resword = &wordlist[170];
 960                 goto compare;
 961               case 569:
 962                 resword = &wordlist[171];
 963                 goto compare;
 964               case 576:
 965                 resword = &wordlist[172];
 966                 goto compare;
 967               case 580:
 968                 resword = &wordlist[173];
 969                 goto compare;
 970               case 583:
 971                 resword = &wordlist[174];
 972                 goto compare;
 973               case 584:
 974                 resword = &wordlist[175];
 975                 goto compare;
 976               case 585:
 977                 resword = &wordlist[176];
 978                 goto compare;
 979               case 589:
 980                 resword = &wordlist[177];
 981                 goto compare;
 982               case 592:
 983                 resword = &wordlist[178];
 984                 goto compare;
 985               case 593:
 986                 resword = &wordlist[179];
 987                 goto compare;
 988               case 596:
 989                 resword = &wordlist[180];
 990                 goto compare;
 991               case 597:
 992                 resword = &wordlist[181];
 993                 goto compare;
 994               case 600:
 995                 resword = &wordlist[182];
 996                 goto compare;
 997               case 610:
 998                 resword = &wordlist[183];
 999                 goto compare;
1000               case 611:
1001                 resword = &wordlist[184];
1002                 goto compare;
1003               case 615:
1004                 resword = &wordlist[185];
1005                 goto compare;
1006               case 616:
1007                 resword = &wordlist[186];
1008                 goto compare;
1009               case 617:
1010                 resword = &wordlist[187];
1011                 goto compare;
1012               case 621:
1013                 resword = &wordlist[188];
1014                 goto compare;
1015               case 629:
1016                 resword = &wordlist[189];
1017                 goto compare;
1018               case 632:
1019                 resword = &wordlist[190];
1020                 goto compare;
1021               case 634:
1022                 resword = &wordlist[191];
1023                 goto compare;
1024               case 643:
1025                 resword = &wordlist[192];
1026                 goto compare;
1027               case 645:
1028                 resword = &wordlist[193];
1029                 goto compare;
1030               case 654:
1031                 resword = &wordlist[194];
1032                 goto compare;
1033               case 657:
1034                 resword = &wordlist[195];
1035                 goto compare;
1036               case 663:
1037                 resword = &wordlist[196];
1038                 goto compare;
1039               case 665:
1040                 resword = &wordlist[197];
1041                 goto compare;
1042               case 675:
1043                 resword = &wordlist[198];
1044                 goto compare;
1045               case 678:
1046                 resword = &wordlist[199];
1047                 goto compare;
1048               case 684:
1049                 resword = &wordlist[200];
1050                 goto compare;
1051               case 690:
1052                 resword = &wordlist[201];
1053                 goto compare;
1054               case 700:
1055                 resword = &wordlist[202];
1056                 goto compare;
1057               case 702:
1058                 resword = &wordlist[203];
1059                 goto compare;
1060               case 710:
1061                 resword = &wordlist[204];
1062                 goto compare;
1063               case 713:
1064                 resword = &wordlist[205];
1065                 goto compare;
1066               case 720:
1067                 resword = &wordlist[206];
1068                 goto compare;
1069               case 723:
1070                 resword = &wordlist[207];
1071                 goto compare;
1072               case 724:
1073                 resword = &wordlist[208];
1074                 goto compare;
1075               case 738:
1076                 resword = &wordlist[209];
1077                 goto compare;
1078               case 741:
1079                 resword = &wordlist[210];
1080                 goto compare;
1081               case 743:
1082                 resword = &wordlist[211];
1083                 goto compare;
1084               case 744:
1085                 resword = &wordlist[212];
1086                 goto compare;
1087               case 749:
1088                 resword = &wordlist[213];
1089                 goto compare;
1090               case 751:
1091                 resword = &wordlist[214];
1092                 goto compare;
1093               case 755:
1094                 resword = &wordlist[215];
1095                 goto compare;
1096               case 761:
1097                 resword = &wordlist[216];
1098                 goto compare;
1099               case 764:
1100                 resword = &wordlist[217];
1101                 goto compare;
1102               case 766:
1103                 resword = &wordlist[218];
1104                 goto compare;
1105               case 768:
1106                 resword = &wordlist[219];
1107                 goto compare;
1108               case 769:
1109                 resword = &wordlist[220];
1110                 goto compare;
1111               case 770:
1112                 resword = &wordlist[221];
1113                 goto compare;
1114               case 772:
1115                 resword = &wordlist[222];
1116                 goto compare;
1117               case 784:
1118                 resword = &wordlist[223];
1119                 goto compare;
1120               case 800:
1121                 resword = &wordlist[224];
1122                 goto compare;
1123               case 807:
1124                 resword = &wordlist[225];
1125                 goto compare;
1126               case 808:
1127                 resword = &wordlist[226];
1128                 goto compare;
1129               case 823:
1130                 resword = &wordlist[227];
1131                 goto compare;
1132               case 826:
1133                 resword = &wordlist[228];
1134                 goto compare;
1135               case 827:
1136                 resword = &wordlist[229];
1137                 goto compare;
1138               case 839:
1139                 resword = &wordlist[230];
1140                 goto compare;
1141               case 842:
1142                 resword = &wordlist[231];
1143                 goto compare;
1144               case 868:
1145                 resword = &wordlist[232];
1146                 goto compare;
1147               case 902:
1148                 resword = &wordlist[233];
1149                 goto compare;
1150               case 903:
1151                 resword = &wordlist[234];
1152                 goto compare;
1153               case 905:
1154                 resword = &wordlist[235];
1155                 goto compare;
1156               case 919:
1157                 resword = &wordlist[236];
1158                 goto compare;
1159               case 924:
1160                 resword = &wordlist[237];
1161                 goto compare;
1162               case 926:
1163                 resword = &wordlist[238];
1164                 goto compare;
1165               case 937:
1166                 resword = &wordlist[239];
1167                 goto compare;
1168               case 940:
1169                 resword = &wordlist[240];
1170                 goto compare;
1171               case 975:
1172                 resword = &wordlist[241];
1173                 goto compare;
1174               case 979:
1175                 resword = &wordlist[242];
1176                 goto compare;
1177               case 982:
1178                 resword = &wordlist[243];
1179                 goto compare;
1180               case 997:
1181                 resword = &wordlist[244];
1182                 goto compare;
1183               case 1000:
1184                 resword = &wordlist[245];
1185                 goto compare;
1186               case 1011:
1187                 resword = &wordlist[246];
1188                 goto compare;
1189               case 1012:
1190                 resword = &wordlist[247];
1191                 goto compare;
1192               case 1016:
1193                 resword = &wordlist[248];
1194                 goto compare;
1195               case 1028:
1196                 resword = &wordlist[249];
1197                 goto compare;
1198               case 1029:
1199                 resword = &wordlist[250];
1200                 goto compare;
1201               case 1032:
1202                 resword = &wordlist[251];
1203                 goto compare;
1204               case 1061:
1205                 resword = &wordlist[252];
1206                 goto compare;
1207               case 1070:
1208                 resword = &wordlist[253];
1209                 goto compare;
1210               case 1075:
1211                 resword = &wordlist[254];
1212                 goto compare;
1213               case 1079:
1214                 resword = &wordlist[255];
1215                 goto compare;
1216               case 1097:
1217                 resword = &wordlist[256];
1218                 goto compare;
1219               case 1098:
1220                 resword = &wordlist[257];
1221                 goto compare;
1222               case 1102:
1223                 resword = &wordlist[258];
1224                 goto compare;
1225               case 1131:
1226                 resword = &wordlist[259];
1227                 goto compare;
1228               case 1145:
1229                 resword = &wordlist[260];
1230                 goto compare;
1231               case 1155:
1232                 resword = &wordlist[261];
1233                 goto compare;
1234               case 1158:
1235                 resword = &wordlist[262];
1236                 goto compare;
1237               case 1160:
1238                 resword = &wordlist[263];
1239                 goto compare;
1240               case 1161:
1241                 resword = &wordlist[264];
1242                 goto compare;
1243               case 1175:
1244                 resword = &wordlist[265];
1245                 goto compare;
1246               case 1187:
1247                 resword = &wordlist[266];
1248                 goto compare;
1249               case 1200:
1250                 resword = &wordlist[267];
1251                 goto compare;
1252               case 1209:
1253                 resword = &wordlist[268];
1254                 goto compare;
1255               case 1210:
1256                 resword = &wordlist[269];
1257                 goto compare;
1258               case 1220:
1259                 resword = &wordlist[270];
1260                 goto compare;
1261               case 1235:
1262                 resword = &wordlist[271];
1263                 goto compare;
1264               case 1264:
1265                 resword = &wordlist[272];
1266                 goto compare;
1267               case 1267:
1268                 resword = &wordlist[273];
1269                 goto compare;
1270               case 1276:
1271                 resword = &wordlist[274];
1272                 goto compare;
1273               case 1294:
1274                 resword = &wordlist[275];
1275                 goto compare;
1276               case 1295:
1277                 resword = &wordlist[276];
1278                 goto compare;
1279               case 1314:
1280                 resword = &wordlist[277];
1281                 goto compare;
1282               case 1317:
1283                 resword = &wordlist[278];
1284                 goto compare;
1285               case 1332:
1286                 resword = &wordlist[279];
1287                 goto compare;
1288               case 1335:
1289                 resword = &wordlist[280];
1290                 goto compare;
1291               case 1338:
1292                 resword = &wordlist[281];
1293                 goto compare;
1294               case 1365:
1295                 resword = &wordlist[282];
1296                 goto compare;
1297               case 1415:
1298                 resword = &wordlist[283];
1299                 goto compare;
1300               case 1441:
1301                 resword = &wordlist[284];
1302                 goto compare;
1303               case 1539:
1304                 resword = &wordlist[285];
1305                 goto compare;
1306               case 1599:
1307                 resword = &wordlist[286];
1308                 goto compare;
1309               case 1647:
1310                 resword = &wordlist[287];
1311                 goto compare;
1312               case 1758:
1313                 resword = &wordlist[288];
1314                 goto compare;
1315               case 1801:
1316                 resword = &wordlist[289];
1317                 goto compare;
1318               case 1868:
1319                 resword = &wordlist[290];
1320                 goto compare;
1321               case 1870:
1322                 resword = &wordlist[291];
1323                 goto compare;
1324               case 1929:
1325                 resword = &wordlist[292];
1326                 goto compare;
1327               case 1982:
1328                 resword = &wordlist[293];
1329                 goto compare;
1330               case 2146:
1331                 resword = &wordlist[294];
1332                 goto compare;
1333               case 2217:
1334                 resword = &wordlist[295];
1335                 goto compare;
1336               case 2376:
1337                 resword = &wordlist[296];
1338                 goto compare;
1339               case 2441:
1340                 resword = &wordlist[297];
1341                 goto compare;
1342               case 2484:
1343                 resword = &wordlist[298];
1344                 goto compare;
1345               case 2814:
1346                 resword = &wordlist[299];
1347                 goto compare;
1348             }
1349           return 0;
1350         multicompare:
1351           while (wordptr < wordendptr)
1352             {
1353               register const char *s = wordptr->name;
1354
1355               if (*str == *s && !strcmp (str + 1, s + 1))
1356                 return wordptr;
1357               wordptr++;
1358             }
1359           return 0;
1360         compare:
1361           {
1362             register const char *s = resword->name;
1363
1364             if (*str == *s && !strcmp (str + 1, s + 1))
1365               return resword;
1366           }
1367         }
1368     }
1369   return 0;
1370 }