![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tree_dump.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / optcfront|
Return to tree_dump.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / optcfront |
1.1 root 1: /* ident "@(#)ctrans:src/tree_dump.c 1.2" */
2: /* -*- Mode:C++ -*- */
3: /* tree_dump.C -- utilities for displaying the cfront tree. */
4: /* BIM 890530 */
5: /* rewritten 890712 to use the tree-walking facilities */
6:
7: /*
8: $Source: /usr3/lang/benson/work/stripped_cfront/RCS/tree_dump.c,v $ $RCSfile: tree_dump.c,v $
9: $Revision: 1.1 $ $Date: 89/11/20 08:50:22 $
10: $Author: benson $ $Locker: $
11: $State: Exp $
12:
13:
14: */
15:
16: #include "tree_dump.h"
17: #include <stdio.h>
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.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_key:\t%d", (int)n.n_key) ;
587: nz_printf( "n_oper:\t\t%s", n.n_oper ?
588: token_name(n.n_oper) : 0);
589: nz_printf( "n_sto:\t\t%s", n.n_sto ?
590: token_name(n.n_sto) : 0);
591: nz_printf( "n_stclass:\t%s", n.n_stclass ?
592: token_name(n.n_stclass) : 0);
593: nz_printf( "n_scope:\t%s", n.n_scope ?
594: token_name(n.n_scope) : 0);
595: nz_printf( "n_union:\t%d", n.n_union);
596: nz_printf( "n_evaluated:\t%d", n.n_evaluated);
597: nz_printf( "n_xref:\t\t%d", n.n_xref);
598: nz_printf( "lex_level:\t%d", n.lex_level);
599: nz_printf( "n_protect:\t%s", n.n_protect ?
600: token_name(n.n_protect) : 0);
601: if (n.n_dcl_printed || print_null_values) {
602: ind();
603: catprintf("n_dcl_printed:\t%d", n.n_dcl_printed);
604:
605: switch(n.n_dcl_printed)
606: {
607: case 0:
608: catprintf("(not)\n");
609: break;
610: case 1:
611: printf("(declaration)\n");
612: break;
613: case 2:
614: printf("(definition)\n");
615: break;
616: }
617:
618: }
619: if(n.n_template_arg) {
620: ind();
621: catprintf( "n_template_arg:\t");
622: switch(n.n_template_arg)
623: {
624: case template_type_formal:
625: catprintf("template_type_formal\n");
626: break;
627: case template_expr_formal:
628: catprintf("template_expr_formal\n");
629: break;
630: case template_stmt_tree_formal:
631: catprintf("template_stmt_formal\n");
632: break;
633: case template_expr_tree_formal:
634: catprintf("template_expr_tree_formal\n");
635: break;
636: case template_actual_arg_dummy:
637: catprintf("template_actual_arg_dummy\n");
638: break;
639: } ;
640: }
641: nz_printf( "n_addr_taken:\t%d", n.n_addr_taken);
642: nz_printf( "n_used:\t\t%d", n.n_used);
643: nz_printf( "n_assigned_to:\t%d", n.n_assigned_to);
644: ind();
645: catprintf("loc:\t\t");
646: print_loc(n.where);
647: catprintf("\n");
648: nz_printf( "n_offset:\t%d", n.n_offset);
649: // if(n.output_string) { print_string("output_string", (void *)n.output_string); }
650: nz_printf( "n_val:\t\t%ld", n.n_val);
651:
652: print_ptr("n_list", n.n_list);
653: print_ptr("n_tbl_list", n.n_tbl_list);
654: if(n.n_gen_fct_name)
655: print_string("n_gen_fct_name", n.n_gen_fct_name);
656: if(n.n_template_arg_string) {
657: print_string("n_template_arg_string",
658: n.n_template_arg_string);
659: }
660: switch(n.discriminator(0)) {
661: case 2: print_ptr("n_realscope", n.n_realscope); break;
662: case 1: print_ptr("n_qualifier", n.n_qualifier); break;
663: }
664: nz_printf("n_val:\t%ld", n.n_val);
665:
666: indent += Indent_Increment;
667: a_expr(1); /* do the supertype. */
668: indent -= Indent_Increment;
669: }
670:
671: void
672: displayer::a_fct()
673: {
674: struct fct& f = *Pfct(node);
675:
676: printf("$fct %s |0x%p",
677: token_name(node->base),
678: node_address);
679:
680:
681: printf("nargs:\t\t%d", f.nargs);
682: printf("nargs_known:\t%d%s", f.nargs_known,
683: f.nargs_known == 0 ? " UNKNOWN" :
684: (f.nargs_known == 1 ? " KNOWN" :
685: (f.nargs_known == ELLIPSIS ? "ELLIPSIS" : "" )));
686: nz_printf( "f_vdef:\t\t%d", f.f_vdef);
687: printf("f_inline:\t%d%s", f.f_inline,
688: f.f_inline == 0 ? "" :
689: f.f_inline == 1 ? " inline" :
690: f.f_inline == 2 ? " inline in expansion" : "");
691: nz_printf( "f_const:\t\t%d", f.f_const);
692: nz_printf( "f_static:\t\t%d", f.f_static);
693: nz_printf( "f_virtual:\t%d", f.f_virtual);
694: nz_printf( "f_imeasure:\t%d", f.f_imeasure);
695: print_string("f_signature", (void *)f.f_signature);
696:
697: print_ptr("returns", f.returns);
698: print_ptr("argtype", f.argtype);
699: print_ptr("s_returns", f.s_returns);
700: print_ptr("f_this", f.f_this);
701: print_ptr("memof", f.memof);
702: print_ptr("body", f.body);
703: print_ptr("f_init", f.f_init);
704: print_ptr("f_expr", f.f_expr);
705: print_ptr("last_expanded", f.last_expanded);
706: print_ptr("f_result", f.f_result);
707: print_ptr("f_args", f.f_args);
708: print_ptr("local_classes", f.local_class);
709:
710: indent += Indent_Increment;
711: a_type(); /* do the supertype. */
712: indent -= Indent_Increment;
713: }
714:
715: void
716: displayer::a_stmt ()
717: {
718: struct stmt& s = *Pstmt(node);
719:
720: ind();
721: catprintf("$stmt %s |0x%p ",
722: token_name(node->base),
723: node_address);
724: print_loc(s.where);
725: *arg->output_stream << "\n";
726:
727: ind();
728: *arg->output_stream << "where:\t";
729: print_loc(s.where);
730: *arg->output_stream << "\n";
731:
732: print_ptr("s", s.s);
733: print_ptr("s_list", s.s_list);
734: print_ptr("memtbl", s.memtbl);
735: switch(s.discriminator(0)) {
736: case 1: print_ptr("d", s.d); break;
737: case 2: print_ptr("e2", s.e2); break;
738: case 3: print_ptr("has_default", s.has_default); break;
739: case 4: nz_printf("case_value:\t0x%x", s.case_value);
740: case 5: print_ptr("ret_tp", s.ret_tp); break;
741: }
742: switch(s.discriminator(1)) {
743: case 1: print_ptr("e", s.e); break;
744: case 2: nz_printf("own_tbl:\t%d", s.own_tbl); break;
745: case 3: print_ptr("s2", s.s2); break;
746: }
747:
748: switch(s.discriminator(2)) {
749: case 1: print_ptr("for_init", s.for_init); break;
750: case 2: print_ptr("else_stmt",s.for_init); break;
751: case 3: print_ptr("case_list", s.case_list); break;
752: }
753: }
754:
755: void
756: displayer::a_enumdef ()
757: {
758: struct enumdef& e = *Penum(node);
759:
760: printf("$enumdef %s |0x%p",
761: token_name(node->base),
762: node_address);
763:
764: nz_printf( "e_body:\t\t%d", e.e_body);
765: nz_printf( "no_of_enumerators: %d",
766: e.no_of_enumerators);
767: nz_printf( "strlen:\t%d", e.strlen);
768: print_string ("string", (void *)e.string);
769:
770: print_ptr("mem", e.mem);
771: print_ptr("e_type", e.e_type);
772: indent += Indent_Increment;
773: a_type(); /* do the supertype. */
774: indent -= Indent_Increment;
775: }
776:
777: void
778: displayer::a_classdef ()
779: {
780: struct classdef& c = *Pclass(node);
781:
782: ind();
783: catprintf("$classdef %s |0x%p ",
784: token_name(node->base),
785: node_address);
786: print_string_brief(c.string);
787: *arg->output_stream << "\n";
788: ind();
789: catprintf("class_base:\t");
790: switch(c.class_base)
791: {
792: case vanilla_class:
793: *arg->output_stream << "vanilla_class\n";
794: break;
795: case template_class:
796: *arg->output_stream << "template_class\n";
797: Template_Class:
798: nz_printf("inst:\t\t%p", (int)Ptclass(&c)->inst);
799: break;
800: case instantiated_template_class:
801: *arg->output_stream << "instantiated_template_class\n";
802: goto Template_Class;
803: case uninstantiated_template_class:
804: *arg->output_stream << "uninstantiated_template_class\n";
805: goto Template_Class;
806: case relationship_class:
807: *arg->output_stream << "relationship_class\n";
808: break;
809: case defining_class:
810: *arg->output_stream << "defining_class\n";
811: break;
812: }
813:
814: nz_printf( "c_body:\t\t%d", c.c_body);
815: printf("csu:\t\t%s",
816: token_name(c.csu));
817: nz_printf( "obj_align:\t%d", c.obj_align);
818: if(c.c_xref) {
819: ind();
820: catprintf( "c_xref:\t%x", c.c_xref);
821: flag(c.c_xref & 1, "has-vptr ");
822: flag(c.c_xref & 2, "X(X&)-defined ");
823: flag(c.c_xref & 4, "operator=(X&)-defined ");
824: flag(c.c_xref & 8, "has-vbaseptr(s) ");
825: *arg->output_stream << "\n";
826: }
827: nz_printf( "virt_count:\t%d", c.virt_count);
828: nz_printf( "virt_merge:\t%d", c.virt_merge);
829: nz_printf( "c_abstract:\t%d", c.c_abstract);
830: nz_printf( "has_vvtab:\t%d", c.has_vvtab);
831: nz_printf( "strlen:\t%d", c.strlen);
832: print_string ("string", (void *)c.string);
833: nz_printf( "obj_size:\t%d", c.obj_size);
834: nz_printf( "real_size:\t%d", c.real_size);
835: nz_printf("lex_level:\t%d", c.lex_level);
836: if(c.lcl)print_string("lcl", c.lcl);
837:
838: print_ptr("baselist", c.baselist);
839: print_ptr("mem_list", c.mem_list);
840: print_ptr("memtbl", c.memtbl);
841: print_ptr("friend_list", c.friend_list);
842: print_ptr("pubdef", c.pubdef);
843: print_ptr("tn_list", c.tn_list); /* not brief */
844: print_ptr("in_class", c.in_class);
845: print_ptr("in_fct", c.in_fct);
846: print_ptr("this_type", c.this_type);
847: print_ptr("virt_list", c.virt_list);
848: print_ptr("c_ctor", c.c_ctor);
849: print_ptr("c_dtor", c.c_dtor);
850: print_ptr("c_itor", c.c_itor);
851: print_ptr("conv", c.conv);
852: indent += Indent_Increment;
853: a_type(); /* do the supertype. */
854: indent -= Indent_Increment;
855: }
856:
857:
858: void
859: displayer::a_virt()
860: {
861: virt& v = *Pvirt(node);
862: void * vna;
863: void * vna_e;
864: int vx;
865:
866: printf("$virt %s |0x%p ",
867: token_name(node->base),
868: node_address);
869:
870: print_ptr("next", v.next);
871: if(v.n_init) {
872: printf("n_init:\t%d", v.n_init);
873: printf("virt_init:");
874: for (vna = v.virt_init, vx = 0; vx < (v.n_init - 1);
875: vna = (char *)vna + sizeof (velem), vx++)
876: {
877: fetch(vna, sizeof (velem), vna_e);
878: struct velem * ve = (struct velem *) vna_e;
879: ind();
880: catprintf("%d offset %d\t", vx, ve->offset);
881: print_ptr(ve->n);
882: free_fetched(vna_e);
883: }
884: }
885: print_ptr("vclass", v.vclass);
886: nz_printf( "\nis_vbase:\t %d", v.is_vbase);
887: nz_printf( "\nprinted:\t %d", v.printed);
888: }
889:
890: void
891: displayer::a_table ()
892: {
893: struct table& t = *Ptable(node);
894: int x;
895: int y;
896: void * nlist;
897: void * slist;
898:
899: printf("$table %s |0x%p",
900: token_name(node->base),
901: node_address);
902:
903: printf("init_stat:\t%d%s", t.init_stat,
904: t.init_stat == 0 ? " not simplified" :
905: t.init_stat == 1 ? " simplified, no inits" :
906: t.init_stat == 2 ? " simplified, inits" :
907: "");
908: printf("size:\t%d", t.size);
909: printf("hashsize:\t%d", t.hashsize);
910: printf("free_slot:\t%d", t.free_slot);
911:
912: /* it looks like there is an array of Pnames here ... */
913: *arg->output_stream << "\n";
914: ind();
915: *arg->output_stream << "entries:\n";
916: fetch((void *)t.entries, t.size * sizeof(Pname), nlist);
917: Pname * tmp_nlist = (Pname *)nlist;
918: for(x = 0; x < t.size; x ++) {
919: if(tmp_nlist[x]) {
920: ind();
921: *arg->output_stream << x;
922: *arg->output_stream << "\t";
923: print_ptr(tmp_nlist[x]);
924: unsigned char tmp_name_s[sizeof(name)];
925: void * tmp_name;
926: tmp_name = (void *)&tmp_name_s[0];
927: fetch(tmp_nlist[x], sizeof(name), tmp_name);
928: catprintf(" key %d\n", Pname(tmp_name)->n_key);
929: }
930: }
931: free_fetched(nlist);
932: /* and then an array of shorts for the hash table. */
933: /* we really need a tabular format here, alright. */
934: ind();
935: *arg->output_stream << "hashtbl:\n";
936: fetch(t.hashtbl, t.hashsize * sizeof(short), slist);
937: short * tmp_slist = (short *)slist;
938: for(x = 0;; x++ ) {
939: for (y = 0; y < 11; y ++) {
940: if(((x * 12) + y) > t.hashsize) break;
941: catprintf("%6d ", tmp_slist[(x*12)+y]);
942: }
943: *arg->output_stream << "\n";
944: if(((x * 12) + y) > t.hashsize) break;
945: }
946:
947: free_fetched (slist);
948:
949: print_ptr("t_name", t.t_name);
950: print_ptr("real_block", t.real_block);
951: print_ptr("name", t.t_name);
952: print_ptr("next", t.next);
953: }
954:
955: void
956: displayer::a_gen ()
957: {
958: struct gen& g = *Pgen(node);
959:
960: printf("$gen %s |0x%p",
961: token_name(node->base),
962: node_address);
963:
964: print_ptr ("fct_list", g.fct_list);
965: indent += Indent_Increment;
966: a_type(); /* do the supertype. */
967: indent -= Indent_Increment;
968: }
969:
970: void
971: displayer::a_vec ()
972: {
973: struct vec& v = *Pvec(node);
974:
975: printf("$vec %s |0x%p",
976: token_name(node->base),
977: node_address);
978: printf("size:\t\t%d", v.size);
979: print_ptr ("typ", v.typ);
980: print_ptr ("dim", v.dim);
981: }
982:
983: void
984: displayer::a_ptr ()
985: {
986: struct ptr& p = *Pptr(node);
987:
988: printf("$ptr %s |0x%p",
989: token_name(node->base),
990: node_address);
991: ind();
992: printf("rdo:\t\t%d", p.rdo);
993: ind();
994:
995: print_ptr ("typ", p.typ);
996: print_ptr ("memof", p.memof);
997: }
998:
999:
1000: void
1001: displayer::a_nlist()
1002: {
1003: name_list& n = *Plist(node);
1004:
1005: printf("$name_list %s |0x%p ",
1006: token_name(node->base),
1007: node_address);
1008:
1009: print_ptr("f", n.f);
1010: print_ptr("l", n.l);
1011: }
1012:
1013: void
1014: displayer::a_iline()
1015: {
1016: struct iline& i = *(struct iline *)node;
1017:
1018: printf("$iline %s |0x%p ",
1019: token_name(node->base),
1020: node_address);
1021:
1022: print_ptr("fct_name", i.fct_name);
1023: print_ptr("i_next", i.i_next);
1024: print_ptr("i_table", i.i_table);
1025: nz_printf("i_slots:\t%d", i.i_slots);
1026: print_ptr("i_args", i.i_args);
1027: }
1028:
1029: void
1030: displayer::a_ia()
1031: {
1032: struct ia& i = *(struct ia *)node;
1033:
1034: printf("$ia %s |0x%p ",
1035: token_name(node->base),
1036: node_address);
1037:
1038: print_ptr("local", i.local);
1039: print_ptr("arg", i.arg);
1040: print_ptr("tp", i.tp);
1041: }
1042:
1043: static int fetcher (void * info,
1044: void * pointer,
1045: unsigned long length,
1046: int zero_stop, /* for character strings.*/
1047: void * target)
1048: {
1049: displayer * d = (displayer *)info;
1050: if(d->arg->fetcher)
1051: return d->arg->fetcher(d->arg->fetcher_info, pointer, length,
1052: zero_stop, target);
1053: }
1054:
1055: static void
1056: do_node (Pnode& node, node_class cl, void * info, tree_node_action& action,
1057: int depth, Pnode na, tree_walk_tree&, int&)
1058: {
1059: displayer * d = (displayer *)info;
1060: d->do_node(node, cl, action, depth, na);
1061: d->arg->output_stream->write("\n", 1);
1062: }
1063:
1064:
1065: /* Note -- declared extern "C" in tree_dump.h. */
1066:
1067: void
1068: display_cfront_node (dcn_arg& arg, Pnode n)
1069: {
1070: tree_walk_control twc;
1071: displayer d (arg);
1072:
1073: if(arg.verbose == dt_normal)arg.max_depth = 0;
1074: twc.callback_info = (void *)&d;
1075: if(arg.fetcher) twc.fetcher = fetcher;
1076: twc.action_proc = do_node;
1077: twc.error_stream = arg.error_stream;
1078: twc.nodes_seen_hash = arg.nodes_seen_hash;
1079: twc.resolve_by_name = 0; /* we want to display the by_name nodes */
1080: twc.dont_chase_lists_top = 1; /* don't display n_list or s_list peers
1081: at the top level. */
1082:
1083: walk_tree(twc, n);
1084:
1085: arg.error_stream->flush();
1086: arg.output_stream->flush();
1087: }
1088:
1089:
1090: extern "C" void _fcout();
1091: void _fcout () { cout.flush(); }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.