![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to strip.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|
Return to strip.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: /*
2: * Object file services.
3: * This section is similar to that in nm and size.
4: */
5:
6: #include <stdio.h>
7: #include <canon.h>
8:
9: #if COHERENT
10: #include <n.out.h>
11: #include <signal.h>
12: #endif
13: #if MSDOS
14: #include <nout.h>
15: #define DOEXE 1
16: #endif
17: #if GEMDOS
18: #include <nout.h>
19: #define DOPRG 1
20: #endif
21:
22: char *argv0; /* Command name */
23: char *fn; /* File name */
24: FILE *ifp; /* Input File Pointer */
25: FILE *ofp; /* Output File Pointer */
26: struct ldheader ldh; /* The l.out.h header */
27: long loadsize; /* Amount of input to copy to output */
28:
29: /*
30: * Read in the l.out header.
31: */
32: gethdr()
33: {
34: register int i;
35: fread((char *)&ldh, 1, sizeof(ldh), ifp);
36: canshort(ldh.l_magic);
37: canshort(ldh.l_flag);
38: canshort(ldh.l_machine);
39: if (ldh.l_magic != L_MAGIC)
40: return 1;
41: if ((ldh.l_flag&LF_32) == 0) {
42: canshort(ldh.l_tbase);
43: ldh.l_entry = ldh.l_tbase;
44: ldh.l_tbase = sizeof(ldh) - 2*sizeof(short);
45: } else {
46: canshort(ldh.l_tbase);
47: canlong(ldh.l_entry);
48: }
49: loadsize = 0;
50: for (i=0; i<NLSEG; i++) {
51: canlong(ldh.l_ssize[i]);
52: if (i < L_DEBUG && i != L_BSSI && i != L_BSSD)
53: loadsize += ldh.l_ssize[i];
54: }
55: return (0);
56: }
57:
58: /*
59: * Read the exe header.
60: */
61: #ifndef DOEXE
62: getexe() { return 1; }
63: #else
64: #include "exe.h"
65:
66:
67: execani(ip) /* convert from MSDOS exe header byte order to host */
68: register short *ip;
69: {
70: /* First convert to standard pdp-11 byte order */
71: /* Notice, nothing to do to accomplish this */
72:
73: /* Now convert from pdp-11 byte order to host */
74:
75: canshort(*ip);
76: }
77:
78: getexe()
79: {
80: long daddr;
81: exehdr_t exehdr;
82:
83: fseek(ifp, 0L, 0);
84: fread((char *)&exehdr, 1, sizeof(exehdr), ifp);
85: execani(&exehdr.x_magic);
86: if (exehdr.x_magic != EXEMAGIC)
87: return (1);
88: execani(&exehdr.x_sectors);
89: execani(&exehdr.x_bytes);
90: daddr = (long) exehdr.x_sectors * 512;
91: if ( exehdr.x_bytes != 0 )
92: daddr += exehdr.x_bytes - 512;
93: fseek(ifp, daddr, 0);
94: if (gethdr() != 0)
95: return 1;
96: loadsize = daddr;
97: return 0;
98: }
99: #endif
100:
101: /*
102: * Read a gemdos .prg header.
103: */
104: #ifndef DOPRG
105: getprg() { return 1; }
106: #else
107: #include "gemout.h"
108: /* convert 68000 byte order to pdp11 byte order and vice versa */
109: #if PDP11
110: gemcani(ip) register unsigned char *ip;
111: {
112: register t;
113: t = ip[0]; ip[0] = ip[1]; ip[1] = t;
114: }
115: gemcanl(lp) register unsigned char *lp;
116: {
117: register t;
118: t = lp[0]; lp[0] = lp[1]; lp[1] = t;
119: t = lp[2]; lp[2] = lp[3]; lp[3] = t;
120: }
121: #endif
122: #if M68000
123: #define gemcani(i) /* Nil */
124: #define gemcanl(l) /* Nil */
125: #endif
126:
127: getprg()
128: {
129: struct gemohdr ghd;
130: register long daddr;
131: register int c;
132: fseek(ifp, 0L, 0);
133: fread((char *)&ghd, 1, sizeof(ghd), ifp);
134: gemcani(&ghd.g_magic);
135: if (ghd.g_magic != GEMOMAGIC)
136: return 1;
137: gemcanl(&ghd.g_ssize[0]);
138: gemcanl(&ghd.g_ssize[1]);
139: gemcanl(&ghd.g_ssize[2]);
140: gemcanl(&ghd.g_ssize[3]);
141: daddr = sizeof(ghd) + ghd.g_ssize[0] + ghd.g_ssize[1] + ghd.g_ssize[3];
142: fseek(ifp, daddr, 0);
143: if (getw(ifp) | getw(ifp)) {
144: while (c = getc(ifp))
145: if (c == EOF)
146: return 1;
147: }
148: daddr = ftell(ifp);
149: if (gethdr() != 0)
150: return 1;
151: loadsize = daddr;
152: return 0;
153: }
154: #endif
155:
156: /*
157: * Strip specific code.
158: * Strip the debug table, the symbol
159: * table and the relocation information from a
160: * object file.
161: * Optionally keep any combination of the three.
162: */
163:
164: char *tmp;
165: char werror[] = "write error";
166: char rerror[] = "cannot reopen";
167: char xerror[] = "unexpected end of file";
168: char oerror[] = "not an object file";
169: char usemsg[] = "Usage: %s [-drs] file [ ... ]\n";
170:
171: int dkeep;
172: int rkeep;
173: int skeep;
174:
175: int notcoh = 1; /* flag indicative of what object type the file is */
176: int notexe = 1;
177: int notprg = 1;
178:
179: struct ldheader olh; /* output file l.out.h header */
180:
181: int cleanup();
182:
183: main(argc, argv)
184: char *argv[];
185: {
186: register estat, i;
187: register char *cp;
188: register c;
189: extern char *tempnam();
190:
191: argv0 = argv[0];
192: if (argc < 2)
193: usage();
194: tmp = tempnam(NULL, "s");
195: #if COHERENT
196: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
197: signal(SIGINT, cleanup);
198: #endif
199: estat = 0;
200: for (i=1; i<argc; i++) {
201: cp = argv[i];
202: if (cp[0] == '-') {
203: while ((c = *++cp) != 0)
204: if (c == 'd') ++dkeep;
205: else if (c == 'r') ++rkeep;
206: else if (c == 's') ++skeep;
207: else usage();
208: continue;
209: }
210: fn = argv[i];
211: estat |= strip();
212: if (ifp != NULL) {
213: fclose(ifp);
214: ifp = NULL;
215: }
216: if (ofp != NULL) {
217: fclose(ofp);
218: ofp = NULL;
219: }
220: }
221: cleanup(estat);
222: }
223:
224: /*
225: * Do all the work.
226: * The external variables 'ifp' and 'ofp'
227: * will be closed by the mainline. This makes the
228: * many error conditions a little easier to
229: * deal with.
230: */
231: strip()
232: {
233: int i;
234: register long nsize;
235:
236: if ((ifp = fopen(fn, "rb")) == NULL) {
237: diag("cannot open", fn);
238: return(1);
239: }
240: if ((ofp = fopen(tmp, "wb")) == NULL) {
241: diag("cannot create", tmp);
242: return(1);
243: }
244: if ( (notcoh=gethdr()) != 0
245: && (notexe=getexe()) != 0
246: && (notprg=getprg()) != 0) {
247: diag("not an object file", fn);
248: return(1);
249: }
250: olh = ldh;
251: if ( ! dkeep) {
252: olh.l_ssize[L_DEBUG] = 0;
253: olh.l_flag &= ~LF_DEBUG;
254: }
255: if ( ! rkeep) {
256: olh.l_flag |= LF_NRB;
257: olh.l_ssize[L_REL] = 0;
258: }
259: if ( ! skeep)
260: olh.l_ssize[L_SYM] = 0;
261: if (ldh.l_flag == olh.l_flag
262: && ldh.l_ssize[L_DEBUG] == olh.l_ssize[L_DEBUG]
263: && ldh.l_ssize[L_SYM] == olh.l_ssize[L_SYM]
264: && ldh.l_ssize[L_REL] == olh.l_ssize[L_REL])
265: return(0);
266:
267: if (writehead() != 0 /* header of output file */
268: || copy(loadsize) != 0 /* all loadable segments */
269: || writelout() != 0) /* l.out.h header in exe and prg */
270: return(1);
271:
272: for (i = L_DEBUG; i < NLSEG; i += 1) {
273: nsize = ldh.l_ssize[i];
274: if (olh.l_ssize[i] == nsize)
275: copy(nsize);
276: else
277: fseek(ifp, nsize, 1);
278: }
279: fflush(ofp);
280: if (ferror(ofp)) {
281: diag(werror, tmp);
282: return (1);
283: }
284: if (ferror(ifp)) {
285: diag("read error", fn);
286: return 1;
287: } else if (feof(ifp)) {
288: diag(xerror, fn);
289: return 1;
290: }
291: fclose(ifp);
292: ifp = NULL;
293: loadsize = ftell(ofp);
294: fclose(ofp);
295: ofp = NULL;
296: if ((ifp = fopen(tmp, "rb")) == NULL) {
297: diag(rerror, tmp);
298: return (1);
299: }
300: if ((ofp = fopen(fn, "wb")) == NULL) {
301: diag(rerror, fn);
302: return (1);
303: }
304: copy(loadsize);
305: fflush(ofp);
306: if (ferror(ofp)) {
307: diag(werror, fn);
308: fprintf(stderr, "%s: file saved in %s\n", argv0, tmp);
309: exit(1);
310: }
311: return (0);
312: }
313:
314: /*
315: * Convert the l.out header structure
316: * in the buffer 'lh' to and from standard
317: * ordering.
318: */
319: canlh(ldhp)
320: register struct ldheader *ldhp;
321: {
322: register i;
323:
324: canshort(ldhp->l_magic);
325: canshort(ldhp->l_flag);
326: canshort(ldhp->l_machine);
327: canshort(ldhp->l_tbase);
328: for (i=0; i<NLSEG; ++i)
329: canlong(ldhp->l_ssize[i]);
330: canlong(ldhp->l_entry);
331: }
332:
333: /*
334: * Writes the header at the beginning of the output file
335: * References flags: notcoh, notexe, and notprg.
336: */
337: writehead()
338: {
339: if ( !notcoh ) {
340: register int size;
341: if ((size = olh.l_tbase) < sizeof olh)
342: olh.l_tbase = olh.l_entry;
343: canlh(&olh);
344: if (fwrite(&olh, size, 1, ofp) != 1) {
345: diag(werror, tmp);
346: return (1);
347: }
348: canlh(&olh);
349: if (size < sizeof olh) {
350: olh.l_entry = olh.l_tbase;
351: olh.l_tbase = size;
352: fseek(ifp, (long)-2*sizeof(short), 1);
353: }
354: } else
355: fseek(ifp, 0l, 0);
356: return(0);
357: }
358:
359: /*
360: * Copy nbytes from ifp to ofp.
361: */
362: copy(nbytes) long nbytes;
363: {
364: register int n;
365: static char buff[16*1024];
366:
367: while (nbytes > 0) {
368: n = nbytes > sizeof buff ? sizeof buff : nbytes;
369: if (fread(buff, 1, n, ifp) != n)
370: return 1;
371: if (fwrite(buff, 1, n, ofp) != n)
372: return 1;
373: nbytes -= n;
374: }
375: return 0;
376: }
377:
378: /*
379: * Write the l.out.h header in the middle of the file for
380: * MS-DOS .exe and GEMDOS .prg
381: * Leave ifp at the beginning of L_DEBUG.
382: */
383: writelout()
384: {
385: if ( !notcoh )
386: return(0);
387:
388: canlh(&olh);
389: if (fwrite(&olh, sizeof(olh), 1, ofp) != 1) {
390: diag(werror, tmp);
391: return(1);
392: }
393: canlh(&olh);
394: fseek(ifp, (long)sizeof(ldh), 1);
395: return(0);
396: }
397:
398:
399: /*
400: * Print diagnostics.
401: */
402: diag(s, fn)
403: char *s;
404: char *fn;
405: {
406: fprintf(stderr, "%s: ", argv0);
407: if (fn != NULL)
408: fprintf(stderr, "%s: ", fn);
409: fprintf(stderr, "%s\n", s);
410: }
411:
412: /*
413: * Cleanup tempfile and exit.
414: * The status is the exit status.
415: * When a signal occurs, it is the signal
416: * number which is non-zero so
417: * this will be an acceptable exit status.
418: */
419: cleanup(s)
420: {
421: unlink(tmp);
422: exit(s);
423: }
424:
425: /*
426: * Print usage message.
427: */
428: usage()
429: {
430: fprintf(stderr, usemsg, argv0);
431: exit(1);
432: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.