![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to printsym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / dbx|
Return to printsym.c CVS log | Up to [CSRG BSD Unix] / 43BSD / 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[] = "@(#)printsym.c 5.3 (Berkeley) 3/5/86";
9: #endif not lint
10:
11: static char rcsid[] = "$Header: printsym.c,v 1.5 84/12/26 10:41:28 linton Exp $";
12:
13: /*
14: * Printing of symbolic information.
15: */
16:
17: #include "defs.h"
18: #include "symbols.h"
19: #include "languages.h"
20: #include "printsym.h"
21: #include "tree.h"
22: #include "eval.h"
23: #include "mappings.h"
24: #include "process.h"
25: #include "runtime.h"
26: #include "machine.h"
27: #include "names.h"
28: #include "keywords.h"
29: #include "main.h"
30:
31: #ifndef public
32: #endif
33:
34: /*
35: * Maximum number of arguments to a function.
36: * This is used as a check for the possibility that the stack has been
37: * overwritten and therefore a saved argument pointer might indicate
38: * to an absurdly large number of arguments.
39: */
40:
41: #define MAXARGSPASSED 20
42:
43: /*
44: * Return a pointer to the string for the name of the class that
45: * the given symbol belongs to.
46: */
47:
48: private String clname[] = {
49: "bad use", "constant", "type", "variable", "array", "@dynarray",
50: "@subarray", "fileptr", "record", "field",
51: "procedure", "function", "funcvar",
52: "ref", "pointer", "file", "set", "range", "label", "withptr",
53: "scalar", "string", "program", "improper", "variant",
54: "procparam", "funcparam", "module", "tag", "common", "extref", "typeref"
55: };
56:
57: public String classname(s)
58: Symbol s;
59: {
60: return clname[ord(s->class)];
61: }
62:
63: /*
64: * Note the entry of the given block, unless it's the main program.
65: */
66:
67: public printentry(s)
68: Symbol s;
69: {
70: if (s != program) {
71: printf("\nentering %s ", classname(s));
72: printname(stdout, s);
73: printf("\n");
74: }
75: }
76:
77: /*
78: * Note the exit of the given block
79: */
80:
81: public printexit(s)
82: Symbol s;
83: {
84: if (s != program) {
85: printf("leaving %s ", classname(s));
86: printname(stdout, s);
87: printf("\n\n");
88: }
89: }
90:
91: /*
92: * Note the call of s from t.
93: */
94:
95: public printcall(s, t)
96: Symbol s, t;
97: {
98: printf("calling ");
99: printname(stdout, s);
100: printparams(s, nil);
101: printf(" from %s ", classname(t));
102: printname(stdout, t);
103: printf("\n");
104: }
105:
106: /*
107: * Note the return from s. If s is a function, print the value
108: * it is returning. This is somewhat painful, since the function
109: * has actually just returned.
110: */
111:
112: public printrtn(s)
113: Symbol s;
114: {
115: register Symbol t;
116: register int len;
117: Boolean isindirect;
118:
119: printf("returning ");
120: if (s->class == FUNC && (!istypename(s->type,"void"))) {
121: len = size(s->type);
122: if (canpush(len)) {
123: t = rtype(s->type);
124: isindirect = (Boolean) (t->class == RECORD or t->class == VARNT);
125: pushretval(len, isindirect);
126: printval(s->type);
127: putchar(' ');
128: } else {
129: printf("(value too large) ");
130: }
131: }
132: printf("from ");
133: printname(stdout, s);
134: printf("\n");
135: }
136:
137: /*
138: * Print the values of the parameters of the given procedure or function.
139: * The frame distinguishes recursive instances of a procedure.
140: *
141: * If the procedure or function is internal, the argument count is
142: * not valid so we ignore it.
143: */
144:
145: public printparams(f, frame)
146: Symbol f;
147: Frame frame;
148: {
149: Symbol param;
150: int n, m, s;
151:
152: n = nargspassed(frame);
153: if (isinternal(f)) {
154: n = 0;
155: }
156: printf("(");
157: param = f->chain;
158: if (param != nil or n > 0) {
159: m = n;
160: if (param != nil) {
161: for (;;) {
162: s = psize(param) div sizeof(Word);
163: if (s == 0) {
164: s = 1;
165: }
166: m -= s;
167: if (showaggrs) {
168: printv(param, frame);
169: } else {
170: printparamv(param, frame);
171: }
172: param = param->chain;
173: if (param == nil) break;
174: printf(", ");
175: }
176: }
177: if (m > 0) {
178: if (m > MAXARGSPASSED) {
179: m = MAXARGSPASSED;
180: }
181: if (f->chain != nil) {
182: printf(", ");
183: }
184: for (;;) {
185: --m;
186: printf("0x%x", argn(n - m, frame));
187: if (m <= 0) break;
188: printf(", ");
189: }
190: }
191: }
192: printf(")");
193: }
194:
195: /*
196: * Test if a symbol should be printed. We don't print files,
197: * for example, simply because there's no good way to do it.
198: * The symbol must be within the given function.
199: */
200:
201: public Boolean should_print(s)
202: Symbol s;
203: {
204: Boolean b;
205: register Symbol t;
206:
207: switch (s->class) {
208: case VAR:
209: case FVAR:
210: if (isparam(s)) {
211: b = false;
212: } else {
213: t = rtype(s->type);
214: if (t == nil) {
215: b = false;
216: } else {
217: switch (t->class) {
218: case FILET:
219: case SET:
220: case BADUSE:
221: b = false;
222: break;
223:
224: default:
225: b = true;
226: break;
227: }
228: }
229: }
230: break;
231:
232: default:
233: b = false;
234: break;
235: }
236: return b;
237: }
238:
239: /*
240: * Print out a parameter value.
241: *
242: * Since this is intended to be printed on a single line with other information
243: * aggregate values are not printed.
244: */
245:
246: public printparamv (p, frame)
247: Symbol p;
248: Frame frame;
249: {
250: Symbol t;
251:
252: t = rtype(p->type);
253: switch (t->class) {
254: case ARRAY:
255: case DYNARRAY:
256: case SUBARRAY:
257: t = rtype(t->type);
258: if (compatible(t, t_char)) {
259: printv(p, frame);
260: } else {
261: printf("%s = (...)", symname(p));
262: }
263: break;
264:
265: case RECORD:
266: printf("%s = (...)", symname(p));
267: break;
268:
269: default:
270: printv(p, frame);
271: break;
272: }
273: }
274:
275: /*
276: * Print the name and value of a variable.
277: */
278:
279: public printv(s, frame)
280: Symbol s;
281: Frame frame;
282: {
283: Address addr;
284: int len;
285:
286: if (isambiguous(s) and ismodule(container(s))) {
287: printname(stdout, s);
288: printf(" = ");
289: } else {
290: printf("%s = ", symname(s));
291: }
292: if (isvarparam(s) and not isopenarray(s)) {
293: rpush(address(s, frame), sizeof(Address));
294: addr = pop(Address);
295: } else {
296: addr = address(s, frame);
297: }
298: len = size(s);
299: if (not canpush(len)) {
300: printf("*** expression too large ***");
301: } else if (isreg(s)) {
302: push(Address, addr);
303: printval(s->type);
304: } else {
305: rpush(addr, len);
306: printval(s->type);
307: }
308: }
309:
310: /*
311: * Print out the name of a symbol.
312: */
313:
314: public printname(f, s)
315: File f;
316: Symbol s;
317: {
318: if (s == nil) {
319: fprintf(f, "(noname)");
320: } else if (s == program) {
321: fprintf(f, ".");
322: } else if (isredirected() or isambiguous(s)) {
323: printwhich(f, s);
324: } else {
325: fprintf(f, "%s", symname(s));
326: }
327: }
328:
329: /*
330: * Print the fully specified variable that is described by the given identifer.
331: */
332:
333: public printwhich(f, s)
334: File f;
335: Symbol s;
336: {
337: printouter(f, container(s));
338: fprintf(f, "%s", symname(s));
339: }
340:
341: /*
342: * Print the fully qualified name of each symbol that has the same name
343: * as the given symbol.
344: */
345:
346: public printwhereis(f, s)
347: File f;
348: Symbol s;
349: {
350: register Name n;
351: register Symbol t;
352:
353: checkref(s);
354: n = s->name;
355: t = lookup(n);
356: printwhich(f, t);
357: t = t->next_sym;
358: while (t != nil) {
359: if (t->name == n) {
360: putc(' ', f);
361: printwhich(f, t);
362: }
363: t = t->next_sym;
364: }
365: putc('\n', f);
366: }
367:
368: private printouter(f, s)
369: File f;
370: Symbol s;
371: {
372: Symbol outer;
373:
374: if (s != nil) {
375: outer = container(s);
376: if (outer != nil and outer != program) {
377: printouter(f, outer);
378: }
379: fprintf(f, "%s.", symname(s));
380: }
381: }
382:
383: public printdecl(s)
384: Symbol s;
385: {
386: Language lang;
387:
388: checkref(s);
389: if (s->language == nil or s->language == primlang) {
390: lang = findlanguage(".s");
391: } else {
392: lang = s->language;
393: }
394: (*language_op(lang, L_PRINTDECL))(s);
395: }
396:
397: /*
398: * Straight dump of symbol information.
399: */
400:
401: public psym(s)
402: Symbol s;
403: {
404: printf("name\t%s\n", symname(s));
405: printf("lang\t%s\n", language_name(s->language));
406: printf("level\t%d\n", s->level);
407: printf("class\t%s\n", classname(s));
408: printf("type\t0x%x", s->type);
409: if (s->type != nil and s->type->name != nil) {
410: printf(" (%s)", symname(s->type));
411: }
412: printf("\nchain\t0x%x", s->chain);
413: if (s->chain != nil and s->chain->name != nil) {
414: printf(" (%s)", symname(s->chain));
415: }
416: printf("\nblock\t0x%x", s->block);
417: if (s->block->name != nil) {
418: printf(" (");
419: printname(stdout, s->block);
420: putchar(')');
421: }
422: putchar('\n');
423: switch (s->class) {
424: case TYPE:
425: printf("size\t%d\n", size(s));
426: break;
427:
428: case VAR:
429: case REF:
430: if (s->level >= 3) {
431: printf("address\t0x%x\n", s->symvalue.offset);
432: } else {
433: printf("offset\t%d\n", s->symvalue.offset);
434: }
435: printf("size\t%d\n", size(s));
436: break;
437:
438: case RECORD:
439: case VARNT:
440: printf("size\t%d\n", s->symvalue.offset);
441: break;
442:
443: case FIELD:
444: printf("offset\t%d\n", s->symvalue.field.offset);
445: printf("size\t%d\n", s->symvalue.field.length);
446: break;
447:
448: case PROG:
449: case PROC:
450: case FUNC:
451: printf("address\t0x%x\n", s->symvalue.funcv.beginaddr);
452: if (isinline(s)) {
453: printf("inline procedure\n");
454: }
455: if (nosource(s)) {
456: printf("does not have source information\n");
457: } else {
458: printf("has source information\n");
459: }
460: break;
461:
462: case RANGE:
463: prangetype(s->symvalue.rangev.lowertype);
464: printf("lower\t%d\n", s->symvalue.rangev.lower);
465: prangetype(s->symvalue.rangev.uppertype);
466: printf("upper\t%d\n", s->symvalue.rangev.upper);
467: break;
468:
469: default:
470: /* do nothing */
471: break;
472: }
473: }
474:
475: private prangetype(r)
476: Rangetype r;
477: {
478: switch (r) {
479: case R_CONST:
480: printf("CONST");
481: break;
482:
483: case R_ARG:
484: printf("ARG");
485: break;
486:
487: case R_TEMP:
488: printf("TEMP");
489: break;
490:
491: case R_ADJUST:
492: printf("ADJUST");
493: break;
494: }
495: }
496:
497: /*
498: * Print out the value on top of the stack according to the given type.
499: */
500:
501: public printval(t)
502: Symbol t;
503: {
504: Symbol s;
505:
506: checkref(t);
507: if (t->class == TYPEREF) {
508: resolveRef(t);
509: }
510: switch (t->class) {
511: case PROC:
512: case FUNC:
513: s = pop(Symbol);
514: printf("%s", symname(s));
515: break;
516:
517: default:
518: if (t->language == nil or t->language == primlang) {
519: (*language_op(findlanguage(".c"), L_PRINTVAL))(t);
520: } else {
521: (*language_op(t->language, L_PRINTVAL))(t);
522: }
523: break;
524: }
525: }
526:
527: /*
528: * Print out the value of a record, field by field.
529: */
530:
531: public printrecord(s)
532: Symbol s;
533: {
534: Symbol f;
535:
536: if (s->chain == nil) {
537: error("record has no fields");
538: }
539: printf("(");
540: sp -= size(s);
541: f = s->chain;
542: if (f != nil) {
543: for (;;) {
544: printfield(f);
545: f = f->chain;
546: if (f == nil) break;
547: printf(", ");
548: }
549: }
550: printf(")");
551: }
552:
553: /*
554: * Print out a field.
555: */
556:
557: private printfield(f)
558: Symbol f;
559: {
560: Stack *savesp;
561: register int off, len;
562:
563: printf("%s = ", symname(f));
564: savesp = sp;
565: off = f->symvalue.field.offset;
566: len = f->symvalue.field.length;
567: sp += ((off + len + BITSPERBYTE - 1) div BITSPERBYTE);
568: printval(f);
569: sp = savesp;
570: }
571:
572: /*
573: * Print out the contents of an array.
574: * Haven't quite figured out what the best format is.
575: *
576: * This is rather inefficient.
577: *
578: * The "2*elsize" is there since "printval" drops the stack by elsize.
579: */
580:
581: public printarray(a)
582: Symbol a;
583: {
584: Stack *savesp, *newsp;
585: Symbol eltype;
586: long elsize;
587: String sep;
588:
589: savesp = sp;
590: sp -= (size(a));
591: newsp = sp;
592: eltype = rtype(a->type);
593: elsize = size(eltype);
594: printf("(");
595: if (eltype->class == RECORD or eltype->class == ARRAY or
596: eltype->class == VARNT) {
597: sep = "\n";
598: putchar('\n');
599: } else {
600: sep = ", ";
601: }
602: for (sp += elsize; sp <= savesp; sp += 2*elsize) {
603: if (sp - elsize != newsp) {
604: fputs(sep, stdout);
605: }
606: printval(eltype);
607: }
608: sp = newsp;
609: if (streq(sep, "\n")) {
610: putchar('\n');
611: }
612: printf(")");
613: }
614:
615: /*
616: * Print out the value of a real number in Pascal notation.
617: * This is, unfortunately, different than what one gets
618: * from "%g" in printf.
619: */
620:
621: public prtreal(r)
622: double r;
623: {
624: extern char *index();
625: char buf[256];
626:
627: sprintf(buf, "%g", r);
628: if (buf[0] == '.') {
629: printf("0%s", buf);
630: } else if (buf[0] == '-' and buf[1] == '.') {
631: printf("-0%s", &buf[1]);
632: } else {
633: printf("%s", buf);
634: }
635: if (index(buf, '.') == nil) {
636: printf(".0");
637: }
638: }
639:
640: /*
641: * Print out a character using ^? notation for unprintables.
642: */
643:
644: public printchar(c)
645: char c;
646: {
647: if (c == 0) {
648: putchar('\\');
649: putchar('0');
650: } else if (c == '\n') {
651: putchar('\\');
652: putchar('n');
653: } else if (c > 0 and c < ' ') {
654: putchar('^');
655: putchar(c - 1 + 'A');
656: } else if (c >= ' ' && c <= '~') {
657: putchar(c);
658: } else {
659: printf("\\0%o",c);
660: }
661: }
662:
663: /*
664: * Print out a value for a range type (integer, char, or boolean).
665: */
666:
667: public printRangeVal (val, t)
668: long val;
669: Symbol t;
670: {
671: if (t == t_boolean->type or istypename(t->type, "boolean")) {
672: if ((boolean) val) {
673: printf("true");
674: } else {
675: printf("false");
676: }
677: } else if (t == t_char->type or istypename(t->type, "char")) {
678: if (varIsSet("$hexchars")) {
679: printf("0x%lx", val);
680: } else {
681: putchar('\'');
682: printchar(val);
683: putchar('\'');
684: }
685: } else if (varIsSet("$hexints")) {
686: printf("0x%lx", val);
687: } else if (t->symvalue.rangev.lower >= 0) {
688: printf("%lu", val);
689: } else {
690: printf("%ld", val);
691: }
692: }
693:
694: /*
695: * Print out an enumerated value by finding the corresponding
696: * name in the enumeration list.
697: */
698:
699: public printEnum (i, t)
700: integer i;
701: Symbol t;
702: {
703: register Symbol e;
704:
705: e = t->chain;
706: while (e != nil and e->symvalue.constval->value.lcon != i) {
707: e = e->chain;
708: }
709: if (e != nil) {
710: printf("%s", symname(e));
711: } else {
712: printf("%d", i);
713: }
714: }
715:
716: /*
717: * Print out a null-terminated string (pointer to char)
718: * starting at the given address.
719: */
720:
721: public printString (addr, quotes)
722: Address addr;
723: boolean quotes;
724: {
725: register Address a;
726: register integer i, len;
727: register boolean endofstring;
728: union {
729: char ch[sizeof(Word)];
730: int word;
731: } u;
732:
733: if (varIsSet("$hexstrings")) {
734: printf("0x%x", addr);
735: } else {
736: if (quotes) {
737: putchar('"');
738: }
739: a = addr;
740: endofstring = false;
741: while (not endofstring) {
742: dread(&u, a, sizeof(u));
743: i = 0;
744: do {
745: if (u.ch[i] == '\0') {
746: endofstring = true;
747: } else {
748: printchar(u.ch[i]);
749: }
750: ++i;
751: } while (i < sizeof(Word) and not endofstring);
752: a += sizeof(Word);
753: }
754: if (quotes) {
755: putchar('"');
756: }
757: }
758: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.