OSDN Git Service

* config/alpha/vms.h (INCLUDE_DEFAULTS): Add /gnu/lib/gcc-lib/include.
[pf3gnuchains/gcc-fork.git] / 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 }