![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to read.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / cmd / cyntax / cem|
Return to read.c CVS log | Up to [Research Unix] / researchv8dc / cmd / cyntax / cem |
1.1 root 1: #include <errno.h>
2: #include "cem.h"
3: #define STD_OBJ 1
4: #include "stdobj.h"
5:
6: /*
7: * Read and load an object file.
8: */
9: static void
10: read_obj(s, fd)
11: register char *s;
12: register int fd;
13: {
14: register int i;
15: register long sz;
16: header obj_header;
17: static char cmd[] = CMD;
18: static char mac[] = MAC;
19: extern void enter_types();
20: extern void enter_vars();
21: extern void install_strings();
22:
23: switch (read(fd, (char *)&obj_header, sizeof (header)))
24: {
25: case SYSERROR:
26: fprintf(stderr, "%s: could not read ", my_name);
27: fflush(stderr);
28: perror(s);
29: exit(1);
30:
31: case sizeof (header):
32: break;
33:
34: default:
35: fprintf(stderr, "%s: %s is not an object module\n", my_name, s);
36: exit(1);
37: }
38:
39: if (strncmp(obj_header.hd_cmd, cmd, CMD_SZ) != 0)
40: {
41: fprintf(stderr, "%s: %s is not an object module\n", my_name, s);
42: exit(1);
43: }
44:
45: if (strncmp(obj_header.hd_mac, mac, MAC_SZ) != 0)
46: {
47: fprintf(stderr, "%s: version mismatch for %s (recompile)\n", my_name, s);
48: exit(1);
49: }
50:
51: if (obj_header.hd_type_size == 0)
52: {
53: fprintf(stderr, "%s: %s has compilation errors\n", my_name, s);
54: exit(1);
55: }
56:
57: sz = obj_header.hd_str_off + obj_header.hd_str_size - sizeof (header);
58: data_base = salloc(sz);
59: str_base = data_base + obj_header.hd_str_off - sizeof (header) - 1;
60:
61: if ((i = read(fd, data_base, (int)sz)) != sz)
62: {
63: if (i == SYSERROR)
64: {
65: fprintf(stderr, "%s: could not read ", my_name);
66: fflush(stderr);
67: perror(s);
68: }
69: else
70: fprintf(stderr, "%s: %s is too small\n", my_name, s);
71:
72: exit(1);
73: }
74:
75: #if DEBUG
76: if (debug)
77: {
78: register char *id;
79: register long l0;
80: register long l1;
81: register long l2;
82:
83: data_ptr = data_base;
84: data_end = data_base + obj_header.hd_str_off - sizeof (header);
85: type_index = 1;
86: var_index = 1;
87: str_num = 0;
88:
89: while (data_ptr < data_end)
90: {
91: i = getd();
92:
93: switch (obj_item(i))
94: {
95: case i_data:
96: l0 = getv();
97: l1 = getv();
98: printf("data: var %ld (%s:%ld)\n", l0, &str_base[l1], getv());
99:
100: loop
101: {
102: i = getd();
103:
104: switch (obj_item(i))
105: {
106: case d_addr:
107: printf("\taddr var %ld for %ld\n", get4(), obj_id(i));
108: continue;
109:
110: case d_bytes:
111: if (obj_id(i) == 0)
112: l0 = getv();
113: else
114: l0 = obj_id(i);
115:
116: printf("\tbytes %ld\n", l0);
117: data_ptr += l0;
118: continue;
119:
120: case d_end:
121: printf("\tend\n");
122: break;
123:
124: case d_istring:
125: if (obj_id(i) == 0)
126: l0 = getv();
127: else
128: l0 = obj_id(i);
129:
130: data_ptr += l0;
131: printf("\tstring %ld, length %ld\n", str_num++, l0);
132: continue;
133:
134: case d_irstring:
135: if (obj_id(i) == 0)
136: l0 = getv();
137: else
138: l0 = obj_id(i);
139:
140: data_ptr += l0;
141: printf("\tstring %ld + %ld, length %ld\n", str_num++, get4(), l0);
142: continue;
143:
144: case d_space:
145: printf("\tspace %ld\n", obj_id(i) == 0 ? getv() : obj_id(i));
146: continue;
147:
148: case d_string:
149: printf("\tstring %ld\n", getv());
150: continue;
151:
152: case d_reloc:
153: l0 = getv();
154: printf("\treloc var %ld + %ld for %ld\n", l0, get4(), obj_id(i));
155: continue;
156:
157: case d_rstring:
158: l0 = getv();
159: printf("\tstring %ld + %ld\n", l0, get4());
160: continue;
161:
162: default:
163: fprintf(stderr, "%s: unknown data id %d\n", my_name, i);
164: exit(1);
165: }
166:
167: break;
168: }
169:
170: break;
171:
172: case i_lib:
173: printf("lib: %s\n", &str_base[getv()]);
174: break;
175:
176: case i_src:
177: printf("src: %s\n", &str_base[getv()]);
178: break;
179:
180: case i_string:
181: if (obj_id(i) == 0)
182: l0 = getv();
183: else
184: l0 = obj_id(i);
185:
186: printf("string %ld, length %ld\n", str_num++, l0);
187: data_ptr += l0;
188: break;
189:
190: case i_type:
191: printf("type ");
192:
193: switch (obj_id(i))
194: {
195: case t_arrayof:
196: l0 = getv();
197: l1 = getv();
198: printf("%ld: array %ld of %ld\n", type_index++, l0, l1);
199: break;
200:
201: case t_basetype:
202: printf("%ld: ", type_index++);
203: print_basetype(getd() & 0xFF);
204: printf("\n");
205: break;
206:
207: case t_bitfield:
208: l0 = getv();
209: l1 = getv();
210: printf("%ld: bitfield %ld of %ld\n", type_index++, l0, l1);
211: break;
212:
213: case t_dimless:
214: printf("%ld: array [] of %ld\n", type_index++, getv());
215: break;
216:
217: case t_elaboration:
218: l0 = getv();
219: l1 = getv();
220: printf("elab %ld: (%s:%ld) ", l0, &str_base[l1], getv());
221:
222: switch (i = obj_id(getd()))
223: {
224: case t_enum:
225: printf("enum\n");
226: l0 = getv();
227: goto elab_enum;
228:
229: case t_structof:
230: printf("struct\n");
231: l0 = getv();
232:
233: do
234: {
235: l1 = getv();
236: printf("\t%s = %ld @ %ld\n", &str_base[l0], l1, getv());
237: l0 = getv();
238: }
239: while (l0 != 0);
240:
241: printf("\t(%ld)\n", getv());
242: break;
243:
244: case t_unionof:
245: printf("union\n");
246: l0 = getv();
247:
248: do
249: {
250: l1 = getv();
251: printf("\t%s = %ld\n", &str_base[l0], l1);
252: l0 = getv();
253: }
254: while (l0 != 0);
255:
256: printf("\t(%ld)\n", getv());
257: break;
258:
259: default:
260: fprintf(stderr, "%s: unknown elaboration id %d\n", my_name, i);
261: exit(1);
262: }
263:
264: break;
265:
266: case t_enum:
267: printf("%ld: ", type_index++);
268:
269: if ((l0 = getv()) == 0)
270: id = "<anon>";
271: else
272: id = &str_base[l0];
273:
274: l0 = getv();
275: l1 = getv();
276:
277: printf("enum %s (%s:%ld)\n", id, &str_base[l0], l1);
278:
279: if ((l0 = getv()) == 0)
280: {
281: printf("\tforward\n");
282: break;
283: }
284:
285: elab_enum:
286: do
287: {
288: l1 = getu();
289: printf("\t%s = %ld\n", &str_base[l0], l1);
290: l0 = getv();
291: }
292: while (l0 != 0);
293:
294: l0 = getu();
295: l1 = getu();
296:
297: printf("\t(%ld, %ld)\n", l0, l1);
298: break;
299:
300: case t_ftnreturning:
301: printf("%ld: function returning %ld\n", type_index++, getv());
302: break;
303:
304: case t_ptrto:
305: printf("%ld: pointer to %ld\n", type_index++, getv());
306: break;
307:
308: case t_structof:
309: printf("%ld: ", type_index++);
310:
311: if ((l0 = getv()) == 0)
312: id = "<anon>";
313: else
314: id = &str_base[l0];
315:
316: l0 = getv();
317: l1 = getv();
318:
319: printf("struct %s (%s:%ld)\n", id, &str_base[l0], l1);
320: break;
321:
322: case t_unionof:
323: printf("%ld: ", type_index++);
324:
325: if ((l0 = getv()) == 0)
326: id = "<anon>";
327: else
328: id = &str_base[l0];
329:
330: l0 = getv();
331: l1 = getv();
332:
333: printf("union %s (%s:%ld)\n", id, &str_base[l0], l1);
334: break;
335:
336: default:
337: fprintf(stderr, "%s: unknown type id %d\n", my_name, obj_id(i));
338: exit(1);
339: }
340:
341: break;
342:
343: case i_var:
344: printf("var ");
345:
346: switch (obj_id(i))
347: {
348: case v_arglist:
349: l0 = getv();
350: l1 = getv();
351: printf("arglist: %ld (%s:%ld)\n", l0, &str_base[l1], getv());
352:
353: while ((l0 = getv()) != 0)
354: {
355: l1 = getv();
356: l2 = getv();
357: printf("\t%ld: %s type %ld (%s:%ld)\n", var_index++, &str_base[l0], l1, &str_base[l2], getv());
358: }
359:
360: break;
361:
362: case v_array_size:
363: l0 = getv();
364: printf("array %ld new type %ld\n", l0, getv());
365: break;
366:
367: case v_auto:
368: id = "auto";
369: goto get_var;
370:
371: case v_block_static:
372: id = "block static";
373: goto get_var;
374:
375: case v_call:
376: l0 = getv();
377: l1 = getv();
378: printf("call: var %ld (%s:%ld)\n", l0, &str_base[l1], getv());
379:
380: while ((l0 = getv()) != 0)
381: printf("\ttype %ld\n", l0);
382:
383: break;
384:
385: case v_global:
386: id = "global";
387: goto get_var;
388:
389: case v_implicit_function:
390: id = "implicit()";
391: goto get_var;
392:
393: case v_static:
394: id = "static";
395: goto get_var;
396:
397: get_var:
398: l0 = getv();
399: l1 = getv();
400: l2 = getv();
401: printf("%ld: %s %s type %ld (%s:%ld)\n", var_index++, id, &str_base[l0], l1, &str_base[l2], getv());
402: break;
403:
404: case v_varargs:
405: l0 = getv();
406: printf("%ld: varargs %ld\n", l0, getv());
407: break;
408:
409: default:
410: fprintf(stderr, "%s: unknown var id %d\n", my_name, obj_id(i));
411: exit(1);
412: }
413:
414: break;
415:
416: default:
417: fprintf(stderr, "%s: unknown obj_item %d\n", my_name, obj_item(i));
418: exit(1);
419: }
420: }
421:
422: fflush(stdout);
423: }
424: #endif DEBUG
425:
426: file_errors = 0;
427: install_strings(str_base + 1, obj_header.hd_str_size);
428:
429: type_index = 1;
430: data_ptr = data_base;
431: data_end = data_base + obj_header.hd_str_off - sizeof (header);
432: enter_types(obj_header.hd_type_size);
433:
434: str_num = 0;
435: var_index = 1;
436: data_ptr = data_base;
437: data_end = data_base + obj_header.hd_str_off - sizeof (header);
438: enter_vars(obj_header.hd_var_size);
439:
440: free((char *)str_trans);
441: free((char *)type_trans);
442: free((char *)var_trans);
443: free(data_base);
444: src_file = NULL;
445:
446: if (file_errors)
447: fflush(stdout);
448: }
449:
450: /*
451: * Open a library and load it.
452: */
453: void
454: load_lib(l)
455: char *l;
456: {
457: register int fd;
458: register char *s;
459: extern int errno;
460: extern char *strcat();
461: extern char *strcpy();
462:
463: s = salloc(strlen(LIB_PATH) + strlen(l) + 1L);
464: (void)strcat(strcpy(s, LIB_PATH), l);
465:
466: if ((fd = open(s, 0)) == SYSERROR)
467: {
468: if (errno == ENOENT)
469: fprintf(stderr, "%s: no library '-l%s'\n", my_name, l);
470: else
471: {
472: fprintf(stderr, "%s: could not open ", my_name);
473: fflush(stderr);
474: perror(s);
475: }
476:
477: exit(1);
478: }
479:
480: read_obj(s, fd);
481: free(s);
482: (void)close(fd);
483: }
484:
485: /*
486: * Open an object file and load it.
487: */
488: void
489: load_obj(s)
490: register char *s;
491: {
492: register int fd;
493:
494: if ((fd = open(s, 0)) == SYSERROR)
495: {
496: fprintf(stderr, "%s: could not open ", my_name);
497: fflush(stderr);
498: perror(s);
499: exit(1);
500: }
501:
502: read_obj(s, fd);
503: (void)close(fd);
504: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.