![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to readobj.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / pdx / object|
Return to readobj.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / pdx / object |
1.1 root 1: /*
2: * Copyright (c) 1982 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[] = "@(#)readobj.c 5.1 (Berkeley) 6/7/85";
9: #endif not lint
10:
11: /*
12: * Read in the namelist from the obj file.
13: */
14:
15: #include "defs.h"
16: #include "sym.h"
17: #include "symtab.h"
18: #include "object.h"
19: #include "objfmt.h"
20: #include "main.h"
21: #include "mappings.h"
22: #include "mappings/filetab.h"
23: #include "mappings/linetab.h"
24: #include "objsym.rep"
25:
26: #define MAXSYMNO 6000
27:
28: char *objname = "obj";
29:
30: LOCAL SYM *sym[MAXSYMNO];
31:
32: readobj(file)
33: char *file;
34: {
35: register FILE *fp;
36: struct pxhdr hdr;
37:
38: if ((fp = fopen(file, "r")) == NIL) {
39: panic("can't open %s", file);
40: }
41: get(fp, hdr);
42: if (hdr.magicnum != MAGICNUM) {
43: fseek(fp, (long) (HEADER_BYTES - sizeof(struct pxhdr)), 0);
44: get(fp, hdr);
45: if (hdr.magicnum != MAGICNUM) {
46: fatal("%s is not a Pascal object file", file);
47: }
48: }
49: if (hdr.symtabsize == 0) {
50: fatal("%s doesn't have symbolic information", file);
51: }
52: objsize = hdr.objsize;
53: fseek(fp, (long) objsize, 1);
54: if (get(fp, nlhdr) != 1) {
55: panic("can't read nlhdr");
56: }
57: if (option('h')) {
58: printf("\nHeader information:\n");
59: printf("\tobject size %d\n", objsize);
60: printf("\tsymtab size %d\n", hdr.symtabsize);
61: printf("\tstringsize %d\n", nlhdr.stringsize);
62: printf("\tnsyms %d\n", nlhdr.nsyms);
63: printf("\tnfiles %d\n", nlhdr.nfiles);
64: printf("\tnlines %d\n", nlhdr.nlines);
65: }
66: stringtab = alloc(nlhdr.stringsize, char);
67: fread(stringtab, sizeof(char), nlhdr.stringsize, fp);
68: readsyms(fp);
69: readfiles(fp);
70: readlines(fp);
71: fclose(fp);
72: }
73:
74: /*
75: * Allocate and read in file name information table.
76: */
77:
78: LOCAL readfiles(fp)
79: register FILE *fp;
80: {
81: register int i;
82: register FILETAB *ftp;
83: FILETAB temp;
84: ADDRESS prevaddr;
85:
86: filetab = alloc(nlhdr.nfiles, FILETAB);
87: ftp = &filetab[0];
88: prevaddr = 0;
89: for (i = 0; i < nlhdr.nfiles; i++) {
90: fread(&temp, sizeof(FILETAB), 1, fp);
91: if (temp.addr != prevaddr) {
92: ftp++;
93: }
94: *ftp = temp;
95: ftp->filename += (int) stringtab;
96: prevaddr = ftp->addr;
97: }
98: nlhdr.nfiles = (ftp - &filetab[0]) + 1;
99: skimsource(filetab[0].filename);
100: dotpfile = filetab[0].filename;
101: }
102:
103: /*
104: * Allocate and read in line number information table.
105: */
106:
107: LOCAL readlines(fp)
108: FILE *fp;
109: {
110: register LINENO oline;
111: register ADDRESS oaddr;
112: register LINETAB *lp;
113: FILETAB *ftp;
114: OBJLINE info;
115:
116: if (nlhdr.nlines == 0) {
117: return;
118: }
119: linetab = alloc(nlhdr.nlines, LINETAB);
120: for (lp = &linetab[0]; lp < &linetab[nlhdr.nlines]; lp++) {
121: lp->line = 0;
122: }
123: for (ftp = &filetab[0]; ftp < &filetab[nlhdr.nfiles]; ftp++) {
124: if (ftp->lineindex < nlhdr.nlines) {
125: linetab[ftp->lineindex].line = ftp->line;
126: }
127: }
128: oline = 0;
129: oaddr = 0;
130: for (lp = &linetab[0]; lp < &linetab[nlhdr.nlines]; lp++) {
131: if (lp->line != 0) {
132: oline = lp->line;
133: }
134: info.together = getw(fp);
135: oline += info.separate.lineincr;
136: oaddr += info.separate.addrincr;
137: lp->line = oline;
138: lp->addr = oaddr;
139: }
140: }
141:
142: /*
143: * Read in the symbols.
144: */
145:
146: readsyms(fp)
147: FILE *fp;
148: {
149: register int i;
150: int symno;
151:
152: symtab = st_creat(nlhdr.nsyms);
153: for (i = 0; i < nlhdr.nsyms; i++) {
154: symno = getw(fp);
155: if (symno >= MAXSYMNO) {
156: panic("symbol number too large (%d)", symno);
157: }
158: sym[symno] = readsym(fp);
159: }
160: if (backpatch() != 0) {
161: panic("patchlist not empty after reading namelist");
162: }
163: if (program == NIL) {
164: panic("no program");
165: }
166: maketypes();
167: }
168:
169: typedef struct patchinfo {
170: SYM **patchsym;
171: struct patchinfo *next_patch;
172: } PATCH;
173:
174: LOCAL PATCH *phead;
175:
176: /*
177: * Go through patchlist looking for symbol numbers for which the
178: * sym array now has a non-NIL entry.
179: *
180: * Afterwards, zap the sym array.
181: */
182:
183: int backpatch()
184: {
185: register PATCH *p, *last, *next;
186: register SYM *s, **t;
187: int count;
188:
189: last = NIL;
190: count = 0;
191: for (p = phead; p != NIL; p = next) {
192: next = p->next_patch;
193: t = p->patchsym;
194: if ((s = sym[(int) *t]) != NIL) {
195: *t = s;
196: if (last == NIL) {
197: phead = next;
198: } else {
199: last->next_patch = next;
200: }
201: dispose(p);
202: } else {
203: last = p;
204: count++;
205: }
206: }
207: for (t = &sym[0]; t < &sym[MAXSYMNO]; t++) {
208: *t = NIL;
209: }
210: return(count);
211: }
212:
213: /*
214: * Check to see if the given pointer (really symbol number) should
215: * be added to the patch list. The argument is double indirect
216: * to do call by reference passing.
217: */
218:
219: chkpatch(p)
220: SYM **p;
221: {
222: register SYM *s, *t;
223: register PATCH *patch;
224:
225: if ((s = *p) != NIL) {
226: if ((t = sym[(int) s]) != NIL) {
227: *p = t;
228: } else {
229: patch = alloc(1, PATCH);
230: patch->patchsym = p;
231: patch->next_patch = phead;
232: phead = patch;
233: }
234: }
235: }
236:
237: /*
238: * Free all the object information.
239: */
240:
241: objfree()
242: {
243: register int i;
244:
245: st_destroy(symtab);
246: dispose(stringtab);
247: dispose(filetab);
248: dispose(linetab);
249: clrfunctab();
250: for (i = 0; i < MAXSYMNO; i++) {
251: sym[i] = NIL;
252: }
253: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.