![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to object.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ucb / dbx|
Return to object.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ucb / dbx |
1.1 root 1: /* Copyright (c) 1982 Regents of the University of California */
2:
3: static char sccsid[] = "@(#)object.c 1.14 10/22/83";
4:
5: /*
6: * Object code interface, mainly for extraction of symbolic information.
7: */
8:
9: #include "defs.h"
10: #include "object.h"
11: #include "main.h"
12: #include "symbols.h"
13: #include "names.h"
14: #include "languages.h"
15: #include "mappings.h"
16: #include "lists.h"
17: #include <a.out.h>
18: #include <stab.h>
19: #include <ctype.h>
20:
21: #ifndef public
22:
23: struct {
24: unsigned int stringsize; /* size of the dumped string table */
25: unsigned int nsyms; /* number of symbols */
26: unsigned int nfiles; /* number of files */
27: unsigned int nlines; /* number of lines */
28: } nlhdr;
29:
30: #endif
31:
32: public String objname = "a.out";
33: public Integer objsize;
34: public char *stringtab;
35:
36: private String progname = nil;
37: private Language curlang;
38: private Symbol curmodule;
39: private Symbol curparam;
40: private Boolean warned;
41: private Symbol curcomm;
42: private Symbol commchain;
43: private Boolean strip_ = false;
44:
45: private Filetab *filep;
46: private Linetab *linep, *prevlinep;
47:
48: #define curfilename() (filep-1)->filename
49:
50: /*
51: * Blocks are figured out on the fly while reading the symbol table.
52: */
53:
54: #define MAXBLKDEPTH 25
55:
56: private Symbol curblock;
57: private Symbol blkstack[MAXBLKDEPTH];
58: private Integer curlevel;
59: private Integer bnum, nesting;
60: private Address addrstk[MAXBLKDEPTH];
61:
62: #define enterblock(b) { \
63: blkstack[curlevel] = curblock; \
64: ++curlevel; \
65: b->level = curlevel; \
66: b->block = curblock; \
67: curblock = b; \
68: }
69:
70: #define exitblock() { \
71: if (curblock->class == FUNC or curblock->class == PROC) { \
72: if (prevlinep != linep) { \
73: curblock->symvalue.funcv.src = true; \
74: } \
75: } \
76: --curlevel; \
77: curblock = blkstack[curlevel]; \
78: }
79:
80: /*
81: * Enter a source line or file name reference into the appropriate table.
82: * Expanded inline to reduce procedure calls.
83: *
84: * private enterline(linenumber, address)
85: * Lineno linenumber;
86: * Address address;
87: * ...
88: */
89:
90: #define enterline(linenumber, address) \
91: { \
92: register Linetab *lp; \
93: \
94: lp = linep - 1; \
95: if (linenumber != lp->line) { \
96: if (address != lp->addr) { \
97: ++lp; \
98: } \
99: lp->line = linenumber; \
100: lp->addr = address; \
101: linep = lp + 1; \
102: } \
103: }
104:
105: #define NTYPES 1000
106:
107: private Symbol typetable[NTYPES];
108:
109: /*
110: * Read in the namelist from the obj file.
111: *
112: * Reads and seeks are used instead of fread's and fseek's
113: * for efficiency sake; there's a lot of data being read here.
114: */
115:
116: public readobj(file)
117: String file;
118: {
119: Fileid f;
120: struct exec hdr;
121: struct nlist nlist;
122:
123: f = open(file, 0);
124: if (f < 0) {
125: fatal("can't open %s", file);
126: }
127: read(f, &hdr, sizeof(hdr));
128: objsize = hdr.a_text;
129: nlhdr.nsyms = hdr.a_syms / sizeof(nlist);
130: nlhdr.nfiles = nlhdr.nsyms;
131: nlhdr.nlines = nlhdr.nsyms;
132: if (nlhdr.nsyms > 0) {
133: lseek(f, (long) N_STROFF(hdr), 0);
134: read(f, &(nlhdr.stringsize), sizeof(nlhdr.stringsize));
135: nlhdr.stringsize -= 4;
136: stringtab = newarr(char, nlhdr.stringsize);
137: read(f, stringtab, nlhdr.stringsize);
138: allocmaps(nlhdr.nfiles, nlhdr.nlines);
139: lseek(f, (long) N_SYMOFF(hdr), 0);
140: readsyms(f);
141: ordfunctab();
142: setnlines();
143: setnfiles();
144: }
145: close(f);
146: }
147:
148: /*
149: * Read in symbols from object file.
150: */
151:
152: private readsyms(f)
153: Fileid f;
154: {
155: struct nlist *namelist;
156: register struct nlist *np, *ub;
157: register int index;
158: register String name;
159: register Boolean afterlg;
160:
161: initsyms();
162: namelist = newarr(struct nlist, nlhdr.nsyms);
163: read(f, namelist, nlhdr.nsyms * sizeof(struct nlist));
164: afterlg = false;
165: ub = &namelist[nlhdr.nsyms];
166: for (np = &namelist[0]; np < ub; np++) {
167: index = np->n_un.n_strx;
168: if (index != 0) {
169: name = &stringtab[index - 4];
170: /*
171: * if the program contains any .f files a trailing _ is stripped
172: * from the name on the assumption it was added by the compiler.
173: * This only affects names that follow the sdb N_SO entry with
174: * the .f name.
175: */
176: if (strip_ and name[0] != '\0' ) {
177: register char *p;
178:
179: p = name;
180: while (*p != '\0') {
181: ++p;
182: }
183: --p;
184: if (*p == '_') {
185: *p = '\0';
186: }
187: }
188:
189: } else {
190: name = nil;
191: }
192: /*
193: * assumptions:
194: * not an N_STAB ==> name != nil
195: * name[0] == '-' ==> name == "-lg"
196: * name[0] != '_' ==> filename or invisible
197: *
198: * The "-lg" signals the beginning of global loader symbols.
199: *
200: */
201: if ((np->n_type&N_STAB) != 0) {
202: enter_nl(name, np);
203: } else if (name[0] == '-') {
204: afterlg = true;
205: if (curblock->class != PROG) {
206: exitblock();
207: if (curblock->class != PROG) {
208: exitblock();
209: }
210: }
211: enterline(0, (linep-1)->addr + 1);
212: } else if (afterlg) {
213: if (name[0] == '_') {
214: check_global(&name[1], np);
215: }
216: } else if (name[0] == '_') {
217: check_local(&name[1], np);
218: } else if ((np->n_type&N_TEXT) == N_TEXT) {
219: check_filename(name);
220: }
221: }
222: if (not afterlg) {
223: fatal("not linked for debugging, use \"cc -g ...\"");
224: }
225: dispose(namelist);
226: }
227:
228: /*
229: * Initialize symbol information.
230: */
231:
232: private initsyms()
233: {
234: curblock = nil;
235: curlevel = 0;
236: nesting = 0;
237: if (progname == nil) {
238: progname = strdup(objname);
239: if (rindex(progname, '/') != nil) {
240: progname = rindex(progname, '/') + 1;
241: }
242: if (index(progname, '.') != nil) {
243: *(index(progname, '.')) = '\0';
244: }
245: }
246: program = insert(identname(progname, true));
247: program->class = PROG;
248: program->symvalue.funcv.beginaddr = 0;
249: program->symvalue.funcv.inline = false;
250: newfunc(program, codeloc(program));
251: findbeginning(program);
252: enterblock(program);
253: curmodule = program;
254: }
255:
256: /*
257: * Free all the object file information that's being stored.
258: */
259:
260: public objfree()
261: {
262: symbol_free();
263: keywords_free();
264: names_free();
265: dispose(stringtab);
266: clrfunctab();
267: }
268:
269: /*
270: * Enter a namelist entry.
271: */
272:
273: private enter_nl(name, np)
274: String name;
275: register struct nlist *np;
276: {
277: register Symbol s;
278: register Name n, nn;
279: char buf[100];
280:
281: s = nil;
282: if (name == nil) {
283: n = nil;
284: } else {
285: n = identname(name, true);
286: }
287: switch (np->n_type) {
288: /*
289: * Build a symbol for the FORTRAN common area. All GSYMS that follow
290: * will be chained in a list with the head kept in common.offset, and
291: * the tail in common.chain.
292: */
293: case N_BCOMM:
294: if (curcomm) {
295: curcomm->symvalue.common.chain = commchain;
296: }
297: curcomm = lookup(n);
298: if (curcomm == nil) {
299: curcomm = insert(n);
300: curcomm->class = COMMON;
301: curcomm->block = curblock;
302: curcomm->level = program->level;
303: curcomm->symvalue.common.chain = nil;
304: }
305: commchain = curcomm->symvalue.common.chain;
306: break;
307:
308: case N_ECOMM:
309: if (curcomm) {
310: curcomm->symvalue.common.chain = commchain;
311: curcomm = nil;
312: }
313: break;
314:
315: case N_LBRAC:
316: ++nesting;
317: addrstk[nesting] = (linep - 1)->addr;
318: break;
319:
320: case N_RBRAC:
321: if (addrstk[nesting] == NOADDR) {
322: exitblock();
323: newfunc(curblock, (linep - 1)->addr);
324: }
325: --nesting;
326: break;
327:
328: case N_SLINE:
329: enterline((Lineno) np->n_desc, (Address) np->n_value);
330: break;
331:
332: /*
333: * Source files.
334: */
335: case N_SO:
336: enterSourceModule(n, (Address) np->n_value);
337: break;
338:
339: /*
340: * Textually included files.
341: */
342: case N_SOL:
343: enterfile(name, (Address) np->n_value);
344: break;
345:
346: /*
347: * These symbols are assumed to have non-nil names.
348: */
349: case N_GSYM:
350: case N_FUN:
351: case N_STSYM:
352: case N_LCSYM:
353: case N_RSYM:
354: case N_PSYM:
355: case N_LSYM:
356: case N_SSYM:
357: case N_LENG:
358: if (index(name, ':') == nil) {
359: if (not warned) {
360: warned = true;
361: warning("old style symbol information found in \"%s\"",
362: curfilename());
363: }
364: } else {
365: entersym(name, np);
366: }
367: break;
368:
369: case N_PC:
370: break;
371:
372: default:
373: printf("warning: stab entry unrecognized: ");
374: if (name != nil) {
375: printf("name %s,", name);
376: }
377: printf("ntype %2x, desc %x, value %x'\n",
378: np->n_type, np->n_desc, np->n_value);
379: break;
380: }
381: }
382:
383: /*
384: * Check to see if a global _name is already in the symbol table,
385: * if not then insert it.
386: */
387:
388: private check_global(name, np)
389: String name;
390: register struct nlist *np;
391: {
392: register Name n;
393: register Symbol t, u;
394:
395: if (not streq(name, "end")) {
396: n = identname(name, true);
397: if ((np->n_type&N_TYPE) == N_TEXT) {
398: find(t, n) where
399: t->level == program->level and
400: (t->class == PROC or t->class == FUNC)
401: endfind(t);
402: if (t == nil) {
403: t = insert(n);
404: t->language = findlanguage(".s");
405: t->class = FUNC;
406: t->type = t_int;
407: t->block = curblock;
408: t->level = program->level;
409: t->symvalue.funcv.src = false;
410: t->symvalue.funcv.inline = false;
411: }
412: t->symvalue.funcv.beginaddr = np->n_value;
413: newfunc(t, codeloc(t));
414: findbeginning(t);
415: } else if ((np->n_type&N_TYPE) == N_BSS) {
416: find(t, n) where
417: t->class == COMMON
418: endfind(t);
419: if (t != nil) {
420: u = (Symbol) t->symvalue.common.offset;
421: while (u != nil) {
422: u->symvalue.offset = u->symvalue.common.offset+np->n_value;
423: u = u->symvalue.common.chain;
424: }
425: } else {
426: check_var(np, n);
427: }
428: } else {
429: check_var(np, n);
430: }
431: }
432: }
433:
434: /*
435: * Check to see if a namelist entry refers to a variable.
436: * If not, create a variable for the entry. In any case,
437: * set the offset of the variable according to the value field
438: * in the entry.
439: */
440:
441: private check_var(np, n)
442: struct nlist *np;
443: register Name n;
444: {
445: register Symbol t;
446:
447: find(t, n) where
448: t->class == VAR and t->level == program->level
449: endfind(t);
450: if (t == nil) {
451: t = insert(n);
452: t->language = findlanguage(".s");
453: t->class = VAR;
454: t->type = t_int;
455: t->level = program->level;
456: }
457: t->block = curblock;
458: t->symvalue.offset = np->n_value;
459: }
460:
461: /*
462: * Check to see if a local _name is known in the current scope.
463: * If not then enter it.
464: */
465:
466: private check_local(name, np)
467: String name;
468: register struct nlist *np;
469: {
470: register Name n;
471: register Symbol t, cur;
472:
473: n = identname(name, true);
474: cur = ((np->n_type&N_TYPE) == N_TEXT) ? curmodule : curblock;
475: find(t, n) where t->block == cur endfind(t);
476: if (t == nil) {
477: t = insert(n);
478: t->language = findlanguage(".s");
479: t->type = t_int;
480: t->block = cur;
481: t->level = cur->level;
482: if ((np->n_type&N_TYPE) == N_TEXT) {
483: t->class = FUNC;
484: t->symvalue.funcv.src = false;
485: t->symvalue.funcv.inline = false;
486: t->symvalue.funcv.beginaddr = np->n_value;
487: newfunc(t, codeloc(t));
488: findbeginning(t);
489: } else {
490: t->class = VAR;
491: t->symvalue.offset = np->n_value;
492: }
493: }
494: }
495:
496: /*
497: * Check to see if a symbol corresponds to a object file name.
498: * For some reason these are listed as in the text segment.
499: */
500:
501: private check_filename(name)
502: String name;
503: {
504: register String mname;
505: register Integer i;
506: register Symbol s;
507:
508: mname = strdup(name);
509: i = strlen(mname) - 2;
510: if (i >= 0 and mname[i] == '.' and mname[i+1] == 'o') {
511: mname[i] = '\0';
512: --i;
513: while (mname[i] != '/' and i >= 0) {
514: --i;
515: }
516: s = insert(identname(&mname[i+1], true));
517: s->language = findlanguage(".s");
518: s->class = MODULE;
519: s->symvalue.funcv.beginaddr = 0;
520: findbeginning(s);
521: if (curblock->class != PROG) {
522: exitblock();
523: if (curblock->class != PROG) {
524: exitblock();
525: }
526: }
527: enterblock(s);
528: curmodule = s;
529: }
530: }
531:
532: /*
533: * Check to see if a symbol is about to be defined within an unnamed block.
534: * If this happens, we create a procedure for the unnamed block, make it
535: * "inline" so that tracebacks don't associate an activation record with it,
536: * and enter it into the function table so that it will be detected
537: * by "whatblock".
538: */
539:
540: private unnamed_block()
541: {
542: register Symbol s;
543: static int bnum = 0;
544: char buf[100];
545:
546: ++bnum;
547: sprintf(buf, "$b%d", bnum);
548: s = insert(identname(buf, false));
549: s->class = PROG;
550: s->symvalue.funcv.src = false;
551: s->symvalue.funcv.inline = true;
552: s->symvalue.funcv.beginaddr = addrstk[nesting];
553: enterblock(s);
554: newfunc(s, addrstk[nesting]);
555: addrstk[nesting] = NOADDR;
556: }
557:
558: /*
559: * Compilation unit. C associates scope with filenames
560: * so we treat them as "modules". The filename without
561: * the suffix is used for the module name.
562: *
563: * Because there is no explicit "end-of-block" mark in
564: * the object file, we must exit blocks for the current
565: * procedure and module.
566: */
567:
568: private enterSourceModule(n, addr)
569: Name n;
570: Address addr;
571: {
572: register Symbol s;
573: Name nn;
574: String mname, suffix;
575:
576: mname = strdup(ident(n));
577: if (rindex(mname, '/') != nil) {
578: mname = rindex(mname, '/') + 1;
579: }
580: suffix = rindex(mname, '.');
581: curlang = findlanguage(suffix);
582: if (curlang == findlanguage(".f")) {
583: strip_ = true;
584: }
585: if (suffix != nil) {
586: *suffix = '\0';
587: }
588: if (curblock->class != PROG) {
589: exitblock();
590: if (curblock->class != PROG) {
591: exitblock();
592: }
593: }
594: nn = identname(mname, true);
595: if (curmodule == nil or curmodule->name != nn) {
596: s = insert(nn);
597: s->class = MODULE;
598: s->symvalue.funcv.beginaddr = 0;
599: findbeginning(s);
600: } else {
601: s = curmodule;
602: }
603: s->language = curlang;
604: enterblock(s);
605: curmodule = s;
606: if (program->language == nil) {
607: program->language = curlang;
608: }
609: warned = false;
610: enterfile(ident(n), addr);
611: bzero(typetable, sizeof(typetable));
612: }
613:
614: /*
615: * Put an nlist into the symbol table.
616: * If it's already there just add the associated information.
617: *
618: * Type information is encoded in the name following a ":".
619: */
620:
621: private Symbol constype();
622: private Char *curchar;
623:
624: #define skipchar(ptr, ch) { \
625: if (*ptr != ch) { \
626: panic("expected char '%c', found char '%c'", ch, *ptr); \
627: } \
628: ++ptr; \
629: }
630:
631: private entersym(str, np)
632: String str;
633: struct nlist *np;
634: {
635: register Symbol s;
636: register char *p;
637: register int c;
638: register Name n;
639: register Integer i;
640: Boolean knowtype, isnew;
641: Symclass class;
642: Integer level;
643:
644: p = index(str, ':');
645: *p = '\0';
646: c = *(p+1);
647: n = identname(str, true);
648: if (index("FfGV", c) != nil) {
649: if (c == 'F' or c == 'f') {
650: class = FUNC;
651: } else {
652: class = VAR;
653: }
654: level = (c == 'f' ? curmodule->level : program->level);
655: find(s, n) where s->level == level and s->class == class endfind(s);
656: if (s == nil) {
657: isnew = true;
658: s = insert(n);
659: } else {
660: isnew = false;
661: }
662: } else {
663: isnew = true;
664: s = insert(n);
665: }
666:
667: if (nesting > 0 and addrstk[nesting] != NOADDR) {
668: unnamed_block();
669: }
670:
671: /*
672: * Default attributes.
673: */
674: s->language = curlang;
675: s->class = VAR;
676: s->block = curblock;
677: s->level = curlevel;
678: s->symvalue.offset = np->n_value;
679: curchar = p + 2;
680: knowtype = false;
681: switch (c) {
682: case 't': /* type name */
683: s->class = TYPE;
684: i = getint();
685: if (i == 0) {
686: panic("bad input on type \"%s\" at \"%s\"", symname(s),
687: curchar);
688: } else if (i >= NTYPES) {
689: panic("too many types in file \"%s\"", curfilename());
690: }
691: /*
692: * A hack for C typedefs that don't create new types,
693: * e.g. typedef unsigned int Hashvalue;
694: * or typedef struct blah BLAH;
695: */
696: if (*curchar == '\0') {
697: s->type = typetable[i];
698: if (s->type == nil) {
699: s->type = symbol_alloc();
700: typetable[i] = s->type;
701: }
702: knowtype = true;
703: } else {
704: typetable[i] = s;
705: skipchar(curchar, '=');
706: }
707: break;
708:
709: case 'T': /* tag */
710: s->class = TAG;
711: i = getint();
712: if (i == 0) {
713: panic("bad input on tag \"%s\" at \"%s\"", symname(s),
714: curchar);
715: } else if (i >= NTYPES) {
716: panic("too many types in file \"%s\"", curfilename());
717: }
718: if (typetable[i] != nil) {
719: typetable[i]->language = curlang;
720: typetable[i]->class = TYPE;
721: typetable[i]->type = s;
722: } else {
723: typetable[i] = s;
724: }
725: skipchar(curchar, '=');
726: break;
727:
728: case 'F': /* public function */
729: case 'f': /* private function */
730: s->class = FUNC;
731: if (curblock->class == FUNC or curblock->class == PROC) {
732: exitblock();
733: }
734: enterblock(s);
735: if (c == 'F') {
736: s->level = program->level;
737: isnew = false;
738: }
739: curparam = s;
740: if (isnew) {
741: s->symvalue.funcv.src = false;
742: s->symvalue.funcv.inline = false;
743: s->symvalue.funcv.beginaddr = np->n_value;
744: newfunc(s, codeloc(s));
745: findbeginning(s);
746: }
747: break;
748:
749: case 'G': /* public variable */
750: s->level = program->level;
751: break;
752:
753: case 'S': /* private variable */
754: s->level = curmodule->level;
755: s->block = curmodule;
756: break;
757:
758: /*
759: * keep global BSS variables chained so can resolve when get the start
760: * of common; keep the list in order so f77 can display all vars in a COMMON
761: */
762: case 'V': /* own variable */
763: s->level = 2;
764: if (curcomm) {
765: if (commchain != nil) {
766: commchain->symvalue.common.chain = s;
767: }
768: else {
769: curcomm->symvalue.common.offset = (int) s;
770: }
771: commchain = s;
772: s->symvalue.common.offset = np->n_value;
773: s->symvalue.common.chain = nil;
774: }
775: break;
776:
777: case 'r': /* register variable */
778: s->level = -(s->level);
779: break;
780:
781: case 'p': /* parameter variable */
782: curparam->chain = s;
783: curparam = s;
784: break;
785:
786: case 'v': /* varies parameter */
787: s->class = REF;
788: s->symvalue.offset = np->n_value;
789: curparam->chain = s;
790: curparam = s;
791: break;
792:
793: default: /* local variable */
794: --curchar;
795: break;
796: }
797: if (not knowtype) {
798: s->type = constype(nil);
799: if (s->class == TAG) {
800: addtag(s);
801: }
802: }
803: if (tracesyms) {
804: printdecl(s);
805: fflush(stdout);
806: }
807: }
808:
809: /*
810: * Construct a type out of a string encoding.
811: *
812: * The forms of the string are
813: *
814: * <number>
815: * <number>=<type>
816: * r<type>;<number>;<number> $ subrange
817: * a<type>;<type> $ array[index] of element
818: * s{<name>:<type>;<number>;<number>} $ record
819: * S<type> $ set
820: * *<type> $ pointer
821: */
822:
823: private Rangetype getrangetype();
824:
825: private Symbol constype(type)
826: Symbol type;
827: {
828: register Symbol t, u;
829: register Char *p, *cur;
830: register Integer n;
831: Integer b;
832: Name name;
833: Char class;
834:
835: b = curlevel;
836: if (isdigit(*curchar)) {
837: n = getint();
838: if (n == 0) {
839: panic("bad type number at \"%s\"", curchar);
840: } else if (n >= NTYPES) {
841: panic("too many types in file \"%s\"", curfilename());
842: }
843: if (*curchar == '=') {
844: if (typetable[n] != nil) {
845: t = typetable[n];
846: } else {
847: t = symbol_alloc();
848: typetable[n] = t;
849: }
850: ++curchar;
851: constype(t);
852: } else {
853: t = typetable[n];
854: if (t == nil) {
855: t = symbol_alloc();
856: typetable[n] = t;
857: }
858: }
859: } else {
860: if (type == nil) {
861: t = symbol_alloc();
862: } else {
863: t = type;
864: }
865: t->language = curlang;
866: t->level = b;
867: t->block = curblock;
868: class = *curchar++;
869: switch (class) {
870: case 'r':
871: t->class = RANGE;
872: t->type = constype(nil);
873: skipchar(curchar, ';');
874: t->symvalue.rangev.lowertype = getrangetype();
875: t->symvalue.rangev.lower = getint();
876: skipchar(curchar, ';');
877: t->symvalue.rangev.uppertype = getrangetype();
878: t->symvalue.rangev.upper = getint();
879: break;
880:
881: case 'a':
882: t->class = ARRAY;
883: t->chain = constype(nil);
884: skipchar(curchar, ';');
885: t->type = constype(nil);
886: break;
887:
888: case 'S':
889: t->class = SET;
890: t->type = constype(nil);
891: break;
892:
893: case 's':
894: case 'u':
895: t->class = (class == 's') ? RECORD : VARNT;
896: t->symvalue.offset = getint();
897: u = t;
898: cur = curchar;
899: while (*cur != ';' and *cur != '\0') {
900: p = index(cur, ':');
901: if (p == nil) {
902: panic("index(\"%s\", ':') failed", curchar);
903: }
904: *p = '\0';
905: name = identname(cur, true);
906: u->chain = newSymbol(name, b, FIELD, nil, nil);
907: cur = p + 1;
908: u = u->chain;
909: u->language = curlang;
910: curchar = cur;
911: u->type = constype(nil);
912: skipchar(curchar, ',');
913: u->symvalue.field.offset = getint();
914: skipchar(curchar, ',');
915: u->symvalue.field.length = getint();
916: skipchar(curchar, ';');
917: cur = curchar;
918: }
919: if (*cur == ';') {
920: ++cur;
921: }
922: curchar = cur;
923: break;
924:
925: case 'e':
926: t->class = SCAL;
927: u = t;
928: while (*curchar != ';' and *curchar != '\0') {
929: p = index(curchar, ':');
930: assert(p != nil);
931: *p = '\0';
932: u->chain = insert(identname(curchar, true));
933: curchar = p + 1;
934: u = u->chain;
935: u->language = curlang;
936: u->class = CONST;
937: u->level = b;
938: u->block = curblock;
939: u->type = t;
940: u->symvalue.iconval = getint();
941: skipchar(curchar, ',');
942: }
943: if (*curchar == ';')
944: curchar++;
945: break;
946:
947: case '*':
948: t->class = PTR;
949: t->type = constype(nil);
950: break;
951:
952: case 'f':
953: t->class = FUNC;
954: t->type = constype(nil);
955: break;
956:
957: default:
958: badcaseval(class);
959: }
960: }
961: return t;
962: }
963:
964: /*
965: * Get a range type.
966: *
967: * Special letters indicate a dynamic bound, i.e. what follows
968: * is the offset from the fp which contains the bound.
969: * J is a special flag to handle fortran a(*) bounds.
970: */
971:
972: private Rangetype getrangetype()
973: {
974: Rangetype t;
975:
976: switch (*curchar) {
977: case 'A':
978: t = R_ARG;
979: curchar++;
980: break;
981:
982: case 'T':
983: t = R_TEMP;
984: curchar++;
985: break;
986:
987: case 'J':
988: t = R_ADJUST;
989: curchar++;
990: break;
991:
992: default:
993: t = R_CONST;
994: break;
995: }
996: return t;
997: }
998:
999: /*
1000: * Read an integer from the current position in the type string.
1001: */
1002:
1003: private Integer getint()
1004: {
1005: register Integer n;
1006: register char *p;
1007: register Boolean isneg;
1008:
1009: n = 0;
1010: p = curchar;
1011: if (*p == '-') {
1012: isneg = true;
1013: ++p;
1014: } else {
1015: isneg = false;
1016: }
1017: while (isdigit(*p)) {
1018: n = 10*n + (*p - '0');
1019: ++p;
1020: }
1021: curchar = p;
1022: return isneg ? (-n) : n;
1023: }
1024:
1025: /*
1026: * Add a tag name. This is a kludge to be able to refer
1027: * to tags that have the same name as some other symbol
1028: * in the same block.
1029: */
1030:
1031: private addtag(s)
1032: register Symbol s;
1033: {
1034: register Symbol t;
1035: char buf[100];
1036:
1037: sprintf(buf, "$$%.90s", ident(s->name));
1038: t = insert(identname(buf, false));
1039: t->language = s->language;
1040: t->class = TAG;
1041: t->type = s->type;
1042: t->block = s->block;
1043: }
1044:
1045: /*
1046: * Allocate file and line tables and initialize indices.
1047: */
1048:
1049: private allocmaps(nf, nl)
1050: Integer nf, nl;
1051: {
1052: if (filetab != nil) {
1053: dispose(filetab);
1054: }
1055: if (linetab != nil) {
1056: dispose(linetab);
1057: }
1058: filetab = newarr(Filetab, nf);
1059: linetab = newarr(Linetab, nl);
1060: filep = filetab;
1061: linep = linetab;
1062: }
1063:
1064: /*
1065: * Add a file to the file table.
1066: *
1067: * If the new address is the same as the previous file address
1068: * this routine used to not enter the file, but this caused some
1069: * problems so it has been removed. It's not clear that this in
1070: * turn may not also cause a problem.
1071: */
1072:
1073: private enterfile(filename, addr)
1074: String filename;
1075: Address addr;
1076: {
1077: filep->addr = addr;
1078: filep->filename = filename;
1079: filep->lineindex = linep - linetab;
1080: ++filep;
1081: }
1082:
1083: /*
1084: * Since we only estimated the number of lines (and it was a poor
1085: * estimation) and since we need to know the exact number of lines
1086: * to do a binary search, we set it when we're done.
1087: */
1088:
1089: private setnlines()
1090: {
1091: nlhdr.nlines = linep - linetab;
1092: }
1093:
1094: /*
1095: * Similarly for nfiles ...
1096: */
1097:
1098: private setnfiles()
1099: {
1100: nlhdr.nfiles = filep - filetab;
1101: setsource(filetab[0].filename);
1102: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.