Return to cp-tree.h CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/cp-tree.h, revision 1.1

1.1     ! root        1: /* Definitions for C++ parsing and type checking.
        !             2:    Copyright (C) 1987 Free Software Foundation, Inc.
        !             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: /* Borrow everything that is C from c-tree.h,
        !            23:    but do so by copy, not by inclusion, since c-tree.h defines
        !            24:    lang_identifier.  */
        !            25: 
        !            26: #ifndef PARANOID
        !            27: #define PARANOID 0
        !            28: #endif
        !            29: #if PARANOID
        !            30: #include <assert.h>
        !            31: #endif
        !            32: 
        !            33: /* Language-dependent contents of an identifier.  */
        !            34: 
        !            35: struct lang_identifier
        !            36: {
        !            37:   struct tree_identifier ignore;
        !            38:   tree global_value, local_value;
        !            39:   tree class_value;
        !            40:   tree class_template_info;
        !            41:   struct lang_id2 *x;
        !            42: };
        !            43: 
        !            44: struct lang_id2
        !            45: {
        !            46:   tree label_value, implicit_decl;
        !            47:   tree type_desc, as_list, error_locus;
        !            48: };
        !            49: 
        !            50: /* Macros for access to language-specific slots in an identifier.  */
        !            51: 
        !            52: #if !PARANOID
        !            53: #define IDENTIFIER_GLOBAL_VALUE(NODE)  \
        !            54:   (((struct lang_identifier *)(NODE))->global_value)
        !            55: #define IDENTIFIER_CLASS_VALUE(NODE)   \
        !            56:   (((struct lang_identifier *)(NODE))->class_value)
        !            57: #define IDENTIFIER_LOCAL_VALUE(NODE)   \
        !            58:   (((struct lang_identifier *)(NODE))->local_value)
        !            59: #define IDENTIFIER_TEMPLATE(NODE)      \
        !            60:   (((struct lang_identifier *)(NODE))->class_template_info)
        !            61: #else
        !            62: #define IDENTIFIER_LANG_SPECIFIC_PTR(NODE) \
        !            63:   (assert (TREE_CODE (NODE) == IDENTIFIER_NODE),       \
        !            64:    (struct lang_identifier *) (NODE))
        !            65: #define IDENTIFIER_GLOBAL_VALUE(NODE)  \
        !            66:   (((struct lang_identifier *)(NODE))->global_value)
        !            67: #define IDENTIFIER_CLASS_VALUE(NODE)   \
        !            68:   (((struct lang_identifier *)(NODE))->class_value)
        !            69: #define IDENTIFIER_LOCAL_VALUE(NODE)   \
        !            70:   (((struct lang_identifier *)(NODE))->local_value)
        !            71: #define IDENTIFIER_TEMPLATE(NODE)      \
        !            72:   (IDENTIFIER_LANG_SPECIFIC_PTR (NODE) -> class_template_info)
        !            73: #endif
        !            74: 
        !            75: #if !PARANOID
        !            76: #define IDENTIFIER_TYPE_VALUE(NODE) (TREE_TYPE (NODE))
        !            77: #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = TYPE)
        !            78: #else
        !            79: #define IDENTIFIER_TYPE_VALUE(NODE) (*IDENTIFIER_TYPE_VALUE_PTR(NODE))
        !            80: #ifdef __GNUC__
        !            81: __inline
        !            82: #endif
        !            83: static tree * IDENTIFIER_TYPE_VALUE_PTR(NODE) tree NODE; { return
        !            84:   (assert (TREE_CODE (NODE) == IDENTIFIER_NODE),
        !            85:    &TREE_TYPE (NODE)) ;}
        !            86: #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (IDENTIFIER_TYPE_VALUE(NODE)=TYPE)
        !            87: #endif
        !            88: #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (TREE_TYPE (NODE) ? 1 : 0)
        !            89: extern tree identifier_typedecl_value ();
        !            90: #define IDENTIFIER_TYPEDECL_VALUE(NODE) identifier_typedecl_value (NODE)
        !            91: 
        !            92: #define IDENTIFIER_LABEL_VALUE(NODE)   \
        !            93:   (((struct lang_identifier *)(NODE))->x \
        !            94:    ? ((struct lang_identifier *)(NODE))->x->label_value : 0)
        !            95: #define SET_IDENTIFIER_LABEL_VALUE(NODE,VALUE) \
        !            96:   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
        !            97:    ((struct lang_identifier *)(NODE))->x->label_value = (VALUE))
        !            98: #define IDENTIFIER_IMPLICIT_DECL(NODE) \
        !            99:   (((struct lang_identifier *)(NODE))->x \
        !           100:    ? ((struct lang_identifier *)(NODE))->x->implicit_decl : 0)
        !           101: #define SET_IDENTIFIER_IMPLICIT_DECL(NODE,VALUE)       \
        !           102:   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
        !           103:    ((struct lang_identifier *)(NODE))->x->implicit_decl = (VALUE))
        !           104: #define IDENTIFIER_AS_DESC(NODE)               \
        !           105:   (((struct lang_identifier *)(NODE))->x \
        !           106:    ? ((struct lang_identifier *)(NODE))->x->type_desc : 0)
        !           107: #define SET_IDENTIFIER_AS_DESC(NODE,DESC)      \
        !           108:   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
        !           109:    ((struct lang_identifier *)(NODE))->x->type_desc = (DESC))
        !           110: #define IDENTIFIER_AS_LIST(NODE)               \
        !           111:   (((struct lang_identifier *)(NODE))->x \
        !           112:    ? ((struct lang_identifier *)(NODE))->x->as_list : 0)
        !           113: #define SET_IDENTIFIER_AS_LIST(NODE,LIST)      \
        !           114:   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
        !           115:    ((struct lang_identifier *)(NODE))->x->as_list = (LIST))
        !           116: #define IDENTIFIER_ERROR_LOCUS(NODE)   \
        !           117:   (((struct lang_identifier *)(NODE))->x \
        !           118:    ? ((struct lang_identifier *)(NODE))->x->error_locus : 0)
        !           119: #define SET_IDENTIFIER_ERROR_LOCUS(NODE,VALUE) \
        !           120:   (((struct lang_identifier *)(NODE))->x == 0 ? ((struct lang_identifier *)(NODE))->x = (struct lang_id2 *)perm_calloc (1, sizeof (struct lang_id2)) : 0, \
        !           121:    ((struct lang_identifier *)(NODE))->x->error_locus = (VALUE))
        !           122: 
        !           123: /* Nonzero if this identifier is the prefix for a mangled C++ operator name.  */
        !           124: #define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2(NODE)
        !           125: 
        !           126: #define IDENTIFIER_TYPENAME_P(NODE)    \
        !           127:   (! strncmp (IDENTIFIER_POINTER (NODE),                       \
        !           128:              IDENTIFIER_POINTER (ansi_opname[TYPE_EXPR]),      \
        !           129:              IDENTIFIER_LENGTH (ansi_opname[TYPE_EXPR])))
        !           130: 
        !           131: /* Nonzero means reject anything that ANSI standard C forbids.  */
        !           132: extern int pedantic;
        !           133: 
        !           134: /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only.  */
        !           135: #define C_TYPE_FIELDS_READONLY(type) TYPE_LANG_FLAG_0 (type)
        !           136: 
        !           137: /* in tree.c */
        !           138: extern tree purpose_member (), value_member ();
        !           139: extern tree binfo_member ();
        !           140: 
        !           141: /* in cp-typeck.c */
        !           142: extern tree build_component_ref(), build_conditional_expr();
        !           143: extern tree build_x_compound_expr (), build_compound_expr();
        !           144: extern tree build_unary_op(), build_binary_op(), build_function_call();
        !           145: extern tree build_binary_op_nodefault ();
        !           146: extern tree build_indirect_ref(), build_array_ref(), build_c_cast();
        !           147: extern tree build_modify_expr();
        !           148: extern tree c_sizeof (), c_alignof ();
        !           149: extern tree store_init_value ();
        !           150: extern tree digest_init ();
        !           151: extern tree c_expand_start_case ();
        !           152: extern tree default_conversion ();
        !           153: 
        !           154: /* Given two integer or real types, return the type for their sum.
        !           155:    Given two compatible ANSI C types, returns the merged type.  */
        !           156: 
        !           157: extern tree common_type ();
        !           158: 
        !           159: /* in cp-decl.c */
        !           160: extern tree build_label ();
        !           161: 
        !           162: /* If non-zero, a VAR_DECL whose cleanup will cause a throw to the
        !           163:    next exception handler.  */
        !           164: extern tree exception_throw_decl;
        !           165: 
        !           166: extern int start_function ();
        !           167: extern void finish_function ();
        !           168: extern void store_parm_decls ();
        !           169: extern tree get_parm_info ();
        !           170: 
        !           171: extern void pushlevel ();
        !           172: extern tree poplevel ();
        !           173: 
        !           174: extern tree groktypename(), lookup_name();
        !           175: 
        !           176: extern tree lookup_label(), define_label();
        !           177: 
        !           178: extern tree implicitly_declare(), getdecls(), gettags ();
        !           179: 
        !           180: extern tree start_decl();
        !           181: extern void finish_decl();
        !           182: 
        !           183: extern tree start_struct(), finish_struct(), xref_tag(), xref_defn_tag();
        !           184: extern tree finish_exception ();
        !           185: extern tree grokfield(), grokbitfield ();
        !           186: 
        !           187: extern tree start_enum(), finish_enum();
        !           188: extern tree build_enumerator();
        !           189: 
        !           190: extern tree make_index_type ();
        !           191: extern tree make_anon_name ();
        !           192: 
        !           193: /* Functions in c-common.c: */
        !           194: 
        !           195: /* Concatenate a list of STRING_CST nodes into one STRING_CST.  */
        !           196: extern tree combine_strings ();
        !           197: 
        !           198: /* Validate the expression after `case' and apply default promotions.  */
        !           199: extern tree check_case_value ();
        !           200: 
        !           201: /* Print an error message for invalid operands to arith operation CODE.
        !           202:    NOP_EXPR is used as a special case (see truthvalue_conversion).  */
        !           203: 
        !           204: extern void binary_op_error ();
        !           205: 
        !           206: /* Subroutine of build_binary_op_nodefault, used for comparison operations.
        !           207:    See if the operands have both been converted from subword integer types
        !           208:    and, if so, perhaps change them both back to their original type.  */
        !           209: 
        !           210: extern tree shorten_compare ();
        !           211: 
        !           212: extern tree double_type_node, long_double_type_node, float_type_node;
        !           213: extern tree char_type_node, unsigned_char_type_node, signed_char_type_node;
        !           214: extern tree ptrdiff_type_node;
        !           215: 
        !           216: extern tree short_integer_type_node, short_unsigned_type_node;
        !           217: extern tree long_integer_type_node, long_unsigned_type_node;
        !           218: extern tree long_long_integer_type_node, long_long_unsigned_type_node;
        !           219: extern tree unsigned_type_node;
        !           220: extern tree string_type_node, char_array_type_node, int_array_type_node;
        !           221: extern tree wchar_array_type_node;
        !           222: extern tree wchar_type_node, signed_wchar_type_node, unsigned_wchar_type_node;
        !           223: 
        !           224: extern int current_function_returns_value;
        !           225: extern int current_function_returns_null;
        !           226: extern tree current_function_return_value;
        !           227: 
        !           228: extern tree ridpointers[];
        !           229: extern tree ansi_opname[];
        !           230: extern tree ansi_assopname[];
        !           231: 
        !           232: /* Nonzero means `$' can be in an identifier.  */
        !           233: 
        !           234: extern int dollars_in_ident;
        !           235: 
        !           236: /* Nonzero means allow type mismatches in conditional expressions;
        !           237:    just make their values `void'.   */
        !           238: 
        !           239: extern int flag_cond_mismatch;
        !           240: 
        !           241: /* Nonzero means don't recognize the keyword `asm'.  */
        !           242: 
        !           243: extern int flag_no_asm;
        !           244: 
        !           245: /* For cross referencing.  */
        !           246: 
        !           247: extern int flag_gnu_xref;
        !           248: 
        !           249: /* For environments where you can use GNU binutils (as, ld in particular).  */
        !           250: 
        !           251: extern int flag_gnu_binutils;
        !           252: 
        !           253: /* Nonzero means warn about implicit declarations.  */
        !           254: 
        !           255: extern int warn_implicit;
        !           256: 
        !           257: /* Nonzero means warn about function definitions that default the return type
        !           258:    or that use a null return and have a return-type other than void.  */
        !           259: 
        !           260: extern int warn_return_type, explicit_warn_return_type;
        !           261: 
        !           262: /* Nonzero means give string constants the type `const char *'
        !           263:    to get extra warnings from them.  These warnings will be too numerous
        !           264:    to be useful, except in thoroughly ANSIfied programs.  */
        !           265: 
        !           266: extern int warn_write_strings;
        !           267: 
        !           268: /* Nonzero means warn about sizeof(function) or addition/subtraction
        !           269:    of function pointers.  */
        !           270: 
        !           271: extern int warn_pointer_arith;
        !           272: 
        !           273: /* Nonzero means warn for all old-style non-prototype function decls.  */
        !           274: 
        !           275: extern int warn_strict_prototypes;
        !           276: 
        !           277: /* Nonzero means warn about suggesting putting in ()'s.  */
        !           278: 
        !           279: extern int warn_parentheses;
        !           280: 
        !           281: /* Nonzero means warn about pointer casts that can drop a type qualifier
        !           282:    from the pointer target type.  */
        !           283: 
        !           284: extern int warn_cast_qual;
        !           285: 
        !           286: /* Nonzero means do some things the same way PCC does.  */
        !           287: 
        !           288: extern int flag_traditional;
        !           289: 
        !           290: /* Nonzero means to treat bitfields as unsigned unless they say `signed'.  */
        !           291: 
        !           292: extern int flag_signed_bitfields;
        !           293: 
        !           294: /* 2 means write out only specific virtual function tables
        !           295:    and give them (C) public visibility.
        !           296:    1 means write out virtual function tables and give them
        !           297:    (C) public visibility.
        !           298:    0 means write out virtual function tables and give them
        !           299:    (C) static visibility.
        !           300:    -1 means declare virtual function tables extern.  */
        !           301: 
        !           302: extern int write_virtuals;
        !           303: 
        !           304: /* INTERFACE_ONLY nonzero means that we are in an "interface"
        !           305:    section of the compiler.  INTERFACE_UNKNOWN nonzero means
        !           306:    we cannot trust the value of INTERFACE_ONLY.  If INTERFACE_UNKNOWN
        !           307:    is zero and INTERFACE_ONLY is zero, it means that we are responsible
        !           308:    for exporting definitions that others might need.  */
        !           309: extern int interface_only, interface_unknown;
        !           310: 
        !           311: /* Nonzero means we should attempt to elide constructors when possible.  */
        !           312: 
        !           313: extern int flag_elide_constructors;
        !           314: 
        !           315: /* Nonzero means recognize and handle exception handling constructs.  */
        !           316: 
        !           317: extern int flag_handle_exceptions;
        !           318: 
        !           319: /* Nonzero means recognize and handle ansi-style exception handling constructs.  */
        !           320: 
        !           321: extern int flag_ansi_exceptions;
        !           322: 
        !           323: /* Nonzero means that member functions defined in class scope are
        !           324:    inline by default.  */
        !           325: 
        !           326: extern int flag_default_inline;
        !           327: 
        !           328: /* Nonzero means emit cadillac protocol.  */
        !           329: 
        !           330: extern int flag_cadillac;
        !           331: 
        !           332: /* C++ language-specific tree codes.  */
        !           333: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM,
        !           334: enum cplus_tree_code {
        !           335:   __DUMMY = LAST_AND_UNUSED_TREE_CODE,
        !           336: #include "cp-tree.def"
        !           337:   LAST_CPLUS_TREE_CODE
        !           338: };
        !           339: #undef DEFTREECODE
        !           340: 
        !           341: enum languages { lang_c, lang_cplusplus };
        !           342: 
        !           343: /* Macros to make error reporting functions' lives easier.  */
        !           344: #if !PARANOID
        !           345: #define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE)))
        !           346: #else
        !           347: #define TYPE_IDENTIFIER(NODE) (*TYPE_IDENTIFIER_PTR (NODE))
        !           348: #ifdef __GNUC__
        !           349: __inline
        !           350: #endif
        !           351: static tree *
        !           352: TYPE_IDENTIFIER_PTR(NODE) tree NODE; { return
        !           353:   (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'),
        !           354:    &DECL_NAME (TYPE_NAME (NODE))) ;}
        !           355: #endif
        !           356: 
        !           357: #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (NODE))))
        !           358: #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (DECL_NAME (TYPE_NAME (NODE))))
        !           359: 
        !           360: #define IS_AGGR_TYPE_2(TYPE1,TYPE2) \
        !           361:   (TREE_CODE (TYPE1) == TREE_CODE (TYPE2)      \
        !           362:    && IS_AGGR_TYPE (TYPE1)&IS_AGGR_TYPE (TYPE2))
        !           363: 
        !           364: /* Macros which might want to be replaced by function calls.  */
        !           365: 
        !           366: #if 1
        !           367: /* Virtual function addresses can be gotten from a virtual function
        !           368:    table entry using this macro.  */
        !           369: #define FNADDR_FROM_VTABLE_ENTRY(ENTRY) \
        !           370:   TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (ENTRY))))
        !           371: #define SET_FNADDR_FROM_VTABLE_ENTRY(ENTRY,VALUE) \
        !           372:   (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (ENTRY)))) = (VALUE))
        !           373: 
        !           374: #define FUNCTION_ARG_CHAIN(NODE) (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE))))
        !           375: #define PROMOTES_TO_AGGR_TYPE(NODE,CODE)       \
        !           376:   (((CODE) == TREE_CODE (NODE)                 \
        !           377:        && IS_AGGR_TYPE (TREE_TYPE (NODE)))     \
        !           378:    || IS_AGGR_TYPE (NODE))
        !           379: 
        !           380: #else
        !           381: extern tree fnaddr_from_vtable_entry ();
        !           382: extern void set_fnaddr_from_vtable_entry ();
        !           383: extern tree function_arg_chain ();
        !           384: extern int promotes_to_aggr_type ();
        !           385: extern int is_aggr_type_2 ();
        !           386: #define FNADDR_FROM_VTABLE_ENTRY(ENTRY) (fnaddr_from_vtable_entry (ENTRY))
        !           387: #define SET_FNADDR_FROM_VTABLE_ENTRY(ENTRY,VALUE) \
        !           388:   (set_fnaddr_from_vtable_entry (ENTRY, VALUE))
        !           389: /* #define TYPE_NAME_STRING(NODE) (type_name_string (NODE)) */
        !           390: #define FUNCTION_ARG_CHAIN(NODE) (function_arg_chain (NODE))
        !           391: #define PROMOTES_TO_AGGR_TYPE(NODE,CODE) (promotes_to_aggr_type (NODE, CODE))
        !           392: /* #define IS_AGGR_TYPE_2(TYPE1, TYPE2) (is_aggr_type_2 (TYPE1, TYPE2)) */
        !           393: #endif
        !           394: /* Nonzero iff TYPE is derived from PARENT.  */
        !           395: #define DERIVED_FROM_P(PARENT, TYPE) (get_base_distance (PARENT, TYPE, 0, 0) >= 0)
        !           396: 
        !           397: enum conversion_type { ptr_conv, constptr_conv, int_conv, real_conv, last_conversion_type };
        !           398: 
        !           399: /* Statistics show that while the GNU C++ compiler may generate
        !           400:    thousands of different types during a compilation run, it
        !           401:    generates relatively few (tens) of classtypes.  Because of this,
        !           402:    it is not costly to store a generous amount of information
        !           403:    in classtype nodes.  This struct must fill out to a multiple of 4 bytes.  */
        !           404: struct lang_type
        !           405: {
        !           406:   struct
        !           407:     {
        !           408:       unsigned has_type_conversion : 1;
        !           409:       unsigned has_int_conversion : 1;
        !           410:       unsigned has_float_conversion : 1;
        !           411:       unsigned has_init_ref : 1;
        !           412:       unsigned gets_init_ref : 1;
        !           413:       unsigned gets_init_aggr : 1;
        !           414:       unsigned has_assignment : 1;
        !           415:       unsigned gets_assignment : 1;
        !           416: 
        !           417:       unsigned needs_constructor : 1;
        !           418:       unsigned has_default_ctor : 1;
        !           419:       unsigned uses_multiple_inheritance : 1;
        !           420:       unsigned const_needs_init : 1;
        !           421:       unsigned ref_needs_init : 1;
        !           422:       unsigned gets_const_init_ref : 1;
        !           423:       unsigned has_const_assign_ref : 1;
        !           424:       unsigned gets_const_assign_ref : 1;
        !           425: 
        !           426:       unsigned vtable_needs_writing : 1;
        !           427:       unsigned has_assign_ref : 1;
        !           428:       unsigned gets_assign_ref : 1;
        !           429:       unsigned gets_new : 1;
        !           430:       unsigned gets_delete : 1;
        !           431:       unsigned has_call_overloaded : 1;
        !           432:       unsigned has_array_ref_overloaded : 1;
        !           433:       unsigned has_arrow_overloaded : 1;
        !           434: 
        !           435:       unsigned local_typedecls : 1;
        !           436:       unsigned interface_only : 1;
        !           437:       unsigned interface_unknown : 1;
        !           438:       unsigned needs_virtual_reinit : 1;
        !           439:       unsigned declared_exception : 1;
        !           440:       unsigned declared_class : 1;
        !           441:       unsigned being_defined : 1;
        !           442:       unsigned redefined : 1;
        !           443: 
        !           444:       unsigned marked : 1;
        !           445:       unsigned marked2 : 1;
        !           446:       unsigned marked3 : 1;
        !           447:       unsigned marked4 : 1;
        !           448:       unsigned marked5 : 1;
        !           449:       unsigned marked6 : 1;
        !           450:       unsigned use_template : 2;
        !           451: 
        !           452:       unsigned debug_requested : 1;
        !           453:       unsigned dynamic : 1;
        !           454:       unsigned has_wrapper_pred : 1;
        !           455:       unsigned has_method_call_overloaded : 1;
        !           456:       unsigned private_attr : 1;
        !           457:       unsigned alters_visibilities : 1;
        !           458:       unsigned got_semicolon : 1;
        !           459:       unsigned dummy : 1;
        !           460: 
        !           461:       /* The MIPS compiler gets it wrong if this struct also
        !           462:         does not fill out to a multiple of 4 bytes.  */
        !           463:       unsigned n_vancestors : 16;
        !           464:     } type_flags;
        !           465: 
        !           466:   int cid;
        !           467:   int n_ancestors;
        !           468:   int vsize;
        !           469:   int max_depth;
        !           470: 
        !           471:   union tree_node *vbinfo[2];
        !           472:   union tree_node *baselink_vec;
        !           473:   union tree_node *vfields;
        !           474:   union tree_node *vbases;
        !           475:   union tree_node *vbase_size;
        !           476: 
        !           477:   union tree_node *tags;
        !           478:   char *memoized_table_entry;
        !           479: 
        !           480:   char *search_slot;
        !           481: 
        !           482: #ifdef ONLY_INT_FIELDS
        !           483:   unsigned int mode : 8;
        !           484: #else
        !           485:   enum machine_mode mode : 8;
        !           486: #endif
        !           487: 
        !           488:   unsigned char size_unit;
        !           489:   unsigned char align;
        !           490:   unsigned char sep_unit;
        !           491: 
        !           492:   union tree_node *sep;
        !           493:   union tree_node *size;
        !           494: 
        !           495:   union tree_node *base_init_list;
        !           496:   union tree_node *abstract_virtuals;
        !           497:   union tree_node *as_list;
        !           498:   union tree_node *id_as_list;
        !           499:   union tree_node *binfo_as_list;
        !           500:   union tree_node *vtbl_ptr;
        !           501:   union tree_node *instance_variable;
        !           502:   union tree_node *friend_classes;
        !           503: 
        !           504:   char *mi_matrix;
        !           505:   union tree_node *conversions[last_conversion_type];
        !           506:   union tree_node *wrap_type;
        !           507: 
        !           508:   union tree_node *dossier;
        !           509: 
        !           510: #ifdef SOS
        !           511:   union tree_node *typename_as_string;
        !           512:   union tree_node *dynamic_filename;
        !           513:   union tree_node *dynamic_table;
        !           514: #endif
        !           515: };
        !           516: 
        !           517: /* Indicates whether a template should be (or has been) expanded for this
        !           518:    class definition.  0=do, 1=did, 2=don't, 3=didn't.  */
        !           519: #define CLASSTYPE_USE_TEMPLATE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.use_template)
        !           520: 
        !           521: /* Fields used for storing information before the class is defined.
        !           522:    After the class is defined, these fields hold other information.  */
        !           523: 
        !           524: /* List of friends which were defined inline in this class definition.  */
        !           525: #define CLASSTYPE_INLINE_FRIENDS(NODE) (TYPE_NONCOPIED_PARTS (NODE))
        !           526: 
        !           527: /* Nonzero for _CLASSTYPE means that the _CLASSTYPE either has
        !           528:    a special meaning for the assignment operator ("operator="),
        !           529:    or one of its fields (or base members) has a special meaning
        !           530:    defined.  */
        !           531: #define TYPE_HAS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assignment)
        !           532: #define TYPE_GETS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assignment)
        !           533: 
        !           534: /* Nonzero for _CLASSTYPE means that operator new and delete are defined,
        !           535:    respectively.  */
        !           536: #define TREE_GETS_NEW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_new)
        !           537: #define TREE_GETS_DELETE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_delete)
        !           538: 
        !           539: /* Nonzero for TREE_LIST or _TYPE node means that this node is class-local.  */
        !           540: #define TREE_NONLOCAL_FLAG(NODE) (TREE_LANG_FLAG_0 (NODE))
        !           541: 
        !           542: /* Ditto, for `private' declarations.  */
        !           543: #define TREE_VIA_PRIVATE(NODE) ((NODE)->common.private_flag)
        !           544: 
        !           545: /* Nonzero for TREE_LIST node means that the path to the
        !           546:    base class is via a `protected' declaration, which preserves
        !           547:    protected fields from the base class as protected.
        !           548:    OVERLOADED.  */
        !           549: #define TREE_VIA_PROTECTED(NODE) ((NODE)->common.static_flag)
        !           550: 
        !           551: /* Nonzero for a _CLASSTYPE node which we know to be private.  */
        !           552: #define TYPE_PRIVATE_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.private_attr)
        !           553: 
        !           554: /* Nonzero means that this _CLASSTYPE node defines ways of converting
        !           555:    itself to other types.  */
        !           556: #define TYPE_HAS_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_type_conversion)
        !           557: 
        !           558: /* Nonzero means that this _CLASSTYPE node can convert itself to an
        !           559:    INTEGER_TYPE.  */
        !           560: #define TYPE_HAS_INT_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_int_conversion)
        !           561: 
        !           562: /* Nonzero means that this _CLASSTYPE node can convert itself to an
        !           563:    REAL_TYPE.  */
        !           564: #define TYPE_HAS_REAL_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_float_conversion)
        !           565: 
        !           566: /* Nonzero means that this _CLASSTYPE node overloads operator=(X&).  */
        !           567: #define TYPE_HAS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assign_ref)
        !           568: #define TYPE_GETS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assign_ref)
        !           569: #define TYPE_HAS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_const_assign_ref)
        !           570: #define TYPE_GETS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_assign_ref)
        !           571: 
        !           572: /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor.  */
        !           573: #define TYPE_HAS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_init_ref)
        !           574: #define TYPE_GETS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_ref)
        !           575: #define TYPE_GETS_CONST_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_init_ref)
        !           576: 
        !           577: /* Nonzero means that this _CLASSTYPE node has an X(X ...) constructor.
        !           578:    Note that there must be other arguments, or this constructor is flaged
        !           579:    as being erroneous.  */
        !           580: #define TYPE_GETS_INIT_AGGR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_aggr)
        !           581: 
        !           582: /* Nonzero means that this type is being defined.  I.e., the left brace
        !           583:    starting the definition of this type has been seen.  */
        !           584: #define TYPE_BEING_DEFINED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.being_defined)
        !           585: /* Nonzero means that this type has been redefined.  In this case, if
        !           586:    convenient, don't reprocess any methods that appear in its redefinition.  */
        !           587: #define TYPE_REDEFINED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.redefined)
        !           588: 
        !           589: /* Nonzero means that this _CLASSTYPE node overloads the method call
        !           590:    operator.  In this case, all method calls go through `operator->()(...).  */
        !           591: #define TYPE_OVERLOADS_METHOD_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_method_call_overloaded)
        !           592: 
        !           593: /* The is the VAR_DECL that contains NODE's dossier.  */
        !           594: #define CLASSTYPE_DOSSIER(NODE) (TYPE_LANG_SPECIFIC(NODE)->dossier)
        !           595: 
        !           596: #define TYPE_WRAP_TYPE(NODE) (TYPE_LANG_SPECIFIC(NODE)->wrap_type)
        !           597: 
        !           598: #define TYPE_HAS_WRAPPER(NODE) (TYPE_LANG_SPECIFIC(NODE)->wrap_type == TYPE_MAIN_VARIANT (NODE))
        !           599: #define TYPE_NEEDS_WRAPPER(NODE) (TYPE_LANG_SPECIFIC(NODE)->wrap_type != 0 && TYPE_LANG_SPECIFIC(NODE)->wrap_type != TYPE_MAIN_VARIANT (NODE))
        !           600: #define TYPE_HAS_WRAPPER_PRED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_wrapper_pred)
        !           601: 
        !           602: /* Nonzero means that this _CLASSTYPE node overloads operator().  */
        !           603: #define TYPE_OVERLOADS_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_call_overloaded)
        !           604: 
        !           605: /* Nonzero means that this _CLASSTYPE node overloads operator[].  */
        !           606: #define TYPE_OVERLOADS_ARRAY_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_array_ref_overloaded)
        !           607: 
        !           608: /* Nonzero means that this _CLASSTYPE node overloads operator->.  */
        !           609: #define TYPE_OVERLOADS_ARROW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_arrow_overloaded)
        !           610: 
        !           611: /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses
        !           612:    multiple inheritance.  If this is 0 for the root of a type
        !           613:    hierarchy, then we can use more efficient search techniques.  */
        !           614: #define TYPE_USES_MULTIPLE_INHERITANCE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.uses_multiple_inheritance)
        !           615: 
        !           616: /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses
        !           617:    virtual base classes.  If this is 0 for the root of a type
        !           618:    hierarchy, then we can use more efficient search techniques.  */
        !           619: #define TYPE_USES_VIRTUAL_BASECLASSES(NODE) (TREE_LANG_FLAG_3(NODE))
        !           620: 
        !           621: /* List of lists of member functions defined in this class.  */
        !           622: #define CLASSTYPE_METHOD_VEC(NODE) TYPE_METHODS(NODE)
        !           623: 
        !           624: /* Pointer from any member function to the head of the list of
        !           625:    member functions of the type that member function belongs to.  */
        !           626: #define CLASSTYPE_BASELINK_VEC(NODE) (TYPE_LANG_SPECIFIC(NODE)->baselink_vec)
        !           627: 
        !           628: /* Mark bits for depth-first and breath-first searches.  */
        !           629: #if !PARANOID
        !           630: #define CLASSTYPE_MARKED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked)
        !           631: #define CLASSTYPE_MARKED2(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2)
        !           632: #define CLASSTYPE_MARKED3(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3)
        !           633: #define CLASSTYPE_MARKED4(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4)
        !           634: #define CLASSTYPE_MARKED5(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5)
        !           635: #define CLASSTYPE_MARKED6(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6)
        !           636: /* Macros to modify the above flags */
        !           637: #define SET_CLASSTYPE_MARKED(NODE) (CLASSTYPE_MARKED(NODE) = 1)
        !           638: #define CLEAR_CLASSTYPE_MARKED(NODE) (CLASSTYPE_MARKED(NODE) = 0)
        !           639: #define SET_CLASSTYPE_MARKED2(NODE) (CLASSTYPE_MARKED2(NODE) = 1)
        !           640: #define CLEAR_CLASSTYPE_MARKED2(NODE) (CLASSTYPE_MARKED2(NODE) = 0)
        !           641: #define SET_CLASSTYPE_MARKED3(NODE) (CLASSTYPE_MARKED3(NODE) = 1)
        !           642: #define CLEAR_CLASSTYPE_MARKED3(NODE) (CLASSTYPE_MARKED3(NODE) = 0)
        !           643: #define SET_CLASSTYPE_MARKED4(NODE) (CLASSTYPE_MARKED4(NODE) = 1)
        !           644: #define CLEAR_CLASSTYPE_MARKED4(NODE) (CLASSTYPE_MARKED4(NODE) = 0)
        !           645: #define SET_CLASSTYPE_MARKED5(NODE) (CLASSTYPE_MARKED5(NODE) = 1)
        !           646: #define CLEAR_CLASSTYPE_MARKED5(NODE) (CLASSTYPE_MARKED5(NODE) = 0)
        !           647: #define SET_CLASSTYPE_MARKED6(NODE) (CLASSTYPE_MARKED6(NODE) = 1)
        !           648: #define CLEAR_CLASSTYPE_MARKED6(NODE) (CLASSTYPE_MARKED6(NODE) = 0)
        !           649: #else
        !           650: #define CLASSTYPE_MARKED(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked)
        !           651: #define CLASSTYPE_MARKED2(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2)
        !           652: #define CLASSTYPE_MARKED3(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3)
        !           653: #define CLASSTYPE_MARKED4(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4)
        !           654: #define CLASSTYPE_MARKED5(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5)
        !           655: #define CLASSTYPE_MARKED6(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6)
        !           656: /* Macros to modify the above flags */
        !           657: #define SET_CLASSTYPE_MARKED(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked = 1)
        !           658: #define CLEAR_CLASSTYPE_MARKED(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked = 0)
        !           659: #define SET_CLASSTYPE_MARKED2(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2 = 1)
        !           660: #define CLEAR_CLASSTYPE_MARKED2(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2 = 0)
        !           661: #define SET_CLASSTYPE_MARKED3(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3 = 1)
        !           662: #define CLEAR_CLASSTYPE_MARKED3(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3 = 0)
        !           663: #define SET_CLASSTYPE_MARKED4(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4 = 1)
        !           664: #define CLEAR_CLASSTYPE_MARKED4(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4 = 0)
        !           665: #define SET_CLASSTYPE_MARKED5(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5 = 1)
        !           666: #define CLEAR_CLASSTYPE_MARKED5(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5 = 0)
        !           667: #define SET_CLASSTYPE_MARKED6(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6 = 1)
        !           668: #define CLEAR_CLASSTYPE_MARKED6(NODE) (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't'), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6 = 0)
        !           669: #endif
        !           670: 
        !           671: #define CLASSTYPE_TAGS(NODE) (TYPE_LANG_SPECIFIC(NODE)->tags)
        !           672: #define CLASSTYPE_NAMES(NODE) (TYPE_LANG_SPECIFIC(NODE)->names)
        !           673: 
        !           674: /* Remove when done merging.  */
        !           675: #define CLASSTYPE_VFIELD(NODE) TYPE_VFIELD(NODE)
        !           676: 
        !           677: /* The number of virtual functions defined for this
        !           678:    _CLASSTYPE node.  */
        !           679: #define CLASSTYPE_VSIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vsize)
        !           680: /* The virtual base classes that this type uses.  */
        !           681: #define CLASSTYPE_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbases)
        !           682: /* The virtual function pointer fields that this type contains.  */
        !           683: #define CLASSTYPE_VFIELDS(NODE) (TYPE_LANG_SPECIFIC(NODE)->vfields)
        !           684: 
        !           685: /* Number of baseclasses defined for this type.
        !           686:    0 means no base classes.  */
        !           687: #define CLASSTYPE_N_BASECLASSES(NODE) \
        !           688:   (TYPE_BINFO_BASETYPES (NODE) ? TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES(NODE)) : 0)
        !           689: 
        !           690: /* Memoize the number of super classes (base classes) tha this node
        !           691:    has.  That way we can know immediately (albeit conservatively how
        !           692:    large a multiple-inheritance matrix we need to build to find
        !           693:    derivation information.  */
        !           694: #define CLASSTYPE_N_SUPERCLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->n_ancestors)
        !           695: #define CLASSTYPE_N_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.n_vancestors)
        !           696: 
        !           697: /* Record how deep the inheritance is for this class so `void*' conversions
        !           698:    are less favorable than a conversion to the most base type.  */
        !           699: #define CLASSTYPE_MAX_DEPTH(NODE) (TYPE_LANG_SPECIFIC(NODE)->max_depth)
        !           700: 
        !           701: /* Used for keeping search-specific information.  Any search routine
        !           702:    which uses this must define what exactly this slot is used for.  */
        !           703: #define CLASSTYPE_SEARCH_SLOT(NODE) (TYPE_LANG_SPECIFIC(NODE)->search_slot)
        !           704: 
        !           705: /* Entry for keeping memoization tables for this type to
        !           706:    hopefully speed up search routines.  Since it is a pointer,
        !           707:    it can mean almost anything.  */
        !           708: #define CLASSTYPE_MTABLE_ENTRY(NODE) (TYPE_LANG_SPECIFIC(NODE)->memoized_table_entry)
        !           709: 
        !           710: /* This is the total size of the baseclasses defined for this type.
        !           711:    Needed because it is desirable to layout such information
        !           712:    before begining to process the class itself, and we
        !           713:    don't want to compute it second time when actually laying
        !           714:    out the type for real.  */
        !           715: #define CLASSTYPE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->size)
        !           716: #define CLASSTYPE_SIZE_UNIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->size_unit)
        !           717: #define CLASSTYPE_MODE(NODE) (TYPE_LANG_SPECIFIC(NODE)->mode)
        !           718: #define CLASSTYPE_ALIGN(NODE) (TYPE_LANG_SPECIFIC(NODE)->align)
        !           719: 
        !           720: /* This is the space needed for virtual base classes.  NULL if
        !           721:    there are no virtual basetypes.  */
        !           722: #define CLASSTYPE_VBASE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbase_size)
        !           723: 
        !           724: /* A cons list of structure elements which either have constructors
        !           725:    to be called, or virtual function table pointers which
        !           726:    need initializing.  Depending on what is being initialized,
        !           727:    the TREE_PURPOSE and TREE_VALUE fields have different meanings:
        !           728: 
        !           729:    Member initialization: <FIELD_DECL, TYPE>
        !           730:    Base class construction: <NULL_TREE, BASETYPE>
        !           731:    Base class initialization: <BASE_INITIALIZAION, THESE_INITIALIZATIONS>
        !           732:    Whole type: <MEMBER_INIT, BASE_INIT>.  */
        !           733: #define CLASSTYPE_BASE_INIT_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->base_init_list)
        !           734: 
        !           735: /* A cons list of virtual functions which cannot be inherited by
        !           736:    derived classes.  When deriving from this type, the derived
        !           737:    class must provide its own definition for each of these functions.  */
        !           738: #define CLASSTYPE_ABSTRACT_VIRTUALS(NODE) (TYPE_LANG_SPECIFIC(NODE)->abstract_virtuals)
        !           739: 
        !           740: #define CLASSTYPE_ALTERS_VISIBILITIES_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.alters_visibilities)
        !           741: 
        !           742: /* Nonzero means that this aggr type has been `closed' by a semicolon.  */
        !           743: #define CLASSTYPE_GOT_SEMICOLON(NODE) (TYPE_LANG_SPECIFIC (NODE)->type_flags.got_semicolon)
        !           744: 
        !           745: /* Nonzero means that the main virtual function table pointer needs to be
        !           746:    set because base constructors have placed the wrong value there.
        !           747:    If this is zero, it means that they placed the right value there,
        !           748:    and there is no need to change it.  */
        !           749: #define CLASSTYPE_NEEDS_VIRTUAL_REINIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_virtual_reinit)
        !           750: 
        !           751: /* Nonzero means that if this type has virtual functions, that
        !           752:    the virtual function table will be written out.  */
        !           753: #define CLASSTYPE_VTABLE_NEEDS_WRITING(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.vtable_needs_writing)
        !           754: 
        !           755: /* Nonzero means that this type defines its own local type declarations.  */
        !           756: #define CLASSTYPE_LOCAL_TYPEDECLS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.local_typedecls)
        !           757: 
        !           758: /* Nonzero means that this type has an X() constructor.  */
        !           759: #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_default_ctor)
        !           760: 
        !           761: /* Many routines need to cons up a list of basetypes for visibility
        !           762:    checking.  This field contains a TREE_LIST node whose TREE_VALUE
        !           763:    is the main variant of the type, and whose TREE_VIA_PUBLIC
        !           764:    and TREE_VIA_VIRTUAL bits are correctly set.  */
        !           765: #define CLASSTYPE_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->as_list)
        !           766: /* Same, but cache a list whose value is the name of this type.  */
        !           767: #define CLASSTYPE_ID_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->id_as_list)
        !           768: /* Same, but cache a list whose value is the binfo of this type.  */
        !           769: #define CLASSTYPE_BINFO_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->binfo_as_list)
        !           770: 
        !           771: /* Slot in which to cache a copy of the local vtable pointer.  */
        !           772: #define CLASSTYPE_VTBL_PTR(NODE) (TYPE_LANG_SPECIFIC(NODE)->vtbl_ptr)
        !           773: 
        !           774: /* Hold the instance object associated with this method.  */
        !           775: #define CLASSTYPE_INST_VAR(NODE) (TYPE_LANG_SPECIFIC(NODE)->instance_variable)
        !           776: 
        !           777: /* A list of class types with which this type is a friend.  */
        !           778: #define CLASSTYPE_FRIEND_CLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->friend_classes)
        !           779: 
        !           780: /* Keep an inheritance lattice around so we can quickly tell whether
        !           781:    a type is derived from another or not.  */
        !           782: #define CLASSTYPE_MI_MATRIX(NODE) (TYPE_LANG_SPECIFIC(NODE)->mi_matrix)
        !           783: 
        !           784: /* If there is exactly one conversion to a non-void, non-const pointer type,
        !           785:    remember that here.  If there are more than one, put
        !           786:    `error_mark_node' here.  If there are none, this holds NULL_TREE.  */
        !           787: #define CLASSTYPE_CONVERSION(NODE,KIND) \
        !           788:   (TYPE_LANG_SPECIFIC(NODE)->conversions[(int) KIND])
        !           789: 
        !           790: /* Nonzero means that class is "dynamic" in SOS sense.  (IRIA-specific.)  */
        !           791: #define TYPE_DYNAMIC(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.dynamic)
        !           792: 
        !           793: #ifdef SOS
        !           794: /* The name of this type as a STRING.  */
        !           795: #define CLASSTYPE_TYPENAME_AS_STRING(NODE) (TYPE_LANG_SPECIFIC(NODE)->typename_as_string)
        !           796: /* The name of the file which defines this type.  */
        !           797: #define CLASSTYPE_DYNAMIC_FILENAME(NODE) (TYPE_LANG_SPECIFIC(NODE)->dynamic_filename)
        !           798: /* The table of all member functions, linearized.  */
        !           799: #define CLASSTYPE_DYNAMIC_TABLE(NODE) (TYPE_LANG_SPECIFIC(NODE)->dynamic_table)
        !           800: #endif
        !           801: 
        !           802: /* Say whether this node was declared as a "class" or a "struct".  */
        !           803: #define CLASSTYPE_DECLARED_CLASS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_class)
        !           804: /* Say whether this node was declared as a "class" or a "struct".  */
        !           805: #define CLASSTYPE_DECLARED_EXCEPTION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_exception)
        !           806: 
        !           807: /* Nonzero if this class has const members which have no specified initialization.  */
        !           808: #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.const_needs_init)
        !           809: 
        !           810: /* Nonzero if this class has ref members which have no specified initialization.  */
        !           811: #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.ref_needs_init)
        !           812: 
        !           813: /* Nonzero if this class is included from a header file which employs
        !           814:    `#pragma interface', and it is not included in its implementation file.  */
        !           815: #define CLASSTYPE_INTERFACE_ONLY(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_only)
        !           816: 
        !           817: /* Same as above, but for classes whose purpose we do not know.  */
        !           818: #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_unknown)
        !           819: 
        !           820: /* Nonzero if a _DECL node requires us to output debug info for this class.  */
        !           821: #define CLASSTYPE_DEBUG_REQUESTED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.debug_requested)
        !           822: 
        !           823: /* Additional macros for inheritance information.  */
        !           824: 
        !           825: #define CLASSTYPE_VBINFO(NODE,VIA_PUBLIC) \
        !           826:   (TYPE_LANG_SPECIFIC (NODE)->vbinfo[VIA_PUBLIC])
        !           827: 
        !           828: /* When following an binfo-specific chain, this is the cumulative
        !           829:    via-public flag.  */
        !           830: #define BINFO_VIA_PUBLIC(NODE) TREE_LANG_FLAG_5 (NODE)
        !           831: 
        !           832: /* When building a matrix to determine by a single lookup
        !           833:    whether one class is derived from another or not,
        !           834:    this field is the index of the class in the table.  */
        !           835: #define CLASSTYPE_CID(NODE) (TYPE_LANG_SPECIFIC(NODE)->cid)
        !           836: #define BINFO_CID(NODE) CLASSTYPE_CID(BINFO_TYPE(NODE))
        !           837: 
        !           838: /* Nonzero means marked by DFS or BFS search, including searches
        !           839:    by `get_binfo' and `get_base_distance'.  */
        !           840: #define BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED(BINFO_TYPE(NODE)):TREE_LANG_FLAG_0(NODE))
        !           841: /* Macros needed because of C compilers that don't allow conditional
        !           842:    expressions to be lvalues.  Grr!  */
        !           843: #define SET_BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_0(NODE)=1))
        !           844: #define CLEAR_BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_0(NODE)=0))
        !           845: 
        !           846: /* Nonzero means marked in building initialization list.  */
        !           847: #define BINFO_BASEINIT_MARKED(NODE) CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
        !           848: /* Modifier macros */
        !           849: #define SET_BINFO_BASEINIT_MARKED(NODE) SET_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
        !           850: #define CLEAR_BINFO_BASEINIT_MARKED(NODE) CLEAR_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
        !           851: 
        !           852: /* Nonzero means marked in search through virtual inheritance hierarchy.  */
        !           853: #define BINFO_VBASE_MARKED(NODE) CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
        !           854: /* Modifier macros */
        !           855: #define SET_BINFO_VBASE_MARKED(NODE) SET_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
        !           856: #define CLEAR_BINFO_VBASE_MARKED(NODE) CLEAR_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE))
        !           857: 
        !           858: /* Nonzero means marked in search for members or member functions.  */
        !           859: #define BINFO_FIELDS_MARKED(NODE) \
        !           860:   (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)):TREE_LANG_FLAG_2(NODE))
        !           861: #define SET_BINFO_FIELDS_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED2(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_2(NODE)=1))
        !           862: #define CLEAR_BINFO_FIELDS_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED2(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_2(NODE)=0))
        !           863: 
        !           864: /* Nonzero means that this class is on a path leading to a new vtable.  */
        !           865: #define BINFO_VTABLE_PATH_MARKED(NODE) \
        !           866:   (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):TREE_LANG_FLAG_3(NODE))
        !           867: #define SET_BINFO_VTABLE_PATH_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_3(NODE)=1))
        !           868: #define CLEAR_BINFO_VTABLE_PATH_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_3(NODE)=0))
        !           869: 
        !           870: /* Nonzero means that this class has a new vtable.  */
        !           871: #define BINFO_NEW_VTABLE_MARKED(NODE) \
        !           872:   (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):TREE_LANG_FLAG_4(NODE))
        !           873: #define SET_BINFO_NEW_VTABLE_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_4(NODE)=1))
        !           874: #define CLEAR_BINFO_NEW_VTABLE_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_4(NODE)=0))
        !           875: 
        !           876: /* Nonzero means this class has initialized its virtual baseclasses.  */
        !           877: #define BINFO_VBASE_INIT_MARKED(NODE) \
        !           878:   (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):TREE_LANG_FLAG_5(NODE))
        !           879: #define SET_BINFO_VBASE_INIT_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_5(NODE)=1))
        !           880: #define CLEAR_BINFO_VBASE_INIT_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_5(NODE)=0))
        !           881: 
        !           882: /* Accessor macros for the vfield slots in structures.  */
        !           883: 
        !           884: /* Get the assoc info that caused this vfield to exist.  */
        !           885: #define VF_BINFO_VALUE(NODE) TREE_PURPOSE (NODE)
        !           886: 
        !           887: /* Get that same information as a _TYPE.  */
        !           888: #define VF_BASETYPE_VALUE(NODE) TREE_VALUE (NODE)
        !           889: 
        !           890: /* Get the value of the top-most type dominating the non-`normal' vfields.  */
        !           891: #define VF_DERIVED_VALUE(NODE) (VF_BINFO_VALUE (NODE) ? BINFO_TYPE (VF_BINFO_VALUE (NODE)) : NULL_TREE)
        !           892: 
        !           893: /* Get the value of the top-most type that's `normal' for the vfield.  */
        !           894: #define VF_NORMAL_VALUE(NODE) TREE_TYPE (NODE)
        !           895: 
        !           896: /* Nonzero for TREE_LIST node means that this list of things
        !           897:    is a list of parameters, as opposed to a list of expressions.  */
        !           898: #define TREE_PARMLIST(NODE) ((NODE)->common.unsigned_flag) /* overloaded! */
        !           899: 
        !           900: /* Nonzero for FIELD_DECL node means that this FIELD_DECL is
        !           901:    a member of an anonymous union construct.  The name of the
        !           902:    union is .  */
        !           903: #define TREE_ANON_UNION_ELEM(NODE) ((NODE)->decl.regdecl_flag) /* overloaded! */
        !           904: 
        !           905: /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that
        !           906:    this type can raise.  */
        !           907: #define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_NONCOPIED_PARTS (NODE)
        !           908: 
        !           909: struct lang_decl_flags
        !           910: {
        !           911: #ifdef ONLY_INT_FIELDS
        !           912:   int language : 8;
        !           913: #else
        !           914:   enum languages language : 8;
        !           915: #endif
        !           916: 
        !           917:   unsigned operator_attr : 1;
        !           918:   unsigned constructor_attr : 1;
        !           919:   unsigned returns_first_arg : 1;
        !           920:   unsigned preserves_first_arg : 1;
        !           921:   unsigned friend_attr : 1;
        !           922:   unsigned static_function : 1;
        !           923:   unsigned const_memfunc : 1;
        !           924:   unsigned volatile_memfunc : 1;
        !           925: 
        !           926:   unsigned abstract_virtual : 1;
        !           927:   unsigned permanent_attr : 1 ;
        !           928:   unsigned constructor_for_vbase_attr : 1;
        !           929:   unsigned dummy : 13;
        !           930: 
        !           931:   tree visibility;
        !           932:   tree context;
        !           933: };
        !           934: 
        !           935: struct lang_decl
        !           936: {
        !           937:   struct lang_decl_flags decl_flags;
        !           938: 
        !           939:   struct template_info *template_info;
        !           940:   tree main_decl_variant;
        !           941:   struct pending_inline *pending_inline_info;
        !           942:   tree vbase_init_list;
        !           943:   tree chain;
        !           944: 
        !           945: #ifdef SOS
        !           946:   tree dynamic_index;
        !           947: #endif
        !           948: };
        !           949: 
        !           950: /* Non-zero if NODE is a _DECL with TREE_READONLY set.  */
        !           951: #define TREE_READONLY_DECL_P(NODE) \
        !           952:   (TREE_READONLY (NODE) && TREE_CODE_CLASS (TREE_CODE (NODE)) == 'd')
        !           953: 
        !           954: /* For FUNCTION_DECLs: return the language in which this decl
        !           955:    was declared.  */
        !           956: #define DECL_LANGUAGE(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.language)
        !           957: 
        !           958: /* For FUNCTION_DECLs: nonzero means that this function is a constructor.  */
        !           959: #define DECL_CONSTRUCTOR_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_attr)
        !           960: /* For FUNCTION_DECLs: nonzero means that this function is a constructor
        !           961:    for an object with virtual baseclasses.  */
        !           962: #define DECL_CONSTRUCTOR_FOR_VBASE_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_for_vbase_attr)
        !           963: 
        !           964: /* For FUNCTION_DECLs: nonzero means that the constructor
        !           965:    is known to return a non-zero `this' unchanged.  */
        !           966: #define DECL_RETURNS_FIRST_ARG(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.returns_first_arg)
        !           967: 
        !           968: /* Nonzero for FUNCTION_DECL means that this constructor is known to
        !           969:    not make any assignment to `this', and therefore can be trusted
        !           970:    to return it unchanged.  Otherwise, we must re-assign `current_class_decl'
        !           971:    after performing base initializations.  */
        !           972: #define DECL_PRESERVES_THIS(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.preserves_first_arg)
        !           973: 
        !           974: /* Nonzero for _DECL means that this decl appears in (or will appear
        !           975:    in) as a member in a RECORD_TYPE or UNION_TYPE node.  It is also for
        !           976:    detecting circularity in case members are multiply defined.  In the
        !           977:    case of a VAR_DECL, it is also used to determince how program storage
        !           978:    should be allocated.  */
        !           979: #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3(NODE))
        !           980: 
        !           981: /* Nonzero for FUNCTION_DECL means that this decl is just a
        !           982:    friend declaration, and should not be added to the list of
        !           983:    member functions for this class.  */
        !           984: #define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.friend_attr)
        !           985: 
        !           986: /* Nonzero for FUNCTION_DECL means that this decl is a static
        !           987:    member function.  */
        !           988: #define DECL_STATIC_FUNCTION_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.static_function)
        !           989: 
        !           990: /* Nonzero for FUNCTION_DECL means that this member function
        !           991:    has `this' as const X *const.  */
        !           992: #define DECL_CONST_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.const_memfunc)
        !           993: 
        !           994: /* Nonzero for FUNCTION_DECL means that this member function
        !           995:    has `this' as volatile X *const.  */
        !           996: #define DECL_VOLATILE_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.volatile_memfunc)
        !           997: 
        !           998: /* Nonzero for FUNCTION_DECL means that this member function
        !           999:    exists only as part of an abstract class's interface.  */
        !          1000: #define DECL_ABSTRACT_VIRTUAL_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.abstract_virtual)
        !          1001: 
        !          1002: /* Nonzero if allocated on permanent_obstack.  */
        !          1003: #define LANG_DECL_PERMANENT(LANGDECL) ((LANGDECL)->decl_flags.permanent_attr)
        !          1004: 
        !          1005: /* The _TYPE context in which this _DECL appears.  This field is used
        !          1006:    only to compute visibility information.  */
        !          1007: #define DECL_CLASS_CONTEXT(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.context)
        !          1008: 
        !          1009: /* For a FUNCTION_DECL: the chain through which the next method
        !          1010:    in the method chain is found.  We now use TREE_CHAIN to
        !          1011:    link into the FIELD_DECL chain.  */
        !          1012: #if 1
        !          1013: #define DECL_CHAIN(NODE) (DECL_LANG_SPECIFIC(NODE)->chain)
        !          1014: #else
        !          1015: #define DECL_CHAIN(NODE) (TREE_CHAIN (NODE))
        !          1016: #endif
        !          1017: 
        !          1018: /* Points back to the decl which caused this lang_decl to be allocated.  */
        !          1019: #define DECL_MAIN_VARIANT(NODE) (DECL_LANG_SPECIFIC(NODE)->main_decl_variant)
        !          1020: 
        !          1021: /* For a FUNCTION_DECL: if this function was declared inline inside of
        !          1022:    a class declaration, this is where the text for the function is
        !          1023:    squirreled away.  */
        !          1024: #define DECL_PENDING_INLINE_INFO(NODE) (DECL_LANG_SPECIFIC(NODE)->pending_inline_info)
        !          1025: 
        !          1026: /* Holds information about how virtual base classes should be initialized
        !          1027:    by this constructor *if* this constructor is the one to perform
        !          1028:    such initialization.  */
        !          1029: #define DECL_VBASE_INIT_LIST(NODE) (DECL_LANG_SPECIFIC(NODE)->vbase_init_list)
        !          1030: 
        !          1031: /* For a TEMPLATE_DECL: template-specific information.  */
        !          1032: #define DECL_TEMPLATE_INFO(NODE) (DECL_LANG_SPECIFIC(NODE)->template_info)
        !          1033: 
        !          1034: /* Nonzero in INT_CST means that this int is negative by dint of
        !          1035:    using a twos-complement negated operand.  */
        !          1036: #define TREE_NEGATED_INT(NODE) (TREE_LANG_FLAG_0 (NODE))
        !          1037: 
        !          1038: /* Nonzero in any kind of _EXPR or _REF node means that it is a call
        !          1039:    to a storage allocation routine.  If, later, alternate storage
        !          1040:    is found to hold the object, this call can be ignored.  */
        !          1041: #define TREE_CALLS_NEW(NODE) (TREE_LANG_FLAG_1 (NODE))
        !          1042: 
        !          1043: /* Nonzero in any kind of _TYPE that uses multiple inheritance
        !          1044:    or virtual baseclasses.  */
        !          1045: #define TYPE_USES_COMPLEX_INHERITANCE(NODE) (TREE_LANG_FLAG_1 (NODE))
        !          1046: 
        !          1047: /* Nonzero in IDENTIFIER_NODE means that this name is overloaded, and
        !          1048:    should be looked up in a non-standard way.  */
        !          1049: #define TREE_OVERLOADED(NODE) (TREE_LANG_FLAG_0 (NODE))
        !          1050: #define DECL_OVERLOADED(NODE) (DECL_LANG_FLAG_4 (NODE))
        !          1051: 
        !          1052: /* Nonzero if this (non-TYPE)_DECL has its virtual attribute set.
        !          1053:    For a FUNCTION_DECL, this is when the function is a virtual function.
        !          1054:    For a VAR_DECL, this is when the variable is a virtual function table.
        !          1055:    For a FIELD_DECL, when the field is the field for the virtual function table.
        !          1056:    For an IDENTIFIER_NODE, nonzero if any function with this name
        !          1057:    has been declared virtual.
        !          1058: 
        !          1059:    For a _TYPE if it uses virtual functions (or is derived from
        !          1060:    one that does).  */
        !          1061: #define TYPE_VIRTUAL_P(NODE) (TREE_LANG_FLAG_2 (NODE))
        !          1062: 
        !          1063: /* Same, but tells if this field is private in current context.  */
        !          1064: #define DECL_PRIVATE(NODE) (DECL_LANG_FLAG_5 (NODE))
        !          1065: 
        !          1066: /* Same, but tells if this field is private in current context.  */
        !          1067: #define DECL_PROTECTED(NODE) (DECL_LANG_FLAG_6(NODE))
        !          1068: 
        !          1069: #define DECL_PUBLIC(NODE) (DECL_LANG_FLAG_7(NODE))
        !          1070: 
        !          1071: /* Record whether a typedef for type `int' was actually `signed int'.  */
        !          1072: #define C_TYPEDEF_EXPLICITLY_SIGNED(exp) DECL_LANG_FLAG_1 ((exp))
        !          1073: 
        !          1074: /* Record whether a type or decl was written with nonconstant size.
        !          1075:    Note that TYPE_SIZE may have simplified to a constant.  */
        !          1076: #define C_TYPE_VARIABLE_SIZE(type) TREE_LANG_FLAG_4 (type)
        !          1077: #define C_DECL_VARIABLE_SIZE(type) DECL_LANG_FLAG_8 (type)
        !          1078: 
        !          1079: /* Nonzero for _TYPE means that the _TYPE defines
        !          1080:    at least one constructor.  */
        !          1081: #define TYPE_HAS_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1(NODE))
        !          1082: 
        !          1083: /* When appearing in an INDIRECT_REF, it means that the tree structure
        !          1084:    underneath is actually a call to a constructor.  This is needed
        !          1085:    when the constructor must initialize local storage (which can
        !          1086:    be automatically destroyed), rather than allowing it to allocate
        !          1087:    space from the heap.
        !          1088: 
        !          1089:    When appearing in a SAVE_EXPR, it means that underneath
        !          1090:    is a call to a constructor.
        !          1091: 
        !          1092:    When appearing in a CONSTRUCTOR, it means that it was
        !          1093:    a GNU C constructor expression.
        !          1094: 
        !          1095:    When appearing in a FIELD_DECL, it means that this field
        !          1096:    has been duly initialized in its constructor.  */
        !          1097: #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4(NODE))
        !          1098: 
        !          1099: /* Indicates that a NON_LVALUE_EXPR came from a C++ reference.
        !          1100:    Used to generate more helpful error message in case somebody
        !          1101:    tries to take its address.  */
        !          1102: #define TREE_REFERENCE_EXPR(NODE) (TREE_LANG_FLAG_3(NODE))
        !          1103: 
        !          1104: /* Nonzero for _TYPE means that the _TYPE defines a destructor.  */
        !          1105: #define TYPE_HAS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_2(NODE))
        !          1106: 
        !          1107: /* Nonzero for _TYPE node means that creating an object of this type
        !          1108:    will involve a call to a constructor.  This can apply to objects
        !          1109:    of ARRAY_TYPE if the type of the elements needs a constructor.  */
        !          1110: #define TYPE_NEEDS_CONSTRUCTING(NODE) (TYPE_LANG_FLAG_3(NODE))
        !          1111: #define TYPE_NEEDS_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_constructor)
        !          1112: 
        !          1113: /* Nonzero for _TYPE node means that destroying an object of this type
        !          1114:    will involve a call to a destructor.  This can apply to objects
        !          1115:    of ARRAY_TYPE is the type of the elements needs a destructor.  */
        !          1116: #define TYPE_NEEDS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_4(NODE))
        !          1117: 
        !          1118: /* Nonzero for VAR_DECL node means that `external' was specified in
        !          1119:    its declaration.  */
        !          1120: #define DECL_EXTERNAL(NODE) (DECL_LANG_FLAG_2(NODE))
        !          1121: 
        !          1122: /* Nonzero for SAVE_EXPR if used to initialize a PARM_DECL.  */
        !          1123: #define PARM_DECL_EXPR(NODE) (TREE_LANG_FLAG_2(NODE))
        !          1124: 
        !          1125: /* Nonzero in FUNCTION_DECL means it is really an operator.
        !          1126:    Just used to communicate formatting information to dbxout.c.  */
        !          1127: #define DECL_OPERATOR(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.operator_attr)
        !          1128: 
        !          1129: /* Define fields and accessors for nodes representing declared names.  */
        !          1130: 
        !          1131: /* C++: A derived class may be able to directly use the virtual
        !          1132:    function table of a base class.  When it does so, it may
        !          1133:    still have a decl node used to access the virtual function
        !          1134:    table (so that variables of this type can initialize their
        !          1135:    virtual function table pointers by name).  When such thievery
        !          1136:    is commited, know exactly which base class's virtual function
        !          1137:    table is the one being stolen.  This effectively computes the
        !          1138:    transitive closure.  */
        !          1139: #define DECL_VPARENT(NODE) ((NODE)->decl.arguments)
        !          1140: 
        !          1141: /* Make a slot so we can implement nested types.  This slot holds
        !          1142:    the IDENTIFIER_NODE that uniquely names the nested type.  This
        !          1143:    is for TYPE_DECLs only.  */
        !          1144: #if !PARANOID
        !          1145: #define DECL_NESTED_TYPENAME(NODE) ((NODE)->decl.arguments)
        !          1146: #else
        !          1147: #define DECL_NESTED_TYPENAME(NODE) (*DECL_NESTED_TYPENAME_PTR(NODE))
        !          1148: #ifdef __GNUC__
        !          1149: __inline
        !          1150: #endif
        !          1151: static tree * DECL_NESTED_TYPENAME_PTR(NODE) tree NODE; { return
        !          1152:   (assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 'd'),
        !          1153:    &(NODE)->decl.arguments) ;}
        !          1154: #endif
        !          1155: 
        !          1156: /* C++: all of these are overloaded!  These apply only to TYPE_DECLs.  */
        !          1157: #define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE))
        !          1158: #define DECL_UNDEFINED_FRIENDS(NODE) ((NODE)->decl.result)
        !          1159: #define DECL_WAITING_FRIENDS(NODE) ((tree)(NODE)->decl.rtl)
        !          1160: #define SET_DECL_WAITING_FRIENDS(NODE,VALUE) ((NODE)->decl.rtl=(struct rtx_def*)VALUE)
        !          1161: 
        !          1162: /* The DECL_VISIBILITY is used to record under which context
        !          1163:    special visibility rules apply.  */
        !          1164: #define DECL_VISIBILITY(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.visibility)
        !          1165: 
        !          1166: /* C++: all of these are overloaded!
        !          1167:    These apply to PARM_DECLs and VAR_DECLs.  */
        !          1168: #define DECL_REFERENCE_SLOT(NODE) ((tree)(NODE)->decl.arguments)
        !          1169: #define SET_DECL_REFERENCE_SLOT(NODE,VAL) ((NODE)->decl.arguments=VAL)
        !          1170: 
        !          1171: /* For local VAR_DECLs, holds index into gc-protected obstack.  */
        !          1172: #define DECL_GC_OFFSET(NODE) ((NODE)->decl.result)
        !          1173: 
        !          1174: /* Accessor macros for C++ template decl nodes.  */
        !          1175: #define DECL_TEMPLATE_IS_CLASS(NODE)    (DECL_RESULT(NODE) == NULL_TREE)
        !          1176: #define DECL_TEMPLATE_PARMS(NODE)       DECL_ARGUMENTS(NODE)
        !          1177: /* For class templates.  */
        !          1178: #define DECL_TEMPLATE_MEMBERS(NODE)     DECL_INITIAL(NODE)
        !          1179: /* For function, method, class-data templates.  */
        !          1180: #define DECL_TEMPLATE_RESULT(NODE)      DECL_RESULT(NODE)
        !          1181: #define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX(NODE)
        !          1182: 
        !          1183: /* ...and for unexpanded-parameterized-type nodes.  */
        !          1184: #define UPT_TEMPLATE(NODE)      TREE_PURPOSE(TYPE_VALUES(NODE))
        !          1185: #define UPT_PARMS(NODE)         TREE_VALUE(TYPE_VALUES(NODE))
        !          1186: 
        !          1187: #ifdef SOS
        !          1188: #define DECL_DINDEX(NODE) (DECL_LANG_SPECIFIC(NODE)->dynamic_index)
        !          1189: #endif
        !          1190: 
        !          1191: /* An enumeration of the kind of tags that C++ accepts.  */
        !          1192: enum tag_types { record_type, class_type, union_type, enum_type, exception_type };
        !          1193: 
        !          1194: /* Zero means prototype weakly, as in ANSI C (no args means nothing).
        !          1195:    Each language context defines how this variable should be set.  */
        !          1196: extern int strict_prototype;
        !          1197: extern int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus;
        !          1198: 
        !          1199: /* Non-zero means that if a label exists, and no other identifier
        !          1200:    applies, use the value of the label.  */
        !          1201: extern int flag_labels_ok;
        !          1202: 
        !          1203: /* Non-zero means to collect statistics which might be expensive
        !          1204:    and to print them when we are done.  */
        !          1205: extern int flag_detailed_statistics;
        !          1206: 
        !          1207: /* Non-zero means warn in function declared in derived class has the
        !          1208:    same name as a virtual in the base class, but fails to match the
        !          1209:    type signature of any virtual function in the base class.  */
        !          1210: extern int warn_overloaded_virtual;
        !          1211: 
        !          1212: /* in cp-decl{2}.c */
        !          1213: extern tree void_list_node;
        !          1214: extern tree void_zero_node;
        !          1215: extern tree default_function_type;
        !          1216: extern tree define_function ();
        !          1217: extern tree build_member_type ();
        !          1218: extern tree build_push_scope ();
        !          1219: 
        !          1220: extern tree vtable_entry_type;
        !          1221: extern tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node;
        !          1222: extern tree class_star_type_node;
        !          1223: extern tree build_vtable_entry ();
        !          1224: extern tree build_vfn_ref ();
        !          1225: extern tree finish_table ();
        !          1226: 
        !          1227: extern tree typedecl_for_tag ();
        !          1228: extern tree identifier_class_value ();
        !          1229: extern tree constructor_name ();
        !          1230: 
        !          1231: extern int complete_array_type ();
        !          1232: extern tree coerce_new_type (), coerce_delete_type ();
        !          1233: 
        !          1234: /* A node that is a list (length 1) of error_mark_nodes.  */
        !          1235: extern tree error_mark_list;
        !          1236: 
        !          1237: extern tree ptr_type_node;
        !          1238: extern tree class_type_node, record_type_node, union_type_node, enum_type_node;
        !          1239: extern tree exception_type_node, unknown_type_node;
        !          1240: 
        !          1241: extern tree get_temp_name (), get_temp_aggr (), get_temp_regvar ();
        !          1242: extern tree cleanup_after_call ();
        !          1243: extern tree build_type_conversion ();
        !          1244: extern tree convert_force ();
        !          1245: extern tree maybe_convert_decl_to_const ();
        !          1246: extern char *lang_printable_name ();
        !          1247: extern char *fndecl_as_string ();
        !          1248: extern char *build_overload_name ();
        !          1249: 
        !          1250: /* The largest size a virtual function table can be.
        !          1251:    Must be a (power of 2).  */
        !          1252: #ifndef VINDEX_MAX
        !          1253: #define VINDEX_MAX ((unsigned)128)
        !          1254: /* This is the integer ~ (vindex_max - 1).  */
        !          1255: #endif
        !          1256: extern tree vtbl_mask;
        !          1257: 
        !          1258: /* Array type `(void *)[]' */
        !          1259: extern tree vtbl_type_node;
        !          1260: 
        !          1261: extern tree get_parm_types ();
        !          1262: extern tree grokopexpr (), getaggrs (), groktypefield ();
        !          1263: extern tree grok_method_quals (), grok_enum_decls ();
        !          1264: extern void finish_anon_union();
        !          1265: extern tree long_long_integer_type_node, long_long_unsigned_type_node;
        !          1266: /* For building calls to `delete'.  */
        !          1267: extern tree integer_two_node, integer_three_node;
        !          1268: extern tree get_first_matching_virtual (), get_abstract_virtuals ();
        !          1269: 
        !          1270: /* in cp-typeck.c */
        !          1271: extern tree build_x_conditional_expr ();
        !          1272: extern tree merge_component_comparisons ();
        !          1273: extern tree build_x_unary_op (), build_x_binary_op ();
        !          1274: extern tree build_component_addr ();
        !          1275: extern tree build_x_function_call ();
        !          1276: extern tree require_complete_type ();
        !          1277: extern tree build_x_indirect_ref (), build_x_array_ref ();
        !          1278: extern tree build_x_modify_expr (), build_x_modify_op_expr ();
        !          1279: 
        !          1280: extern tree build_m_component_ref ();
        !          1281: extern tree build_component_type_expr ();
        !          1282: extern tree build_x_arrow ();
        !          1283: extern tree build_component_ref_1 ();
        !          1284: extern tree datatype (), unary_complex_lvalue (), target_type ();
        !          1285: extern tree build_return_stmt ();
        !          1286: extern tree convert_arguments (), commonparms ();
        !          1287: extern tree cplus_size_in_bytes ();
        !          1288: extern tree cplus_sizeof (), cplus_sizeof_nowarn ();
        !          1289: extern tree error_not_base_type ();
        !          1290: 
        !          1291: /* in cp-type2.c */
        !          1292: extern tree binfo_or_else ();
        !          1293: 
        !          1294: /* in tree.c */
        !          1295: extern tree build_let ();
        !          1296: extern tree decl_type_context ();
        !          1297: 
        !          1298: /* in cp-tree.c */
        !          1299: extern tree build1 ();
        !          1300: extern tree build_cplus_new ();
        !          1301: extern tree build_cplus_array_type ();
        !          1302: extern tree build_cplus_method_type ();
        !          1303: extern tree build_classtype_variant ();
        !          1304: extern tree hash_tree_cons (), hash_tree_chain ();
        !          1305: extern tree list_hash_lookup_or_cons ();
        !          1306: extern tree layout_basetypes ();
        !          1307: extern tree copy_to_permanent ();
        !          1308: extern tree get_decl_list ();
        !          1309: extern tree break_out_cleanups ();
        !          1310: 
        !          1311: /* in cp-except.c */
        !          1312: extern tree current_exception_type;
        !          1313: extern tree current_exception_decl;
        !          1314: extern tree current_exception_object;
        !          1315: extern tree build_exception_variant ();
        !          1316: extern tree lookup_exception_type (), lookup_exception_cname ();
        !          1317: extern tree lookup_exception_object ();
        !          1318: extern tree cplus_expand_start_catch ();
        !          1319: extern tree cplus_expand_end_try ();
        !          1320: 
        !          1321: /* in cp-class.c */
        !          1322: extern tree current_class_name;
        !          1323: extern tree current_class_type;
        !          1324: 
        !          1325: extern tree current_lang_name, lang_name_cplusplus, lang_name_c;
        !          1326: 
        !          1327: extern tree convert_pointer_to (), convert_pointer_to_vbase ();
        !          1328: extern tree convert_to_reference (), convert_to_aggr (), convert_aggr ();
        !          1329: extern tree build_x_new (), build_x_delete ();
        !          1330: extern tree build_new (), build_vec_new (), build_delete (), build_vec_delete ();
        !          1331: extern tree make_destructor_name ();
        !          1332: extern tree build_scoped_ref (), build_vfield_ref ();
        !          1333: extern tree build_method_call (), build_overload_call ();
        !          1334: extern tree build_type_pathname ();
        !          1335: extern tree start_method (), start_type_method ();
        !          1336: extern tree finish_method ();
        !          1337: 
        !          1338: extern tree lookup_field (), lookup_fnfields ();
        !          1339: 
        !          1340: void pushclass (), popclass (), pushclasstype ();
        !          1341: extern tree build_operator_fnname (), build_opfncall (), build_type_conversion ();
        !          1342: extern tree build_wrapper ();
        !          1343: 
        !          1344: /* Points to the name of that function. May not be the DECL_NAME
        !          1345:    of CURRENT_FUNCTION_DECL due to overloading */
        !          1346: extern tree original_function_name;
        !          1347: 
        !          1348: # define IS_AGGR_TYPE(t) (TYPE_LANG_FLAG_5 (t))
        !          1349: 
        !          1350: # define IS_AGGR_TYPE_CODE(t) \
        !          1351:   (t == RECORD_TYPE || t == UNION_TYPE)
        !          1352: 
        !          1353: extern tree build_decl_overload (), build_typename_overload ();
        !          1354: extern tree build_destructor_call ();
        !          1355: extern tree resolve_scope_to_name ();
        !          1356: extern tree build_scoped_method_call ();
        !          1357: extern tree current_class_name, current_class_type, current_class_decl, C_C_D;
        !          1358: extern tree current_vtable_decl;
        !          1359: 
        !          1360: /* in cp-init.c  */
        !          1361: extern tree resolve_offset_ref ();
        !          1362: extern void check_base_init ();
        !          1363: extern void do_member_init ();
        !          1364: extern tree global_base_init_list;
        !          1365: extern tree current_base_init_list, current_member_init_list;
        !          1366: #ifdef SOS
        !          1367: extern tree get_linktable_name (), get_dtable_name (), get_sos_dtable ();
        !          1368: #endif
        !          1369: extern tree get_member_function ();
        !          1370: extern tree build_member_call (), build_offset_ref ();
        !          1371: 
        !          1372: extern int current_function_assigns_this;
        !          1373: extern int current_function_just_assigned_this;
        !          1374: extern int current_function_parms_stored;
        !          1375: 
        !          1376: /* Here's where we control how name mangling takes place.  */
        !          1377: 
        !          1378: #define OPERATOR_ASSIGN_FORMAT "__a%s"
        !          1379: #define OPERATOR_FORMAT "__%s"
        !          1380: #define OPERATOR_TYPENAME_FORMAT "__op"
        !          1381: 
        !          1382: /* Cannot use '$' up front, because this confuses gdb.
        !          1383:    Note that any format of this kind *must* make the
        !          1384:    format for `this' lexicgraphically less than any other
        !          1385:    parameter name, i.e. "$this" is less than anything else can be.
        !          1386: 
        !          1387:    Note that all forms in which the '$' is significant are long enough
        !          1388:    for direct indexing.  */
        !          1389: 
        !          1390: /* Define NO_DOLLAR_IN_LABEL in your favorite tm file if your assembler
        !          1391:    doesn't allow '$' in symbol names.  */
        !          1392: #ifndef NO_DOLLAR_IN_LABEL
        !          1393: 
        !          1394: #define JOINER '$'
        !          1395: 
        !          1396: #define THIS_NAME "$t"
        !          1397: #define VPTR_NAME "$v"
        !          1398: #define THROW_NAME "$eh_throw"
        !          1399: #define DESTRUCTOR_DECL_PREFIX "_$_"
        !          1400: #define WRAPPER_DECL_FORMAT "__W$%s"
        !          1401: #define WRAPPER_PRED_DECL_FORMAT "__P$%s"
        !          1402: #define ANTI_WRAPPER_DECL_FORMAT "__w$%s"
        !          1403: #define IN_CHARGE_NAME "__in$chrg"
        !          1404: #define AUTO_VTABLE_NAME "__vtbl$me__"
        !          1405: #define AUTO_TEMP_NAME "_$tmp_"
        !          1406: #define AUTO_TEMP_FORMAT "_$tmp_%d"
        !          1407: #define VTBL_PTR_TYPE "$vtbl_ptr_type"
        !          1408: #define VTABLE_NAME_FORMAT "_vt$%s"
        !          1409: #define VFIELD_NAME "_vptr$"
        !          1410: #define VFIELD_NAME_FORMAT "_vptr$%s"
        !          1411: #define VBASE_NAME "_vb$"
        !          1412: #define VBASE_NAME_FORMAT "_vb$%s"
        !          1413: #define STATIC_NAME_FORMAT "_%s$%s"
        !          1414: #define FILE_FUNCTION_FORMAT "_GLOBAL_$D$%s"
        !          1415: #define ANON_AGGRNAME_FORMAT "$_%d"
        !          1416: 
        !          1417: #else  /* NO_DOLLAR_IN_LABEL */
        !          1418: 
        !          1419: #define JOINER '.'
        !          1420: 
        !          1421: #define THIS_NAME ".t"
        !          1422: #define VPTR_NAME ".v"
        !          1423: #define THROW_NAME ".eh_throw"
        !          1424: #define DESTRUCTOR_DECL_PREFIX "_._"
        !          1425: #define WRAPPER_DECL_FORMAT "__W.%s"
        !          1426: #define WRAPPER_PRED_DECL_FORMAT "__P.%s"
        !          1427: #define ANTI_WRAPPER_DECL_FORMAT "__w.%s"
        !          1428: #define IN_CHARGE_NAME "__in.chrg"
        !          1429: #define AUTO_VTABLE_NAME "__vtbl.me__"
        !          1430: #define AUTO_TEMP_NAME "_.tmp_"
        !          1431: #define AUTO_TEMP_FORMAT "_.tmp_%d"
        !          1432: #define VTBL_PTR_TYPE ".vtbl_ptr_type"
        !          1433: #define VTABLE_NAME_FORMAT "_vt.%s"
        !          1434: #define VFIELD_NAME "_vptr."
        !          1435: #define VFIELD_NAME_FORMAT "_vptr.%s"
        !          1436: #define VBASE_NAME "_vb."
        !          1437: #define VBASE_NAME_FORMAT "_vb.%s"
        !          1438: #define STATIC_NAME_FORMAT "_%s.%s"
        !          1439: #define FILE_FUNCTION_FORMAT "_GLOBAL_.D.%s"
        !          1440: 
        !          1441: #define ANON_AGGRNAME_FORMAT "._%d"
        !          1442: 
        !          1443: #endif /* NO_DOLLAR_IN_LABEL */
        !          1444: 
        !          1445: #define DESTRUCTOR_NAME_FORMAT "~%s"
        !          1446: #define WRAPPER_NAME_FORMAT "()%s"
        !          1447: #define WRAPPER_PRED_NAME_FORMAT "()?%s"
        !          1448: #define ANTI_WRAPPER_NAME_FORMAT "~()%s"
        !          1449: #define FILE_FUNCTION_PREFIX_LEN 9
        !          1450: #define VTABLE_DELTA_NAME "delta"
        !          1451: #define VTABLE_DELTA2_NAME "delta2"
        !          1452: #define VTABLE_INDEX_NAME "index"
        !          1453: #define VTABLE_PFN_NAME "pfn"
        !          1454: #define EXCEPTION_CLEANUP_NAME "exception cleanup"
        !          1455: 
        !          1456: #define THIS_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \
        !          1457:                              && IDENTIFIER_POINTER (ID_NODE)[1] == 't')
        !          1458: #define VPTR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \
        !          1459:                              && IDENTIFIER_POINTER (ID_NODE)[1] == 'v')
        !          1460: #define DESTRUCTOR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == JOINER)
        !          1461: 
        !          1462: #define WRAPPER_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
        !          1463:                                 && IDENTIFIER_POINTER (ID_NODE)[2] == 'W' \
        !          1464:                                 && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
        !          1465: #define WRAPPER_PRED_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
        !          1466:                                 && IDENTIFIER_POINTER (ID_NODE)[2] == 'P' \
        !          1467:                                 && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
        !          1468: #define ANTI_WRAPPER_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
        !          1469:                                      && IDENTIFIER_POINTER (ID_NODE)[2] == 'w' \
        !          1470:                                      && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
        !          1471: #define WRAPPER_OR_ANTI_WRAPPER_NAME_P(ID_NODE) \
        !          1472:   (IDENTIFIER_POINTER (ID_NODE)[1] == '_' \
        !          1473:    && (IDENTIFIER_POINTER (ID_NODE)[2]|('W'^'w')) == 'w' \
        !          1474:    && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER)
        !          1475: 
        !          1476: #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[3] == JOINER \
        !          1477:   && IDENTIFIER_POINTER (ID_NODE)[2] == 't'\
        !          1478:   && IDENTIFIER_POINTER (ID_NODE)[1] == 'v')
        !          1479: 
        !          1480: #define VBASE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[3] == JOINER \
        !          1481:   && IDENTIFIER_POINTER (ID_NODE)[2] == 'b'\
        !          1482:   && IDENTIFIER_POINTER (ID_NODE)[1] == 'v')
        !          1483: 
        !          1484: #define OPERATOR_TYPENAME_P(ID_NODE) \
        !          1485:   (IDENTIFIER_POINTER (ID_NODE)[0] == '_'      \
        !          1486:    && IDENTIFIER_POINTER (ID_NODE)[1] == '_'   \
        !          1487:    && IDENTIFIER_POINTER (ID_NODE)[2] == 'o'   \
        !          1488:    && IDENTIFIER_POINTER (ID_NODE)[3] == 'p')
        !          1489: 
        !          1490: #define TEMP_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1))
        !          1491: #define VFIELD_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1))
        !          1492: 
        !          1493: /* For anonymous aggregate types, we need some sort of name to
        !          1494:    hold on to.  In practice, this should not appear, but it should
        !          1495:    not be harmful if it does.  */
        !          1496: #define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER)
        !          1497: #define ANON_PARMNAME_FORMAT "_%d"
        !          1498: #define ANON_PARMNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == '_' \
        !          1499:                                  && IDENTIFIER_POINTER (ID_NODE)[1] <= '9')
        !          1500: 
        !          1501: /* Define the sets of attributes that member functions and baseclasses
        !          1502:    can have.  These are sensible combinations of {public,private,protected}
        !          1503:    cross {virtual,non-virtual}.  */
        !          1504: 
        !          1505: enum visibility_type {
        !          1506:   visibility_default,
        !          1507:   visibility_public,
        !          1508:   visibility_private,
        !          1509:   visibility_protected,
        !          1510:   visibility_default_virtual,
        !          1511:   visibility_public_virtual,
        !          1512:   visibility_private_virtual
        !          1513: };
        !          1514: 
        !          1515: enum visibility_type compute_visibility ();
        !          1516: 
        !          1517: /* in cp-lex.c  */
        !          1518: extern tree current_unit_name, current_unit_language;
        !          1519: extern char *operator_name_string ();
        !          1520: 
        !          1521: /* Things for handling inline functions.  */
        !          1522: 
        !          1523: struct pending_inline
        !          1524: {
        !          1525:   struct pending_inline *next; /* pointer to next in chain */
        !          1526:   int lineno;                  /* line number we got the text from */
        !          1527:   char *filename;              /* name of file we were processing */
        !          1528:   tree fndecl;                 /* FUNCTION_DECL that brought us here */
        !          1529:   int token;                   /* token we were scanning */
        !          1530:   int token_value;             /* value of token we were scanning (YYSTYPE) */
        !          1531: 
        !          1532:   char *buf;                   /* pointer to character stream */
        !          1533:   int len;                     /* length of stream */
        !          1534:   tree parm_vec, bindings;     /* in case this is derived from a template */
        !          1535:   unsigned int can_free : 1;   /* free this after we're done with it? */
        !          1536:   unsigned int deja_vu : 1;    /* set iff we don't want to see it again.  */
        !          1537: };
        !          1538: 
        !          1539: extern tree combine_strings ();
        !          1540: extern int yylex ();
        !          1541: 
        !          1542: /* in cp-method.c */
        !          1543: extern tree wrapper_name, wrapper_pred_name, anti_wrapper_name;
        !          1544: extern struct pending_inline *pending_inlines;
        !          1545: extern char *print_fndecl_with_types ();
        !          1546: extern tree hack_identifier ();
        !          1547: extern tree hack_operator (), hack_wrapper ();
        !          1548: 
        !          1549: /* 1 for -fall-virtual: make every member function (except
        !          1550:    constructors) lay down in the virtual function table.
        !          1551:    Calls can then either go through the virtual function table or not,
        !          1552:    depending on whether we know what function will actually be called.
        !          1553: 
        !          1554:    2 for -fSOS: make every member function (including constructors)
        !          1555:    lay down in the virtual function table.  All calls go through the
        !          1556:    virtual function table: this takes the place of using a linker.  */
        !          1557: 
        !          1558: extern int flag_all_virtual;
        !          1559: 
        !          1560: /* Nonzero means that we cannot make optimizing assumptions about `this'.  */
        !          1561: 
        !          1562: extern int flag_this_is_variable;
        !          1563: 
        !          1564: /* Nonzero means layout structures so that we can do garbage collection.  */
        !          1565: 
        !          1566: extern int flag_gc;
        !          1567: 
        !          1568: /* Nonzero means generate 'dossiers' that give run-time type information.  */
        !          1569: 
        !          1570: extern int flag_dossier;
        !          1571: 
        !          1572: /* Current end of entries in the gc obstack for stack pointer variables.  */
        !          1573: 
        !          1574: extern int current_function_obstack_index;
        !          1575: 
        !          1576: /* Flag saying whether we have used the obstack in this function or not.  */
        !          1577: 
        !          1578: extern int current_function_obstack_usage;
        !          1579: 
        !          1580: enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG, WRAPPER_FLAG, WRAPPER_PRED_FLAG, ANTI_WRAPPER_FLAG };
        !          1581: 
        !          1582: extern tree default_conversion (), pushdecl (), pushdecl_top_level ();
        !          1583: extern tree push_overloaded_decl ();
        !          1584: extern void push_overloaded_decl_top_level ();
        !          1585: extern tree make_instance_name (), do_decl_overload ();
        !          1586: extern tree maybe_build_cleanup ();
        !          1587: extern tree build_instantiated_decl (), instantiate_type ();
        !          1588: extern tree require_instantiated_type ();
        !          1589: extern tree build_vtbl_ref ();
        !          1590: extern tree make_anon_parm_name ();
        !          1591: extern int resolves_to_fixed_type_p ();
        !          1592: 
        !          1593: extern tree do_friend ();
        !          1594: extern void grokclassfn ();
        !          1595: 
        !          1596: extern tree current_class_decl, C_C_D; /* PARM_DECL: the class instance variable */
        !          1597: 
        !          1598: /* The following two can be derived from the previous one */
        !          1599: extern tree current_class_name;        /* IDENTIFIER_NODE: name of current class */
        !          1600: extern tree current_class_type;        /* _TYPE: the type of the current class */
        !          1601: 
        !          1602: /* Some macros for char-based bitfields.  */
        !          1603: #define B_SET(a,x) (a[x>>3] |= (1 << (x&7)))
        !          1604: #define B_CLR(a,x) (a[x>>3] &= ~(1 << (x&7)))
        !          1605: #define B_TST(a,x) (a[x>>3] & (1 << (x&7)))
        !          1606: 
        !          1607: /* These are uses as bits in flags passed to build_method_call
        !          1608:    to control its error reporting behavior.
        !          1609: 
        !          1610:    LOOKUP_PROTECT means flag visibility violations.
        !          1611:    LOOKUP_COMPLAIN mean complain if no suitable member function
        !          1612:      matching the arguments is found.
        !          1613:    LOOKUP_NORMAL is just a combination of these two.
        !          1614:    LOOKUP_AGGR requires the instance to be of aggregate type.
        !          1615:    LOOKUP_NONVIRTUAL means make a direct call to the member function found
        !          1616:    LOOKUP_GLOBAL means search through the space of overloaded functions,
        !          1617:      rather than the space of member functions.
        !          1618:    LOOKUP_HAS_IN_CHARGE means that the "in charge" variable is already
        !          1619:      in the parameter list.
        !          1620:    LOOKUP_PROTECTED_OK means that even if the constructor we find appears
        !          1621:      to be non-visibile to current scope, call it anyway.
        !          1622:    LOOKUP_DYNAMIC means call dynamic functions, a la SOS.
        !          1623:    LOOKUP_NO_CONVERSION means that user-defined conversions are not
        !          1624:      permitted.  Built-in conversions are permitted.
        !          1625:    LOOKUP_DESTRUCTOR means explicit call to destructor.  */
        !          1626: 
        !          1627: #define LOOKUP_PROTECT (1)
        !          1628: #define LOOKUP_COMPLAIN (2)
        !          1629: #define LOOKUP_NORMAL (3)
        !          1630: #define LOOKUP_AGGR (4)
        !          1631: #define LOOKUP_NONVIRTUAL (8)
        !          1632: #define LOOKUP_GLOBAL (16)
        !          1633: #define LOOKUP_HAS_IN_CHARGE (32)
        !          1634: #define LOOKUP_SPECULATIVELY (64)
        !          1635: #define LOOKUP_PROTECTED_OK (128)
        !          1636: #define LOOKUP_DYNAMIC (256)
        !          1637: #define LOOKUP_NO_CONVERSION (512)
        !          1638: #define LOOKUP_DESTRUCTOR (512)
        !          1639: 
        !          1640: /* Anatomy of a DECL_FRIENDLIST (which is a TREE_LIST):
        !          1641:    purpose = friend name (IDENTIFIER_NODE);
        !          1642:    value = TREE_LIST of FUNCTION_DECLS;
        !          1643:    chain, type = EMPTY;  */
        !          1644: #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST))
        !          1645: #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST))
        !          1646: 
        !          1647: extern tree get_temp_name (), get_temp_aggr (), get_temp_regvar ();
        !          1648: extern tree get_decl_list ();
        !          1649: extern tree build_method_call ();
        !          1650: extern tree build_type_conversion ();
        !          1651: extern tree build_functional_cast ();
        !          1652: extern tree decl_constant_value ();
        !          1653: 
        !          1654: /* These macros are for accessing the fields of TEMPLATE...PARM nodes.  */
        !          1655: #define TEMPLATE_TYPE_TPARMLIST(NODE) TREE_PURPOSE (TYPE_FIELDS (NODE))
        !          1656: #define TEMPLATE_TYPE_IDX(NODE) TREE_INT_CST_LOW (TREE_VALUE (TYPE_FIELDS (NODE)))
        !          1657: #define TEMPLATE_TYPE_SET_INFO(NODE,P,I) \
        !          1658:   (TYPE_FIELDS (NODE) = build_tree_list (P, build_int_2 (I, 0)))
        !          1659: #define TEMPLATE_CONST_TPARMLIST(NODE) (*(tree*)&TREE_INT_CST_LOW(NODE))
        !          1660: #define TEMPLATE_CONST_IDX(NODE) (TREE_INT_CST_HIGH(NODE))
        !          1661: #define TEMPLATE_CONST_SET_INFO(NODE,P,I) \
        !          1662:   (TEMPLATE_CONST_TPARMLIST (NODE) = saved_parmlist, \
        !          1663:    TEMPLATE_CONST_IDX (NODE) = I)
        !          1664: 
        !          1665: /* in cp-init.c */
        !          1666: extern tree resolve_offset_ref ();
        !          1667: 
        !          1668: /* in cp-lex.c  */
        !          1669: extern char *operator_name_string ();
        !          1670: 
        !          1671: extern tree build_opid ();
        !          1672: extern tree do_identifier ();
        !          1673: extern tree arbitrate_lookup ();
        !          1674: 
        !          1675: /* Indexed by TREE_CODE, these tables give C-looking names to
        !          1676:    operators represented by TREE_CODES.  For example,
        !          1677:    opname_tab[(int) MINUS_EXPR] == "-".  */
        !          1678: extern char **opname_tab, **assignop_tab;
        !          1679: 
        !          1680: extern tree build_lang_decl (), build_lang_field_decl ();
        !          1681: extern tree make_lang_type ();
        !          1682: extern tree cons_up_default_function ();
        !          1683: 
        !          1684: /* in cp-convert.c  */
        !          1685: extern tree convert_from_reference ();
        !          1686: 
        !          1687: /* in cp-search.c  */
        !          1688: extern tree init_vbase_pointers ();
        !          1689: extern tree build_vbase_pointer (), build_vbase_path ();
        !          1690: extern tree lookup_fnfield (), next_baselink ();
        !          1691: 
        !          1692: extern tree get_binfo ();
        !          1693: extern tree get_vbase_types ();
        !          1694: extern tree get_baselinks ();
        !          1695: extern tree get_wrapper ();
        !          1696: extern tree make_binfo (), copy_binfo ();
        !          1697: extern tree binfo_value (), virtual_member ();
        !          1698: extern tree virtual_offset ();
        !          1699: extern tree reverse_path ();
        !          1700: 
        !          1701: /* in cp-gc.c  */
        !          1702: tree protect_value_from_gc ();
        !          1703: tree build_headof ();
        !          1704: tree build_classof ();
        !          1705: tree build_t_desc ();
        !          1706: tree build_i_desc ();
        !          1707: tree build_m_desc ();
        !          1708: 
        !          1709: /* in cp-template.c  */
        !          1710: /* PARM_VEC is a vector of template parameters, either IDENTIFIER_NODEs or
        !          1711:    PARM_DECLs.  BINDINGS, if non-null, is a vector of bindings for those
        !          1712:    parameters.  */
        !          1713: struct template_info {
        !          1714:   /* Vector of template parameters, either PARM_DECLs or IDENTIFIER_NODEs.  */
        !          1715:   tree parm_vec;
        !          1716:   /* If non-null, a vector of bindings for the template parms.  */
        !          1717:   tree bindings;
        !          1718: 
        !          1719:   /* Text of template, and length.  */
        !          1720:   char *text;
        !          1721:   int length;
        !          1722:   /* Where it came from.  */
        !          1723:   char *filename;
        !          1724:   int lineno;
        !          1725: 
        !          1726:   /* What kind of aggregate -- struct, class, or null.  */
        !          1727:   tree aggr;
        !          1728: };
        !          1729: 
        !          1730: extern tree end_template_parm_list ();
        !          1731: extern tree process_template_parm ();
        !          1732: extern tree lookup_template_class ();
        !          1733: extern tree instantiate_template ();
        !          1734: extern tree instantiate_class_template ();
        !          1735: extern int processing_template_decl, processing_template_defn;
        !          1736: 
        !          1737: #define PRINT_LANG_DECL
        !          1738: #define PRINT_LANG_TYPE
        !          1739: 
        !          1740: #define UNKNOWN_TYPE LANG_TYPE
        !          1741: 
        !          1742: /* -- end of C++ */

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