![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tables.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / cdb / transBsd|
Return to tables.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.bin / cdb / transBsd |
1.1 root 1: /* $Header: tables.c,v 1.1 86/03/24 16:19:23 rcs Exp $ */
2: /* (C) Copyright 1985 Third Eye Software, Inc. - All Rights Reserved */
3:
4: #include "tes42.h"
5:
6: #include <stab.h>
7:
8:
9: /* E N D P R O C */
10:
11: export void EndProc(adr)
12: ADRT adr;
13: {
14: pSYMR sym;
15:
16: sym = SymFInsert();
17: sym->st = stEnd;
18: sym->sc = scText;
19: sym->index = IsymFSym(vsymProc);
20: sym->value = adr;
21: ChangeAux(vsymProc->index, visym+1);
22: vsymProc = symNil;
23:
24: sym = SymFIsym(visym-1); /* check previous guy, too */
25: if (sym->st == stEnd)
26: sym->value = adr;
27: } /* EndProc */
28:
29:
30: /* D O P R O C */
31:
32: export void DoProc(nlist)
33: pNLISTR nlist;
34: {
35: if (vsymProc != symNil)
36: EndProc(nlist->n_value);
37:
38: vsymProc = SymFInsert();
39: vsymProc->st = stProc;
40: vsymProc->index = AddAux(-1);
41: ProcInsert(IsymFSym(vsymProc), nlist->n_value, vilineMac);
42: vcLinesInProc = 0;
43: } /* DoProc */
44:
45:
46: /* P S B H F H A S H S B */
47:
48: local pSBHR PsbhFHashSb(sb)
49: register char *sb;
50: {
51: register int sum = 0;
52:
53: while (sb && *sb)
54: sum += *sb++;
55:
56: return(&vpsbhBucket [sum % hashMod]);
57: } /* PsbhFHashSb */
58:
59:
60: /* I S S F S B I N S E R T */
61:
62: export long IssFSbInsert(sb)
63: register char *sb;
64: {
65: register pSBHR psbh;
66: register pSBHR psbhPrev;
67: register char *sbT;
68: register int sum;
69:
70: sum = 0;
71: if (sb != 0) {
72: sbT = sb;
73: while (*sbT)
74: sum += *sbT++;
75: } /* if */
76: psbh = vpsbhBucket + (sum % hashMod);
77:
78: while (psbh) {
79: if ( (psbh->sb != 0)
80: && (!strcmp(sb, psbh->sb)) ) {
81: return(psbh->iss);
82: } /* if */
83: psbhPrev = psbh;
84: psbh = psbh->psbh;
85: } /* while */
86:
87: psbh = psbhPrev;
88: psbh->psbh = (pSBHR) malloc (cbSBHR);
89: psbh = psbh->psbh;
90: sbT = psbh->sb = vsbMax;
91: psbh->iss = vissMac;
92: while (*(sbT++) = *(sb++))
93: ;
94:
95: vsbMax = sbT;
96: vissMac = vsbMax - vsbNewStr;
97: if (vissMac > vissMax)
98: panic("Ran out of string space - use scaling factor");
99:
100: vissMac++;
101: *(vsbMax++) = '\0';
102: psbh->psbh = (pSBHR) 0;
103:
104: return (psbh->iss);
105: } /* IssFSbInsert */
106:
107:
108: /* D O L I N E */
109:
110: export void DoLine(nlist)
111: pNLISTR nlist;
112: {
113: pLINER line;
114: static ADRT adrSecondLine;
115:
116: if (vcLinesInProc == 1) {
117: /* If there is more than one line in a proc, we ignore the first.
118: * This is correct for all cases except:
119: * foo() {int x = 1;
120: * .... etc.
121: *
122: * Which is brain damaged and life is tough, so there.
123: */
124: vilineMac--;
125: adrSecondLine = nlist->n_value;
126: } else if ((vcLinesInProc >= 2) && (nlist->n_value == adrSecondLine)) {
127: /* throw away previous line */
128: vilineMac--;
129: } /* if */
130:
131: if (vilineMac >= vilineMax)
132: panic ("line table overflow");
133: viline = vilineMac++;
134:
135: line= vrgLine + viline;
136: line->iln= nlist->n_desc;
137: line->dadr= nlist->n_value - vrgPd[vipd].adr;
138: vdot = nlist->n_value;
139: vcLinesInProc++;
140: } /* DoLine */
141:
142:
143: /* E N D F I L E */
144:
145: export void EndFile(adr)
146: ADRT adr;
147: {
148: register pSYMR sym;
149:
150: if (vsymProc != symNil)
151: EndProc(adr);
152:
153: vrgFd[vifd].ilnMac = vrgLine[viline].iln; /* kludge? */
154: sym = SymFInsert();
155: sym->st = stEnd;
156: sym->sc = scText;
157: sym->index = IsymFSym (vsymFile);
158: vsymFile->index = IsymFSym(sym) + 1; /* forward link */
159: sym->value = (vdot == vsymFile->value) ? adr : vdot;
160: } /* EndFile */
161:
162:
163: /* D O F I L E */
164:
165: export void DoFile (nlist, sbName)
166: pNLISTR nlist;
167: char *sbName;
168: {
169: register pFDR fd;
170: register pSYMR sym;
171: ADRT adr;
172: int cb;
173:
174: if (vsymFile != symNil)
175: EndFile(nlist->n_value);
176:
177: adr = (nlist == nlistNil) ? -1L : nlist->n_value;
178:
179: /* The weird chack for ending character of the filename
180: * is to see if a file of pure data came before us.
181: */
182: if ((vifd > 0)
183: && (sbName[strlen(sbName)-1] != 'o')
184: && (vrgFd[vifd].adr == adr)) {
185: /* this is the TRUE source file after Loader freebie symbol */
186: fd= vrgFd + vifd;
187: visymMac = IsymFSym(vsymFile); /* one more time! */
188: } else {
189: if (vifdMac >= vifdMax)
190: panic ("file table overflow");
191: vifd = vifdMac++;
192: fd= vrgFd + vifd;
193: } /* if */
194:
195: cb = strlen(sbName);
196: fd->iss = IssFSbInsert(sbName);
197: fd->adr = adr;
198: fd->isym = visymMac;
199: fd->iline = vilineMac;
200:
201: vsymFile = sym = SymFInsert();
202: sym->iss = fd->iss;
203: sym->st = stFile;
204: sym->sc = scText;
205: vdot = sym->value = adr;
206:
207: /* reinit mapping array */
208: ZeroBlock(&vrgTesF42 [tesF42Low],
209: ((vites42Max + 1) - tesF42Low) * sizeof(int) );
210: vites42Max = tesF42Low;
211: } /* DoFile */
212:
213:
214: /* P R O C I N S E R T */
215:
216: export void ProcInsert(isym, adr, iline)
217: register int isym;
218: register long adr;
219: register int iline;
220: {
221: register pPDR pd, pd2;
222:
223: if (vipdMac >= vipdMax)
224: panic("proc table overflow");
225:
226: vipd = vipdMac++;
227:
228: if ((vipd > 0) && (adr < vrgPd [vipd - 1].adr)) {
229: /* we need to INSERT - not Append */
230:
231: /* find the proc we come AFTER */
232: for (pd = vrgPd + vipd - 1; (pd >= vrgPd) && (pd->adr > adr); pd--)
233: ;
234: /* move everything below it DOWN one */
235: for (pd2 = vrgPd + vipd - 1; pd2 > pd; pd2--)
236: pd2[1] = *pd2;
237: pd++; /* point at new empty slot */
238: } else {
239: pd = vrgPd + vipd;
240: } /* if */
241:
242: pd->isym = isym;
243: pd->adr = adr;
244: pd->iline = iline;
245: } /* ProcInsert */
246:
247: strcmp(sb1, sb2)
248: char *sb1, *sb2;
249: {
250: if (sb1 == 0 || sb2 == 0)
251: return(1);
252: while (*sb1 == *sb2) {
253: if (*sb1 == '\0')
254: return(0);
255: sb1++;
256: sb2++;
257: } /* while */
258: return(1);
259: } /* strcmp */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.