Return to cp-ptree.c CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/cp-ptree.c, revision 1.1.1.3

1.1.1.3 ! root        1: /* Prints out trees in human readable form.
        !             2:    Copyright (C) 1992, 1993 Free Software Foundation, Inc.
1.1       root        3:    Hacked by Michael Tiemann ([email protected])
                      4: 
                      5: This file is part of GNU CC.
                      6: 
                      7: GNU CC is free software; you can redistribute it and/or modify
                      8: it under the terms of the GNU General Public License as published by
                      9: the Free Software Foundation; either version 2, or (at your option)
                     10: any later version.
                     11: 
                     12: GNU CC is distributed in the hope that it will be useful,
                     13: but WITHOUT ANY WARRANTY; without even the implied warranty of
                     14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     15: GNU General Public License for more details.
                     16: 
                     17: You should have received a copy of the GNU General Public License
                     18: along with GNU CC; see the file COPYING.  If not, write to
                     19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
                     20: 
                     21: 
                     22: #include "config.h"
                     23: #include "tree.h"
                     24: #include <stdio.h>
                     25: #include "cp-tree.h"
                     26: 
                     27: void
                     28: print_lang_decl (file, node, indent)
                     29:      FILE *file;
                     30:      tree node;
                     31:      int indent;
                     32: {
                     33:   if (!DECL_LANG_SPECIFIC (node))
                     34:     return;
                     35:   /* A FIELD_DECL only has the flags structure, which we aren't displaying
                     36:      anyways.  */
                     37:   if (TREE_CODE (node) == FIELD_DECL)
                     38:     return;
                     39:   indent_to (file, indent + 3);
                     40:   if (DECL_MAIN_VARIANT (node))
1.1.1.2   root       41:     {
                     42:       fprintf (file, " decl-main-variant ");
                     43:       fprintf (file, HOST_PTR_PRINTF, DECL_MAIN_VARIANT (node));
                     44:     }
1.1       root       45:   if (DECL_PENDING_INLINE_INFO (node))
1.1.1.2   root       46:     {
                     47:       fprintf (file, " pending-inline-info ");
                     48:       fprintf (file, HOST_PTR_PRINTF, DECL_PENDING_INLINE_INFO (node));
                     49:     }
1.1       root       50:   if (DECL_TEMPLATE_INFO (node))
1.1.1.2   root       51:     {
                     52:       fprintf (file, " template-info ");
                     53:       fprintf (file, HOST_PTR_PRINTF,  DECL_TEMPLATE_INFO (node));
                     54:     }
1.1       root       55: }
                     56: 
                     57: void
                     58: print_lang_type (file, node, indent)
                     59:      FILE *file;
                     60:      register tree node;
                     61:      int indent;
                     62: {
                     63:   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM)
                     64:     {
                     65:       print_node (file, "tinfo", TYPE_VALUES (node), indent + 4);
                     66:       return;
                     67:     }
                     68: 
                     69:   if (TREE_CODE (node) == UNINSTANTIATED_P_TYPE)
                     70:     {
                     71:       print_node (file, "template", UPT_TEMPLATE (node), indent + 4);
                     72:       print_node (file, "parameters", UPT_PARMS (node), indent + 4);
                     73:       return;
                     74:     }
                     75: 
                     76:   if (! (TREE_CODE (node) == RECORD_TYPE
                     77:         || TREE_CODE (node) == UNION_TYPE))
                     78:     return;
                     79: 
                     80:   if (!TYPE_LANG_SPECIFIC (node))
                     81:     return;
                     82: 
                     83:   indent_to (file, indent + 3);
                     84: 
                     85:   if (TYPE_NEEDS_CONSTRUCTOR (node))
                     86:     fputs ( "needs-constructor", file);
                     87:   if (TYPE_NEEDS_DESTRUCTOR (node))
                     88:     fputs (" needs-destructor", file);
                     89:   if (TYPE_HAS_CONVERSION (node))
                     90:     fputs (" has-type-conversion", file);
                     91:   if (TYPE_HAS_INT_CONVERSION (node))
                     92:     fputs (" has-int-conversion", file);
                     93:   if (TYPE_HAS_REAL_CONVERSION (node))
                     94:     fputs (" has-float-conversion", file);
                     95:   if (TYPE_HAS_INIT_REF (node))
                     96:     fputs (" X(X&)", file);
                     97:   if (TREE_GETS_NEW (node))
                     98:     fputs (" gets-new", file);
                     99:   if (TREE_GETS_DELETE (node))
                    100:     fputs (" gets-delete", file);
                    101:   if (TYPE_HAS_ASSIGNMENT (node))
                    102:     fputs (" has=", file);
                    103:   if (TYPE_GETS_ASSIGNMENT (node))
                    104:     fputs (" gets=", file);
                    105:   if (TYPE_HAS_ASSIGN_REF (node))
                    106:     fputs (" this=(X&)", file);
                    107:   if (TYPE_GETS_ASSIGN_REF (node))
                    108:     fputs (" gets=(X&)", file);
                    109:   if (TYPE_OVERLOADS_METHOD_CALL_EXPR (node))
                    110:     fputs (" op->()", file);
                    111:   if (TYPE_GETS_INIT_AGGR (node))
                    112:     fputs (" gets X(X, ...)", file);
                    113:   if (TYPE_OVERLOADS_CALL_EXPR (node))
                    114:     fputs (" op()", file);
                    115:   if (TYPE_OVERLOADS_ARRAY_REF (node))
                    116:     fputs (" op[]", file);
                    117:   if (TYPE_OVERLOADS_ARROW (node))
                    118:     fputs (" op->", file);
                    119:   if (TYPE_USES_MULTIPLE_INHERITANCE (node))
                    120:     fputs (" uses-multiple-inheritance", file);
                    121: 
                    122:   if (TREE_CODE (node) == RECORD_TYPE)
                    123:     {
                    124:       fprintf (file, " n_parents %d n_ancestors %d",
                    125:               CLASSTYPE_N_BASECLASSES (node),
                    126:               CLASSTYPE_N_SUPERCLASSES (node));
                    127:       fprintf (file, " use_template=%d", CLASSTYPE_USE_TEMPLATE (node));
                    128:       if (CLASSTYPE_INTERFACE_ONLY (node))
                    129:        fprintf (file, " interface-only");
                    130:       if (CLASSTYPE_INTERFACE_UNKNOWN (node))
                    131:        fprintf (file, " interface-unknown");
                    132:       print_node (file, "member-functions", CLASSTYPE_METHOD_VEC (node),
                    133:                  indent + 4);
                    134:       print_node (file, "baselinks",
                    135:                  TYPE_BINFO_BASETYPES (node) ? CLASSTYPE_BASELINK_VEC (node) : NULL_TREE,
                    136:                  indent + 4);
                    137:     }
                    138: }
                    139: 
                    140: void
                    141: print_lang_identifier (file, node, indent)
                    142:      FILE *file;
                    143:      tree node;
                    144:      int indent;
                    145: {
                    146:   print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
                    147:   print_node (file, "class", IDENTIFIER_CLASS_VALUE (node), indent + 4);
                    148:   print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
                    149:   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
                    150:   print_node (file, "template", IDENTIFIER_TEMPLATE (node), indent + 4);
                    151:   print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
                    152:   print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
                    153: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.