![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stabstring.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / dbx|
Return to stabstring.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / ucb / dbx |
1.1 root 1: /*
2: * Copyright (c) 1983 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[] = "@(#)stabstring.c 5.3 (Berkeley) 5/11/88";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: stabstring.c,v 1.5 88/04/01 18:13:58 donn Exp $";
12:
13: /*
14: * String information interpretation
15: *
16: * The string part of a stab entry is broken up into name and type information.
17: */
18:
19: #include "defs.h"
20: #include "stabstring.h"
21: #include "object.h"
22: #include "main.h"
23: #include "symbols.h"
24: #include "names.h"
25: #include "languages.h"
26: #include "tree.h"
27: #include <a.out.h>
28: #include <ctype.h>
29:
30: #ifndef public
31: #endif
32:
33: /*
34: * Special characters in symbol table information.
35: */
36:
37: #define CONSTNAME 'c'
38: #define TYPENAME 't'
39: #define TAGNAME 'T'
40: #define MODULEBEGIN 'm'
41: #define EXTPROCEDURE 'P'
42: #define PRIVPROCEDURE 'Q'
43: #define INTPROCEDURE 'I'
44: #define EXTFUNCTION 'F'
45: #define PRIVFUNCTION 'f'
46: #define INTFUNCTION 'J'
47: #define EXTVAR 'G'
48: #define MODULEVAR 'S'
49: #define OWNVAR 'V'
50: #define REGVAR 'r'
51: #define VALUEPARAM 'p'
52: #define VARIABLEPARAM 'v'
53: #define LOCALVAR /* default */
54:
55: /*
56: * Type information special characters.
57: */
58:
59: #define T_SUBRANGE 'r'
60: #define T_ARRAY 'a'
61: #define T_OLDOPENARRAY 'A'
62: #define T_OPENARRAY 'O'
63: #define T_DYNARRAY 'D'
64: #define T_SUBARRAY 'E'
65: #define T_RECORD 's'
66: #define T_UNION 'u'
67: #define T_ENUM 'e'
68: #define T_PTR '*'
69: #define T_FUNCVAR 'f'
70: #define T_PROCVAR 'p'
71: #define T_IMPORTED 'i'
72: #define T_SET 'S'
73: #define T_OPAQUE 'o'
74: #define T_FILE 'd'
75:
76: /*
77: * Table of types indexed by per-file unique identification number.
78: */
79:
80: #define NTYPES 1000
81:
82: private Symbol typetable[NTYPES];
83:
84: public initTypeTable ()
85: {
86: bzero(typetable, sizeof(typetable));
87: (*language_op(curlang, L_MODINIT))(typetable);
88: }
89:
90: /*
91: * Put an nlist entry into the symbol table.
92: * If it's already there just add the associated information.
93: *
94: * Type information is encoded in the name following a ":".
95: */
96:
97: private Symbol constype();
98: private Char *curchar;
99:
100: #define skipchar(ptr, ch) \
101: { \
102: if (*ptr != ch) { \
103: panic("expected char '%c', found '%s'", ch, ptr); \
104: } \
105: ++ptr; \
106: }
107:
108: #define optchar(ptr, ch) \
109: { \
110: if (*ptr == ch) { \
111: ++ptr; \
112: } \
113: }
114:
115: #ifdef sun
116: # define chkcont(ptr) \
117: { \
118: if (*ptr == '\\' or *ptr == '?') { \
119: ptr = getcont(); \
120: } \
121: }
122: #else if notsun
123: # define chkcont(ptr) \
124: { \
125: if (*ptr == '?') { \
126: ptr = getcont(); \
127: } \
128: }
129: #endif
130:
131: #define newSym(s, n) \
132: { \
133: s = insert(n); \
134: s->level = curblock->level + 1; \
135: s->language = curlang; \
136: s->block = curblock; \
137: }
138:
139: #define makeVariable(s, n, off) \
140: { \
141: newSym(s, n); \
142: s->class = VAR; \
143: s->symvalue.offset = off; \
144: getType(s); \
145: }
146:
147: #define makeParameter(s, n, cl, off) \
148: { \
149: if ((s = lookup(n)) == nil or s->block != curblock) { \
150: newSym(s, n); \
151: s->storage = STK; \
152: s->class = cl; \
153: s->symvalue.offset = off; \
154: getType(s); \
155: } \
156: curparam->chain = s; \
157: curparam = s; \
158: }
159:
160: public entersym (name, np)
161: String name;
162: struct nlist *np;
163: {
164: Symbol s;
165: register char *p, *q, *r;
166: register Name n;
167: char c;
168:
169: p = index(name, ':');
170: *p = '\0';
171: c = *(p+1);
172: if (autostrip and streq(language_name(curlang), "c++")) {
173: /*
174: * Strip off redundant prefixes from C++ names.
175: * Static variables are prefixed with _static_.
176: * Formal arguments of functions are prefixed with _au0_.
177: * Automatic variables are prefixed with _au[1-9][0-9]*_.
178: * Class members are prefixed with _T_, where T is a class tag.
179: */
180: if (strncmp("_static_", name, 8) == 0 and name[8] != '\0') {
181: name += 8;
182: }
183: q = name;
184: if (*q++ == '_' and *q++ == 'a' and *q++ == 'u' and isdigit(*q++)) {
185: while (isdigit(*q))
186: ++q;
187: if (*q++ == '_' and *q != '\0')
188: name = q;
189: }
190: q = name;
191: if (*q++ == '_' and c == EXTFUNCTION) {
192: /*
193: * Punt on static class members, for speed.
194: */
195: for (r = q; (r = index(r, '_')) != nil; ++r) {
196: if (r == q) {
197: continue;
198: }
199: *r = '\0';
200: s = lookup(identname(q, true));
201: if (s != nil and s->class == TYPE) {
202: char *newname = r + 1;
203: if (*newname != '\0') {
204: name = newname;
205: break;
206: }
207: }
208: *r = '_';
209: }
210: }
211: }
212: n = identname(name, true);
213: chkUnnamedBlock();
214: curchar = p + 2;
215: switch (c) {
216: case CONSTNAME:
217: newSym(s, n);
218: constName(s);
219: break;
220:
221: case TYPENAME:
222: newSym(s, n);
223: typeName(s);
224: break;
225:
226: case TAGNAME:
227: s = symbol_alloc();
228: s->name = n;
229: s->level = curblock->level + 1;
230: s->language = curlang;
231: s->block = curblock;
232: tagName(s);
233: break;
234:
235: case MODULEBEGIN:
236: publicRoutine(&s, n, MODULE, np->n_value, false);
237: curmodule = s;
238: break;
239:
240: case EXTPROCEDURE:
241: publicRoutine(&s, n, PROC, np->n_value, false);
242: break;
243:
244: case PRIVPROCEDURE:
245: privateRoutine(&s, n, PROC, np->n_value);
246: break;
247:
248: case INTPROCEDURE:
249: publicRoutine(&s, n, PROC, np->n_value, true);
250: break;
251:
252: case EXTFUNCTION:
253: publicRoutine(&s, n, FUNC, np->n_value, false);
254: break;
255:
256: case PRIVFUNCTION:
257: privateRoutine(&s, n, FUNC, np->n_value);
258: break;
259:
260: case INTFUNCTION:
261: publicRoutine(&s, n, FUNC, np->n_value, true);
262: break;
263:
264: case EXTVAR:
265: extVar(&s, n, np->n_value);
266: break;
267:
268: case MODULEVAR:
269: if (curblock->class != MODULE) {
270: exitblock();
271: }
272: makeVariable(s, n, np->n_value);
273: s->storage = EXT;
274: s->level = program->level;
275: s->block = curmodule;
276: getExtRef(s);
277: break;
278:
279: case OWNVAR:
280: makeVariable(s, n, np->n_value);
281: ownVariable(s, np->n_value);
282: getExtRef(s);
283: break;
284:
285: case REGVAR:
286: makeVariable(s, n, np->n_value);
287: s->storage = INREG;
288: break;
289:
290: case VALUEPARAM:
291: makeParameter(s, n, VAR, np->n_value);
292: # ifdef IRIS
293: /*
294: * Bug in SGI C compiler -- generates stab offset
295: * for parameters with size added in.
296: */
297: if (s->storage == STK and curlang == findlanguage(".c")) {
298: s->symvalue.offset -= size(s);
299: }
300: # endif
301: break;
302:
303: case VARIABLEPARAM:
304: makeParameter(s, n, REF, np->n_value);
305: break;
306:
307: default: /* local variable */
308: --curchar;
309: makeVariable(s, n, np->n_value);
310: s->storage = STK;
311: break;
312: }
313: if (tracesyms) {
314: printdecl(s);
315: fflush(stdout);
316: }
317: }
318:
319: /*
320: * Enter a named constant.
321: */
322:
323: private constName (s)
324: Symbol s;
325: {
326: integer i;
327: double d;
328: char *p, buf[1000];
329:
330: s->class = CONST;
331: skipchar(curchar, '=');
332: p = curchar;
333: ++curchar;
334: switch (*p) {
335: case 'b':
336: s->type = t_boolean;
337: s->symvalue.constval = build(O_LCON, getint());
338: break;
339:
340: case 'c':
341: s->type = t_char;
342: s->symvalue.constval = build(O_LCON, getint());
343: break;
344:
345: case 'i':
346: s->type = t_int;
347: s->symvalue.constval = build(O_LCON, getint());
348: break;
349:
350: case 'r':
351: sscanf(curchar, "%lf", &d);
352: while (*curchar != '\0' and *curchar != ';') {
353: ++curchar;
354: }
355: --curchar;
356: s->type = t_real;
357: s->symvalue.constval = build(O_FCON, d);
358: break;
359:
360: case 's':
361: p = &buf[0];
362: skipchar(curchar, '\'');
363: while (*curchar != '\'') {
364: *p = *curchar;
365: ++p;
366: ++curchar;
367: }
368: *p = '\0';
369: s->symvalue.constval = build(O_SCON, strdup(buf));
370: s->type = s->symvalue.constval->nodetype;
371: break;
372:
373: case 'e':
374: getType(s);
375: skipchar(curchar, ',');
376: s->symvalue.constval = build(O_LCON, getint());
377: break;
378:
379: case 'S':
380: getType(s);
381: skipchar(curchar, ',');
382: i = getint(); /* set size */
383: skipchar(curchar, ',');
384: i = getint(); /* number of bits in constant */
385: s->symvalue.constval = build(O_LCON, 0);
386: break;
387:
388: default:
389: s->type = t_int;
390: s->symvalue.constval = build(O_LCON, 0);
391: printf("[internal error: unknown constant type '%c']", *p);
392: break;
393: }
394: s->symvalue.constval->nodetype = s->type;
395: }
396:
397: /*
398: * Enter a type name.
399: */
400:
401: private typeName (s)
402: Symbol s;
403: {
404: register integer i;
405:
406: s->class = TYPE;
407: s->language = curlang;
408: s->block = curblock;
409: s->level = curblock->level + 1;
410: i = getint();
411: if (i == 0) {
412: panic("bad input on type \"%s\" at \"%s\"", symname(s), curchar);
413: } else if (i >= NTYPES) {
414: panic("too many types in file \"%s\"", curfilename());
415: }
416: /*
417: * A hack for C typedefs that don't create new types,
418: * e.g. typedef unsigned int Hashvalue;
419: * or typedef struct blah BLAH;
420: */
421: if (*curchar != '=') {
422: s->type = typetable[i];
423: if (s->type == nil) {
424: s->type = symbol_alloc();
425: typetable[i] = s->type;
426: }
427: } else {
428: if (typetable[i] != nil) {
429: typetable[i]->language = curlang;
430: typetable[i]->class = TYPE;
431: typetable[i]->type = s;
432: } else {
433: typetable[i] = s;
434: }
435: skipchar(curchar, '=');
436: getType(s);
437: }
438: }
439:
440: /*
441: * Enter a tag name.
442: */
443:
444: private tagName (s)
445: Symbol s;
446: {
447: register integer i;
448:
449: s->class = TAG;
450: i = getint();
451: if (i == 0) {
452: panic("bad input on tag \"%s\" at \"%s\"", symname(s), curchar);
453: } else if (i >= NTYPES) {
454: panic("too many types in file \"%s\"", curfilename());
455: }
456: if (typetable[i] != nil) {
457: typetable[i]->language = curlang;
458: typetable[i]->class = TYPE;
459: typetable[i]->type = s;
460: } else {
461: typetable[i] = s;
462: }
463: skipchar(curchar, '=');
464: getType(s);
465: }
466:
467: /*
468: * Setup a symbol entry for a public procedure or function.
469: *
470: * If it contains nested procedures, then it may already be defined
471: * in the current block as a MODULE.
472: */
473:
474: private publicRoutine (s, n, class, addr, isinternal)
475: Symbol *s;
476: Name n;
477: Symclass class;
478: Address addr;
479: boolean isinternal;
480: {
481: Symbol nt, t;
482:
483: newSym(nt, n);
484: if (isinternal) {
485: markInternal(nt);
486: }
487: enterRoutine(nt, class);
488: find(t, n) where
489: t != nt and t->class == MODULE and t->block == nt->block
490: endfind(t);
491: if (t == nil) {
492: t = nt;
493: } else {
494: t->language = nt->language;
495: t->class = nt->class;
496: t->type = nt->type;
497: t->chain = nt->chain;
498: t->symvalue = nt->symvalue;
499: nt->class = EXTREF;
500: nt->symvalue.extref = t;
501: delete(nt);
502: curparam = t;
503: changeBlock(t);
504: }
505: if (t->block == program) {
506: t->level = program->level;
507: } else if (t->class == MODULE) {
508: t->level = t->block->level;
509: } else if (t->block->class == MODULE) {
510: t->level = t->block->block->level;
511: } else {
512: t->level = t->block->level + 1;
513: }
514: *s = t;
515: }
516:
517: /*
518: * Setup a symbol entry for a private procedure or function.
519: */
520:
521: private privateRoutine (s, n, class, addr)
522: Symbol *s;
523: Name n;
524: Symclass class;
525: Address addr;
526: {
527: Symbol t;
528: boolean isnew;
529:
530: find(t, n) where
531: t->level == curmodule->level and t->class == class
532: endfind(t);
533: if (t == nil) {
534: isnew = true;
535: t = insert(n);
536: } else {
537: isnew = false;
538: }
539: t->language = curlang;
540: enterRoutine(t, class);
541: if (isnew) {
542: t->symvalue.funcv.src = false;
543: t->symvalue.funcv.inline = false;
544: t->symvalue.funcv.beginaddr = addr;
545: newfunc(t, codeloc(t));
546: findbeginning(t);
547: }
548: *s = t;
549: }
550:
551: /*
552: * Set up for beginning a new procedure, function, or module.
553: * If it's a function, then read the type.
554: *
555: * If the next character is a ",", then read the name of the enclosing block.
556: * Otherwise assume the previous function, if any, is over, and the current
557: * routine is at the same level.
558: */
559:
560: private enterRoutine (s, class)
561: Symbol s;
562: Symclass class;
563: {
564: s->class = class;
565: if (class == FUNC) {
566: getType(s);
567: }
568: if (s->class != MODULE) {
569: getExtRef(s);
570: } else if (*curchar == ',') {
571: ++curchar;
572: }
573: if (*curchar != '\0') {
574: exitblock();
575: enterNestedBlock(s);
576: } else {
577: if (curblock->class == FUNC or curblock->class == PROC) {
578: exitblock();
579: }
580: if (class == MODULE) {
581: exitblock();
582: }
583: enterblock(s);
584: }
585: curparam = s;
586: }
587:
588: /*
589: * Handling an external variable is tricky, since we might already
590: * know it but need to define it's type for other type information
591: * in the file. So just in case we read the type information anyway.
592: */
593:
594: private extVar (symp, n, off)
595: Symbol *symp;
596: Name n;
597: integer off;
598: {
599: Symbol s, t;
600:
601: find(s, n) where
602: s->level == program->level and s->class == VAR
603: endfind(s);
604: if (s == nil) {
605: makeVariable(s, n, off);
606: s->storage = EXT;
607: s->level = program->level;
608: s->block = curmodule;
609: getExtRef(s);
610: } else {
611: t = constype(nil);
612: }
613: *symp = s;
614: }
615:
616: /*
617: * Check to see if the stab string contains the name of the external
618: * reference. If so, we create a symbol with that name and class EXTREF, and
619: * connect it to the given symbol. This link is created so that when
620: * we see the linker symbol we can resolve it to the given symbol.
621: */
622:
623: private getExtRef (s)
624: Symbol s;
625: {
626: char *p;
627: Name n;
628: Symbol t;
629:
630: if (*curchar == ',' and *(curchar + 1) != '\0') {
631: p = index(curchar + 1, ',');
632: *curchar = '\0';
633: if (p != nil) {
634: *p = '\0';
635: n = identname(curchar + 1, false);
636: curchar = p + 1;
637: } else {
638: n = identname(curchar + 1, true);
639: }
640: t = insert(n);
641: t->language = s->language;
642: t->class = EXTREF;
643: t->block = program;
644: t->level = program->level;
645: t->symvalue.extref = s;
646: }
647: }
648:
649: /*
650: * Find a block with the given identifier in the given outer block.
651: * If not there, then create it.
652: */
653:
654: private Symbol findBlock (id, m)
655: String id;
656: Symbol m;
657: {
658: Name n;
659: Symbol s;
660:
661: n = identname(id, true);
662: find(s, n) where s->block == m and isblock(s) endfind(s);
663: if (s == nil) {
664: s = insert(n);
665: s->block = m;
666: s->language = curlang;
667: s->class = MODULE;
668: s->level = m->level + 1;
669: }
670: return s;
671: }
672:
673: /*
674: * Enter a nested block.
675: * The block within which it is nested is described
676: * by "module{:module}[:proc]".
677: */
678:
679: private enterNestedBlock (b)
680: Symbol b;
681: {
682: register char *p, *q;
683: Symbol m, s;
684: Name n;
685:
686: q = curchar;
687: p = index(q, ':');
688: m = program;
689: while (p != nil) {
690: *p = '\0';
691: m = findBlock(q, m);
692: q = p + 1;
693: p = index(q, ':');
694: }
695: if (*q != '\0') {
696: m = findBlock(q, m);
697: }
698: b->level = m->level + 1;
699: b->block = m;
700: pushBlock(b);
701: }
702:
703: /*
704: * Enter a statically-allocated variable defined within a routine.
705: *
706: * Global BSS variables are chained together so we can resolve them
707: * when the start of common is determined. The list is kept in order
708: * so that f77 can display all vars in a COMMON.
709: */
710:
711: private ownVariable (s, addr)
712: Symbol s;
713: Address addr;
714: {
715: s->storage = EXT;
716: /* s->level = 1; */
717: if (curcomm) {
718: if (commchain != nil) {
719: commchain->symvalue.common.chain = s;
720: } else {
721: curcomm->symvalue.common.offset = (integer) s;
722: }
723: commchain = s;
724: s->symvalue.common.offset = addr;
725: s->symvalue.common.chain = nil;
726: }
727: }
728:
729: /*
730: * Get a type from the current stab string for the given symbol.
731: */
732:
733: private getType (s)
734: Symbol s;
735: {
736: Symbol t, addtag();
737:
738: if (s->class == TAG) {
739: t = addtag(s);
740: t->type = constype(nil);
741: s->type = t->type;
742: } else {
743: s->type = constype(nil);
744: }
745: }
746:
747: /*
748: * Construct a type out of a string encoding.
749: */
750:
751: private Rangetype getRangeBoundType();
752:
753: private Symbol constype (type)
754: Symbol type;
755: {
756: register Symbol t;
757: register integer n;
758: char class;
759: char *p;
760:
761: while (*curchar == '@') {
762: p = index(curchar, ';');
763: if (p == nil) {
764: fflush(stdout);
765: fprintf(stderr, "missing ';' after type attributes");
766: } else {
767: curchar = p + 1;
768: }
769: }
770: if (isdigit(*curchar)) {
771: n = getint();
772: if (n >= NTYPES) {
773: panic("too many types in file \"%s\"", curfilename());
774: }
775: if (*curchar == '=') {
776: if (typetable[n] != nil) {
777: t = typetable[n];
778: } else {
779: t = symbol_alloc();
780: typetable[n] = t;
781: }
782: ++curchar;
783: constype(t);
784: } else {
785: t = typetable[n];
786: if (t == nil) {
787: t = symbol_alloc();
788: typetable[n] = t;
789: }
790: }
791: } else {
792: if (type == nil) {
793: t = symbol_alloc();
794: } else {
795: t = type;
796: }
797: t->language = curlang;
798: t->level = curblock->level + 1;
799: t->block = curblock;
800: class = *curchar++;
801: switch (class) {
802: case T_SUBRANGE:
803: consSubrange(t);
804: break;
805:
806: case T_ARRAY:
807: t->class = ARRAY;
808: t->chain = constype(nil);
809: skipchar(curchar, ';');
810: chkcont(curchar);
811: t->type = constype(nil);
812: break;
813:
814: case T_OLDOPENARRAY:
815: t->class = DYNARRAY;
816: t->symvalue.ndims = 1;
817: t->type = constype(nil);
818: t->chain = t_int;
819: break;
820:
821: case T_OPENARRAY:
822: consDynarray(t, OPENARRAY);
823: break;
824:
825: case T_DYNARRAY:
826: consDynarray(t, DYNARRAY);
827: break;
828:
829: case T_SUBARRAY:
830: t->class = SUBARRAY;
831: t->symvalue.ndims = getint();
832: skipchar(curchar, ',');
833: t->type = constype(nil);
834: t->chain = t_int;
835: break;
836:
837: case T_RECORD:
838: consRecord(t, RECORD);
839: break;
840:
841: case T_UNION:
842: consRecord(t, VARNT);
843: break;
844:
845: case T_ENUM:
846: consEnum(t);
847: break;
848:
849: case T_PTR:
850: t->class = PTR;
851: t->type = constype(nil);
852: break;
853:
854: /*
855: * C function variables are different from Modula-2's.
856: */
857: case T_FUNCVAR:
858: t->class = FFUNC;
859: t->type = constype(nil);
860: if (streq(language_name(curlang), "modula-2")) {
861: skipchar(curchar, ',');
862: consParamlist(t);
863: }
864: break;
865:
866: case T_PROCVAR:
867: t->class = FPROC;
868: consParamlist(t);
869: break;
870:
871: case T_IMPORTED:
872: consImpType(t);
873: break;
874:
875: case T_SET:
876: t->class = SET;
877: t->type = constype(nil);
878: break;
879:
880: case T_OPAQUE:
881: consOpaqType(t);
882: break;
883:
884: case T_FILE:
885: t->class = FILET;
886: t->type = constype(nil);
887: break;
888:
889: default:
890: badcaseval(class);
891: }
892: }
893: return t;
894: }
895:
896: /*
897: * Construct a subrange type.
898: */
899:
900: private consSubrange (t)
901: Symbol t;
902: {
903: t->class = RANGE;
904: t->type = constype(nil);
905: skipchar(curchar, ';');
906: chkcont(curchar);
907: t->symvalue.rangev.lowertype = getRangeBoundType();
908: t->symvalue.rangev.lower = getint();
909: skipchar(curchar, ';');
910: chkcont(curchar);
911: t->symvalue.rangev.uppertype = getRangeBoundType();
912: t->symvalue.rangev.upper = getint();
913: }
914:
915: /*
916: * Figure out the bound type of a range.
917: *
918: * Some letters indicate a dynamic bound, ie what follows
919: * is the offset from the fp which contains the bound; this will
920: * need a different encoding when pc a['A'..'Z'] is
921: * added; J is a special flag to handle fortran a(*) bounds
922: */
923:
924: private Rangetype getRangeBoundType ()
925: {
926: Rangetype r;
927:
928: switch (*curchar) {
929: case 'A':
930: r = R_ARG;
931: curchar++;
932: break;
933:
934: case 'T':
935: r = R_TEMP;
936: curchar++;
937: break;
938:
939: case 'J':
940: r = R_ADJUST;
941: curchar++;
942: break;
943:
944: default:
945: r = R_CONST;
946: break;
947: }
948: return r;
949: }
950:
951: /*
952: * Construct a dynamic array descriptor.
953: */
954:
955: private consDynarray (t, c)
956: register Symbol t;
957: Symclass c;
958: {
959: t->class = c;
960: t->symvalue.ndims = getint();
961: skipchar(curchar, ',');
962: t->type = constype(nil);
963: t->chain = t_int;
964: }
965:
966: /*
967: * Construct a record or union type.
968: */
969:
970: private consRecord (t, class)
971: Symbol t;
972: Symclass class;
973: {
974: register Symbol u;
975: register char *cur, *p;
976: Name name;
977: integer d;
978:
979: t->class = class;
980: t->symvalue.offset = getint();
981: d = curblock->level + 1;
982: u = t;
983: chkcont(curchar);
984: cur = curchar;
985: while (*cur != ';' and *cur != '\0') {
986: p = index(cur, ':');
987: if (p == nil) {
988: panic("index(\"%s\", ':') failed", curchar);
989: }
990: *p = '\0';
991: if (
992: autostrip and
993: *cur == '_' and
994: streq(language_name(curlang), "c++")
995: ) {
996: /*
997: * Strip off redundant prefixes from C++ names.
998: * Class members are prefixed with _T_, where T is a class tag.
999: */
1000: register char *q, *r;
1001: Symbol s;
1002:
1003: /*
1004: * The slow way... Check for members defined in the base class.
1005: */
1006: for (q = cur + 1, r = q; (r = index(r, '_')) != nil; ++r) {
1007: if (r == q) {
1008: continue;
1009: }
1010: *r = '\0';
1011: s = lookup(identname(q, true));
1012: if (s != nil and s->class == TYPE) {
1013: char *newcur = r + 1;
1014: if (*newcur != '\0') {
1015: cur = newcur;
1016: break;
1017: }
1018: }
1019: *r = '_';
1020: }
1021: }
1022: name = identname(cur, true);
1023: u->chain = newSymbol(name, d, FIELD, nil, nil);
1024: cur = p + 1;
1025: u = u->chain;
1026: u->language = curlang;
1027: curchar = cur;
1028: u->type = constype(nil);
1029: skipchar(curchar, ',');
1030: u->symvalue.field.offset = getint();
1031: skipchar(curchar, ',');
1032: u->symvalue.field.length = getint();
1033: skipchar(curchar, ';');
1034: chkcont(curchar);
1035: cur = curchar;
1036: }
1037: if (*cur == ';') {
1038: ++cur;
1039: }
1040: curchar = cur;
1041: }
1042:
1043: /*
1044: * Construct an enumeration type.
1045: */
1046:
1047: private consEnum (t)
1048: Symbol t;
1049: {
1050: register Symbol u;
1051: register char *p;
1052: register integer count;
1053:
1054: t->class = SCAL;
1055: count = 0;
1056: u = t;
1057: while (*curchar != ';' and *curchar != '\0' and *curchar != ',') {
1058: p = index(curchar, ':');
1059: assert(p != nil);
1060: *p = '\0';
1061: u->chain = insert(identname(curchar, true));
1062: curchar = p + 1;
1063: u = u->chain;
1064: u->language = curlang;
1065: u->class = CONST;
1066: u->level = curblock->level + 1;
1067: u->block = curblock;
1068: u->type = t;
1069: u->symvalue.constval = build(O_LCON, (long) getint());
1070: ++count;
1071: skipchar(curchar, ',');
1072: chkcont(curchar);
1073: }
1074: if (*curchar == ';') {
1075: ++curchar;
1076: }
1077: t->symvalue.iconval = count;
1078: }
1079:
1080: /*
1081: * Construct a parameter list for a function or procedure variable.
1082: */
1083:
1084: private consParamlist (t)
1085: Symbol t;
1086: {
1087: Symbol p;
1088: integer i, d, n, paramclass;
1089:
1090: n = getint();
1091: skipchar(curchar, ';');
1092: p = t;
1093: d = curblock->level + 1;
1094: for (i = 0; i < n; i++) {
1095: p->chain = newSymbol(nil, d, VAR, nil, nil);
1096: p = p->chain;
1097: p->type = constype(nil);
1098: skipchar(curchar, ',');
1099: paramclass = getint();
1100: if (paramclass == 0) {
1101: p->class = REF;
1102: }
1103: skipchar(curchar, ';');
1104: chkcont(curchar);
1105: }
1106: }
1107:
1108: /*
1109: * Construct an imported type.
1110: * Add it to a list of symbols to get fixed up.
1111: */
1112:
1113: private consImpType (t)
1114: Symbol t;
1115: {
1116: register char *p;
1117: Symbol tmp;
1118:
1119: p = curchar;
1120: while (*p != ',' and *p != ';' and *p != '\0') {
1121: ++p;
1122: }
1123: if (*p == '\0') {
1124: panic("bad import symbol entry '%s'", curchar);
1125: }
1126: t->class = TYPEREF;
1127: t->symvalue.typeref = curchar;
1128: if (*p == ',') {
1129: curchar = p + 1;
1130: tmp = constype(nil);
1131: } else {
1132: curchar = p;
1133: }
1134: skipchar(curchar, ';');
1135: *p = '\0';
1136: }
1137:
1138: /*
1139: * Construct an opaque type entry.
1140: */
1141:
1142: private consOpaqType (t)
1143: Symbol t;
1144: {
1145: register char *p;
1146: register Symbol s;
1147: register Name n;
1148: boolean def;
1149:
1150: p = curchar;
1151: while (*p != ';' and *p != ',') {
1152: if (*p == '\0') {
1153: panic("bad opaque symbol entry '%s'", curchar);
1154: }
1155: ++p;
1156: }
1157: def = (Boolean) (*p == ',');
1158: *p = '\0';
1159: n = identname(curchar, true);
1160: find(s, n) where s->class == TYPEREF endfind(s);
1161: if (s == nil) {
1162: s = insert(n);
1163: s->class = TYPEREF;
1164: s->type = nil;
1165: }
1166: curchar = p + 1;
1167: if (def) {
1168: s->type = constype(nil);
1169: skipchar(curchar, ';');
1170: }
1171: t->class = TYPE;
1172: t->type = s;
1173: }
1174:
1175: /*
1176: * Read an integer from the current position in the type string.
1177: */
1178:
1179: private integer getint ()
1180: {
1181: register integer n;
1182: register char *p;
1183: register Boolean isneg;
1184:
1185: n = 0;
1186: p = curchar;
1187: if (*p == '-') {
1188: isneg = true;
1189: ++p;
1190: } else {
1191: isneg = false;
1192: }
1193: while (isdigit(*p)) {
1194: n = 10*n + (*p - '0');
1195: ++p;
1196: }
1197: curchar = p;
1198: return isneg ? (-n) : n;
1199: }
1200:
1201: /*
1202: * Add a tag name. This is a kludge to be able to refer
1203: * to tags that have the same name as some other symbol
1204: * in the same block.
1205: */
1206:
1207: private Symbol addtag (s)
1208: register Symbol s;
1209: {
1210: register Symbol t;
1211: char buf[100];
1212:
1213: if (streq(language_name(curlang), "c++")) {
1214: t = insert(s->name);
1215: t->class = TYPE;
1216: } else {
1217: sprintf(buf, "$$%.90s", ident(s->name));
1218: t = insert(identname(buf, false));
1219: t->class = TAG;
1220: }
1221: t->language = s->language;
1222: t->block = s->block;
1223: return t;
1224: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.