![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dump_tree.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to dump_tree.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /* -*- Mode:C++ -*- */
2: /* dump_tree.C -- utilities for displaying the cfront tree. */
3: /* BIM 890530 */
4: /* rewritten 890712 to use the tree-walking facilities */
5:
6: /*
7: $Source: /usr3/lang/benson/work/stripped_cfront/RCS/dump_tree.c,v $ $RCSfile: dump_tree.c,v $
8: $Revision: 1.1 $ $Date: 89/11/20 08:50:22 $
9: $Author: benson $ $Locker: $
10: $State: Exp $
11:
12:
13: */
14:
15:
16: #include "dump_tree.H"
17: #include <stdio.h> /* turds and whey */
18: #include <malloc.h>
19: #include "template.h"
20: #include "token_names.H"
21:
22: const int Indent_Increment = 4;
23: static char badnamebuf[100];
24:
25: char *
26: token_name(TOK t)
27: {
28: char * bnb = badnamebuf;
29:
30: if((int) t == -1) return "-1";
31: if(t > DUMMY_LAST_NODE) {
32: bad:
33: printf_to_string(bnb, sizeof(badnamebuf),
34: "<unknown token %d>", (int) t);
35: return bnb;
36: }
37: int x;
38: for (x = 0; x < DUMMY_LAST_NODE; x++) {
39: if(token_names[x].val == t) return token_names[x].string;
40: }
41: goto bad;
42: }
43:
44: class displayer{
45: public:
46: dcn_arg * arg;
47: Pnode node;
48: Pnode node_address;
49: displayer (dcn_arg& d) { arg = &d; indent = 0; print_null_values = 0; };
50: void do_node (Pnode& node, node_class cl, tree_node_action& action, int depth, Pnode);
51: private:
52: enum ppc {print_ptr_copy = 0, print_ptr_copied = 1};
53: int indent;
54: int err;
55: int print_null_values;
56: void printf (const char *, ...);
57: void catprintf (const char *, ...);
58: void print_ptr (const char *, Pnode);
59: void print_ptr (Pnode, ppc = print_ptr_copy);
60: void minimal ();
61: void a_basetype ();
62: void a_basecl() ;
63: void a_type() ;
64: void a_node() ;
65: void a_name ();
66: void a_expr (int from_name = 0);
67: void a_fct ();
68: void a_stmt ();
69: void a_enumdef ();
70: void a_table();
71: void a_classdef ();
72: void a_gen ();
73: void a_vec ();
74: void a_ptr ();
75: void a_virt ();
76: void a_nlist ();
77: void a_iline ();
78: void a_elist ();
79: void a_ia ();
80: void a_by_name ();
81: void print_loc(loc&);
82: void * display_address () { return node_address; }
83: void fetch (void * addr, unsigned long length, void *& taddr);
84: void fetch_string (void * addr, unsigned long length, void *& taddr);
85: void free_fetched(void *);
86: void flag (int, const char *);
87: void print_string (const char *, void *);
88: void print_string_brief (void *);
89: void null_field (const char *);
90: void nz_printf(const char *format, const int i) ;
91: void nz_printf(const char *format, const char *p) ;
92: void nz_printf(const char *format, const long l) ;
93: void ind();
94: };
95:
96: const char many_spaces[] = " ";
97:
98: inline void
99: displayer::ind()
100: {
101: arg->output_stream->write(many_spaces, indent);
102: }
103:
104: /* call me for full lines */
105:
106: void
107: displayer::printf (const char * format, ...)
108: {
109: va_list args;
110: va_start(args, format);
111:
112: ind();
113: vostream_printf (format, args, *arg->output_stream);
114: arg->output_stream->write("\n", 1);
115: va_end (args);
116: }
117:
118: void
119: displayer::catprintf (const char * format, ...)
120: {
121: va_list args;
122: va_start(args, format);
123:
124: vostream_printf (format, args, *arg->output_stream);
125: va_end (args);
126: }
127:
128: void
129: displayer::minimal ()
130: {
131: print_ptr(node, print_ptr_copied);
132: }
133:
134: void
135: displayer::print_ptr(const char * label, Pnode node)
136: {
137: if(node || print_null_values) {
138: ind();
139: catprintf("%s:\t", label);
140: print_ptr(node);
141: catprintf("\n");
142: }
143: }
144:
145:
146: void
147: displayer::print_ptr(Pnode node, ppc copy_ptr)
148: {
149: void * string = 0;
150: void * ncopy;
151: void * na = (void *)node;
152:
153: if(node) {
154:
155: if(copy_ptr == print_ptr_copy) {
156: fetch(na, sizeof(node), ncopy);
157: node = Pnode(ncopy);
158: } else ncopy = node;
159:
160: switch(node->base) {
161: case CLASS:
162: free_fetched(ncopy);
163: fetch(na, sizeof(classdef),ncopy);
164: node = Pnode(ncopy);
165: string = Pclass(node)->string;
166: break;
167: case ENUM:
168: free_fetched(ncopy);
169: fetch(na, sizeof(enumdef),ncopy);
170: node = Pnode(ncopy);
171: string = Penum(node)->string;
172: break;
173: case NAME:
174: case TNAME:
175: case PUBLIC:
176: case PROTECTED:
177: if(!node->baseclass) {
178: free_fetched(ncopy);
179: fetch(na, sizeof(name),ncopy);
180: node = Pnode(ncopy);
181: string = Pname(node)->string;
182: }
183: break;
184: }
185: if(string) {
186: catprintf("<%s |0x%p ", token_name(node->base), na);
187: print_string_brief(string);
188: catprintf(">");
189: }
190: else catprintf("<%s |0x%p>", token_name(node->base), na);
191: free_fetched (ncopy);
192: }
193: else catprintf("Null");
194: }
195:
196: void
197: displayer::do_node (Pnode& n, node_class cl, tree_node_action& action,
198: int depth, Pnode na)
199: {
200: int forced_min = 0;
201: int printed_min = 0;
202: int prune = 0;
203:
204: switch(cl) {
205: case nc_table:
206: if(depth > 0 && !arg->walk_tables)prune = 1;
207: case nc_fct:
208: case nc_classdef:
209: case nc_enumdef:
210: if(arg->stop_at_top && depth > 1) prune = 1;
211: break;
212: }
213:
214: if((arg->max_depth > 0) && (depth >= arg->max_depth))
215: prune = 1;
216:
217: if(prune || arg->max_depth == 0)
218: action = tna_stop;
219: else action = tna_continue;
220:
221: node = n;
222: node_address = na;
223:
224: if(arg->verbose == dt_brief || prune) {
225: printed_min = 1;
226: minimal();
227: }
228: else {
229: switch(cl)
230: {
231: default:
232: case nc_unused:
233: ostream_printf(*arg->error_stream, "Unknown node %d\n", node->base);
234: forced_min = 1;
235:
236: case nc_eof:
237: minimal();
238: printed_min = 1;
239: break;
240:
241: case nc_virt:
242: a_virt ();
243: break;
244:
245: case nc_nlist:
246: a_nlist();
247: break;
248:
249: case nc_gen:
250: a_gen();
251: break;
252:
253: case nc_vec:
254: a_vec();
255: break;
256:
257: case nc_ptr:
258: a_ptr();
259: break;
260:
261: case nc_fct:
262: a_fct();
263: break;
264:
265: case nc_table:
266: a_table();
267: break;
268:
269: case nc_basetype:
270: a_basetype();
271: break;
272:
273: case nc_name:
274: a_name();
275: break;
276:
277: case nc_expr:
278: a_expr();
279: break;
280:
281: case nc_stmt:
282: a_stmt();
283: break;
284:
285: case nc_enumdef:
286: a_enumdef();
287: break;
288:
289: case nc_classdef:
290: a_classdef();
291: break;
292:
293: case nc_baseclass:
294: a_basecl ();
295: break;
296:
297: case nc_iline:
298: a_iline();
299: break;
300:
301: case nc_ia:
302: a_ia();
303: break;
304:
305: }
306: if(printed_min) catprintf(">");
307: }
308: }
309:
310:
311: void
312: displayer::flag(int f, const char * n)
313: {
314: if(f)catprintf("%s", n);
315: }
316:
317: void
318: displayer::free_fetched (void * addr)
319: {
320: if (arg->fetcher != null_tfp) /* not in the same address space. */
321: free ((char *)addr);
322: }
323:
324:
325: void
326: displayer::fetch (void * addr, unsigned long length, void *& taddr)
327: {
328: if (arg->fetcher == null_tfp) { /* in the same address space. */
329: taddr = addr;
330: err = 0;
331: } else {
332: taddr = (void *)malloc ((unsigned int)length);
333: err = arg->fetcher (arg->fetcher_info,
334: addr,
335: length,
336: 0,
337: taddr);
338: }
339: }
340:
341: void
342: displayer::fetch_string (void * addr, unsigned long length, void *& taddr)
343: {
344: if (arg->fetcher == null_tfp) { /* in the same address space. */
345: taddr = addr;
346: err = 0;
347: } else {
348: taddr = (void *)malloc ((unsigned int)length);
349: err = arg->fetcher (arg->fetcher_info,
350: addr,
351: length,
352: 1,
353: taddr);
354: }
355: }
356:
357: /* Print the field, only if it has a non_zero value, or requested to print */
358: /* always */
359: void
360: displayer::nz_printf(const char *format, const int i)
361: {
362: if (i || print_null_values) {
363: printf(format, i) ;
364: }
365: }
366:
367: void
368: displayer::nz_printf(const char *format, const char *p)
369: {
370: if (p || print_null_values) {
371: printf(format, (p ? p : "0")) ;
372: }
373: }
374:
375:
376: void
377: displayer::nz_printf(const char *format, const long i)
378: {
379: if (i || print_null_values) {
380: printf(format, i) ;
381: }
382: }
383:
384: void
385: displayer::a_node()
386: {
387: struct node &n = *node ;
388:
389: nz_printf("$node", (n.n_key || n.permanent)) ;
390: nz_printf("n_key:\t%d", (int)n.n_key) ;
391: nz_printf("permanent:\t%d", n.permanent) ;
392: nz_printf("baseclass:\t%d", n.baseclass) ;
393: }
394:
395:
396:
397: void
398: displayer::a_type()
399: {
400: struct type& t = *Ptype(node);
401: int show_up = t.defined || t.inline_temp_index != 0;
402:
403: if(show_up) {
404: printf("$type") ;
405: nz_printf("defined:\t%d", t.defined) ;
406: nz_printf("inline_temp_index:\t%d", t.inline_temp_index);
407: indent += Indent_Increment;
408: }
409: a_node();
410: if(show_up) indent -= Indent_Increment;
411: }
412:
413:
414:
415:
416:
417: void
418: displayer::null_field(const char * name)
419: {
420: nz_printf( "%s:\t0", name);
421: }
422:
423:
424: void
425: displayer::a_basecl()
426: {
427: struct basecl& bc = *Pbcl(node);
428:
429: printf("$basecl %s |0x%p",
430: token_name(node->base),
431: node_address);
432:
433: nz_printf ("ppp:\t%s", token_name(bc.ppp)) ;
434: nz_printf ("allocated:\t%d", bc.allocated) ;
435: nz_printf ("promoted:\t%d", bc.promoted) ;
436: print_ptr("bclass", bc.bclass);
437: nz_printf ("ptr_offset:\t%d", bc.ptr_offset) ;
438: nz_printf ("obj_offset:\t%d", bc.obj_offset) ;
439: indent += Indent_Increment;
440: a_node(); /* do the supertype. */
441: indent -= Indent_Increment;
442: }
443:
444:
445:
446:
447: void
448: displayer::a_basetype ()
449: {
450: struct basetype& bt = *Pbase(node);
451:
452: printf("$basetype %s |0x%p",
453: token_name(node->base),
454: node_address);
455:
456: ind();
457: catprintf("Flags:\t");
458: flag(bt.b_unsigned, "unsigned ");
459: flag(bt.b_signed, "signed ");
460: flag(bt.b_volatile, "volatile ");
461: flag(bt.b_const, "const ");
462: flag(bt.b_typedef, "typedef ");
463: flag(bt.b_virtual, "virtual ");
464: flag(bt.b_short, "short ");
465: flag(bt.b_long, "long ");
466: catprintf("\n");
467: nz_printf( "b_bits:\t%d", bt.b_bits);
468: nz_printf( "b_offset:\t%d", bt.b_offset);
469: nz_printf( "b_sto:\t%s", bt.b_sto ? token_name(bt.b_sto) : 0);
470: switch(bt.discriminator(0)) {
471: case 1:
472: print_ptr("b_fieldtype", bt.b_fieldtype);
473: break;
474: case 2:
475: nz_printf( "b_linkage:\t%s", bt.b_linkage ? "C" : "0(C++)");
476: }
477:
478: print_ptr("b_name", bt.b_name);
479: print_ptr("b_table", bt.b_table);
480: print_ptr("b_field", bt.b_field);
481: print_ptr("b_xname", bt.b_xname);
482:
483: indent += Indent_Increment;
484: a_type(); /* do the supertype. */
485: indent -= Indent_Increment;
486:
487: }
488:
489: void
490: displayer::print_loc(loc& loc)
491: {
492: catprintf("file %d line %d", (int)loc.file, (int)loc.line);
493: }
494:
495:
496: void
497: displayer::print_string_brief(void * addr)
498: {
499: void * tmp;
500:
501: fetch_string (addr, 1000, tmp);
502: *arg->output_stream << (char *)tmp;
503: free_fetched (tmp);
504: }
505:
506: void
507: displayer::print_string(const char * label, void * addr)
508: {
509: ind();
510: catprintf("%s:\t", label);
511: print_string_brief(addr);
512: *arg->output_stream << "\n";
513: }
514:
515: void
516: displayer::a_expr(int from_name)
517: {
518: struct expr& e = *Pexpr(node);
519:
520: if(from_name) printf("$expr");
521: else printf("$expr %s |0x%p",
522: token_name(node->base),
523: node_address);
524:
525: print_ptr("tp", e.tp);
526:
527: switch(e.discriminator(1)) {
528: case 0: break;
529: case 1:
530: print_ptr("e1", e.e1);
531: break;
532: case 2:
533: printf("i1:\t%ld", e.i1);
534: break;
535: case 3:
536: print_string("string", (void *)e.string);
537: }
538:
539: switch(e.discriminator(2)) {
540: case 0: break;
541: case 1:
542: print_ptr("e2", e.e2);
543: break;
544: case 2:
545: printf("i2:\t%ld", e.i2);
546: break;
547: case 3:
548: print_string("string2", (void *)e.string2);
549: break;
550: case 4:
551: print_ptr("n_initializer", e.n_initializer);
552: }
553:
554: switch(e.discriminator(3)) {
555: case 0:
556: break;
557: case 1: print_ptr ("tp2", e.tp2); break;
558: case 2: print_ptr ("fct_name", e.fct_name); break;
559: case 3: print_ptr ("cond", e.cond); break;
560: case 4: print_ptr ("mem", e.mem); break;
561: case 5: print_ptr ("as_type", e.as_type); break;
562: case 6: print_ptr ("n_table", e.n_table); break;
563: case 7: print_ptr ("il", e.il); break;
564: case 8: print_ptr ("query_this", e.query_this); break;
565: }
566:
567: indent += Indent_Increment;
568: a_node();
569: indent -= Indent_Increment;
570:
571: }
572:
573: void
574: displayer::a_name()
575: {
576: struct name& n = *Pname(node);
577:
578:
579: ind();
580: catprintf("$name %s |0x%p ",
581: token_name(node->base),
582: node_address);
583: print_string_brief((void *)n.string);
584: *arg->output_stream << "\n";
585:
586: nz_printf( "n_oper:\t\t%s", n.n_oper ?
587: token_name(n.n_oper) : 0);
588: nz_printf( "n_sto:\t\t%s", n.n_sto ?
589: token_name(n.n_sto) : 0);
590: nz_printf( "n_stclass:\t%s", n.n_stclass ?
591: token_name(n.n_stclass) : 0);
592: nz_printf( "n_scope:\t%s", n.n_scope ?
593: token_name(n.n_scope) : 0);
594: nz_printf( "n_union:\t%d", n.n_union);
595: nz_printf( "n_evaluated:\t%d", n.n_evaluated);
596: nz_printf( "n_xref:\t\t%d", n.n_xref);
597: nz_printf( "lex_level:\t%d", n.lex_level);
598: nz_printf( "n_protect:\t%s", n.n_protect ?
599: token_name(n.n_protect) : 0);
600: if (n.n_dcl_printed || print_null_values) {
601: ind();
602: catprintf("n_dcl_printed:\t%d", n.n_dcl_printed);
603:
604: switch(n.n_dcl_printed)
605: {
606: case 0:
607: catprintf("(not)\n");
608: break;
609: case 1:
610: printf("(declaration)\n");
611: break;
612: case 2:
613: printf("(definition)\n");
614: break;
615: }
616:
617: }
618: if(n.n_template_arg) {
619: ind();
620: catprintf( "n_template_arg:\t");
621: switch(n.n_template_arg)
622: {
623: case name::template_type_formal:
624: catprintf("template_type_formal\n");
625: break;
626: case name::template_expr_formal:
627: catprintf("template_expr_formal\n");
628: break;
629: case name::template_stmt_tree_formal:
630: catprintf("template_stmt_formal\n");
631: break;
632: case name::template_expr_tree_formal:
633: catprintf("template_expr_tree_formal\n");
634: break;
635: case name::template_actual_arg_dummy:
636: catprintf("template_actual_arg_dummy\n");
637: break;
638: } ;
639: }
640: nz_printf( "n_addr_taken:\t%d", n.n_addr_taken);
641: nz_printf( "n_used:\t\t%d", n.n_used);
642: nz_printf( "n_assigned_to:\t%d", n.n_assigned_to);
643: ind();
644: catprintf("loc:\t\t");
645: print_loc(n.where);
646: catprintf("\n");
647: nz_printf( "n_offset:\t%d", n.n_offset);
648: if(n.output_string) {
649: print_string("output_string", (void *)n.output_string);
650: }
651: nz_printf( "n_val:\t\t%ld", n.n_val);
652:
653: print_ptr("n_list", n.n_list);
654: print_ptr("n_tbl_list", n.n_tbl_list);
655: if(n.n_gen_fct_name)
656: print_string("n_gen_fct_name", n.n_gen_fct_name);
657: if(n.n_template_arg_string) {
658: print_string("n_template_arg_string",
659: n.n_template_arg_string);
660: }
661: switch(n.discriminator(0)) {
662: case 2: print_ptr("n_realscope", n.n_realscope); break;
663: case 1: print_ptr("n_qualifier", n.n_qualifier); break;
664: }
665: nz_printf("n_val:\t%ld", n.n_val);
666:
667: indent += Indent_Increment;
668: a_expr(1); /* do the supertype. */
669: indent -= Indent_Increment;
670: }
671:
672: void
673: displayer::a_fct()
674: {
675: struct fct& f = *Pfct(node);
676:
677: printf("$fct %s |0x%p",
678: token_name(node->base),
679: node_address);
680:
681:
682: printf("nargs:\t\t%d", f.nargs);
683: printf("nargs_known:\t%d%s", f.nargs_known,
684: f.nargs_known == 0 ? " UNKNOWN" :
685: (f.nargs_known == 1 ? " KNOWN" :
686: (f.nargs_known == ELLIPSIS ? "ELLIPSIS" : "" )));
687: nz_printf( "f_vdef:\t\t%d", f.f_vdef);
688: printf("f_inline:\t%d%s", f.f_inline,
689: f.f_inline == 0 ? "" :
690: f.f_inline == 1 ? " inline" :
691: f.f_inline == 2 ? " inline in expansion" : "");
692: nz_printf( "f_const:\t\t%d", f.f_const);
693: nz_printf( "f_static:\t\t%d", f.f_static);
694: nz_printf( "f_virtual:\t%d", f.f_virtual);
695: nz_printf( "f_imeasure:\t%d", f.f_imeasure);
696: print_string("f_signature", (void *)f.f_signature);
697:
698: print_ptr("returns", f.returns);
699: print_ptr("argtype", f.argtype);
700: print_ptr("s_returns", f.s_returns);
701: print_ptr("f_this", f.f_this);
702: print_ptr("memof", f.memof);
703: print_ptr("body", f.body);
704: print_ptr("f_init", f.f_init);
705: print_ptr("f_expr", f.f_expr);
706: print_ptr("last_expanded", f.last_expanded);
707: print_ptr("f_result", f.f_result);
708: print_ptr("f_args", f.f_args);
709: print_ptr("local_classes", f.local_class);
710:
711: indent += Indent_Increment;
712: a_type(); /* do the supertype. */
713: indent -= Indent_Increment;
714: }
715:
716: void
717: displayer::a_stmt ()
718: {
719: struct stmt& s = *Pstmt(node);
720:
721: ind();
722: catprintf("$stmt %s |0x%p ",
723: token_name(node->base),
724: node_address);
725: print_loc(s.where);
726: *arg->output_stream << "\n";
727:
728: ind();
729: *arg->output_stream << "where:\t";
730: print_loc(s.where);
731: *arg->output_stream << "\n";
732:
733: print_ptr("s", s.s);
734: print_ptr("s_list", s.s_list);
735: print_ptr("memtbl", s.memtbl);
736: switch(s.discriminator(0)) {
737: case 1: print_ptr("d", s.d); break;
738: case 2: print_ptr("e2", s.e2); break;
739: case 3: print_ptr("has_default", s.has_default); break;
740: case 4: nz_printf("case_value:\t0x%x", s.case_value);
741: case 5: print_ptr("ret_tp", s.ret_tp); break;
742: }
743: switch(s.discriminator(1)) {
744: case 1: print_ptr("e", s.e); break;
745: case 2: nz_printf("own_tbl:\t%d", s.own_tbl); break;
746: case 3: print_ptr("s2", s.s2); break;
747: }
748:
749: switch(s.discriminator(2)) {
750: case 1: print_ptr("for_init", s.for_init); break;
751: case 2: print_ptr("else_stmt",s.for_init); break;
752: case 3: print_ptr("case_list", s.case_list); break;
753: }
754: }
755:
756: void
757: displayer::a_enumdef ()
758: {
759: struct enumdef& e = *Penum(node);
760:
761: printf("$enumdef %s |0x%p",
762: token_name(node->base),
763: node_address);
764:
765: nz_printf( "e_body:\t\t%d", e.e_body);
766: nz_printf( "no_of_enumerators: %d",
767: e.no_of_enumerators);
768: nz_printf( "strlen:\t%d", e.strlen);
769: print_string ("string", (void *)e.string);
770:
771: print_ptr("mem", e.mem);
772: print_ptr("e_type", e.e_type);
773: indent += Indent_Increment;
774: a_type(); /* do the supertype. */
775: indent -= Indent_Increment;
776: }
777:
778: void
779: displayer::a_classdef ()
780: {
781: struct classdef& c = *Pclass(node);
782:
783: ind();
784: catprintf("$classdef %s |0x%p ",
785: token_name(node->base),
786: node_address);
787: print_string_brief(c.string);
788: *arg->output_stream << "\n";
789: ind();
790: catprintf("class_base:\t");
791: switch(c.class_base)
792: {
793: case vanilla_class:
794: *arg->output_stream << "vanilla_class\n";
795: break;
796: case template_class:
797: *arg->output_stream << "template_class\n";
798: Template_Class:
799: nz_printf("inst:\t\t%p", (int)Ptclass(&c)->inst);
800: break;
801: case instantiated_template_class:
802: *arg->output_stream << "instantiated_template_class\n";
803: goto Template_Class;
804: case uninstantiated_template_class:
805: *arg->output_stream << "uninstantiated_template_class\n";
806: goto Template_Class;
807: case relationship_class:
808: *arg->output_stream << "relationship_class\n";
809: break;
810: case defining_class:
811: *arg->output_stream << "defining_class\n";
812: break;
813: }
814:
815: nz_printf( "c_body:\t\t%d", c.c_body);
816: printf("csu:\t\t%s",
817: token_name(c.csu));
818: nz_printf( "obj_align:\t%d", c.obj_align);
819: if(c.c_xref) {
820: ind();
821: catprintf( "c_xref:\t%x", c.c_xref);
822: flag(c.c_xref & 1, "has-vptr ");
823: flag(c.c_xref & 2, "X(X&)-defined ");
824: flag(c.c_xref & 4, "operator=(X&)-defined ");
825: flag(c.c_xref & 8, "has-vbaseptr(s) ");
826: *arg->output_stream << "\n";
827: }
828: nz_printf( "virt_count:\t%d", c.virt_count);
829: nz_printf( "virt_merge:\t%d", c.virt_merge);
830: nz_printf( "c_abstract:\t%d", c.c_abstract);
831: nz_printf( "has_vvtab:\t%d", c.has_vvtab);
832: nz_printf( "strlen:\t%d", c.strlen);
833: print_string ("string", (void *)c.string);
834: nz_printf( "obj_size:\t%d", c.obj_size);
835: nz_printf( "real_size:\t%d", c.real_size);
836: nz_printf("lex_level:\t%d", c.lex_level);
837: if(c.lcl)print_string("lcl", c.lcl);
838:
839: print_ptr("baselist", c.baselist);
840: print_ptr("mem_list", c.mem_list);
841: print_ptr("memtbl", c.memtbl);
842: print_ptr("friend_list", c.friend_list);
843: print_ptr("pubdef", c.pubdef);
844: print_ptr("tn_list", c.tn_list); /* not brief */
845: print_ptr("in_class", c.in_class);
846: print_ptr("in_fct", c.in_fct);
847: print_ptr("this_type", c.this_type);
848: print_ptr("virt_list", c.virt_list);
849: print_ptr("c_ctor", c.c_ctor);
850: print_ptr("c_dtor", c.c_dtor);
851: print_ptr("c_itor", c.c_itor);
852: print_ptr("conv", c.conv);
853: indent += Indent_Increment;
854: a_type(); /* do the supertype. */
855: indent -= Indent_Increment;
856: }
857:
858:
859: void
860: displayer::a_virt()
861: {
862: virt& v = *Pvirt(node);
863: void * vna;
864: void * vna_e;
865: int vx;
866:
867: printf("$virt %s |0x%p ",
868: token_name(node->base),
869: node_address);
870:
871: print_ptr("next", v.next);
872: if(v.n_init) {
873: printf("n_init:\t%d", v.n_init);
874: printf("virt_init:");
875: for (vna = v.virt_init, vx = 0; vx < (v.n_init - 1);
876: vna = (char *)vna + sizeof (velem), vx++)
877: {
878: fetch(vna, sizeof (velem), vna_e);
879: struct velem * ve = (struct velem *) vna_e;
880: ind();
881: catprintf("%d offset %d\t", vx, ve->offset);
882: print_ptr(ve->n);
883: free_fetched(vna_e);
884: }
885: }
886: print_ptr("vclass", v.vclass);
887: nz_printf( "\nis_vbase:\t %d", v.is_vbase);
888: nz_printf( "\nprinted:\t %d", v.printed);
889: }
890:
891: void
892: displayer::a_table ()
893: {
894: struct table& t = *Ptable(node);
895: int x;
896: int y;
897: void * nlist;
898: void * slist;
899:
900: printf("$table %s |0x%p",
901: token_name(node->base),
902: node_address);
903:
904: printf("init_stat:\t%d%s", t.init_stat,
905: t.init_stat == 0 ? " not simplified" :
906: t.init_stat == 1 ? " simplified, no inits" :
907: t.init_stat == 2 ? " simplified, inits" :
908: "");
909: printf("size:\t%d", t.size);
910: printf("hashsize:\t%d", t.hashsize);
911: printf("free_slot:\t%d", t.free_slot);
912:
913: /* it looks like there is an array of Pnames here ... */
914: *arg->output_stream << "\n";
915: ind();
916: *arg->output_stream << "entries:\n";
917: fetch((void *)t.entries, t.size * sizeof(Pname), nlist);
918: Pname * tmp_nlist = (Pname *)nlist;
919: for(x = 0; x < t.size; x ++) {
920: if(tmp_nlist[x]) {
921: ind();
922: *arg->output_stream << x;
923: *arg->output_stream << "\t";
924: print_ptr(tmp_nlist[x]);
925: unsigned char tmp_name_s[sizeof(name)];
926: void * tmp_name;
927: tmp_name = (void *)&tmp_name_s[0];
928: fetch(tmp_nlist[x], sizeof(name), tmp_name);
929: catprintf(" key %d\n", Pname(tmp_name)->n_key);
930: }
931: }
932: free_fetched(nlist);
933: /* and then an array of shorts for the hash table. */
934: /* we really need a tabular format here, alright. */
935: ind();
936: *arg->output_stream << "hashtbl:\n";
937: fetch(t.hashtbl, t.hashsize * sizeof(short), slist);
938: short * tmp_slist = (short *)slist;
939: for(x = 0;; x++ ) {
940: for (y = 0; y < 11; y ++) {
941: if(((x * 12) + y) > t.hashsize) break;
942: catprintf("%6d ", tmp_slist[(x*12)+y]);
943: }
944: *arg->output_stream << "\n";
945: if(((x * 12) + y) > t.hashsize) break;
946: }
947:
948: free_fetched (slist);
949:
950: print_ptr("t_name", t.t_name);
951: print_ptr("real_block", t.real_block);
952: print_ptr("name", t.t_name);
953: print_ptr("next", t.next);
954: }
955:
956: void
957: displayer::a_gen ()
958: {
959: struct gen& g = *Pgen(node);
960:
961: printf("$gen %s |0x%p",
962: token_name(node->base),
963: node_address);
964:
965: print_ptr ("fct_list", g.fct_list);
966: indent += Indent_Increment;
967: a_type(); /* do the supertype. */
968: indent -= Indent_Increment;
969: }
970:
971: void
972: displayer::a_vec ()
973: {
974: struct vec& v = *Pvec(node);
975:
976: printf("$vec %s |0x%p",
977: token_name(node->base),
978: node_address);
979: printf("size:\t\t%d", v.size);
980: print_ptr ("typ", v.typ);
981: print_ptr ("dim", v.dim);
982: }
983:
984: void
985: displayer::a_ptr ()
986: {
987: struct ptr& p = *Pptr(node);
988:
989: printf("$ptr %s |0x%p",
990: token_name(node->base),
991: node_address);
992: ind();
993: printf("rdo:\t\t%d", p.rdo);
994: ind();
995:
996: print_ptr ("typ", p.typ);
997: print_ptr ("memof", p.memof);
998: }
999:
1000:
1001: void
1002: displayer::a_nlist()
1003: {
1004: name_list& n = *Plist(node);
1005:
1006: printf("$name_list %s |0x%p ",
1007: token_name(node->base),
1008: node_address);
1009:
1010: print_ptr("f", n.f);
1011: print_ptr("l", n.l);
1012: }
1013:
1014: void
1015: displayer::a_iline()
1016: {
1017: struct iline& i = *(struct iline *)node;
1018:
1019: printf("$iline %s |0x%p ",
1020: token_name(node->base),
1021: node_address);
1022:
1023: print_ptr("fct_name", i.fct_name);
1024: print_ptr("i_next", i.i_next);
1025: print_ptr("i_table", i.i_table);
1026: nz_printf("i_slots:\t%d", i.i_slots);
1027: print_ptr("i_args", i.i_args);
1028: }
1029:
1030: void
1031: displayer::a_ia()
1032: {
1033: struct ia& i = *(struct ia *)node;
1034:
1035: printf("$ia %s |0x%p ",
1036: token_name(node->base),
1037: node_address);
1038:
1039: print_ptr("local", i.local);
1040: print_ptr("arg", i.arg);
1041: print_ptr("tp", i.tp);
1042: }
1043:
1044: static int fetcher (void * info,
1045: void * pointer,
1046: unsigned long length,
1047: int zero_stop, /* for character strings.*/
1048: void * target)
1049: {
1050: displayer * d = (displayer *)info;
1051: if(d->arg->fetcher)
1052: return d->arg->fetcher(d->arg->fetcher_info, pointer, length,
1053: zero_stop, target);
1054: }
1055:
1056: static void
1057: do_node (Pnode& node, node_class cl, void * info, tree_node_action& action,
1058: int depth, Pnode na, tree_walk_tree&, int&)
1059: {
1060: displayer * d = (displayer *)info;
1061: d->do_node(node, cl, action, depth, na);
1062: d->arg->output_stream->write("\n", 1);
1063: }
1064:
1065:
1066: /* Note -- declared extern "C" in dump_tree.H. */
1067:
1068: void
1069: display_cfront_node (dcn_arg& arg, Pnode n)
1070: {
1071: tree_walk_control twc;
1072: displayer d (arg);
1073:
1074: if(arg.verbose == dt_normal)arg.max_depth = 0;
1075: twc.callback_info = (void *)&d;
1076: if(arg.fetcher) twc.fetcher = fetcher;
1077: twc.action_proc = do_node;
1078: twc.error_stream = arg.error_stream;
1079: twc.nodes_seen_hash = arg.nodes_seen_hash;
1080: twc.resolve_by_name = 0; /* we want to display the by_name nodes */
1081: twc.dont_chase_lists_top = 1; /* don't display n_list or s_list peers
1082: at the top level. */
1083:
1084: walk_tree(twc, n);
1085:
1086: arg.error_stream->flush();
1087: arg.output_stream->flush();
1088: }
1089:
1090:
1091: extern "C" void _fcout();
1092:
1093: void _fcout () { cout.flush(); }
1094:
1095: static char rcsinfo[] = "$Header: /usr3/lang/benson/work/stripped_cfront/RCS/dump_tree.c,v 1.1 89/11/20 08:50:22 benson Exp $";
1096:
1097:
1098: /* $Log: dump_tree.c,v $
1099: * Revision 1.1 89/11/20 08:50:22 benson
1100: * Initial revision
1101: *
1102: Revision 1.32 89/11/03 16:18:32 benson
1103: mind rot.
1104:
1105: Revision 1.31 89/11/03 16:10:04 benson
1106: Oh, don't try to use the name constructor inside dgb.
1107:
1108: Revision 1.30 89/11/03 15:28:39 benson
1109: fix cn for tables.
1110:
1111: Revision 1.29 89/10/31 14:47:24 benson
1112: new function flags. Bug in vector printing.
1113:
1114: Revision 1.28 89/10/20 14:33:06 benson
1115: print abnormal function flag, don't print n_list and s_list peers
1116: of top item dumped.
1117:
1118: Revision 1.27 89/10/06 14:44:28 benson
1119: use new token name array courtesy of byacc.
1120:
1121: Revision 1.26 89/10/04 18:54:21 dysak
1122: Add code to dump the let_address_of_deref_be_address_of and
1123: nonempty_converted_collection flags in an expression node.
1124: Add code to dump the n_persistent_db field of a name node.
1125: Fix failure to discriminate properly between the n_realscope
1126: and n_qualifier nodes properly when dumping.
1127:
1128: Revision 1.25 89/09/22 14:03:32 benson
1129: fixes for locs.
1130:
1131: Revision 1.24 89/09/14 15:25:47 benson
1132: display a table as the top level item, but not deeper in.
1133:
1134: Revision 1.23 89/09/13 09:17:10 benson
1135: rename aggregate to collection.
1136:
1137: Revision 1.22 89/09/08 13:49:52 benson
1138: fix handling for dt_normal to print something,
1139: and also stop printing a spurious >.
1140:
1141: Revision 1.21 89/09/02 22:08:10 benson
1142: deal with changes to tree copies.
1143:
1144: Revision 1.20 89/08/29 13:39:57 benson
1145: disentangle the character string name of a generic function
1146: from n_table_list.
1147:
1148: Revision 1.19 89/08/24 08:45:11 benson
1149: some support for queries and templates.
1150:
1151: Revision 1.17 89/07/27 13:30:33 benson
1152: agg changes.
1153:
1154: Revision 1.16 89/07/21 16:49:44 benson
1155: checked in with -k by benson at 89.07.24.15.48.50.
1156:
1157: Revision 1.16 89/07/21 16:49:44 benson
1158: support for by_name nodes.
1159:
1160: Revision 1.15 89/07/18 15:17:39 benson
1161: print local classes, not args, under label local_classes.
1162: other bugfixes.
1163:
1164: Revision 1.14 89/07/14 10:58:30 benson
1165: rewrite as a user of the new tree_walk facilities. Brief mode
1166: is most likely busted.
1167:
1168: Revision 1.13 89/07/10 10:51:32 benson
1169: add fields added in 2.0 or just plain missed before.
1170:
1171: Revision 1.13 89/07/09 14:37:21 benson
1172: print aggregate facts. Treat QUERIES as exprs.
1173:
1174: Revision 1.12 89/06/30 15:28:26 benson
1175: checked in with -k by benson at 89.07.07.08.32.34.
1176:
1177: Revision 1.12 89/06/30 15:28:26 benson
1178: add ZTYPE to the list of type nodes, whatever it is.
1179:
1180: Revision 1.11 89/06/30 14:34:07 benson
1181: run script to make token name list automatically from tokens
1182: in gram.y
1183:
1184: Revision 1.9 89/06/29 08:44:47 benson
1185: checked in with -k by benson at 89.06.29.20.54.47.
1186:
1187: Revision 1.9 89/06/29 08:44:47 benson
1188: token_name function useful in parse tracing.
1189:
1190: Revision 1.8 89/06/28 12:57:53 benson
1191: Port of changes from 2.0beta6 odi bugfixes
1192:
1193: end_log
1194:
1195: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.