![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / c|
Return to sym.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 root 1: /* C compiler: symbol table management */
2: #include "c.h"
3:
4: struct entry { /* symbol table entry: */
5: struct symbol sym; /* the symbol */
6: List refs; /* list form of sym.uses (omit) */
7: struct entry *link; /* next entry on hash chain */
8: };
9: struct table { /* symbol tables: */
10: int level; /* scope level for this table */
11: struct table *previous; /* table for previous scope */
12: Symbol list; /* list of entries via up fields */
13: struct entry *buckets[HASHSIZE];
14: };
15: static struct table
16: tconstants = { CONSTANTS },
17: texternals = { GLOBAL },
18: tidentifiers = { GLOBAL },
19: ttypes = { GLOBAL };
20: Table constants = &tconstants; /* constants */
21: Table externals = &texternals; /* externals */
22: Table identifiers = &tidentifiers; /* identifiers */
23: Table globals = &tidentifiers; /* globals */
24: Table labels[2]; /* labels */
25: Table types = &ttypes; /* types */
26: static struct temporary {/* temporaries: */
27: Symbol sym; /* pointer to the symbol */
28: struct temporary *link; /* next available temporary */
29: } *temps; /* list of available temporaries */
30: int bnumber; /* current block number */
31: int level; /* current block level */
32: List symbols; /* list of all symbols; used only if xref != 0 */
33:
34: Table table(tp, lev) Table tp; {
35: int i;
36: Table new = (Table)talloc(sizeof *new);
37:
38: assert(lev > GLOBAL || lev == LABELS);
39: new->previous = tp;
40: new->level = lev;
41: new->list = tp ? tp->list : (Symbol)0; /* (omit) */
42: for (i = 0; i < HASHSIZE; i++)
43: new->buckets[i] = 0;
44: return new;
45: }
46: void foreach(tp, lev, apply, cl) Table tp;
47: dclproto(void (*apply),(Symbol, Generic)); Generic cl; {
48: assert(tp);
49: while (tp && tp->level > lev)
50: tp = tp->previous;
51: if (tp && tp->level == lev) {
52: Symbol p;
53: Coordinate sav;
54: sav = src;
55: for (p = tp->list; p && p->scope == lev; p = p->up) {
56: src = p->src;
57: (*apply)(p, cl);
58: }
59: src = sav;
60: }
61: }
62: void enterscope() {
63: if (++level >= USHRT_MAX)
64: error("compound statements nested too deeply\n");
65: }
66: void exitscope() {
67: rmtypes();
68: rmtemps(0, level);
69: if (identifiers->level == level) {
70: if (Aflag >= 2) {
71: int n = 0;
72: Symbol p;
73: for (p = identifiers->list; p && p->scope == level; p = p->up)
74: if (++n > 127) {
75: warning("more than 127 identifiers declared in a block\n");
76: break;
77: }
78: }
79: if (xref) /* (omit) */
80: setuses(identifiers); /* (omit) */
81: identifiers = identifiers->previous;
82: }
83: if (types->level == level) {
84: if (xref) { /* (omit) */
85: foreach(types, level, fielduses, (Generic)0); /* (omit) */
86: setuses(types); /* (omit) */
87: } /* (omit) */
88: types = types->previous;
89: }
90: assert(level >= GLOBAL);
91: --level;
92: }
93: Symbol install(name, tpp, perm) char *name; Table *tpp; {
94: struct entry *p;
95: unsigned h = (unsigned)name&(HASHSIZE-1);
96:
97: if ((tpp == &identifiers || tpp == &types) && (*tpp)->level < level)
98: *tpp = table(*tpp, level);
99: if (perm)
100: p = (struct entry *) alloc(sizeof *p);
101: else
102: p = (struct entry *) talloc(sizeof *p);
103: BZERO(&p->sym, struct symbol);
104: p->sym.name = name;
105: p->sym.scope = (*tpp)->level;
106: p->sym.up = (*tpp)->list;
107: (*tpp)->list = &p->sym;
108: p->link = (*tpp)->buckets[h];
109: (*tpp)->buckets[h] = p;
110: p->refs = 0; /* (omit) */
111: return &p->sym;
112: }
113: Symbol lookup(name, tp) char *name; Table tp; {
114: struct entry *p;
115: unsigned h = (unsigned)name&(HASHSIZE-1);
116:
117: assert(tp);
118: do
119: for (p = tp->buckets[h]; p; p = p->link)
120: if (name == p->sym.name)
121: return &p->sym;
122: while (tp = tp->previous);
123: return 0;
124: }
125: int genlabel(n) {
126: static int label = 1;
127:
128: label += n;
129: return label - n;
130: }
131: Symbol findlabel(lab) {
132: char *label = stringd(lab);
133: Symbol p;
134:
135: if (p = lookup(label, labels[1]))
136: return p;
137: p = install(label, &labels[1], 0);
138: p->generated = 1;
139: p->u.l.label = lab;
140: p->u.l.equatedto = p;
141: (*IR->defsymbol)(p);
142: return p;
143: }
144: Symbol constant(ty, v) Type ty; Value v; {
145: struct entry *p;
146: unsigned h = v.u&(HASHSIZE-1);
147:
148: ty = unqual(ty);
149: for (p = constants->buckets[h]; p; p = p->link)
150: if (eqtype(ty, p->sym.type, 1))
151: switch (ty->op) {
152: case CHAR: if (v.uc == p->sym.u.c.v.uc) return &p->sym; break;
153: case SHORT: if (v.ss == p->sym.u.c.v.ss) return &p->sym; break;
154: case INT: if (v.i == p->sym.u.c.v.i) return &p->sym; break;
155: case UNSIGNED: if (v.u == p->sym.u.c.v.u) return &p->sym; break;
156: case FLOAT: if (v.f == p->sym.u.c.v.f) return &p->sym; break;
157: case DOUBLE: if (v.d == p->sym.u.c.v.d) return &p->sym; break;
158: case ARRAY: case FUNCTION:
159: case POINTER: if (v.p == p->sym.u.c.v.p) return &p->sym; break;
160: default: assert(0);
161: }
162: p = (struct entry *) alloc(sizeof *p);
163: BZERO(&p->sym, struct symbol);
164: p->sym.name = vtoa(ty, v);
165: p->sym.scope = CONSTANTS;
166: p->sym.type = ty;
167: p->sym.sclass = STATIC;
168: p->sym.u.c.v = v;
169: p->link = constants->buckets[h];
170: p->sym.up = constants->list;
171: constants->list = &p->sym;
172: constants->buckets[h] = p;
173: p->refs = 0; /* (omit) */
174: (*IR->defsymbol)(&p->sym);
175: return &p->sym;
176: }
177: Symbol intconst(n) {
178: Value v;
179:
180: v.i = n;
181: return constant(inttype, v);
182: }
183: Symbol genident(sclass, ty, lev) Type ty; {
184: Symbol p;
185:
186: if (lev <= PARAM)
187: p = (Symbol) alloc(sizeof *p);
188: else
189: p = (Symbol) talloc(sizeof *p);
190: BZERO(p, struct symbol);
191: p->name = stringd(genlabel(1));
192: p->scope = lev;
193: p->sclass = sclass;
194: p->type = ty;
195: p->generated = 1;
196: if (lev < PARAM)
197: (*IR->defsymbol)(p);
198: return p;
199: }
200: Symbol temporary(sclass, ty) Type ty; {
201: Symbol t1;
202: struct temporary *p, **q = &temps;
203:
204: for (p = *q; p; q = &p->link, p = *q)
205: if (p->sym->sclass == sclass && eqtype(p->sym->type, ty, 1))
206: /* && p->sym->type->size == ty->size
207: && p->sym->type->align >= ty->align)*/ {
208: *q = p->link;
209: p->sym->type = ty;
210: return p->sym;
211: }
212: t1 = genident(sclass, ty, level);
213: t1->temporary = 1;
214: return t1;
215: }
216: void rmtemps(sclass, level) {
217: struct temporary *p, **q = &temps;
218:
219: for (p = *q; p; p = *q)
220: if (p->sym->scope == level || p->sym->sclass == sclass)
221: *q = p->link;
222: else
223: q = &p->link;
224: }
225: void release(t1) Symbol t1; {
226: if (0 && t1->ref) {
227: struct temporary *p = (struct temporary *) talloc(sizeof *p);
228: p->sym = t1;
229: p->link = temps;
230: temps = p;
231: t1->ref = 0;
232: }
233: }
234: Symbol newtemp(sclass, tc) {
235: Symbol t1 = temporary(sclass, btot(tc));
236:
237: t1->scope = LOCAL;
238: if (t1->defined == 0) {
239: (*IR->local)(t1);
240: t1->defined = 1;
241: }
242: return t1;
243: }
244: /* fielduses - convert use lists for fields in type p */
245: void fielduses(p, cl) Symbol p; Generic cl; {
246: if (p->type && isstruct(p->type) && p->u.s.ftab)
247: setuses(p->u.s.ftab);
248: }
249:
250: /* findtype - find type ty in identifiers */
251: Symbol findtype(ty) Type ty; {
252: Table tp = identifiers;
253: int i;
254: struct entry *p;
255:
256: assert(tp);
257: do
258: for (i = 0; i < HASHSIZE; i++)
259: for (p = tp->buckets[i]; p; p = p->link)
260: if (p->sym.type == ty && p->sym.sclass == TYPEDEF)
261: return &p->sym;
262: while (tp = tp->previous);
263: return 0;
264: }
265:
266: /* locus - append (table, cp) to the evolving loci and symbol tables lists */
267: void locus(tp, cp) Table tp; Coordinate *cp; {
268: extern List loci, tables;
269:
270: loci = append((Generic)cp, loci);
271: tables = append((Generic)tp->list, tables);
272: }
273:
274: /* setuses - convert p->refs to p->uses for all p at the current level in *tp */
275: void setuses(tp) Table tp; {
276: if (xref) {
277: int i;
278: struct entry *p;
279: for (i = 0; i < HASHSIZE; i++)
280: for (p = tp->buckets[i]; p; p = p->link) {
281: if (p->refs)
282: p->sym.uses = (Coordinate **)ltoa(p->refs, 0);
283: p->refs = 0;
284: symbols = append((Generic)&p->sym, symbols);
285: }
286: }
287: }
288:
289: /* use - add src to the list of uses for p */
290: void use(p, src) Symbol p; Coordinate src; {
291: if (xref) {
292: Coordinate *cp = (Coordinate *)alloc(sizeof *cp);
293: *cp = src;
294: ((struct entry *)p)->refs = append((Generic)cp, ((struct entry *)p)->refs);
295: }
296: }
297:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.