Return to ptree.c CVS log

Up to [GCC 2.x] / gcc / cp

Annotation of gcc/cp/ptree.c, revision 1.1.1.2

1.1       root        1: /* Prints out trees in human readable form.
1.1.1.2 ! root        2:    Copyright (C) 1992, 1993, 1994, 1995 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
1.1.1.2 ! root       19: the Free Software Foundation, 59 Temple Place - Suite 330,
        !            20: Boston, MA 02111-1307, USA.  */
1.1       root       21: 
                     22: 
                     23: #include "config.h"
                     24: #include "tree.h"
                     25: #include <stdio.h>
                     26: #include "cp-tree.h"
                     27: 
                     28: void
                     29: print_lang_decl (file, node, indent)
                     30:      FILE *file;
                     31:      tree node;
                     32:      int indent;
                     33: {
                     34:   if (!DECL_LANG_SPECIFIC (node))
                     35:     return;
                     36:   /* A FIELD_DECL only has the flags structure, which we aren't displaying
                     37:      anyways.  */
                     38:   if (DECL_MUTABLE_P (node))
                     39:     {
                     40:       indent_to (file, indent + 3);
                     41:       fprintf (file, " mutable ");
                     42:     }
                     43:   if (TREE_CODE (node) == FIELD_DECL)
                     44:     return;
                     45:   indent_to (file, indent + 3);
                     46:   if (DECL_MAIN_VARIANT (node))
                     47:     {
                     48:       fprintf (file, " decl-main-variant ");
                     49:       fprintf (file, HOST_PTR_PRINTF, DECL_MAIN_VARIANT (node));
                     50:     }
                     51:   if (DECL_PENDING_INLINE_INFO (node))
                     52:     {
                     53:       fprintf (file, " pending-inline-info ");
                     54:       fprintf (file, HOST_PTR_PRINTF, DECL_PENDING_INLINE_INFO (node));
                     55:     }
                     56:   if (DECL_TEMPLATE_INFO (node))
                     57:     {
                     58:       fprintf (file, " template-info ");
                     59:       fprintf (file, HOST_PTR_PRINTF,  DECL_TEMPLATE_INFO (node));
                     60:     }
                     61: }
                     62: 
                     63: void
                     64: print_lang_type (file, node, indent)
                     65:      FILE *file;
                     66:      register tree node;
                     67:      int indent;
                     68: {
                     69:   if (TREE_CODE (node) == TEMPLATE_TYPE_PARM)
                     70:     {
                     71:       print_node (file, "tinfo", TYPE_VALUES (node), indent + 4);
                     72:       return;
                     73:     }
                     74: 
                     75:   if (TREE_CODE (node) == UNINSTANTIATED_P_TYPE)
                     76:     {
                     77:       print_node (file, "template", UPT_TEMPLATE (node), indent + 4);
                     78:       print_node (file, "parameters", UPT_PARMS (node), indent + 4);
                     79:       return;
                     80:     }
                     81: 
                     82:   if (! (TREE_CODE (node) == RECORD_TYPE
                     83:         || TREE_CODE (node) == UNION_TYPE))
                     84:     return;
                     85: 
                     86:   if (!TYPE_LANG_SPECIFIC (node))
                     87:     return;
                     88: 
                     89:   indent_to (file, indent + 3);
                     90: 
                     91:   if (TYPE_NEEDS_CONSTRUCTING (node))
                     92:     fputs ( "needs-constructor", file);
                     93:   if (TYPE_NEEDS_DESTRUCTOR (node))
                     94:     fputs (" needs-destructor", file);
                     95:   if (TYPE_HAS_DESTRUCTOR (node))
                     96:     fputs (" ~X()", file);
                     97:   if (TYPE_HAS_DEFAULT_CONSTRUCTOR (node))
                     98:     fputs (" X()", file);
                     99:   if (TYPE_HAS_CONVERSION (node))
                    100:     fputs (" has-type-conversion", file);
                    101:   if (TYPE_HAS_INT_CONVERSION (node))
                    102:     fputs (" has-int-conversion", file);
                    103:   if (TYPE_HAS_REAL_CONVERSION (node))
                    104:     fputs (" has-float-conversion", file);
                    105:   if (TYPE_HAS_INIT_REF (node))
                    106:     {
                    107:       if (TYPE_HAS_CONST_INIT_REF (node))
                    108:        fputs (" X(constX&)", file);
                    109:       else
                    110:        fputs (" X(X&)", file);
                    111:     }
                    112:   if (TYPE_GETS_NEW (node) & 1)
                    113:     fputs (" new", file);
                    114:   if (TYPE_GETS_NEW (node) & 2)
                    115:     fputs (" new[]", file);
                    116:   if (TYPE_GETS_DELETE (node) & 1)
                    117:     fputs (" delete", file);
                    118:   if (TYPE_GETS_DELETE (node) & 2)
                    119:     fputs (" delete[]", file);
                    120:   if (TYPE_HAS_ASSIGNMENT (node))
                    121:     fputs (" has=", file);
                    122:   if (TYPE_HAS_ASSIGN_REF (node))
                    123:     fputs (" this=(X&)", file);
                    124:   if (TYPE_OVERLOADS_METHOD_CALL_EXPR (node))
                    125:     fputs (" op->()", file);
                    126:   if (TYPE_GETS_INIT_AGGR (node))
                    127:     fputs (" gets X(X, ...)", file);
                    128:   if (TYPE_OVERLOADS_CALL_EXPR (node))
                    129:     fputs (" op()", file);
                    130:   if (TYPE_OVERLOADS_ARRAY_REF (node))
                    131:     fputs (" op[]", file);
                    132:   if (TYPE_OVERLOADS_ARROW (node))
                    133:     fputs (" op->", file);
                    134:   if (TYPE_USES_MULTIPLE_INHERITANCE (node))
                    135:     fputs (" uses-multiple-inheritance", file);
                    136: 
                    137:   if (TREE_CODE (node) == RECORD_TYPE)
                    138:     {
                    139:       fprintf (file, " n_parents %d n_ancestors %d",
                    140:               CLASSTYPE_N_BASECLASSES (node),
                    141:               CLASSTYPE_N_SUPERCLASSES (node));
                    142:       fprintf (file, " use_template=%d", CLASSTYPE_USE_TEMPLATE (node));
                    143:       if (CLASSTYPE_INTERFACE_ONLY (node))
                    144:        fprintf (file, " interface-only");
                    145:       if (CLASSTYPE_INTERFACE_UNKNOWN (node))
                    146:        fprintf (file, " interface-unknown");
                    147:       print_node (file, "member-functions", CLASSTYPE_METHOD_VEC (node),
                    148:                  indent + 4);
                    149:       print_node (file, "baselinks",
                    150:                  TYPE_BINFO_BASETYPES (node) ? CLASSTYPE_BASELINK_VEC (node) : NULL_TREE,
                    151:                  indent + 4);
                    152:     }
                    153: }
                    154: 
                    155: void
                    156: print_lang_identifier (file, node, indent)
                    157:      FILE *file;
                    158:      tree node;
                    159:      int indent;
                    160: {
                    161:   print_node (file, "global", IDENTIFIER_GLOBAL_VALUE (node), indent + 4);
                    162:   print_node (file, "class", IDENTIFIER_CLASS_VALUE (node), indent + 4);
                    163:   print_node (file, "local", IDENTIFIER_LOCAL_VALUE (node), indent + 4);
                    164:   print_node (file, "label", IDENTIFIER_LABEL_VALUE (node), indent + 4);
                    165:   print_node (file, "template", IDENTIFIER_TEMPLATE (node), indent + 4);
                    166:   print_node (file, "implicit", IDENTIFIER_IMPLICIT_DECL (node), indent + 4);
                    167:   print_node (file, "error locus", IDENTIFIER_ERROR_LOCUS (node), indent + 4);
                    168: }

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