gcc/ch/hash.h

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