![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to awk2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / awk|
Return to awk2.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / awk |
1.1 root 1: /*
2: * AWK - part 2
3: * Initialisation, and
4: * other compiler support.
5: * Symbol table maintenance
6: * and lookup.
7: */
8:
9: #include "awk.h"
10: #include "y.tab.h"
11:
12: void keyenter();
13: void funcenter();
14:
15: typedef struct FUNC {
16: int (*f_funcp)();
17: CHAR *f_name;
18: CHAR f_minarg; /* Minimum number of arguments */
19: CHAR f_maxarg; /* Maximum # args (-1 = variable) */
20: } FUNC;
21:
22: FUNC functions[] = {
23: f_length, "length", 0, 1,
24: f_sqrt, "sqrt", 1, 1,
25: f_log, "log", 1, 1,
26: f_exp, "exp", 1, 1,
27: f_int, "int", 1, 1,
28: f_substr, "substr", 2, 3,
29: f_index, "index", 2, 2,
30: f_sprintf, "sprintf", 1, -1,
31: f_split, "split", 2, 3,
32: f_abs, "abs", 1, 1,
33: };
34:
35: typedef struct KEYW {
36: int k_lval;
37: CHAR *k_name;
38: } KEYW;
39:
40: KEYW keywords[] = {
41: BEGIN_, "BEGIN",
42: END_, "END",
43: PRINT_, "print",
44: PRINTF_, "printf",
45: IF_, "if",
46: ELSE_, "else",
47: WHILE_, "while",
48: FOR_, "for",
49: IN_, "in",
50: BREAK_, "break",
51: CONTINUE_, "continue",
52: NEXT_, "next",
53: EXIT_, "exit",
54: };
55:
56: /*
57: * Initialisation --
58: * Turn on buffering for output.
59: * Initialse static constant values,
60: * install keywords,
61: * and install built-in functions.
62: */
63: awkinit()
64: {
65: setbuf(stdin, inbuf);
66: setbuf(stdout, outbuf);
67: setbuf(stderr, NULL);
68: /*
69: * Initialise keywords into
70: * the symbol table.
71: */
72: {
73: register KEYW *kp;
74:
75: for (kp = keywords; kp < endof(keywords); kp++)
76: keyenter(kp->k_name, kp->k_lval);
77: }
78: /*
79: * Install functions into symbol
80: * table.
81: */
82: {
83: register FUNC *fp;
84:
85: for (fp = functions; fp < endof(functions); fp++)
86: funcenter(fp->f_name, fp->f_funcp, fp->f_minarg,
87: fp->f_maxarg);
88: }
89: xzero.t_INT = 0;
90: xone.t_INT = 1;
91: xone.t_op = xzero.t_op = ATERM;
92: xone.t_flag = xzero.t_flag = T_INT|T_NUM;
93: xfield0.n_op = AFIELD;
94: xfield0.n_O1 = &xzero;
95: /*
96: * Set up the built-in variables.
97: */
98: NRp = install("NR", (INT)0);
99: NFp = install("NF", (INT)0);
100: FILENAMEp = lookup("FILENAME");
101: sassign(FSp = install("FS", (INT)0), " \t");
102: sassign(RSp = install("RS", (INT)0), "\n");
103: sassign(OFSp = install("OFS", (INT)0), " ");
104: sassign(ORSp = install("ORS", (INT)0), "\n");
105: sassign(OFMTp = install("OFMT", (INT)0), "%ld");
106: }
107:
108: /*
109: * Lookup an identifier - `id' and
110: * if it is not found, initialise it
111: * with the NULL string.
112: * The hash value is the sum of all
113: * the characters in the name +
114: * the length of the name.
115: */
116: NODE *
117: lookup(id)
118: CHAR *id;
119: {
120: register CHAR *ip;
121: register TERM *tp;
122: register unsigned hash;
123: register unsigned nb;
124:
125: hash = 0;
126: nb = sizeof (CHAR);
127: for (ip = id; *ip != '\0'; hash++, nb++)
128: hash += *ip++;
129: for (tp = symtab[hash%NHASH]; tp != NULL; tp = tp->t_next)
130: if (hash==tp->t_hval && tp->t_flag&T_VAR
131: && streq(tp->t_name, id))
132: return (tp);
133: tp = (TERM *)xalloc(sizeof(NODE) + nb);
134: strcpy(tp->t_name, id);
135: tp->t_STRING = xalloc(sizeof(CHAR));
136: tp->t_STRING[0] = '\0';
137: tp->t_op = ATERM;
138: tp->t_flag = T_VAR|T_ALLOC;
139: tp->t_hval = hash;
140: tp->t_ahval = -1;
141: tp->t_next = symtab[hash %= NHASH];
142: symtab[hash] = tp;
143: return ((NODE *)tp);
144: }
145:
146: /*
147: * Lookup for an array.
148: * Arguments are `array' and `index'
149: * (both strings). Hashing is an
150: * extension of that in lookup().
151: * New array elements are given value the
152: * NULL string.
153: */
154: NODE *
155: alookup(array, index)
156: CHAR *array;
157: CHAR *index;
158: {
159: register CHAR *ip;
160: register TERM *tp;
161: register unsigned hash;
162: register unsigned nba, nbi;
163: register unsigned hash2;
164:
165: hash = 0;
166: nba = nbi = sizeof (CHAR);
167: for (ip = array; *ip != '\0'; hash++, nba++)
168: hash += *ip++;
169: hash2 = hash;
170: for (ip = index; *ip != '\0'; hash++, nbi++)
171: hash += *ip++;
172: for (tp = symtab[hash % NHASH]; tp != NULL; tp = tp->t_next)
173: if (hash==tp->t_hval && tp->t_flag&T_ARRAY
174: && streq(tp->t_name, array) && streq(tp->t_name+nba, index))
175: return (tp);
176: tp = (TERM *)xalloc(sizeof(NODE) + nba + nbi);
177: strcpy(tp->t_name, array);
178: strcpy(tp->t_name+nba, index);
179: tp->t_STRING = xalloc(sizeof(CHAR));
180: tp->t_STRING[0] = '\0';
181: tp->t_op = ATERM;
182: tp->t_flag = T_ARRAY|T_ALLOC;
183: tp->t_hval = hash;
184: tp->t_ahval = hash2;
185: tp->t_next = symtab[hash %= NHASH];
186: symtab[hash] = tp;
187: return ((NODE *)tp);
188: }
189:
190: /*
191: * Install a built-in integer
192: * name with value `val'.
193: */
194: NODE *
195: install(id, val)
196: CHAR *id;
197: INT val;
198: {
199: register NODE *np;
200:
201: np = lookup(id);
202: np->t_flag |= T_NUM|T_INT;
203: free(np->t_STRING);
204: np->t_INT = val;
205: return (np);
206: }
207:
208: /*
209: * Enter a keyword in the symbol table.
210: * `lval' is the lexical value of the keyword
211: * and the TERM type is `AKEYW'.
212: */
213: void
214: keyenter(word, lval)
215: CHAR *word;
216: int lval;
217: {
218: register CHAR *ip;
219: register unsigned hash;
220: register TERM *tp;
221: register int nb;
222:
223: hash = 0;
224: nb = sizeof (CHAR);
225: for (ip = word; *ip != '\0'; hash++, nb++)
226: hash += *ip++;
227: tp = (TERM *)xalloc(nb + sizeof(TERM));
228: tp->t_hval = hash;
229: tp->t_op = AKEYW;
230: tp->t_flag = T_ALLOC|T_VAR;
231: strcpy(tp->t_name, word);
232: tp->t_INT = lval;
233: tp->t_next = symtab[hash %= NHASH];
234: symtab[hash] = tp;
235: }
236:
237: /*
238: * Enter a function name into the
239: * symbol table.
240: * `min' and `max' are the minimum and
241: * maximum number of arguments, respectively.
242: */
243: void
244: funcenter(name, fun, min, max)
245: CHAR *name;
246: int (*fun)();
247: int min, max;
248: {
249: register CHAR *np;
250: register unsigned hash;
251: register TERM *tp;
252: register unsigned nb;
253:
254: hash = 0;
255: nb = sizeof (CHAR);
256: for (np = name; *np != '\0'; hash++, nb++)
257: hash += *np++;
258: tp = (TERM *)xalloc(nb + sizeof(TERM));
259: tp->t_hval = hash;
260: tp->t_op = AFUNC;
261: tp->t_flag = T_ALLOC|T_VAR;
262: strcpy(tp->t_name, name);
263: tp->t_FUNC = fun;
264: tp->t_MINARG = min;
265: tp->t_MAXARG = max;
266: tp->t_next = symtab[hash %= NHASH];
267: symtab[hash] = tp;
268: }
269:
270: /*
271: * Assign a new value to a string.
272: * It produces a static string.
273: */
274: sassign(np, s)
275: register NODE *np;
276: STRING s;
277: {
278: if ((np->t_flag & (T_ALLOC|T_NUM)) == T_ALLOC)
279: free(np->t_STRING);
280: np->t_flag &= ~(T_ALLOC|T_NUM);
281: np->t_STRING = s;
282: }
283:
284: /*
285: * Assign an INT to a node.
286: */
287: iassign(np, i)
288: register NODE *np;
289: INT i;
290: {
291: if ((np->t_flag & (T_ALLOC|T_NUM)) == T_ALLOC)
292: free(np->t_STRING);
293: np->t_flag &= ~T_ALLOC;
294: np->t_flag |= T_INT|T_NUM;
295: np->t_INT = i;
296: }
297:
298: /*
299: * Initialise (or reset) the mapping
300: * table for field extraction. It is
301: * set to non-zero for every character
302: * that can end a field + '\0'
303: * Note that FSMAP is defined over `wordbuf'
304: * which is only used lexically and by `sprintf'
305: * Therefore this routine must be called if this
306: * buffer is disturbed.
307: */
308: fsmapinit(fsp)
309: register CHAR *fsp;
310: {
311: register CHAR *cp;
312:
313: whitesw = !strcmp(fsp, " \t");
314: for (cp = FSMAP; cp < &FSMAP[NCSET]; )
315: *cp++ = 0;
316: while (*fsp != '\0')
317: FSMAP[*fsp++] = 1;
318: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.