![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to keyword-gen.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd|
Return to keyword-gen.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / ntpd |
1.1 misho 1: /*
2: * keyword-gen.c -- generate keyword scanner finite state machine and
3: * keyword_text array.
4: * This program is run to generate ntp_keyword.h
5: */
6: #include <config.h>
7: #include <stdio.h>
8: #include <stdlib.h>
9: #include <time.h>
10:
11: #include <ntp_stdlib.h>
12: #include <ntp_config.h>
13: #include <lib_strbuf.h>
14: #include "ntp_scanner.h"
15: #include "ntp_parser.h"
16:
17:
18: #ifdef QSORT_USES_VOID_P
19: typedef const void * QSORTP;
20: #else
21: typedef char * QSORTP;
22: #endif
23:
24: /* Define a structure to hold a (keyword, token) pair */
25: struct key_tok {
26: char * key; /* Keyword */
27: int token; /* Associated Token */
28: follby followedby; /* nonzero indicates the next token(s)
29: forced to be string(s) */
30: };
31:
32: struct key_tok ntp_keywords[] = {
33: { "...", T_Ellipsis, FOLLBY_TOKEN },
34: { "automax", T_Automax, FOLLBY_TOKEN },
35: { "broadcast", T_Broadcast, FOLLBY_STRING },
36: { "broadcastclient", T_Broadcastclient, FOLLBY_TOKEN },
37: { "broadcastdelay", T_Broadcastdelay, FOLLBY_TOKEN },
38: { "calldelay", T_Calldelay, FOLLBY_TOKEN },
39: { "disable", T_Disable, FOLLBY_TOKEN },
40: { "driftfile", T_Driftfile, FOLLBY_STRING },
41: { "enable", T_Enable, FOLLBY_TOKEN },
42: { "end", T_End, FOLLBY_TOKEN },
43: { "filegen", T_Filegen, FOLLBY_TOKEN },
44: { "fudge", T_Fudge, FOLLBY_STRING },
45: { "includefile", T_Includefile, FOLLBY_STRING },
46: { "leapfile", T_Leapfile, FOLLBY_STRING },
47: { "logconfig", T_Logconfig, FOLLBY_STRINGS_TO_EOC },
48: { "logfile", T_Logfile, FOLLBY_STRING },
49: { "manycastclient", T_Manycastclient, FOLLBY_STRING },
50: { "manycastserver", T_Manycastserver, FOLLBY_STRINGS_TO_EOC },
51: { "multicastclient", T_Multicastclient, FOLLBY_STRINGS_TO_EOC },
52: { "peer", T_Peer, FOLLBY_STRING },
53: { "phone", T_Phone, FOLLBY_STRINGS_TO_EOC },
54: { "pidfile", T_Pidfile, FOLLBY_STRING },
55: { "pool", T_Pool, FOLLBY_STRING },
56: { "discard", T_Discard, FOLLBY_TOKEN },
57: { "restrict", T_Restrict, FOLLBY_TOKEN },
58: { "server", T_Server, FOLLBY_STRING },
59: { "setvar", T_Setvar, FOLLBY_STRING },
60: { "statistics", T_Statistics, FOLLBY_TOKEN },
61: { "statsdir", T_Statsdir, FOLLBY_STRING },
62: { "tick", T_Tick, FOLLBY_TOKEN },
63: { "tinker", T_Tinker, FOLLBY_TOKEN },
64: { "tos", T_Tos, FOLLBY_TOKEN },
65: { "trap", T_Trap, FOLLBY_STRING },
66: { "unconfig", T_Unconfig, FOLLBY_STRING },
67: { "unpeer", T_Unpeer, FOLLBY_STRING },
68: /* authentication_command */
69: { "controlkey", T_ControlKey, FOLLBY_TOKEN },
70: { "crypto", T_Crypto, FOLLBY_TOKEN },
71: { "keys", T_Keys, FOLLBY_STRING },
72: { "keysdir", T_Keysdir, FOLLBY_STRING },
73: { "ntpsigndsocket", T_NtpSignDsocket, FOLLBY_STRING },
74: { "requestkey", T_Requestkey, FOLLBY_TOKEN },
75: { "revoke", T_Revoke, FOLLBY_TOKEN },
76: { "trustedkey", T_Trustedkey, FOLLBY_TOKEN },
77: /* IPv4/IPv6 protocol override flag */
78: { "-4", T_Ipv4_flag, FOLLBY_TOKEN },
79: { "-6", T_Ipv6_flag, FOLLBY_TOKEN },
80: /* option */
81: { "autokey", T_Autokey, FOLLBY_TOKEN },
82: { "bias", T_Bias, FOLLBY_TOKEN },
83: { "burst", T_Burst, FOLLBY_TOKEN },
84: { "iburst", T_Iburst, FOLLBY_TOKEN },
85: { "key", T_Key, FOLLBY_TOKEN },
86: { "maxpoll", T_Maxpoll, FOLLBY_TOKEN },
87: { "minpoll", T_Minpoll, FOLLBY_TOKEN },
88: { "mode", T_Mode, FOLLBY_TOKEN },
89: { "noselect", T_Noselect, FOLLBY_TOKEN },
90: { "preempt", T_Preempt, FOLLBY_TOKEN },
91: { "true", T_True, FOLLBY_TOKEN },
92: { "prefer", T_Prefer, FOLLBY_TOKEN },
93: { "ttl", T_Ttl, FOLLBY_TOKEN },
94: { "version", T_Version, FOLLBY_TOKEN },
95: { "xleave", T_Xleave, FOLLBY_TOKEN },
96: /* crypto_command */
97: { "host", T_Host, FOLLBY_STRING },
98: { "ident", T_Ident, FOLLBY_STRING },
99: { "pw", T_Pw, FOLLBY_STRING },
100: { "randfile", T_Randfile, FOLLBY_STRING },
101: { "sign", T_Sign, FOLLBY_STRING },
102: { "digest", T_Digest, FOLLBY_STRING },
103: /*** MONITORING COMMANDS ***/
104: /* stat */
105: { "clockstats", T_Clockstats, FOLLBY_TOKEN },
106: { "cryptostats", T_Cryptostats, FOLLBY_TOKEN },
107: { "loopstats", T_Loopstats, FOLLBY_TOKEN },
108: { "peerstats", T_Peerstats, FOLLBY_TOKEN },
109: { "rawstats", T_Rawstats, FOLLBY_TOKEN },
110: { "sysstats", T_Sysstats, FOLLBY_TOKEN },
111: { "protostats", T_Protostats, FOLLBY_TOKEN },
112: { "timingstats", T_Timingstats, FOLLBY_TOKEN },
113: /* filegen_option */
114: { "file", T_File, FOLLBY_STRING },
115: { "link", T_Link, FOLLBY_TOKEN },
116: { "nolink", T_Nolink, FOLLBY_TOKEN },
117: { "type", T_Type, FOLLBY_TOKEN },
118: /* filegen_type */
119: { "age", T_Age, FOLLBY_TOKEN },
120: { "day", T_Day, FOLLBY_TOKEN },
121: { "month", T_Month, FOLLBY_TOKEN },
122: { "none", T_None, FOLLBY_TOKEN },
123: { "pid", T_Pid, FOLLBY_TOKEN },
124: { "week", T_Week, FOLLBY_TOKEN },
125: { "year", T_Year, FOLLBY_TOKEN },
126: /*** ORPHAN MODE COMMANDS ***/
127: /* tos_option */
128: { "minclock", T_Minclock, FOLLBY_TOKEN },
129: { "maxclock", T_Maxclock, FOLLBY_TOKEN },
130: { "minsane", T_Minsane, FOLLBY_TOKEN },
131: { "floor", T_Floor, FOLLBY_TOKEN },
132: { "ceiling", T_Ceiling, FOLLBY_TOKEN },
133: { "cohort", T_Cohort, FOLLBY_TOKEN },
134: { "mindist", T_Mindist, FOLLBY_TOKEN },
135: { "maxdist", T_Maxdist, FOLLBY_TOKEN },
136: { "beacon", T_Beacon, FOLLBY_TOKEN },
137: { "orphan", T_Orphan, FOLLBY_TOKEN },
138: /* access_control_flag */
139: { "default", T_Default, FOLLBY_TOKEN },
140: { "flake", T_Flake, FOLLBY_TOKEN },
141: { "ignore", T_Ignore, FOLLBY_TOKEN },
142: { "limited", T_Limited, FOLLBY_TOKEN },
143: { "mssntp", T_Mssntp, FOLLBY_TOKEN },
144: { "kod", T_Kod, FOLLBY_TOKEN },
145: { "lowpriotrap", T_Lowpriotrap, FOLLBY_TOKEN },
146: { "mask", T_Mask, FOLLBY_TOKEN },
147: { "nomodify", T_Nomodify, FOLLBY_TOKEN },
148: { "nopeer", T_Nopeer, FOLLBY_TOKEN },
149: { "noquery", T_Noquery, FOLLBY_TOKEN },
150: { "noserve", T_Noserve, FOLLBY_TOKEN },
151: { "notrap", T_Notrap, FOLLBY_TOKEN },
152: { "notrust", T_Notrust, FOLLBY_TOKEN },
153: { "ntpport", T_Ntpport, FOLLBY_TOKEN },
154: /* discard_option */
155: { "average", T_Average, FOLLBY_TOKEN },
156: { "minimum", T_Minimum, FOLLBY_TOKEN },
157: { "monitor", T_Monitor, FOLLBY_TOKEN },
158: /* fudge_factor */
159: { "flag1", T_Flag1, FOLLBY_TOKEN },
160: { "flag2", T_Flag2, FOLLBY_TOKEN },
161: { "flag3", T_Flag3, FOLLBY_TOKEN },
162: { "flag4", T_Flag4, FOLLBY_TOKEN },
163: { "refid", T_Refid, FOLLBY_STRING },
164: { "stratum", T_Stratum, FOLLBY_TOKEN },
165: { "time1", T_Time1, FOLLBY_TOKEN },
166: { "time2", T_Time2, FOLLBY_TOKEN },
167: /* system_option */
168: { "auth", T_Auth, FOLLBY_TOKEN },
169: { "bclient", T_Bclient, FOLLBY_TOKEN },
170: { "calibrate", T_Calibrate, FOLLBY_TOKEN },
171: { "kernel", T_Kernel, FOLLBY_TOKEN },
172: { "ntp", T_Ntp, FOLLBY_TOKEN },
173: { "stats", T_Stats, FOLLBY_TOKEN },
174: /* tinker_option */
175: { "step", T_Step, FOLLBY_TOKEN },
176: { "panic", T_Panic, FOLLBY_TOKEN },
177: { "dispersion", T_Dispersion, FOLLBY_TOKEN },
178: { "stepout", T_Stepout, FOLLBY_TOKEN },
179: { "allan", T_Allan, FOLLBY_TOKEN },
180: { "huffpuff", T_Huffpuff, FOLLBY_TOKEN },
181: { "freq", T_Freq, FOLLBY_TOKEN },
182: /* miscellaneous_command */
183: { "port", T_Port, FOLLBY_TOKEN },
184: { "interface", T_Interface, FOLLBY_TOKEN },
185: { "qos", T_Qos, FOLLBY_TOKEN },
186: { "saveconfigdir", T_Saveconfigdir, FOLLBY_STRING },
187: /* interface_command (ignore and interface already defined) */
188: { "nic", T_Nic, FOLLBY_TOKEN },
189: { "all", T_All, FOLLBY_TOKEN },
190: { "ipv4", T_Ipv4, FOLLBY_TOKEN },
191: { "ipv6", T_Ipv6, FOLLBY_TOKEN },
192: { "wildcard", T_Wildcard, FOLLBY_TOKEN },
193: { "listen", T_Listen, FOLLBY_TOKEN },
194: { "drop", T_Drop, FOLLBY_TOKEN },
195: /* simulator commands */
196: { "simulate", T_Simulate, FOLLBY_TOKEN },
197: { "simulation_duration",T_Sim_Duration, FOLLBY_TOKEN },
198: { "beep_delay", T_Beep_Delay, FOLLBY_TOKEN },
199: { "duration", T_Duration, FOLLBY_TOKEN },
200: { "server_offset", T_Server_Offset, FOLLBY_TOKEN },
201: { "freq_offset", T_Freq_Offset, FOLLBY_TOKEN },
202: { "wander", T_Wander, FOLLBY_TOKEN },
203: { "jitter", T_Jitter, FOLLBY_TOKEN },
204: { "prop_delay", T_Prop_Delay, FOLLBY_TOKEN },
205: { "proc_delay", T_Proc_Delay, FOLLBY_TOKEN },
206: };
207:
208:
209: typedef struct big_scan_state_tag {
210: char ch; /* Character this state matches on */
211: char followedby; /* Forces next token(s) to T_String */
212: u_short finishes_token; /* nonzero ID if last keyword char */
213: u_short match_next_s; /* next state to check matching ch */
214: u_short other_next_s; /* next state to check if not ch */
215: } big_scan_state;
216:
217: /*
218: * Note: to increase MAXSTATES beyond 2048, be aware it is currently
219: * crammed into 11 bits in scan_state form. Raising to 4096 would be
220: * relatively easy by storing the followedby value in a separate
221: * array with one entry per token, and shrinking the char value to
222: * 7 bits to free a bit for accepting/non-accepting. More than 4096
223: * states will require expanding scan_state beyond 32 bits each.
224: */
225: #define MAXSTATES 2048
226:
227: const char * current_keyword;/* for error reporting */
228: big_scan_state sst[MAXSTATES]; /* scanner FSM state entries */
229: int sst_highwater; /* next entry index to consider */
230: char * symb[1024]; /* map token ID to symbolic name */
231:
232: /* for libntp */
233: const char * progname = "keyword-gen";
234: volatile int debug = 1;
235:
236: int main (int, char **);
237: static void generate_preamble (void);
238: static void generate_fsm (void);
239: static void generate_token_text (void);
240: static int create_keyword_scanner (void);
241: static int create_scan_states (char *, int, follby, int);
242: int compare_key_tok_id (QSORTP, QSORTP);
243: int compare_key_tok_text (QSORTP, QSORTP);
244: void populate_symb (char *);
245: const char * symbname (int);
246:
247:
248: int main(int argc, char **argv)
249: {
250: if (argc < 2) {
251: fprintf(stderr, "Usage:\n%s t_header.h\n", argv[0]);
252: exit(1);
253: }
254: populate_symb(argv[1]);
255:
256: generate_preamble();
257: generate_token_text();
258: generate_fsm();
259:
260: return 0;
261: }
262:
263:
264: static void
265: generate_preamble(void)
266: {
267: time_t now;
268: char timestamp[128];
269: char preamble[] =
270: "/*\n"
271: " * ntp_keyword.h\n"
272: " * \n"
273: " * NOTE: edit this file with caution, it is generated by keyword-gen.c\n"
274: " *\t Generated %s UTC diff_ignore_line\n"
275: " *\n"
276: " */\n"
277: "#include \"ntp_scanner.h\"\n"
278: "#include \"ntp_parser.h\"\n"
279: "\n";
280:
281: time(&now);
282: if (!strftime(timestamp, sizeof(timestamp),
283: "%Y-%m-%d %H:%M:%S", gmtime(&now)))
284: timestamp[0] = '\0';
285:
286: printf(preamble, timestamp);
287: }
288:
289:
290: static void
291: generate_fsm(void)
292: {
293: char token_id_comment[128];
294: int initial_state;
295: int i;
296: int token;
297:
298: /*
299: * Sort ntp_keywords in alphabetical keyword order. This is
300: * not necessary, but minimizes nonfunctional changes in the
301: * generated finite state machine when keywords are modified.
302: */
303: qsort(ntp_keywords, COUNTOF(ntp_keywords),
304: sizeof(ntp_keywords[0]), compare_key_tok_text);
305:
306: /*
307: * To save space, reserve the state array entry matching each
308: * token number for its terminal state, so the token identifier
309: * does not need to be stored in each state, but can be
310: * recovered trivially. To mark the entry reserved,
311: * finishes_token is nonzero.
312: */
313:
314: for (i = 0; i < COUNTOF(ntp_keywords); i++) {
315: token = ntp_keywords[i].token;
316: if (1 > token || token >= COUNTOF(sst)) {
317: fprintf(stderr,
318: "keyword-gen sst[%u] too small "
319: "for keyword '%s' id %d\n",
320: COUNTOF(sst),
321: ntp_keywords[i].key,
322: token);
323: exit(4);
324: }
325: sst[token].finishes_token = token;
326: }
327:
328: initial_state = create_keyword_scanner();
329:
330: fprintf(stderr,
331: "%d keywords consumed %d states of %d max.\n",
332: (int)COUNTOF(ntp_keywords),
333: sst_highwater - 1,
334: (int)COUNTOF(sst) - 1);
335:
336: printf("#define SCANNER_INIT_S %d\n\n", initial_state);
337:
338: printf("const scan_state sst[%d] = {\n"
339: "/*SS_T( ch,\tf-by, match, other ),\t\t\t\t */\n"
340: " 0,\t\t\t\t /* %5d %-17s */\n",
341: sst_highwater,
342: 0, "");
343:
344: for (i = 1; i < sst_highwater; i++) {
345:
346: /* verify fields will fit */
347: if (sst[i].followedby & ~0x3) {
348: fprintf(stderr,
349: "keyword-gen internal error "
350: "sst[%d].followedby %d too big\n",
351: i, sst[i].followedby);
352: exit(7);
353: }
354:
355: if (sst_highwater <= sst[i].match_next_s
356: || sst[i].match_next_s & ~0x7ff) {
357: fprintf(stderr,
358: "keyword-gen internal error "
359: "sst[%d].match_next_s %d too big\n",
360: i, sst[i].match_next_s);
361: exit(8);
362: }
363:
364: if (sst_highwater <= sst[i].other_next_s
365: || sst[i].other_next_s & ~0x7ff) {
366: fprintf(stderr,
367: "keyword-gen internal error "
368: "sst[%d].other_next_s %d too big\n",
369: i, sst[i].other_next_s);
370: exit(9);
371: }
372:
373: if (!sst[i].finishes_token)
374: snprintf(token_id_comment,
375: sizeof(token_id_comment), "%5d %-17s",
376: i, (initial_state == i)
377: ? "initial state"
378: : "");
379: else {
380: snprintf(token_id_comment,
381: sizeof(token_id_comment), "%5d %-17s",
382: i, symbname(sst[i].finishes_token));
383: if (i != sst[i].finishes_token) {
384: fprintf(stderr,
385: "keyword-gen internal error "
386: "entry %d finishes token %d\n",
387: i, sst[i].finishes_token);
388: exit(5);
389: }
390: }
391:
392: printf(" S_ST( '%c',\t%d, %5u, %5u )%s /* %s */\n",
393: sst[i].ch,
394: sst[i].followedby,
395: sst[i].match_next_s,
396: sst[i].other_next_s,
397: (i + 1 < sst_highwater)
398: ? ","
399: : " ",
400: token_id_comment);
401: }
402:
403: printf("};\n\n");
404: }
405:
406:
407: /* Define a function to create the states of the scanner. This function
408: * is used by the create_keyword_scanner function below.
409: *
410: * This function takes a suffix of a keyword, the token to be returned on
411: * recognizing the complete keyword, and any pre-existing state that exists
412: * for some other keyword that has the same prefix as the current one.
413: */
414: static int
415: create_scan_states(
416: char * text,
417: int token,
418: follby followedby,
419: int prev_state
420: )
421: {
422: int my_state;
423: int return_state;
424: int prev_char_s;
425: int curr_char_s;
426:
427: return_state = prev_state;
428: curr_char_s = prev_state;
429: prev_char_s = 0;
430:
431: /* Find the correct position to insert the state.
432: * All states should be in alphabetical order
433: */
434: while (curr_char_s && (text[0] < sst[curr_char_s].ch)) {
435: prev_char_s = curr_char_s;
436: curr_char_s = sst[curr_char_s].other_next_s;
437: }
438:
439: /*
440: * Check if a previously seen keyword has the same prefix as
441: * the current keyword. If so, simply use the state for that
442: * keyword as my_state, otherwise, allocate a new state.
443: */
444: if (curr_char_s && (text[0] == sst[curr_char_s].ch)) {
445: my_state = curr_char_s;
446: if ('\0' == text[1]) {
447: fprintf(stderr,
448: "Duplicate entries for keyword '%s' in"
449: " keyword_gen.c ntp_keywords[].\n",
450: current_keyword);
451: exit(2);
452: }
453: } else {
454: do
455: my_state = sst_highwater++;
456: while (my_state < COUNTOF(sst)
457: && sst[my_state].finishes_token);
458: if (my_state >= COUNTOF(sst)) {
459: fprintf(stderr,
460: "fatal, keyword scanner state array "
461: "sst[%d] is too small, modify\n"
462: "keyword-gen.c to increase.\n",
463: (int)COUNTOF(sst));
464: exit(3);
465: }
466: /* Store the next character of the keyword */
467: sst[my_state].ch = text[0];
468: sst[my_state].other_next_s = curr_char_s;
469: sst[my_state].followedby = FOLLBY_NON_ACCEPTING;
470:
471: if (prev_char_s)
472: sst[prev_char_s].other_next_s = my_state;
473: else
474: return_state = my_state;
475: }
476:
477: /* Check if the next character is '\0'.
478: * If yes, we are done with the recognition and this is an accepting
479: * state.
480: * If not, we need to continue scanning
481: */
482: if ('\0' == text[1]) {
483: sst[my_state].finishes_token = (u_short)token;
484: sst[my_state].followedby = (char)followedby;
485:
486: if (sst[token].finishes_token != (u_short)token) {
487: fprintf(stderr,
488: "fatal, sst[%d] not reserved for %s.\n",
489: token, symbname(token));
490: exit(6);
491: }
492: /* relocate so token id is sst[] index */
493: if (my_state != token) {
494: sst[token] = sst[my_state];
495: memset(&sst[my_state], 0,
496: sizeof(sst[my_state]));
497: do
498: sst_highwater--;
499: while (sst[sst_highwater].finishes_token);
500: my_state = token;
501: if (prev_char_s)
502: sst[prev_char_s].other_next_s = my_state;
503: else
504: return_state = my_state;
505: }
506: } else
507: sst[my_state].match_next_s =
508: create_scan_states(
509: &text[1],
510: token,
511: followedby,
512: sst[my_state].match_next_s);
513:
514: return return_state;
515: }
516:
517:
518: /* Define a function that takes a list of (keyword, token) values and
519: * creates a keywords scanner out of it.
520: */
521:
522: static int
523: create_keyword_scanner(void)
524: {
525: int scanner;
526: int i;
527:
528: sst_highwater = 1; /* index 0 invalid, unused */
529: scanner = 0;
530:
531: for (i = 0; i < COUNTOF(ntp_keywords); i++) {
532: current_keyword = ntp_keywords[i].key;
533: scanner =
534: create_scan_states(
535: ntp_keywords[i].key,
536: ntp_keywords[i].token,
537: ntp_keywords[i].followedby,
538: scanner);
539: }
540:
541: return scanner;
542: }
543:
544:
545: static void
546: generate_token_text(void)
547: {
548: int lowest_id;
549: int highest_id;
550: int id_count;
551: int id;
552: int i;
553:
554: /* sort ntp_keywords in token ID order */
555: qsort(ntp_keywords, COUNTOF(ntp_keywords),
556: sizeof(ntp_keywords[0]), compare_key_tok_id);
557:
558: lowest_id = ntp_keywords[0].token;
559: highest_id = ntp_keywords[COUNTOF(ntp_keywords) - 1].token;
560: id_count = highest_id - lowest_id + 1;
561:
562: printf("#define LOWEST_KEYWORD_ID %d\n\n", lowest_id);
563:
564: printf("const char * const keyword_text[%d] = {", id_count);
565:
566: id = lowest_id;
567: i = 0;
568: while (i < COUNTOF(ntp_keywords)) {
569: while (id < ntp_keywords[i].token) {
570: printf(",\n\t/* %-5d %5d %20s */\tNULL",
571: id - lowest_id, id, symbname(id));
572: id++;
573: }
574: if (i > 0)
575: printf(",");
576: printf("\n\t/* %-5d %5d %20s */\t\"%s\"",
577: id - lowest_id, id, symbname(id),
578: ntp_keywords[i].key);
579: i++;
580: id++;
581: }
582:
583: printf("\n};\n\n");
584: }
585:
586:
587: int
588: compare_key_tok_id(
589: QSORTP a1,
590: QSORTP a2
591: )
592: {
593: const struct key_tok *p1 = (const void *)a1;
594: const struct key_tok *p2 = (const void *)a2;
595:
596: if (p1->token == p2->token)
597: return 0;
598:
599: if (p1->token < p2->token)
600: return -1;
601: else
602: return 1;
603: }
604:
605:
606: int
607: compare_key_tok_text(
608: QSORTP a1,
609: QSORTP a2
610: )
611: {
612: const struct key_tok *p1 = (const void *)a1;
613: const struct key_tok *p2 = (const void *)a2;
614:
615: return strcmp(p1->key, p2->key);
616: }
617:
618:
619: /*
620: * populate_symb() - populate symb[] lookup array with symbolic token
621: * names such that symb[T_Age] == "T_Age", etc.
622: */
623: void
624: populate_symb(
625: char *header_file
626: )
627: {
628: FILE * yh;
629: char line[128];
630: char name[128];
631: int token;
632:
633: yh = fopen(header_file, "r");
634: if (NULL == yh) {
635: perror("unable to open yacc/bison header file");
636: exit(4);
637: }
638:
639: while (NULL != fgets(line, sizeof(line), yh))
640: if (2 == sscanf(line, "#define %s %d", name, &token)
641: && 'T' == name[0] && '_' == name[1] && token >= 0
642: && token < COUNTOF(symb))
643:
644: symb[token] = estrdup(name);
645:
646: fclose(yh);
647: }
648:
649:
650: const char *
651: symbname(
652: int token
653: )
654: {
655: char *name;
656:
657: if (token >= 0 && token < COUNTOF(symb) && symb[token] != NULL)
658: return symb[token];
659:
660: LIB_GETBUF(name);
661: snprintf(name, LIB_BUFLENGTH, "%d", token);
662: return name;
663: }