![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lsym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / icon / link|
Return to lsym.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / icon / link |
1.1 root 1: /*
2: * Routines for symbol table manipulation.
3: */
4:
5: #include "ilink.h"
6:
7: int dynoff; /* stack offset counter for locals */
8: int argoff; /* stack offset counter for arguments */
9: int static1; /* first static in procedure */
10: int statics = 0; /* static variable counter */
11:
12: int nlocal; /* number of locals in local table */
13: int nconst; /* number of constants in constant table */
14: int nfields = 0; /* number of fields in field table */
15:
16: /*
17: * instalid - copy the string s to the start of the string free space
18: * and call putident with the length of the string.
19: */
20: char *instalid(s)
21: char *s;
22: {
23: register int l;
24: register char *p1, *p2;
25: extern char *putident();
26:
27: p1 = sfree;
28: p2 = s;
29: l = 1;
30: while (*p1++ = *p2++)
31: l++;
32: return (putident(l));
33: }
34:
35: /*
36: * putident - install the identifier named by the string starting at sfree
37: * and extending for len bytes. The installation entails making an
38: * entry in the identifier hash table and then making an identifier
39: * table entry for it with alcident. A side effect of installation
40: * is the incrementing of sfree by the length of the string, thus
41: * "saving" it.
42: *
43: * Nothing is changed if the identifier has already been installed.
44: */
45: char *putident(len)
46: int len;
47: {
48: register int hash;
49: register char *s;
50: register struct ientry *ip;
51: int l;
52: extern struct ientry *alcident();
53:
54: /*
55: * Compute hash value by adding bytes and masking result with imask.
56: * (Recall that imask is ihsize-1.)
57: */
58: s = sfree;
59: hash = 0;
60: l = len;
61: while (l--)
62: hash += *s++;
63: l = len;
64: s = sfree;
65: hash &= imask;
66: /*
67: * If the identifier hasn't been installed, install it.
68: */
69: if ((ip = ihash[hash]) != NULL) { /* collision */
70: for (;;) { /* work down i_blink chain until id is found or the
71: end of the chain is reached */
72: if (l == ip->i_length && lexeq(l, s, ip->i_name))
73: return (ip->i_name); /* id is already installed, return it */
74: if (ip->i_blink == NULL) { /* end of chain */
75: ip->i_blink = alcident(NULL, s, l);
76: sfree += l;
77: return (s);
78: }
79: ip = ip->i_blink;
80: }
81: }
82: /*
83: * Hashed to an empty slot.
84: */
85: ihash[hash] = alcident(NULL, s, l);
86: sfree += l;
87: return (s);
88: }
89:
90: /*
91: * lexeq - compare two strings of given length. Returns non-zero if
92: * equal, zero if not equal.
93: */
94: lexeq(l, s1, s2)
95: register int l;
96: register char *s1, *s2;
97: {
98: while (l--)
99: if (*s1++ != *s2++)
100: return (0);
101: return (1);
102: }
103:
104: /*
105: * alcident - get the next free identifier table entry, and fill it in with
106: * the specified values.
107: */
108: struct ientry *alcident(blink, nam, len)
109: struct ientry *blink;
110: char *nam;
111: int len;
112: {
113: register struct ientry *ip;
114:
115: if (ifree >= &itable[isize])
116: syserr("out of identifier table space");
117: ip = ifree++;
118: ip->i_blink = blink;
119: ip->i_name = nam;
120: ip->i_length = len;
121: return (ip);
122: }
123:
124: /*
125: * locinit - clear local symbol table.
126: */
127: locinit()
128: {
129: dynoff = 0;
130: argoff = 0;
131: nlocal = -1;
132: nconst = -1;
133: static1 = statics;
134: }
135:
136: /*
137: * putloc - make a local symbol table entry.
138: */
139: struct lentry *putloc(n, id, flags, imperror, procname)
140: int n;
141: char *id;
142: register int flags;
143: int imperror;
144: char *procname;
145: {
146: register struct lentry *lp;
147: register union {
148: struct gentry *gp;
149: int bn;
150: } p;
151: extern struct gentry *glocate(), *putglob();
152:
153: if (n >= lsize)
154: syserr("out of local symbol table space.");
155: if (n > nlocal)
156: nlocal = n;
157: lp = <able[n];
158: lp->l_name = id;
159: lp->l_flag = flags;
160: if (flags == 0) { /* undeclared */
161: if ((p.gp = glocate(id)) != NULL) { /* check global */
162: lp->l_flag = F_GLOBAL;
163: lp->l_val.global = p.gp;
164: }
165: else if ((p.bn = blocate(id)) != 0) { /* check builtin */
166: lp->l_flag = F_BUILTIN;
167: lp->l_val.global = putglob(id, F_BUILTIN | F_PROC, -1, p.bn);
168: }
169: else { /* implicit local */
170: if (imperror)
171: warn(id, "undeclared identifier, procedure ", procname);
172: lp->l_flag = F_DYNAMIC;
173: lp->l_val.offset = ++dynoff;
174: }
175: }
176: else if (flags & F_GLOBAL) { /* global variable */
177: if ((p.gp = glocate(id)) == NULL)
178: syserr("putloc: global not in global table");
179: lp->l_val.global = p.gp;
180: }
181: else if (flags & F_ARGUMENT) /* procedure argument */
182: lp->l_val.offset = ++argoff;
183: else if (flags & F_DYNAMIC) /* local dynamic */
184: lp->l_val.offset = ++dynoff;
185: else if (flags & F_STATIC) /* local static */
186: lp->l_val.staticid = ++statics;
187: else
188: syserr("putloc: unknown flags");
189: return (lp);
190: }
191:
192: /*
193: * putglob - make a global symbol table entry.
194: */
195: struct gentry *putglob(id, flags, nargs, procid)
196: char *id;
197: int flags;
198: int nargs;
199: int procid;
200: {
201: register struct gentry *p;
202: extern struct gentry *glocate(), *alcglob();
203:
204: if ((p = glocate(id)) == NULL) { /* add to head of hash chain */
205: p = ghash[ghasher(id)];
206: ghash[ghasher(id)] = alcglob(p, id, flags, nargs, procid);
207: return (ghash[ghasher(id)]);
208: }
209: p->g_flag |= flags;
210: p->g_nargs = nargs;
211: p->g_procid = procid;
212: return (p);
213: }
214:
215: /*
216: * putconst - make a constant symbol table entry.
217: */
218: struct centry *putconst(n, flags, len, pc, val)
219: int n;
220: int flags, len;
221: int pc;
222: union {
223: long ival;
224: double rval;
225: char *sval;
226: } val;
227: {
228: register struct centry *p;
229:
230: if (n >= csize)
231: syserr("out of constant table space");
232: if (nconst < n)
233: nconst = n;
234: p = &ctable[n];
235: p->c_flag = flags;
236: p->c_pc = pc;
237: if (flags & F_INTLIT) {
238: p->c_val.ival = val.ival;
239: #ifdef LONGS
240: if (val.ival < (long)(short)MINSHORT | val.ival > (long)(short)MAXSHORT)
241: p->c_flag |= F_LONGLIT;
242: #endif LONGS
243: }
244: else if (flags & F_STRLIT) {
245: p->c_val.sval = val.sval;
246: p->c_length = len;
247: }
248: else if (flags & F_CSETLIT) {
249: p->c_val.sval = val.sval;
250: p->c_length = len;
251: }
252: else if (flags & F_REALLIT)
253: p->c_val.rval = val.rval;
254: else
255: fprintf(stderr, "putconst: bad flags: %06o %011o\n", flags, val.ival);
256: return (p);
257: }
258:
259: /*
260: * putfield - make a record/field table entry.
261: */
262: putfield(fname, rnum, fnum)
263: char *fname;
264: int rnum, fnum;
265: {
266: register struct fentry *fp;
267: register struct rentry *rp, *rp2;
268: int hash;
269: extern struct fentry *flocate(), *alcfhead();
270: extern struct rentry *alcfrec();
271:
272: fp = flocate(fname);
273: if (fp == NULL) { /* create a field entry */
274: nfields++;
275: hash = fhasher(fname);
276: fp = fhash[hash];
277: fhash[hash] = alcfhead(fp, fname, nfields, alcfrec(NULL, rnum, fnum));
278: return;
279: }
280: rp = fp->f_rlist; /* found field entry, look for */
281: if (rp->r_recid > rnum) { /* spot in record list */
282: fp->f_rlist = alcfrec(rp, rnum, fnum);
283: return;
284: }
285: while (rp->r_recid < rnum) { /* keep record list ascending */
286: if (rp->r_link == NULL) {
287: rp->r_link = alcfrec(NULL, rnum, fnum);
288: return;
289: }
290: rp2 = rp;
291: rp = rp->r_link;
292: }
293: rp2->r_link = alcfrec(rp, rnum, fnum);
294: }
295:
296: /*
297: * glocate - lookup identifier in global symbol table, return NULL
298: * if not present.
299: */
300: struct gentry *glocate(id)
301: char *id;
302: {
303: register struct gentry *p;
304:
305: p = ghash[ghasher(id)];
306: while (p != NULL && p->g_name != id)
307: p = p->g_blink;
308: return (p);
309: }
310:
311: /*
312: * flocate - lookup identifier in field table.
313: */
314: struct fentry *flocate(id)
315: char *id;
316: {
317: register struct fentry *p;
318:
319: p = fhash[fhasher(id)];
320: while (p != NULL && p->f_name != id)
321: p = p->f_blink;
322: return (p);
323: }
324:
325: /*
326: * alcglob - create a new global symbol table entry.
327: */
328: struct gentry *alcglob(blink, name, flag, nargs, procid)
329: struct gentry *blink;
330: char *name;
331: int flag;
332: int nargs;
333: int procid;
334: {
335: register struct gentry *gp;
336:
337: if (gfree >= >able[gsize])
338: syserr("out of global symbol table space");
339: gp = gfree++;
340: gp->g_blink = blink;
341: gp->g_name = name;
342: gp->g_flag = flag;
343: gp->g_nargs = nargs;
344: gp->g_procid = procid;
345: return (gp);
346: }
347:
348: /*
349: * alcfhead - allocate a field table header.
350: */
351: struct fentry *alcfhead(blink, name, fid, rlist)
352: struct fentry *blink;
353: char *name;
354: int fid;
355: struct rentry *rlist;
356: {
357: register struct fentry *fp;
358:
359: if (ffree >= &ftable[fsize])
360: syserr("out of field table space");
361: fp = ffree++;
362: fp->f_blink = blink;
363: fp->f_name = name;
364: fp->f_fid = fid;
365: fp->f_rlist = rlist;
366: return (fp);
367: }
368:
369: /*
370: * alcfrec - allocate a field table record list element.
371: */
372: struct rentry *alcfrec(link, rnum, fnum)
373: struct rentry *link;
374: int rnum, fnum;
375: {
376: register struct rentry *rp;
377:
378: if (rfree >= &rtable[rsize])
379: syserr("out of field table space for record lists");
380: rp = rfree++;
381: rp->r_link = link;
382: rp->r_recid = rnum;
383: rp->r_fnum = fnum;
384: return (rp);
385: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.