![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to keywords.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / dbx|
Return to keywords.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)keywords.c 5.2 (Berkeley) 6/4/85";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: keywords.c,v 1.5 84/12/26 10:39:45 linton Exp $";
12:
13: /*
14: * Keywords, variables, and aliases (oh my!).
15: */
16:
17: #include "defs.h"
18: #include "keywords.h"
19: #include "scanner.h"
20: #include "names.h"
21: #include "symbols.h"
22: #include "tree.h"
23: #include "lists.h"
24: #include "main.h"
25: #include "y.tab.h"
26:
27: #ifndef public
28:
29: #include "scanner.h"
30: #include "tree.h"
31:
32: #endif
33:
34: private String reserved[] ={
35: "alias", "and", "assign", "at", "call", "catch", "cont",
36: "debug", "delete", "div", "down", "dump", "edit", "file", "func",
37: "gripe", "help", "if", "ignore", "in",
38: "list", "mod", "next", "nexti", "nil", "not", "or",
39: "print", "psym", "quit", "rerun", "return", "run",
40: "set", "sh", "skip", "source", "status", "step", "stepi",
41: "stop", "stopi", "trace", "tracei", "unalias", "unset", "up", "use",
42: "whatis", "when", "where", "whereis", "which",
43: "INT", "CHAR", "REAL", "NAME", "STRING", "->"
44: };
45:
46: /*
47: * The keyword table is a traditional hash table with collisions
48: * resolved by chaining.
49: */
50:
51: #define HASHTABLESIZE 1007
52:
53: typedef enum { ISKEYWORD, ISALIAS, ISVAR } KeywordType;
54:
55: typedef struct Keyword {
56: Name name;
57: KeywordType class : 16;
58: union {
59: /* ISKEYWORD: */
60: Token toknum;
61:
62: /* ISALIAS: */
63: struct {
64: List paramlist;
65: String expansion;
66: } alias;
67:
68: /* ISVAR: */
69: Node var;
70: } value;
71: struct Keyword *chain;
72: } *Keyword;
73:
74: typedef unsigned int Hashvalue;
75:
76: private Keyword hashtab[HASHTABLESIZE];
77:
78: #define hash(n) ((((unsigned) n) >> 2) mod HASHTABLESIZE)
79:
80: /*
81: * Enter all the reserved words into the keyword table.
82: *
83: * If the vaddrs flag is set (through the -k command line option) then
84: * set the special "$mapaddrs" variable. This assumes that the
85: * command line arguments are scanned before this routine is called.
86: */
87:
88: public enterkeywords()
89: {
90: register integer i;
91:
92: for (i = ALIAS; i <= WHICH; i++) {
93: keyword(reserved[ord(i) - ord(ALIAS)], i);
94: }
95: defalias("c", "cont");
96: defalias("d", "delete");
97: defalias("h", "help");
98: defalias("e", "edit");
99: defalias("l", "list");
100: defalias("n", "next");
101: defalias("p", "print");
102: defalias("q", "quit");
103: defalias("r", "run");
104: defalias("s", "step");
105: defalias("st", "stop");
106: defalias("j", "status");
107: defalias("t", "where");
108: if (vaddrs) {
109: defvar(identname("$mapaddrs", true), nil);
110: }
111: }
112:
113: /*
114: * Deallocate the keyword table.
115: */
116:
117: public keywords_free()
118: {
119: register Integer i;
120: register Keyword k, nextk;
121:
122: for (i = 0; i < HASHTABLESIZE; i++) {
123: k = hashtab[i];
124: while (k != nil) {
125: nextk = k->chain;
126: dispose(k);
127: k = nextk;
128: }
129: hashtab[i] = nil;
130: }
131: }
132:
133: /*
134: * Insert a name into the keyword table and return the keyword for it.
135: */
136:
137: private Keyword keywords_insert (n)
138: Name n;
139: {
140: Hashvalue h;
141: Keyword k;
142:
143: h = hash(n);
144: k = new(Keyword);
145: k->name = n;
146: k->chain = hashtab[h];
147: hashtab[h] = k;
148: return k;
149: }
150:
151: /*
152: * Find the keyword associated with the given name.
153: */
154:
155: private Keyword keywords_lookup (n)
156: Name n;
157: {
158: Hashvalue h;
159: register Keyword k;
160:
161: h = hash(n);
162: k = hashtab[h];
163: while (k != nil and k->name != n) {
164: k = k->chain;
165: }
166: return k;
167: }
168:
169: /*
170: * Delete the given keyword of the given class.
171: */
172:
173: private boolean keywords_delete (n, class)
174: Name n;
175: KeywordType class;
176: {
177: Hashvalue h;
178: register Keyword k, prevk;
179: boolean b;
180:
181: h = hash(n);
182: k = hashtab[h];
183: prevk = nil;
184: while (k != nil and (k->name != n or k->class != class)) {
185: prevk = k;
186: k = k->chain;
187: }
188: if (k != nil) {
189: b = true;
190: if (prevk == nil) {
191: hashtab[h] = k->chain;
192: } else {
193: prevk->chain = k->chain;
194: }
195: dispose(k);
196: } else {
197: b = false;
198: }
199: return b;
200: }
201:
202: /*
203: * Enter a keyword into the table. It is assumed to not be there already.
204: * The string is assumed to be statically allocated.
205: */
206:
207: private keyword (s, t)
208: String s;
209: Token t;
210: {
211: Keyword k;
212: Name n;
213:
214: n = identname(s, true);
215: k = keywords_insert(n);
216: k->class = ISKEYWORD;
217: k->value.toknum = t;
218: }
219:
220: /*
221: * Define a builtin command name alias.
222: */
223:
224: private defalias (s1, s2)
225: String s1, s2;
226: {
227: alias(identname(s1, true), nil, s2);
228: }
229:
230: /*
231: * Look for a word of a particular class.
232: */
233:
234: private Keyword findword (n, class)
235: Name n;
236: KeywordType class;
237: {
238: register Keyword k;
239:
240: k = keywords_lookup(n);
241: while (k != nil and (k->name != n or k->class != class)) {
242: k = k->chain;
243: }
244: return k;
245: }
246:
247: /*
248: * Return the token associated with a given keyword string.
249: * If there is none, return the given default value.
250: */
251:
252: public Token findkeyword (n, def)
253: Name n;
254: Token def;
255: {
256: Keyword k;
257: Token t;
258:
259: k = findword(n, ISKEYWORD);
260: if (k == nil) {
261: t = def;
262: } else {
263: t = k->value.toknum;
264: }
265: return t;
266: }
267:
268: /*
269: * Return the associated string if there is an alias with the given name.
270: */
271:
272: public boolean findalias (n, pl, str)
273: Name n;
274: List *pl;
275: String *str;
276: {
277: Keyword k;
278: boolean b;
279:
280: k = findword(n, ISALIAS);
281: if (k == nil) {
282: b = false;
283: } else {
284: *pl = k->value.alias.paramlist;
285: *str = k->value.alias.expansion;
286: b = true;
287: }
288: return b;
289: }
290:
291: /*
292: * Return the string associated with a token corresponding to a keyword.
293: */
294:
295: public String keywdstring (t)
296: Token t;
297: {
298: return reserved[ord(t) - ord(ALIAS)];
299: }
300:
301: /*
302: * Process an alias command, either entering a new alias or printing out
303: * an existing one.
304: */
305:
306: public alias (newcmd, args, str)
307: Name newcmd;
308: List args;
309: String str;
310: {
311: Keyword k;
312:
313: if (str == nil) {
314: print_alias(newcmd);
315: } else {
316: k = findword(newcmd, ISALIAS);
317: if (k == nil) {
318: k = keywords_insert(newcmd);
319: }
320: k->class = ISALIAS;
321: k->value.alias.paramlist = args;
322: k->value.alias.expansion = str;
323: }
324: }
325:
326: /*
327: * Print out an alias.
328: */
329:
330: private print_alias (cmd)
331: Name cmd;
332: {
333: register Keyword k;
334: register Integer i;
335: Name n;
336:
337: if (cmd == nil) {
338: for (i = 0; i < HASHTABLESIZE; i++) {
339: for (k = hashtab[i]; k != nil; k = k->chain) {
340: if (k->class == ISALIAS) {
341: if (isredirected()) {
342: printf("alias %s", ident(k->name));
343: printparams(k->value.alias.paramlist);
344: printf("\t\"%s\"\n", k->value.alias.expansion);
345: } else {
346: printf("%s", ident(k->name));
347: printparams(k->value.alias.paramlist);
348: printf("\t%s\n", k->value.alias.expansion);
349: }
350: }
351: }
352: }
353: } else {
354: k = findword(cmd, ISALIAS);
355: if (k == nil) {
356: printf("\n");
357: } else {
358: printparams(k->value.alias.paramlist);
359: printf("%s\n", k->value.alias.expansion);
360: }
361: }
362: }
363:
364: private printparams (pl)
365: List pl;
366: {
367: Name n;
368:
369: if (pl != nil) {
370: printf("(");
371: foreach(Name, n, pl)
372: printf("%s", ident(n));
373: if (not list_islast()) {
374: printf(", ");
375: }
376: endfor
377: printf(")");
378: }
379: }
380:
381: /*
382: * Remove an alias.
383: */
384:
385: public unalias (n)
386: Name n;
387: {
388: if (not keywords_delete(n, ISALIAS)) {
389: error("%s is not aliased", ident(n));
390: }
391: }
392:
393: /*
394: * Define a variable.
395: */
396:
397: public defvar (n, val)
398: Name n;
399: Node val;
400: {
401: Keyword k;
402:
403: if (n == nil) {
404: print_vars();
405: } else {
406: if (lookup(n) != nil) {
407: error("\"%s\" is a program symbol -- use assign", ident(n));
408: }
409: k = findword(n, ISVAR);
410: if (k == nil) {
411: k = keywords_insert(n);
412: }
413: k->class = ISVAR;
414: k->value.var = val;
415: if (n == identname("$mapaddrs", true)) {
416: vaddrs = true;
417: }
418: }
419: }
420:
421: /*
422: * Return the value associated with a variable.
423: */
424:
425: public Node findvar (n)
426: Name n;
427: {
428: Keyword k;
429: Node val;
430:
431: k = findword(n, ISVAR);
432: if (k == nil) {
433: val = nil;
434: } else {
435: val = k->value.var;
436: }
437: return val;
438: }
439:
440: /*
441: * Return whether or not a variable is set.
442: */
443:
444: public boolean varIsSet (s)
445: String s;
446: {
447: return (boolean) (findword(identname(s, false), ISVAR) != nil);
448: }
449:
450: /*
451: * Delete a variable.
452: */
453:
454: public undefvar (n)
455: Name n;
456: {
457: if (not keywords_delete(n, ISVAR)) {
458: error("%s is not set", ident(n));
459: }
460: if (n == identname("$mapaddrs", true)) {
461: vaddrs = false;
462: }
463: }
464:
465: /*
466: * Print out all the values of set variables.
467: */
468:
469: private print_vars ()
470: {
471: register integer i;
472: register Keyword k;
473:
474: for (i = 0; i < HASHTABLESIZE; i++) {
475: for (k = hashtab[i]; k != nil; k = k->chain) {
476: if (k->class == ISVAR) {
477: if (isredirected()) {
478: printf("set ");
479: }
480: printf("%s", ident(k->name));
481: if (k->value.var != nil) {
482: printf("\t");
483: prtree(stdout, k->value.var);
484: }
485: printf("\n");
486: }
487: }
488: }
489: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.