![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-tree.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cp-tree.h CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Definitions for C++ parsing and type checking. 1.1.1.5 ! root 2: Copyright (C) 1987, 1993 Free Software Foundation, Inc. 1.1 root 3: Hacked by Michael Tiemann ([email protected]) 4: 5: This file is part of GNU CC. 6: 7: GNU CC is free software; you can redistribute it and/or modify 8: it under the terms of the GNU General Public License as published by 9: the Free Software Foundation; either version 2, or (at your option) 10: any later version. 11: 12: GNU CC is distributed in the hope that it will be useful, 13: but WITHOUT ANY WARRANTY; without even the implied warranty of 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15: GNU General Public License for more details. 16: 17: You should have received a copy of the GNU General Public License 18: along with GNU CC; see the file COPYING. If not, write to 19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 20: 1.1.1.5 ! root 21: #include "cp-class.h" 1.1 root 22: 23: /* Borrow everything that is C from c-tree.h, 24: but do so by copy, not by inclusion, since c-tree.h defines 25: lang_identifier. */ 26: 27: #ifndef PARANOID 28: #define PARANOID 0 29: #endif 30: 31: /* Language-dependent contents of an identifier. */ 32: 33: struct lang_identifier 34: { 35: struct tree_identifier ignore; 36: tree global_value, local_value; 37: tree class_value; 38: tree class_template_info; 39: struct lang_id2 *x; 40: }; 41: 42: struct lang_id2 43: { 44: tree label_value, implicit_decl; 45: tree type_desc, as_list, error_locus; 46: }; 47: 1.1.1.5 ! root 48: /* To identify to the debug emitters if it should pay attention to the ! 49: flag `-Wtemplate-debugging'. */ ! 50: #define HAVE_TEMPLATES 1 ! 51: 1.1 root 52: /* Macros for access to language-specific slots in an identifier. */ 53: 54: #if !PARANOID 55: #define IDENTIFIER_GLOBAL_VALUE(NODE) \ 56: (((struct lang_identifier *)(NODE))->global_value) 57: #define IDENTIFIER_CLASS_VALUE(NODE) \ 58: (((struct lang_identifier *)(NODE))->class_value) 59: #define IDENTIFIER_LOCAL_VALUE(NODE) \ 60: (((struct lang_identifier *)(NODE))->local_value) 61: #define IDENTIFIER_TEMPLATE(NODE) \ 62: (((struct lang_identifier *)(NODE))->class_template_info) 63: #else 64: #define IDENTIFIER_LANG_SPECIFIC_PTR(NODE) \ 1.1.1.4 root 65: (my_friendly_assert (TREE_CODE (NODE) == IDENTIFIER_NODE, 325), \ 1.1 root 66: (struct lang_identifier *) (NODE)) 67: #define IDENTIFIER_GLOBAL_VALUE(NODE) \ 68: (((struct lang_identifier *)(NODE))->global_value) 69: #define IDENTIFIER_CLASS_VALUE(NODE) \ 70: (((struct lang_identifier *)(NODE))->class_value) 71: #define IDENTIFIER_LOCAL_VALUE(NODE) \ 72: (((struct lang_identifier *)(NODE))->local_value) 73: #define IDENTIFIER_TEMPLATE(NODE) \ 74: (IDENTIFIER_LANG_SPECIFIC_PTR (NODE) -> class_template_info) 75: #endif 76: 77: #if !PARANOID 78: #define IDENTIFIER_TYPE_VALUE(NODE) (TREE_TYPE (NODE)) 79: #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = TYPE) 80: #else 81: #define IDENTIFIER_TYPE_VALUE(NODE) (*IDENTIFIER_TYPE_VALUE_PTR(NODE)) 82: #ifdef __GNUC__ 83: __inline 84: #endif 85: static tree * IDENTIFIER_TYPE_VALUE_PTR(NODE) tree NODE; { return 1.1.1.4 root 86: (my_friendly_assert (TREE_CODE (NODE) == IDENTIFIER_NODE, 326), 1.1 root 87: &TREE_TYPE (NODE)) ;} 88: #define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (IDENTIFIER_TYPE_VALUE(NODE)=TYPE) 89: #endif 90: #define IDENTIFIER_HAS_TYPE_VALUE(NODE) (TREE_TYPE (NODE) ? 1 : 0) 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: 1.1.1.4 root 123: #define IDENTIFIER_VIRTUAL_P(NODE) TREE_LANG_FLAG_1(NODE) 124: 1.1 root 125: /* Nonzero if this identifier is the prefix for a mangled C++ operator name. */ 126: #define IDENTIFIER_OPNAME_P(NODE) TREE_LANG_FLAG_2(NODE) 127: 128: #define IDENTIFIER_TYPENAME_P(NODE) \ 129: (! strncmp (IDENTIFIER_POINTER (NODE), \ 1.1.1.2 root 130: IDENTIFIER_POINTER (ansi_opname[(int) TYPE_EXPR]), \ 131: IDENTIFIER_LENGTH (ansi_opname[(int) TYPE_EXPR]))) 1.1 root 132: 133: /* Nonzero means reject anything that ANSI standard C forbids. */ 134: extern int pedantic; 135: 136: /* In a RECORD_TYPE or UNION_TYPE, nonzero if any component is read-only. */ 137: #define C_TYPE_FIELDS_READONLY(type) TYPE_LANG_FLAG_0 (type) 1.1.1.5 ! root 138: 1.1 root 139: /* If non-zero, a VAR_DECL whose cleanup will cause a throw to the 140: next exception handler. */ 141: extern tree exception_throw_decl; 142: 143: extern tree double_type_node, long_double_type_node, float_type_node; 144: extern tree char_type_node, unsigned_char_type_node, signed_char_type_node; 145: extern tree ptrdiff_type_node; 146: 147: extern tree short_integer_type_node, short_unsigned_type_node; 148: extern tree long_integer_type_node, long_unsigned_type_node; 149: extern tree long_long_integer_type_node, long_long_unsigned_type_node; 150: extern tree unsigned_type_node; 151: extern tree string_type_node, char_array_type_node, int_array_type_node; 152: extern tree wchar_array_type_node; 153: extern tree wchar_type_node, signed_wchar_type_node, unsigned_wchar_type_node; 1.1.1.4 root 154: extern tree intQI_type_node, unsigned_intQI_type_node; 155: extern tree intHI_type_node, unsigned_intHI_type_node; 156: extern tree intSI_type_node, unsigned_intSI_type_node; 157: extern tree intDI_type_node, unsigned_intDI_type_node; 1.1 root 158: 159: extern int current_function_returns_value; 160: extern int current_function_returns_null; 161: extern tree current_function_return_value; 162: 163: extern tree ridpointers[]; 164: extern tree ansi_opname[]; 165: extern tree ansi_assopname[]; 166: 167: /* Nonzero means `$' can be in an identifier. */ 168: 169: extern int dollars_in_ident; 170: 171: /* Nonzero means allow type mismatches in conditional expressions; 172: just make their values `void'. */ 173: 174: extern int flag_cond_mismatch; 175: 176: /* Nonzero means don't recognize the keyword `asm'. */ 177: 178: extern int flag_no_asm; 179: 180: /* For cross referencing. */ 181: 182: extern int flag_gnu_xref; 183: 184: /* For environments where you can use GNU binutils (as, ld in particular). */ 185: 186: extern int flag_gnu_binutils; 187: 1.1.1.4 root 188: /* Nonzero means ignore `#ident' directives. */ 189: 190: extern int flag_no_ident; 191: 1.1 root 192: /* Nonzero means warn about implicit declarations. */ 193: 194: extern int warn_implicit; 195: 196: /* Nonzero means warn about function definitions that default the return type 197: or that use a null return and have a return-type other than void. */ 198: 199: extern int warn_return_type, explicit_warn_return_type; 200: 201: /* Nonzero means give string constants the type `const char *' 202: to get extra warnings from them. These warnings will be too numerous 203: to be useful, except in thoroughly ANSIfied programs. */ 204: 205: extern int warn_write_strings; 206: 207: /* Nonzero means warn about sizeof(function) or addition/subtraction 208: of function pointers. */ 209: 210: extern int warn_pointer_arith; 211: 212: /* Nonzero means warn for all old-style non-prototype function decls. */ 213: 214: extern int warn_strict_prototypes; 215: 216: /* Nonzero means warn about suggesting putting in ()'s. */ 217: 218: extern int warn_parentheses; 219: 1.1.1.4 root 220: /* Warn about a subscript that has type char. */ 221: 222: extern int warn_char_subscripts; 223: 1.1 root 224: /* Nonzero means warn about pointer casts that can drop a type qualifier 225: from the pointer target type. */ 226: 227: extern int warn_cast_qual; 228: 1.1.1.4 root 229: /* Warn about traditional constructs whose meanings changed in ANSI C. */ 230: 231: extern int warn_traditional; 232: 233: /* Nonzero means warn about non virtual destructors in classes that have 234: virtual functions. */ 235: 236: extern int warn_nonvdtor; 237: 1.1 root 238: /* Nonzero means do some things the same way PCC does. */ 239: 240: extern int flag_traditional; 241: 242: /* Nonzero means to treat bitfields as unsigned unless they say `signed'. */ 243: 244: extern int flag_signed_bitfields; 245: 1.1.1.4 root 246: /* 3 means write out only virtuals function tables `defined' 247: in this implementation file. 248: 2 means write out only specific virtual function tables 1.1 root 249: and give them (C) public visibility. 250: 1 means write out virtual function tables and give them 251: (C) public visibility. 252: 0 means write out virtual function tables and give them 1.1.1.4 root 253: (C) static visibility (default). 1.1 root 254: -1 means declare virtual function tables extern. */ 255: 256: extern int write_virtuals; 257: 258: /* INTERFACE_ONLY nonzero means that we are in an "interface" 259: section of the compiler. INTERFACE_UNKNOWN nonzero means 260: we cannot trust the value of INTERFACE_ONLY. If INTERFACE_UNKNOWN 261: is zero and INTERFACE_ONLY is zero, it means that we are responsible 262: for exporting definitions that others might need. */ 263: extern int interface_only, interface_unknown; 264: 265: /* Nonzero means we should attempt to elide constructors when possible. */ 266: 267: extern int flag_elide_constructors; 268: 269: /* Nonzero means recognize and handle exception handling constructs. */ 270: 271: extern int flag_handle_exceptions; 272: 273: /* Nonzero means recognize and handle ansi-style exception handling constructs. */ 274: 275: extern int flag_ansi_exceptions; 276: 277: /* Nonzero means that member functions defined in class scope are 278: inline by default. */ 279: 280: extern int flag_default_inline; 281: 282: /* Nonzero means emit cadillac protocol. */ 283: 284: extern int flag_cadillac; 285: 286: /* C++ language-specific tree codes. */ 287: #define DEFTREECODE(SYM, NAME, TYPE, LENGTH) SYM, 288: enum cplus_tree_code { 289: __DUMMY = LAST_AND_UNUSED_TREE_CODE, 290: #include "cp-tree.def" 291: LAST_CPLUS_TREE_CODE 292: }; 293: #undef DEFTREECODE 294: 295: enum languages { lang_c, lang_cplusplus }; 296: 297: /* Macros to make error reporting functions' lives easier. */ 298: #if !PARANOID 299: #define TYPE_IDENTIFIER(NODE) (DECL_NAME (TYPE_NAME (NODE))) 300: #else 301: #define TYPE_IDENTIFIER(NODE) (*TYPE_IDENTIFIER_PTR (NODE)) 302: #ifdef __GNUC__ 303: __inline 304: #endif 305: static tree * 306: TYPE_IDENTIFIER_PTR(NODE) tree NODE; { return 1.1.1.4 root 307: (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 327), 1.1 root 308: &DECL_NAME (TYPE_NAME (NODE))) ;} 309: #endif 310: 1.1.1.3 root 311: #define TYPE_NAME_STRING(NODE) (IDENTIFIER_POINTER (TYPE_IDENTIFIER (NODE))) 312: #define TYPE_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (TYPE_IDENTIFIER (NODE))) 1.1 root 313: 1.1.1.4 root 314: #define TYPE_ASSEMBLER_NAME_STRING(NODE) (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE)))) 315: #define TYPE_ASSEMBLER_NAME_LENGTH(NODE) (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (TYPE_NAME (NODE)))) 316: 1.1 root 317: #define IS_AGGR_TYPE_2(TYPE1,TYPE2) \ 318: (TREE_CODE (TYPE1) == TREE_CODE (TYPE2) \ 319: && IS_AGGR_TYPE (TYPE1)&IS_AGGR_TYPE (TYPE2)) 320: 321: /* Macros which might want to be replaced by function calls. */ 322: 323: #if 1 324: /* Virtual function addresses can be gotten from a virtual function 325: table entry using this macro. */ 326: #define FNADDR_FROM_VTABLE_ENTRY(ENTRY) \ 327: TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (ENTRY)))) 328: #define SET_FNADDR_FROM_VTABLE_ENTRY(ENTRY,VALUE) \ 329: (TREE_VALUE (TREE_CHAIN (TREE_CHAIN (CONSTRUCTOR_ELTS (ENTRY)))) = (VALUE)) 330: 331: #define FUNCTION_ARG_CHAIN(NODE) (TREE_CHAIN (TYPE_ARG_TYPES (TREE_TYPE (NODE)))) 332: #define PROMOTES_TO_AGGR_TYPE(NODE,CODE) \ 333: (((CODE) == TREE_CODE (NODE) \ 334: && IS_AGGR_TYPE (TREE_TYPE (NODE))) \ 335: || IS_AGGR_TYPE (NODE)) 336: 337: #else 338: #define FNADDR_FROM_VTABLE_ENTRY(ENTRY) (fnaddr_from_vtable_entry (ENTRY)) 339: #define SET_FNADDR_FROM_VTABLE_ENTRY(ENTRY,VALUE) \ 340: (set_fnaddr_from_vtable_entry (ENTRY, VALUE)) 341: /* #define TYPE_NAME_STRING(NODE) (type_name_string (NODE)) */ 342: #define FUNCTION_ARG_CHAIN(NODE) (function_arg_chain (NODE)) 343: #define PROMOTES_TO_AGGR_TYPE(NODE,CODE) (promotes_to_aggr_type (NODE, CODE)) 344: /* #define IS_AGGR_TYPE_2(TYPE1, TYPE2) (is_aggr_type_2 (TYPE1, TYPE2)) */ 345: #endif 1.1.1.4 root 346: /* Nonzero iff TYPE is uniquely derived from PARENT. Under MI, PARENT can be an 347: ambiguous base class of TYPE, and this macro will be false. */ 1.1.1.5 ! root 348: #define UNIQUELY_DERIVED_FROM_P(PARENT, TYPE) (get_base_distance (PARENT, TYPE, 0, (tree *)0) >= 0) 1.1 root 349: 350: enum conversion_type { ptr_conv, constptr_conv, int_conv, real_conv, last_conversion_type }; 351: 352: /* Statistics show that while the GNU C++ compiler may generate 353: thousands of different types during a compilation run, it 354: generates relatively few (tens) of classtypes. Because of this, 355: it is not costly to store a generous amount of information 356: in classtype nodes. This struct must fill out to a multiple of 4 bytes. */ 357: struct lang_type 358: { 359: struct 360: { 361: unsigned has_type_conversion : 1; 362: unsigned has_int_conversion : 1; 363: unsigned has_float_conversion : 1; 364: unsigned has_init_ref : 1; 365: unsigned gets_init_ref : 1; 366: unsigned gets_init_aggr : 1; 367: unsigned has_assignment : 1; 368: unsigned gets_assignment : 1; 369: 370: unsigned needs_constructor : 1; 371: unsigned has_default_ctor : 1; 372: unsigned uses_multiple_inheritance : 1; 373: unsigned const_needs_init : 1; 374: unsigned ref_needs_init : 1; 375: unsigned gets_const_init_ref : 1; 376: unsigned has_const_assign_ref : 1; 377: unsigned gets_const_assign_ref : 1; 378: 379: unsigned vtable_needs_writing : 1; 380: unsigned has_assign_ref : 1; 381: unsigned gets_assign_ref : 1; 382: unsigned gets_new : 1; 383: unsigned gets_delete : 1; 384: unsigned has_call_overloaded : 1; 385: unsigned has_array_ref_overloaded : 1; 386: unsigned has_arrow_overloaded : 1; 387: 388: unsigned local_typedecls : 1; 389: unsigned interface_only : 1; 390: unsigned interface_unknown : 1; 391: unsigned needs_virtual_reinit : 1; 392: unsigned declared_exception : 1; 393: unsigned declared_class : 1; 394: unsigned being_defined : 1; 395: unsigned redefined : 1; 396: 397: unsigned marked : 1; 398: unsigned marked2 : 1; 399: unsigned marked3 : 1; 400: unsigned marked4 : 1; 401: unsigned marked5 : 1; 402: unsigned marked6 : 1; 403: unsigned use_template : 2; 404: 405: unsigned debug_requested : 1; 406: unsigned dynamic : 1; 407: unsigned has_method_call_overloaded : 1; 408: unsigned private_attr : 1; 409: unsigned alters_visibilities : 1; 410: unsigned got_semicolon : 1; 411: unsigned dummy : 1; 412: 413: /* The MIPS compiler gets it wrong if this struct also 414: does not fill out to a multiple of 4 bytes. */ 415: unsigned n_vancestors : 16; 416: } type_flags; 417: 418: int cid; 419: int n_ancestors; 420: int vsize; 421: int max_depth; 422: 423: union tree_node *vbinfo[2]; 424: union tree_node *baselink_vec; 425: union tree_node *vfields; 426: union tree_node *vbases; 427: union tree_node *vbase_size; 428: 429: union tree_node *tags; 430: char *memoized_table_entry; 431: 432: char *search_slot; 433: 434: #ifdef ONLY_INT_FIELDS 435: unsigned int mode : 8; 436: #else 437: enum machine_mode mode : 8; 438: #endif 439: 440: unsigned char size_unit; 441: unsigned char align; 442: unsigned char sep_unit; 443: 444: union tree_node *sep; 445: union tree_node *size; 446: 447: union tree_node *base_init_list; 448: union tree_node *abstract_virtuals; 449: union tree_node *as_list; 450: union tree_node *id_as_list; 451: union tree_node *binfo_as_list; 452: union tree_node *vtbl_ptr; 453: union tree_node *instance_variable; 454: union tree_node *friend_classes; 455: 456: char *mi_matrix; 457: union tree_node *conversions[last_conversion_type]; 458: 459: union tree_node *dossier; 460: }; 461: 462: /* Indicates whether a template should be (or has been) expanded for this 463: class definition. 0=do, 1=did, 2=don't, 3=didn't. */ 464: #define CLASSTYPE_USE_TEMPLATE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.use_template) 465: 466: /* Fields used for storing information before the class is defined. 467: After the class is defined, these fields hold other information. */ 468: 469: /* List of friends which were defined inline in this class definition. */ 470: #define CLASSTYPE_INLINE_FRIENDS(NODE) (TYPE_NONCOPIED_PARTS (NODE)) 471: 472: /* Nonzero for _CLASSTYPE means that the _CLASSTYPE either has 473: a special meaning for the assignment operator ("operator="), 474: or one of its fields (or base members) has a special meaning 475: defined. */ 476: #define TYPE_HAS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assignment) 477: #define TYPE_GETS_ASSIGNMENT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assignment) 478: 479: /* Nonzero for _CLASSTYPE means that operator new and delete are defined, 480: respectively. */ 481: #define TREE_GETS_NEW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_new) 482: #define TREE_GETS_DELETE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_delete) 483: 484: /* Nonzero for TREE_LIST or _TYPE node means that this node is class-local. */ 485: #define TREE_NONLOCAL_FLAG(NODE) (TREE_LANG_FLAG_0 (NODE)) 486: 487: /* Nonzero for a _CLASSTYPE node which we know to be private. */ 488: #define TYPE_PRIVATE_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.private_attr) 489: 490: /* Nonzero means that this _CLASSTYPE node defines ways of converting 491: itself to other types. */ 492: #define TYPE_HAS_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_type_conversion) 493: 494: /* Nonzero means that this _CLASSTYPE node can convert itself to an 495: INTEGER_TYPE. */ 496: #define TYPE_HAS_INT_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_int_conversion) 497: 498: /* Nonzero means that this _CLASSTYPE node can convert itself to an 499: REAL_TYPE. */ 500: #define TYPE_HAS_REAL_CONVERSION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_float_conversion) 501: 502: /* Nonzero means that this _CLASSTYPE node overloads operator=(X&). */ 503: #define TYPE_HAS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_assign_ref) 504: #define TYPE_GETS_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_assign_ref) 505: #define TYPE_HAS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_const_assign_ref) 506: #define TYPE_GETS_CONST_ASSIGN_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_assign_ref) 507: 508: /* Nonzero means that this _CLASSTYPE node has an X(X&) constructor. */ 509: #define TYPE_HAS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_init_ref) 510: #define TYPE_GETS_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_ref) 511: #define TYPE_GETS_CONST_INIT_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_const_init_ref) 512: 513: /* Nonzero means that this _CLASSTYPE node has an X(X ...) constructor. 1.1.1.3 root 514: Note that there must be other arguments, or this constructor is flagged 1.1 root 515: as being erroneous. */ 516: #define TYPE_GETS_INIT_AGGR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.gets_init_aggr) 517: 518: /* Nonzero means that this type is being defined. I.e., the left brace 519: starting the definition of this type has been seen. */ 520: #define TYPE_BEING_DEFINED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.being_defined) 521: /* Nonzero means that this type has been redefined. In this case, if 522: convenient, don't reprocess any methods that appear in its redefinition. */ 523: #define TYPE_REDEFINED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.redefined) 524: 525: /* Nonzero means that this _CLASSTYPE node overloads the method call 526: operator. In this case, all method calls go through `operator->()(...). */ 527: #define TYPE_OVERLOADS_METHOD_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_method_call_overloaded) 528: 529: /* The is the VAR_DECL that contains NODE's dossier. */ 530: #define CLASSTYPE_DOSSIER(NODE) (TYPE_LANG_SPECIFIC(NODE)->dossier) 531: 532: /* Nonzero means that this _CLASSTYPE node overloads operator(). */ 533: #define TYPE_OVERLOADS_CALL_EXPR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_call_overloaded) 534: 535: /* Nonzero means that this _CLASSTYPE node overloads operator[]. */ 536: #define TYPE_OVERLOADS_ARRAY_REF(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_array_ref_overloaded) 537: 538: /* Nonzero means that this _CLASSTYPE node overloads operator->. */ 539: #define TYPE_OVERLOADS_ARROW(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_arrow_overloaded) 540: 541: /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses 542: multiple inheritance. If this is 0 for the root of a type 543: hierarchy, then we can use more efficient search techniques. */ 544: #define TYPE_USES_MULTIPLE_INHERITANCE(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.uses_multiple_inheritance) 545: 546: /* Nonzero means that this _CLASSTYPE (or one of its ancestors) uses 547: virtual base classes. If this is 0 for the root of a type 548: hierarchy, then we can use more efficient search techniques. */ 549: #define TYPE_USES_VIRTUAL_BASECLASSES(NODE) (TREE_LANG_FLAG_3(NODE)) 550: 551: /* List of lists of member functions defined in this class. */ 552: #define CLASSTYPE_METHOD_VEC(NODE) TYPE_METHODS(NODE) 553: 554: /* Pointer from any member function to the head of the list of 555: member functions of the type that member function belongs to. */ 556: #define CLASSTYPE_BASELINK_VEC(NODE) (TYPE_LANG_SPECIFIC(NODE)->baselink_vec) 557: 558: /* Mark bits for depth-first and breath-first searches. */ 559: #if !PARANOID 560: #define CLASSTYPE_MARKED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked) 561: #define CLASSTYPE_MARKED2(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2) 562: #define CLASSTYPE_MARKED3(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3) 563: #define CLASSTYPE_MARKED4(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4) 564: #define CLASSTYPE_MARKED5(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5) 565: #define CLASSTYPE_MARKED6(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6) 566: /* Macros to modify the above flags */ 567: #define SET_CLASSTYPE_MARKED(NODE) (CLASSTYPE_MARKED(NODE) = 1) 568: #define CLEAR_CLASSTYPE_MARKED(NODE) (CLASSTYPE_MARKED(NODE) = 0) 569: #define SET_CLASSTYPE_MARKED2(NODE) (CLASSTYPE_MARKED2(NODE) = 1) 570: #define CLEAR_CLASSTYPE_MARKED2(NODE) (CLASSTYPE_MARKED2(NODE) = 0) 571: #define SET_CLASSTYPE_MARKED3(NODE) (CLASSTYPE_MARKED3(NODE) = 1) 572: #define CLEAR_CLASSTYPE_MARKED3(NODE) (CLASSTYPE_MARKED3(NODE) = 0) 573: #define SET_CLASSTYPE_MARKED4(NODE) (CLASSTYPE_MARKED4(NODE) = 1) 574: #define CLEAR_CLASSTYPE_MARKED4(NODE) (CLASSTYPE_MARKED4(NODE) = 0) 575: #define SET_CLASSTYPE_MARKED5(NODE) (CLASSTYPE_MARKED5(NODE) = 1) 576: #define CLEAR_CLASSTYPE_MARKED5(NODE) (CLASSTYPE_MARKED5(NODE) = 0) 577: #define SET_CLASSTYPE_MARKED6(NODE) (CLASSTYPE_MARKED6(NODE) = 1) 578: #define CLEAR_CLASSTYPE_MARKED6(NODE) (CLASSTYPE_MARKED6(NODE) = 0) 579: #else 1.1.1.4 root 580: #define CLASSTYPE_MARKED(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 328), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked) 581: #define CLASSTYPE_MARKED2(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 329), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2) 582: #define CLASSTYPE_MARKED3(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 330), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3) 583: #define CLASSTYPE_MARKED4(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 331), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4) 584: #define CLASSTYPE_MARKED5(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 332), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5) 585: #define CLASSTYPE_MARKED6(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 333), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6) 1.1 root 586: /* Macros to modify the above flags */ 1.1.1.4 root 587: #define SET_CLASSTYPE_MARKED(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 334), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked = 1) 588: #define CLEAR_CLASSTYPE_MARKED(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 335), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked = 0) 589: #define SET_CLASSTYPE_MARKED2(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 336), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2 = 1) 590: #define CLEAR_CLASSTYPE_MARKED2(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 337), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked2 = 0) 591: #define SET_CLASSTYPE_MARKED3(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 338), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3 = 1) 592: #define CLEAR_CLASSTYPE_MARKED3(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 339), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked3 = 0) 593: #define SET_CLASSTYPE_MARKED4(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 340), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4 = 1) 594: #define CLEAR_CLASSTYPE_MARKED4(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 341), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked4 = 0) 595: #define SET_CLASSTYPE_MARKED5(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 342), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5 = 1) 596: #define CLEAR_CLASSTYPE_MARKED5(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 343), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked5 = 0) 597: #define SET_CLASSTYPE_MARKED6(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 344), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6 = 1) 598: #define CLEAR_CLASSTYPE_MARKED6(NODE) (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 't', 345), TYPE_LANG_SPECIFIC(NODE)->type_flags.marked6 = 0) 1.1 root 599: #endif 600: 601: #define CLASSTYPE_TAGS(NODE) (TYPE_LANG_SPECIFIC(NODE)->tags) 602: 603: /* Remove when done merging. */ 604: #define CLASSTYPE_VFIELD(NODE) TYPE_VFIELD(NODE) 605: 606: /* The number of virtual functions defined for this 607: _CLASSTYPE node. */ 608: #define CLASSTYPE_VSIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vsize) 609: /* The virtual base classes that this type uses. */ 610: #define CLASSTYPE_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbases) 611: /* The virtual function pointer fields that this type contains. */ 612: #define CLASSTYPE_VFIELDS(NODE) (TYPE_LANG_SPECIFIC(NODE)->vfields) 613: 614: /* Number of baseclasses defined for this type. 615: 0 means no base classes. */ 616: #define CLASSTYPE_N_BASECLASSES(NODE) \ 617: (TYPE_BINFO_BASETYPES (NODE) ? TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES(NODE)) : 0) 618: 619: /* Memoize the number of super classes (base classes) tha this node 620: has. That way we can know immediately (albeit conservatively how 621: large a multiple-inheritance matrix we need to build to find 622: derivation information. */ 623: #define CLASSTYPE_N_SUPERCLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->n_ancestors) 624: #define CLASSTYPE_N_VBASECLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.n_vancestors) 625: 626: /* Record how deep the inheritance is for this class so `void*' conversions 627: are less favorable than a conversion to the most base type. */ 628: #define CLASSTYPE_MAX_DEPTH(NODE) (TYPE_LANG_SPECIFIC(NODE)->max_depth) 629: 630: /* Used for keeping search-specific information. Any search routine 631: which uses this must define what exactly this slot is used for. */ 632: #define CLASSTYPE_SEARCH_SLOT(NODE) (TYPE_LANG_SPECIFIC(NODE)->search_slot) 633: 634: /* Entry for keeping memoization tables for this type to 635: hopefully speed up search routines. Since it is a pointer, 636: it can mean almost anything. */ 637: #define CLASSTYPE_MTABLE_ENTRY(NODE) (TYPE_LANG_SPECIFIC(NODE)->memoized_table_entry) 638: 639: /* This is the total size of the baseclasses defined for this type. 640: Needed because it is desirable to layout such information 1.1.1.2 root 641: before beginning to process the class itself, and we 1.1 root 642: don't want to compute it second time when actually laying 643: out the type for real. */ 644: #define CLASSTYPE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->size) 645: #define CLASSTYPE_SIZE_UNIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->size_unit) 646: #define CLASSTYPE_MODE(NODE) (TYPE_LANG_SPECIFIC(NODE)->mode) 647: #define CLASSTYPE_ALIGN(NODE) (TYPE_LANG_SPECIFIC(NODE)->align) 648: 649: /* This is the space needed for virtual base classes. NULL if 650: there are no virtual basetypes. */ 651: #define CLASSTYPE_VBASE_SIZE(NODE) (TYPE_LANG_SPECIFIC(NODE)->vbase_size) 652: 653: /* A cons list of structure elements which either have constructors 654: to be called, or virtual function table pointers which 655: need initializing. Depending on what is being initialized, 656: the TREE_PURPOSE and TREE_VALUE fields have different meanings: 657: 658: Member initialization: <FIELD_DECL, TYPE> 659: Base class construction: <NULL_TREE, BASETYPE> 1.1.1.2 root 660: Base class initialization: <BASE_INITIALIZATION, THESE_INITIALIZATIONS> 1.1 root 661: Whole type: <MEMBER_INIT, BASE_INIT>. */ 662: #define CLASSTYPE_BASE_INIT_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->base_init_list) 663: 664: /* A cons list of virtual functions which cannot be inherited by 665: derived classes. When deriving from this type, the derived 666: class must provide its own definition for each of these functions. */ 667: #define CLASSTYPE_ABSTRACT_VIRTUALS(NODE) (TYPE_LANG_SPECIFIC(NODE)->abstract_virtuals) 668: 669: #define CLASSTYPE_ALTERS_VISIBILITIES_P(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.alters_visibilities) 670: 671: /* Nonzero means that this aggr type has been `closed' by a semicolon. */ 672: #define CLASSTYPE_GOT_SEMICOLON(NODE) (TYPE_LANG_SPECIFIC (NODE)->type_flags.got_semicolon) 673: 674: /* Nonzero means that the main virtual function table pointer needs to be 675: set because base constructors have placed the wrong value there. 676: If this is zero, it means that they placed the right value there, 677: and there is no need to change it. */ 678: #define CLASSTYPE_NEEDS_VIRTUAL_REINIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_virtual_reinit) 679: 680: /* Nonzero means that if this type has virtual functions, that 681: the virtual function table will be written out. */ 682: #define CLASSTYPE_VTABLE_NEEDS_WRITING(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.vtable_needs_writing) 683: 684: /* Nonzero means that this type defines its own local type declarations. */ 685: #define CLASSTYPE_LOCAL_TYPEDECLS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.local_typedecls) 686: 687: /* Nonzero means that this type has an X() constructor. */ 688: #define TYPE_HAS_DEFAULT_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.has_default_ctor) 689: 690: /* Many routines need to cons up a list of basetypes for visibility 691: checking. This field contains a TREE_LIST node whose TREE_VALUE 692: is the main variant of the type, and whose TREE_VIA_PUBLIC 693: and TREE_VIA_VIRTUAL bits are correctly set. */ 694: #define CLASSTYPE_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->as_list) 695: /* Same, but cache a list whose value is the name of this type. */ 696: #define CLASSTYPE_ID_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->id_as_list) 697: /* Same, but cache a list whose value is the binfo of this type. */ 698: #define CLASSTYPE_BINFO_AS_LIST(NODE) (TYPE_LANG_SPECIFIC(NODE)->binfo_as_list) 699: 700: /* Slot in which to cache a copy of the local vtable pointer. */ 701: #define CLASSTYPE_VTBL_PTR(NODE) (TYPE_LANG_SPECIFIC(NODE)->vtbl_ptr) 702: 703: /* Hold the instance object associated with this method. */ 704: #define CLASSTYPE_INST_VAR(NODE) (TYPE_LANG_SPECIFIC(NODE)->instance_variable) 705: 706: /* A list of class types with which this type is a friend. */ 707: #define CLASSTYPE_FRIEND_CLASSES(NODE) (TYPE_LANG_SPECIFIC(NODE)->friend_classes) 708: 709: /* Keep an inheritance lattice around so we can quickly tell whether 710: a type is derived from another or not. */ 711: #define CLASSTYPE_MI_MATRIX(NODE) (TYPE_LANG_SPECIFIC(NODE)->mi_matrix) 712: 713: /* If there is exactly one conversion to a non-void, non-const pointer type, 714: remember that here. If there are more than one, put 715: `error_mark_node' here. If there are none, this holds NULL_TREE. */ 716: #define CLASSTYPE_CONVERSION(NODE,KIND) \ 717: (TYPE_LANG_SPECIFIC(NODE)->conversions[(int) KIND]) 718: 719: /* Say whether this node was declared as a "class" or a "struct". */ 720: #define CLASSTYPE_DECLARED_CLASS(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_class) 721: /* Say whether this node was declared as a "class" or a "struct". */ 722: #define CLASSTYPE_DECLARED_EXCEPTION(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.declared_exception) 723: 724: /* Nonzero if this class has const members which have no specified initialization. */ 725: #define CLASSTYPE_READONLY_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.const_needs_init) 726: 727: /* Nonzero if this class has ref members which have no specified initialization. */ 728: #define CLASSTYPE_REF_FIELDS_NEED_INIT(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.ref_needs_init) 729: 730: /* Nonzero if this class is included from a header file which employs 731: `#pragma interface', and it is not included in its implementation file. */ 732: #define CLASSTYPE_INTERFACE_ONLY(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_only) 733: 734: /* Same as above, but for classes whose purpose we do not know. */ 735: #define CLASSTYPE_INTERFACE_UNKNOWN(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.interface_unknown) 736: 737: /* Nonzero if a _DECL node requires us to output debug info for this class. */ 738: #define CLASSTYPE_DEBUG_REQUESTED(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.debug_requested) 739: 740: /* Additional macros for inheritance information. */ 741: 742: #define CLASSTYPE_VBINFO(NODE,VIA_PUBLIC) \ 743: (TYPE_LANG_SPECIFIC (NODE)->vbinfo[VIA_PUBLIC]) 744: 745: /* When following an binfo-specific chain, this is the cumulative 746: via-public flag. */ 747: #define BINFO_VIA_PUBLIC(NODE) TREE_LANG_FLAG_5 (NODE) 748: 749: /* When building a matrix to determine by a single lookup 750: whether one class is derived from another or not, 751: this field is the index of the class in the table. */ 752: #define CLASSTYPE_CID(NODE) (TYPE_LANG_SPECIFIC(NODE)->cid) 753: #define BINFO_CID(NODE) CLASSTYPE_CID(BINFO_TYPE(NODE)) 754: 755: /* Nonzero means marked by DFS or BFS search, including searches 756: by `get_binfo' and `get_base_distance'. */ 757: #define BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED(BINFO_TYPE(NODE)):TREE_LANG_FLAG_0(NODE)) 758: /* Macros needed because of C compilers that don't allow conditional 759: expressions to be lvalues. Grr! */ 760: #define SET_BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_0(NODE)=1)) 761: #define CLEAR_BINFO_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_0(NODE)=0)) 762: 763: /* Nonzero means marked in building initialization list. */ 764: #define BINFO_BASEINIT_MARKED(NODE) CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)) 765: /* Modifier macros */ 766: #define SET_BINFO_BASEINIT_MARKED(NODE) SET_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)) 767: #define CLEAR_BINFO_BASEINIT_MARKED(NODE) CLEAR_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)) 768: 769: /* Nonzero means marked in search through virtual inheritance hierarchy. */ 770: #define BINFO_VBASE_MARKED(NODE) CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)) 771: /* Modifier macros */ 772: #define SET_BINFO_VBASE_MARKED(NODE) SET_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)) 773: #define CLEAR_BINFO_VBASE_MARKED(NODE) CLEAR_CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)) 774: 775: /* Nonzero means marked in search for members or member functions. */ 776: #define BINFO_FIELDS_MARKED(NODE) \ 777: (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED2 (BINFO_TYPE (NODE)):TREE_LANG_FLAG_2(NODE)) 778: #define SET_BINFO_FIELDS_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED2(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_2(NODE)=1)) 779: #define CLEAR_BINFO_FIELDS_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED2(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_2(NODE)=0)) 780: 781: /* Nonzero means that this class is on a path leading to a new vtable. */ 782: #define BINFO_VTABLE_PATH_MARKED(NODE) \ 783: (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):TREE_LANG_FLAG_3(NODE)) 784: #define SET_BINFO_VTABLE_PATH_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_3(NODE)=1)) 785: #define CLEAR_BINFO_VTABLE_PATH_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED3(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_3(NODE)=0)) 786: 787: /* Nonzero means that this class has a new vtable. */ 788: #define BINFO_NEW_VTABLE_MARKED(NODE) \ 789: (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):TREE_LANG_FLAG_4(NODE)) 790: #define SET_BINFO_NEW_VTABLE_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_4(NODE)=1)) 791: #define CLEAR_BINFO_NEW_VTABLE_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED4(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_4(NODE)=0)) 792: 793: /* Nonzero means this class has initialized its virtual baseclasses. */ 794: #define BINFO_VBASE_INIT_MARKED(NODE) \ 795: (TREE_VIA_VIRTUAL(NODE)?CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):TREE_LANG_FLAG_5(NODE)) 796: #define SET_BINFO_VBASE_INIT_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?SET_CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_5(NODE)=1)) 797: #define CLEAR_BINFO_VBASE_INIT_MARKED(NODE) (TREE_VIA_VIRTUAL(NODE)?CLEAR_CLASSTYPE_MARKED5(BINFO_TYPE(NODE)):(TREE_LANG_FLAG_5(NODE)=0)) 798: 799: /* Accessor macros for the vfield slots in structures. */ 800: 801: /* Get the assoc info that caused this vfield to exist. */ 802: #define VF_BINFO_VALUE(NODE) TREE_PURPOSE (NODE) 803: 804: /* Get that same information as a _TYPE. */ 805: #define VF_BASETYPE_VALUE(NODE) TREE_VALUE (NODE) 806: 807: /* Get the value of the top-most type dominating the non-`normal' vfields. */ 808: #define VF_DERIVED_VALUE(NODE) (VF_BINFO_VALUE (NODE) ? BINFO_TYPE (VF_BINFO_VALUE (NODE)) : NULL_TREE) 809: 810: /* Get the value of the top-most type that's `normal' for the vfield. */ 811: #define VF_NORMAL_VALUE(NODE) TREE_TYPE (NODE) 812: 813: /* Nonzero for TREE_LIST node means that this list of things 814: is a list of parameters, as opposed to a list of expressions. */ 815: #define TREE_PARMLIST(NODE) ((NODE)->common.unsigned_flag) /* overloaded! */ 816: 817: /* Nonzero for FIELD_DECL node means that this FIELD_DECL is 818: a member of an anonymous union construct. The name of the 819: union is . */ 820: #define TREE_ANON_UNION_ELEM(NODE) ((NODE)->decl.regdecl_flag) /* overloaded! */ 821: 822: /* For FUNCTION_TYPE or METHOD_TYPE, a list of the exceptions that 823: this type can raise. */ 824: #define TYPE_RAISES_EXCEPTIONS(NODE) TYPE_NONCOPIED_PARTS (NODE) 825: 826: struct lang_decl_flags 827: { 828: #ifdef ONLY_INT_FIELDS 829: int language : 8; 830: #else 831: enum languages language : 8; 832: #endif 833: 834: unsigned operator_attr : 1; 835: unsigned constructor_attr : 1; 836: unsigned returns_first_arg : 1; 837: unsigned preserves_first_arg : 1; 838: unsigned friend_attr : 1; 839: unsigned static_function : 1; 840: unsigned const_memfunc : 1; 841: unsigned volatile_memfunc : 1; 842: 843: unsigned abstract_virtual : 1; 844: unsigned permanent_attr : 1 ; 845: unsigned constructor_for_vbase_attr : 1; 846: unsigned dummy : 13; 847: 848: tree visibility; 849: tree context; 850: }; 851: 852: struct lang_decl 853: { 854: struct lang_decl_flags decl_flags; 855: 856: struct template_info *template_info; 857: tree main_decl_variant; 858: struct pending_inline *pending_inline_info; 859: tree vbase_init_list; 860: tree chain; 861: }; 862: 863: /* Non-zero if NODE is a _DECL with TREE_READONLY set. */ 864: #define TREE_READONLY_DECL_P(NODE) \ 865: (TREE_READONLY (NODE) && TREE_CODE_CLASS (TREE_CODE (NODE)) == 'd') 866: 867: /* For FUNCTION_DECLs: return the language in which this decl 868: was declared. */ 869: #define DECL_LANGUAGE(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.language) 870: 871: /* For FUNCTION_DECLs: nonzero means that this function is a constructor. */ 872: #define DECL_CONSTRUCTOR_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_attr) 873: /* For FUNCTION_DECLs: nonzero means that this function is a constructor 874: for an object with virtual baseclasses. */ 875: #define DECL_CONSTRUCTOR_FOR_VBASE_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.constructor_for_vbase_attr) 876: 877: /* For FUNCTION_DECLs: nonzero means that the constructor 878: is known to return a non-zero `this' unchanged. */ 879: #define DECL_RETURNS_FIRST_ARG(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.returns_first_arg) 880: 881: /* Nonzero for FUNCTION_DECL means that this constructor is known to 882: not make any assignment to `this', and therefore can be trusted 883: to return it unchanged. Otherwise, we must re-assign `current_class_decl' 884: after performing base initializations. */ 885: #define DECL_PRESERVES_THIS(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.preserves_first_arg) 886: 887: /* Nonzero for _DECL means that this decl appears in (or will appear 888: in) as a member in a RECORD_TYPE or UNION_TYPE node. It is also for 889: detecting circularity in case members are multiply defined. In the 1.1.1.2 root 890: case of a VAR_DECL, it is also used to determine how program storage 1.1 root 891: should be allocated. */ 892: #define DECL_IN_AGGR_P(NODE) (DECL_LANG_FLAG_3(NODE)) 893: 894: /* Nonzero for FUNCTION_DECL means that this decl is just a 895: friend declaration, and should not be added to the list of 896: member functions for this class. */ 897: #define DECL_FRIEND_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.friend_attr) 898: 899: /* Nonzero for FUNCTION_DECL means that this decl is a static 900: member function. */ 901: #define DECL_STATIC_FUNCTION_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.static_function) 902: 903: /* Nonzero for FUNCTION_DECL means that this member function 904: has `this' as const X *const. */ 905: #define DECL_CONST_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.const_memfunc) 906: 907: /* Nonzero for FUNCTION_DECL means that this member function 908: has `this' as volatile X *const. */ 909: #define DECL_VOLATILE_MEMFUNC_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.volatile_memfunc) 910: 911: /* Nonzero for FUNCTION_DECL means that this member function 1.1.1.5 ! root 912: exists as part of an abstract class's interface. */ 1.1 root 913: #define DECL_ABSTRACT_VIRTUAL_P(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.abstract_virtual) 914: 915: /* Nonzero if allocated on permanent_obstack. */ 916: #define LANG_DECL_PERMANENT(LANGDECL) ((LANGDECL)->decl_flags.permanent_attr) 917: 918: /* The _TYPE context in which this _DECL appears. This field is used 919: only to compute visibility information. */ 920: #define DECL_CLASS_CONTEXT(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.context) 921: 922: /* For a FUNCTION_DECL: the chain through which the next method 923: in the method chain is found. We now use TREE_CHAIN to 924: link into the FIELD_DECL chain. */ 925: #if 1 926: #define DECL_CHAIN(NODE) (DECL_LANG_SPECIFIC(NODE)->chain) 927: #else 928: #define DECL_CHAIN(NODE) (TREE_CHAIN (NODE)) 929: #endif 930: 931: /* Points back to the decl which caused this lang_decl to be allocated. */ 932: #define DECL_MAIN_VARIANT(NODE) (DECL_LANG_SPECIFIC(NODE)->main_decl_variant) 933: 934: /* For a FUNCTION_DECL: if this function was declared inline inside of 935: a class declaration, this is where the text for the function is 936: squirreled away. */ 937: #define DECL_PENDING_INLINE_INFO(NODE) (DECL_LANG_SPECIFIC(NODE)->pending_inline_info) 938: 939: /* Holds information about how virtual base classes should be initialized 940: by this constructor *if* this constructor is the one to perform 941: such initialization. */ 942: #define DECL_VBASE_INIT_LIST(NODE) (DECL_LANG_SPECIFIC(NODE)->vbase_init_list) 943: 944: /* For a TEMPLATE_DECL: template-specific information. */ 945: #define DECL_TEMPLATE_INFO(NODE) (DECL_LANG_SPECIFIC(NODE)->template_info) 946: 947: /* Nonzero in INT_CST means that this int is negative by dint of 948: using a twos-complement negated operand. */ 949: #define TREE_NEGATED_INT(NODE) (TREE_LANG_FLAG_0 (NODE)) 950: 951: /* Nonzero in any kind of _EXPR or _REF node means that it is a call 952: to a storage allocation routine. If, later, alternate storage 953: is found to hold the object, this call can be ignored. */ 954: #define TREE_CALLS_NEW(NODE) (TREE_LANG_FLAG_1 (NODE)) 955: 956: /* Nonzero in any kind of _TYPE that uses multiple inheritance 957: or virtual baseclasses. */ 958: #define TYPE_USES_COMPLEX_INHERITANCE(NODE) (TREE_LANG_FLAG_1 (NODE)) 959: 960: /* Nonzero in IDENTIFIER_NODE means that this name is overloaded, and 961: should be looked up in a non-standard way. */ 962: #define TREE_OVERLOADED(NODE) (TREE_LANG_FLAG_0 (NODE)) 963: #define DECL_OVERLOADED(NODE) (DECL_LANG_FLAG_4 (NODE)) 964: 965: /* Nonzero if this (non-TYPE)_DECL has its virtual attribute set. 966: For a FUNCTION_DECL, this is when the function is a virtual function. 967: For a VAR_DECL, this is when the variable is a virtual function table. 968: For a FIELD_DECL, when the field is the field for the virtual function table. 969: For an IDENTIFIER_NODE, nonzero if any function with this name 970: has been declared virtual. 971: 972: For a _TYPE if it uses virtual functions (or is derived from 973: one that does). */ 974: #define TYPE_VIRTUAL_P(NODE) (TREE_LANG_FLAG_2 (NODE)) 975: 976: /* Same, but tells if this field is private in current context. */ 977: #define DECL_PRIVATE(NODE) (DECL_LANG_FLAG_5 (NODE)) 978: 979: /* Same, but tells if this field is private in current context. */ 980: #define DECL_PROTECTED(NODE) (DECL_LANG_FLAG_6(NODE)) 981: 982: #define DECL_PUBLIC(NODE) (DECL_LANG_FLAG_7(NODE)) 983: 984: /* Record whether a typedef for type `int' was actually `signed int'. */ 985: #define C_TYPEDEF_EXPLICITLY_SIGNED(exp) DECL_LANG_FLAG_1 ((exp)) 986: 1.1.1.4 root 987: /* Nonzero if the type T promotes to itself. 988: ANSI C states explicitly the list of types that promote; 989: in particular, short promotes to int even if they have the same width. */ 990: #define C_PROMOTING_INTEGER_TYPE_P(t) \ 991: (TREE_CODE ((t)) == INTEGER_TYPE \ 992: && (TYPE_MAIN_VARIANT (t) == char_type_node \ 993: || TYPE_MAIN_VARIANT (t) == signed_char_type_node \ 994: || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node \ 995: || TYPE_MAIN_VARIANT (t) == short_integer_type_node \ 996: || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node)) 997: 1.1.1.2 root 998: /* Mark which labels are explicitly declared. 999: These may be shadowed, and may be referenced from nested functions. */ 1000: #define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label) 1001: 1.1 root 1002: /* Record whether a type or decl was written with nonconstant size. 1003: Note that TYPE_SIZE may have simplified to a constant. */ 1004: #define C_TYPE_VARIABLE_SIZE(type) TREE_LANG_FLAG_4 (type) 1005: #define C_DECL_VARIABLE_SIZE(type) DECL_LANG_FLAG_8 (type) 1006: 1007: /* Nonzero for _TYPE means that the _TYPE defines 1008: at least one constructor. */ 1009: #define TYPE_HAS_CONSTRUCTOR(NODE) (TYPE_LANG_FLAG_1(NODE)) 1010: 1011: /* When appearing in an INDIRECT_REF, it means that the tree structure 1012: underneath is actually a call to a constructor. This is needed 1013: when the constructor must initialize local storage (which can 1014: be automatically destroyed), rather than allowing it to allocate 1015: space from the heap. 1016: 1017: When appearing in a SAVE_EXPR, it means that underneath 1018: is a call to a constructor. 1019: 1020: When appearing in a CONSTRUCTOR, it means that it was 1021: a GNU C constructor expression. 1022: 1023: When appearing in a FIELD_DECL, it means that this field 1024: has been duly initialized in its constructor. */ 1025: #define TREE_HAS_CONSTRUCTOR(NODE) (TREE_LANG_FLAG_4(NODE)) 1026: 1027: /* Indicates that a NON_LVALUE_EXPR came from a C++ reference. 1028: Used to generate more helpful error message in case somebody 1029: tries to take its address. */ 1030: #define TREE_REFERENCE_EXPR(NODE) (TREE_LANG_FLAG_3(NODE)) 1031: 1032: /* Nonzero for _TYPE means that the _TYPE defines a destructor. */ 1033: #define TYPE_HAS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_2(NODE)) 1034: 1035: /* Nonzero for _TYPE node means that creating an object of this type 1036: will involve a call to a constructor. This can apply to objects 1037: of ARRAY_TYPE if the type of the elements needs a constructor. */ 1038: #define TYPE_NEEDS_CONSTRUCTING(NODE) (TYPE_LANG_FLAG_3(NODE)) 1039: #define TYPE_NEEDS_CONSTRUCTOR(NODE) (TYPE_LANG_SPECIFIC(NODE)->type_flags.needs_constructor) 1040: 1041: /* Nonzero for _TYPE node means that destroying an object of this type 1042: will involve a call to a destructor. This can apply to objects 1043: of ARRAY_TYPE is the type of the elements needs a destructor. */ 1044: #define TYPE_NEEDS_DESTRUCTOR(NODE) (TYPE_LANG_FLAG_4(NODE)) 1045: 1046: /* Nonzero for VAR_DECL node means that `external' was specified in 1047: its declaration. */ 1.1.1.4 root 1048: #define DECL_THIS_EXTERN(NODE) (DECL_LANG_FLAG_2(NODE)) 1.1 root 1049: 1050: /* Nonzero for SAVE_EXPR if used to initialize a PARM_DECL. */ 1051: #define PARM_DECL_EXPR(NODE) (TREE_LANG_FLAG_2(NODE)) 1052: 1053: /* Nonzero in FUNCTION_DECL means it is really an operator. 1054: Just used to communicate formatting information to dbxout.c. */ 1055: #define DECL_OPERATOR(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.operator_attr) 1056: 1057: /* Define fields and accessors for nodes representing declared names. */ 1058: 1.1.1.5 ! root 1059: #if 0 1.1 root 1060: /* C++: A derived class may be able to directly use the virtual 1061: function table of a base class. When it does so, it may 1062: still have a decl node used to access the virtual function 1063: table (so that variables of this type can initialize their 1064: virtual function table pointers by name). When such thievery 1.1.1.2 root 1065: is committed, know exactly which base class's virtual function 1.1 root 1066: table is the one being stolen. This effectively computes the 1067: transitive closure. */ 1068: #define DECL_VPARENT(NODE) ((NODE)->decl.arguments) 1.1.1.5 ! root 1069: #endif 1.1 root 1070: 1071: /* Make a slot so we can implement nested types. This slot holds 1072: the IDENTIFIER_NODE that uniquely names the nested type. This 1073: is for TYPE_DECLs only. */ 1074: #if !PARANOID 1075: #define DECL_NESTED_TYPENAME(NODE) ((NODE)->decl.arguments) 1076: #else 1077: #define DECL_NESTED_TYPENAME(NODE) (*DECL_NESTED_TYPENAME_PTR(NODE)) 1078: #ifdef __GNUC__ 1079: __inline 1080: #endif 1081: static tree * DECL_NESTED_TYPENAME_PTR(NODE) tree NODE; { return 1.1.1.4 root 1082: (my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (NODE)) == 'd', 346), 1.1 root 1083: &(NODE)->decl.arguments) ;} 1084: #endif 1085: 1086: /* C++: all of these are overloaded! These apply only to TYPE_DECLs. */ 1087: #define DECL_FRIENDLIST(NODE) (DECL_INITIAL (NODE)) 1088: #define DECL_UNDEFINED_FRIENDS(NODE) ((NODE)->decl.result) 1089: #define DECL_WAITING_FRIENDS(NODE) ((tree)(NODE)->decl.rtl) 1090: #define SET_DECL_WAITING_FRIENDS(NODE,VALUE) ((NODE)->decl.rtl=(struct rtx_def*)VALUE) 1091: 1092: /* The DECL_VISIBILITY is used to record under which context 1093: special visibility rules apply. */ 1094: #define DECL_VISIBILITY(NODE) (DECL_LANG_SPECIFIC(NODE)->decl_flags.visibility) 1095: 1096: /* C++: all of these are overloaded! 1097: These apply to PARM_DECLs and VAR_DECLs. */ 1098: #define DECL_REFERENCE_SLOT(NODE) ((tree)(NODE)->decl.arguments) 1099: #define SET_DECL_REFERENCE_SLOT(NODE,VAL) ((NODE)->decl.arguments=VAL) 1100: 1101: /* For local VAR_DECLs, holds index into gc-protected obstack. */ 1102: #define DECL_GC_OFFSET(NODE) ((NODE)->decl.result) 1103: 1104: /* Accessor macros for C++ template decl nodes. */ 1105: #define DECL_TEMPLATE_IS_CLASS(NODE) (DECL_RESULT(NODE) == NULL_TREE) 1106: #define DECL_TEMPLATE_PARMS(NODE) DECL_ARGUMENTS(NODE) 1107: /* For class templates. */ 1108: #define DECL_TEMPLATE_MEMBERS(NODE) DECL_INITIAL(NODE) 1109: /* For function, method, class-data templates. */ 1110: #define DECL_TEMPLATE_RESULT(NODE) DECL_RESULT(NODE) 1111: #define DECL_TEMPLATE_INSTANTIATIONS(NODE) DECL_VINDEX(NODE) 1112: 1113: /* ...and for unexpanded-parameterized-type nodes. */ 1114: #define UPT_TEMPLATE(NODE) TREE_PURPOSE(TYPE_VALUES(NODE)) 1115: #define UPT_PARMS(NODE) TREE_VALUE(TYPE_VALUES(NODE)) 1116: 1117: /* An enumeration of the kind of tags that C++ accepts. */ 1118: enum tag_types { record_type, class_type, union_type, enum_type, exception_type }; 1119: 1120: /* Zero means prototype weakly, as in ANSI C (no args means nothing). 1121: Each language context defines how this variable should be set. */ 1122: extern int strict_prototype; 1123: extern int strict_prototypes_lang_c, strict_prototypes_lang_cplusplus; 1124: 1125: /* Non-zero means that if a label exists, and no other identifier 1126: applies, use the value of the label. */ 1127: extern int flag_labels_ok; 1128: 1129: /* Non-zero means to collect statistics which might be expensive 1130: and to print them when we are done. */ 1131: extern int flag_detailed_statistics; 1132: 1133: /* Non-zero means warn in function declared in derived class has the 1134: same name as a virtual in the base class, but fails to match the 1135: type signature of any virtual function in the base class. */ 1136: extern int warn_overloaded_virtual; 1137: 1138: /* in cp-decl{2}.c */ 1139: extern tree void_list_node; 1140: extern tree void_zero_node; 1141: extern tree default_function_type; 1142: extern tree vtable_entry_type; 1143: extern tree __t_desc_type_node, __i_desc_type_node, __m_desc_type_node; 1144: extern tree class_star_type_node; 1145: 1146: /* A node that is a list (length 1) of error_mark_nodes. */ 1147: extern tree error_mark_list; 1148: 1149: extern tree ptr_type_node; 1150: extern tree class_type_node, record_type_node, union_type_node, enum_type_node; 1151: extern tree exception_type_node, unknown_type_node; 1152: 1153: /* The largest size a virtual function table can be. 1154: Must be a (power of 2). */ 1155: #ifndef VINDEX_MAX 1156: #define VINDEX_MAX ((unsigned)128) 1157: /* This is the integer ~ (vindex_max - 1). */ 1158: #endif 1159: extern tree vtbl_mask; 1160: 1161: /* Array type `(void *)[]' */ 1162: extern tree vtbl_type_node; 1163: 1164: extern tree long_long_integer_type_node, long_long_unsigned_type_node; 1165: /* For building calls to `delete'. */ 1166: extern tree integer_two_node, integer_three_node; 1167: 1168: /* in cp-except.c */ 1169: extern tree current_exception_type; 1170: extern tree current_exception_decl; 1171: extern tree current_exception_object; 1.1.1.5 ! root 1172: ! 1173: /* in cp-pt.c */ ! 1174: /* PARM_VEC is a vector of template parameters, either IDENTIFIER_NODEs or ! 1175: PARM_DECLs. BINDINGS, if non-null, is a vector of bindings for those ! 1176: parameters. */ ! 1177: struct template_info { ! 1178: /* Vector of template parameters, either PARM_DECLs or IDENTIFIER_NODEs. */ ! 1179: tree parm_vec; ! 1180: /* If non-null, a vector of bindings for the template parms. */ ! 1181: tree bindings; ! 1182: ! 1183: /* Text of template, and length. */ ! 1184: char *text; ! 1185: int length; ! 1186: /* Where it came from. */ ! 1187: char *filename; ! 1188: int lineno; ! 1189: ! 1190: /* What kind of aggregate -- struct, class, or null. */ ! 1191: tree aggr; ! 1192: }; ! 1193: extern int processing_template_decl, processing_template_defn; ! 1194: ! 1195: #define PRINT_LANG_DECL ! 1196: #define PRINT_LANG_TYPE ! 1197: ! 1198: #define UNKNOWN_TYPE LANG_TYPE 1.1 root 1199: 1200: /* in cp-class.c */ 1201: extern tree current_class_name; 1202: extern tree current_class_type; 1203: 1204: extern tree current_lang_name, lang_name_cplusplus, lang_name_c; 1205: 1206: /* Points to the name of that function. May not be the DECL_NAME 1207: of CURRENT_FUNCTION_DECL due to overloading */ 1208: extern tree original_function_name; 1209: 1210: # define IS_AGGR_TYPE(t) (TYPE_LANG_FLAG_5 (t)) 1211: 1212: # define IS_AGGR_TYPE_CODE(t) \ 1213: (t == RECORD_TYPE || t == UNION_TYPE) 1214: 1215: extern tree current_class_name, current_class_type, current_class_decl, C_C_D; 1216: extern tree current_vtable_decl; 1217: 1218: /* in cp-init.c */ 1219: extern tree global_base_init_list; 1220: extern tree current_base_init_list, current_member_init_list; 1221: 1222: extern int current_function_assigns_this; 1223: extern int current_function_just_assigned_this; 1224: extern int current_function_parms_stored; 1225: 1226: /* Here's where we control how name mangling takes place. */ 1227: 1228: #define OPERATOR_ASSIGN_FORMAT "__a%s" 1229: #define OPERATOR_FORMAT "__%s" 1230: #define OPERATOR_TYPENAME_FORMAT "__op" 1231: 1.1.1.4 root 1232: /* Cannot use '$' up front, because this confuses gdb 1233: (names beginning with '$' are gdb-local identifiers). 1.1 root 1234: 1235: Note that all forms in which the '$' is significant are long enough 1.1.1.4 root 1236: for direct indexing (meaning that if we know there is a '$' 1237: at a particular location, we can index into the string at 1238: any other location that provides distinguishing characters). */ 1.1 root 1239: 1240: /* Define NO_DOLLAR_IN_LABEL in your favorite tm file if your assembler 1241: doesn't allow '$' in symbol names. */ 1242: #ifndef NO_DOLLAR_IN_LABEL 1243: 1244: #define JOINER '$' 1245: 1246: #define VPTR_NAME "$v" 1247: #define THROW_NAME "$eh_throw" 1248: #define DESTRUCTOR_DECL_PREFIX "_$_" 1249: #define IN_CHARGE_NAME "__in$chrg" 1250: #define AUTO_VTABLE_NAME "__vtbl$me__" 1251: #define AUTO_TEMP_NAME "_$tmp_" 1252: #define AUTO_TEMP_FORMAT "_$tmp_%d" 1253: #define VTBL_PTR_TYPE "$vtbl_ptr_type" 1.1.1.3 root 1254: #define VTABLE_BASE "$vb" 1.1 root 1255: #define VTABLE_NAME_FORMAT "_vt$%s" 1.1.1.3 root 1256: #define VFIELD_BASE "$vf" 1.1 root 1257: #define VFIELD_NAME "_vptr$" 1258: #define VFIELD_NAME_FORMAT "_vptr$%s" 1259: #define VBASE_NAME "_vb$" 1260: #define VBASE_NAME_FORMAT "_vb$%s" 1261: #define STATIC_NAME_FORMAT "_%s$%s" 1262: #define FILE_FUNCTION_FORMAT "_GLOBAL_$D$%s" 1263: #define ANON_AGGRNAME_FORMAT "$_%d" 1264: 1.1.1.5 ! root 1265: #else /* NO_DOLLAR_IN_LABEL */ ! 1266: ! 1267: #ifndef NO_DOT_IN_LABEL 1.1 root 1268: 1269: #define JOINER '.' 1270: 1271: #define VPTR_NAME ".v" 1272: #define THROW_NAME ".eh_throw" 1273: #define DESTRUCTOR_DECL_PREFIX "_._" 1274: #define IN_CHARGE_NAME "__in.chrg" 1275: #define AUTO_VTABLE_NAME "__vtbl.me__" 1276: #define AUTO_TEMP_NAME "_.tmp_" 1277: #define AUTO_TEMP_FORMAT "_.tmp_%d" 1278: #define VTBL_PTR_TYPE ".vtbl_ptr_type" 1.1.1.3 root 1279: #define VTABLE_BASE ".vb" 1.1 root 1280: #define VTABLE_NAME_FORMAT "_vt.%s" 1.1.1.3 root 1281: #define VFIELD_BASE ".vf" 1.1 root 1282: #define VFIELD_NAME "_vptr." 1283: #define VFIELD_NAME_FORMAT "_vptr.%s" 1284: #define VBASE_NAME "_vb." 1285: #define VBASE_NAME_FORMAT "_vb.%s" 1286: #define STATIC_NAME_FORMAT "_%s.%s" 1287: #define FILE_FUNCTION_FORMAT "_GLOBAL_.D.%s" 1288: 1289: #define ANON_AGGRNAME_FORMAT "._%d" 1290: 1.1.1.5 ! root 1291: #else /* NO_DOT_IN_LABEL */ ! 1292: ! 1293: #define VPTR_NAME "__vptr" ! 1294: #define VPTR_NAME_P(ID_NODE) \ ! 1295: (!strncmp (IDENTIFIER_POINTER (ID_NODE), VPTR_NAME, sizeof (VPTR_NAME) - 1)) ! 1296: #define THROW_NAME "__eh_throw" ! 1297: #define DESTRUCTOR_DECL_PREFIX "__destr_" ! 1298: #define DESTRUCTOR_NAME_P(ID_NODE) \ ! 1299: (!strncmp (IDENTIFIER_POINTER (ID_NODE), DESTRUCTOR_DECL_PREFIX, \ ! 1300: sizeof (DESTRUCTOR_DECL_PREFIX) - 1)) ! 1301: #define IN_CHARGE_NAME "__in_chrg" ! 1302: #define AUTO_VTABLE_NAME "__vtbl_me__" ! 1303: #define AUTO_TEMP_NAME "__tmp_" ! 1304: #define TEMP_NAME_P(ID_NODE) \ ! 1305: (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, \ ! 1306: sizeof (AUTO_TEMP_NAME) - 1)) ! 1307: #define AUTO_TEMP_FORMAT "__tmp_%d" ! 1308: #define VTBL_PTR_TYPE "__vtbl_ptr_type" ! 1309: #define VTABLE_BASE "__vtb" ! 1310: #define VTABLE_NAME_FORMAT "__vt_%s" ! 1311: #define VFIELD_BASE "__vfb" ! 1312: #define VFIELD_NAME "__vptr_" ! 1313: #define VFIELD_NAME_P(ID_NODE) \ ! 1314: (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, \ ! 1315: sizeof (VFIELD_NAME) - 1)) ! 1316: #define VFIELD_NAME_FORMAT "_vptr_%s" ! 1317: #define VBASE_NAME "__vb_" ! 1318: #define VBASE_NAME_P(ID_NODE) \ ! 1319: (!strncmp (IDENTIFIER_POINTER (ID_NODE), VBASE_NAME, \ ! 1320: sizeof (VBASE_NAME) - 1)) ! 1321: #define VBASE_NAME_FORMAT "__vb_%s" ! 1322: #define STATIC_NAME_FORMAT "__static_%s_%s" ! 1323: #define FILE_FUNCTION_FORMAT "__GLOBAL_D_%s" ! 1324: ! 1325: #define ANON_AGGRNAME_PREFIX "__anon_" ! 1326: #define ANON_AGGRNAME_P(ID_NODE) \ ! 1327: (!strncmp (IDENTIFIER_POINTER (ID_NODE), ANON_AGGRNAME_PREFIX, \ ! 1328: sizeof (ANON_AGGRNAME_PREFIX) - 1)) ! 1329: #define ANON_AGGRNAME_FORMAT "__anon_%d" ! 1330: #define ANON_PARMNAME_FORMAT "__%d" ! 1331: #define ANON_PARMNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == '_' \ ! 1332: && IDENTIFIER_POINTER (ID_NODE)[1] == '_' \ ! 1333: && IDENTIFIER_POINTER (ID_NODE)[2] <= '9') ! 1334: ! 1335: #endif /* NO_DOT_IN_LABEL */ 1.1 root 1336: #endif /* NO_DOLLAR_IN_LABEL */ 1337: 1.1.1.4 root 1338: #define THIS_NAME "this" 1.1 root 1339: #define DESTRUCTOR_NAME_FORMAT "~%s" 1340: #define FILE_FUNCTION_PREFIX_LEN 9 1341: #define VTABLE_DELTA_NAME "delta" 1342: #define VTABLE_DELTA2_NAME "delta2" 1343: #define VTABLE_INDEX_NAME "index" 1344: #define VTABLE_PFN_NAME "pfn" 1345: #define EXCEPTION_CLEANUP_NAME "exception cleanup" 1346: 1.1.1.4 root 1347: #define THIS_NAME_P(ID_NODE) (strcmp(IDENTIFIER_POINTER (ID_NODE), "this") == 0) 1.1.1.5 ! root 1348: ! 1349: #if !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) ! 1350: 1.1 root 1351: #define VPTR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ 1352: && IDENTIFIER_POINTER (ID_NODE)[1] == 'v') 1353: #define DESTRUCTOR_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == JOINER) 1354: 1.1.1.5 ! root 1355: #define VTABLE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \ ! 1356: && IDENTIFIER_POINTER (ID_NODE)[2] == 't' \ ! 1357: && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER) ! 1358: ! 1359: #define VBASE_NAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[1] == 'v' \ ! 1360: && IDENTIFIER_POINTER (ID_NODE)[2] == 'b' \ ! 1361: && IDENTIFIER_POINTER (ID_NODE)[3] == JOINER) 1.1 root 1362: 1363: #define OPERATOR_TYPENAME_P(ID_NODE) \ 1364: (IDENTIFIER_POINTER (ID_NODE)[0] == '_' \ 1365: && IDENTIFIER_POINTER (ID_NODE)[1] == '_' \ 1366: && IDENTIFIER_POINTER (ID_NODE)[2] == 'o' \ 1367: && IDENTIFIER_POINTER (ID_NODE)[3] == 'p') 1368: 1369: #define TEMP_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), AUTO_TEMP_NAME, sizeof (AUTO_TEMP_NAME)-1)) 1370: #define VFIELD_NAME_P(ID_NODE) (!strncmp (IDENTIFIER_POINTER (ID_NODE), VFIELD_NAME, sizeof(VFIELD_NAME)-1)) 1371: 1372: /* For anonymous aggregate types, we need some sort of name to 1373: hold on to. In practice, this should not appear, but it should 1374: not be harmful if it does. */ 1.1.1.4 root 1375: #define ANON_AGGRNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == JOINER \ 1376: && IDENTIFIER_POINTER (ID_NODE)[1] == '_') 1.1 root 1377: #define ANON_PARMNAME_FORMAT "_%d" 1378: #define ANON_PARMNAME_P(ID_NODE) (IDENTIFIER_POINTER (ID_NODE)[0] == '_' \ 1379: && IDENTIFIER_POINTER (ID_NODE)[1] <= '9') 1.1.1.5 ! root 1380: #endif /* !defined(NO_DOLLAR_IN_LABEL) || !defined(NO_DOT_IN_LABEL) */ 1.1 root 1381: 1382: /* Define the sets of attributes that member functions and baseclasses 1383: can have. These are sensible combinations of {public,private,protected} 1384: cross {virtual,non-virtual}. */ 1385: 1386: enum visibility_type { 1387: visibility_default, 1388: visibility_public, 1389: visibility_private, 1390: visibility_protected, 1391: visibility_default_virtual, 1392: visibility_public_virtual, 1393: visibility_private_virtual 1394: }; 1395: 1396: /* in cp-lex.c */ 1397: extern tree current_unit_name, current_unit_language; 1398: 1399: /* Things for handling inline functions. */ 1400: 1401: struct pending_inline 1402: { 1403: struct pending_inline *next; /* pointer to next in chain */ 1404: int lineno; /* line number we got the text from */ 1405: char *filename; /* name of file we were processing */ 1406: tree fndecl; /* FUNCTION_DECL that brought us here */ 1407: int token; /* token we were scanning */ 1408: int token_value; /* value of token we were scanning (YYSTYPE) */ 1409: 1410: char *buf; /* pointer to character stream */ 1411: int len; /* length of stream */ 1412: tree parm_vec, bindings; /* in case this is derived from a template */ 1413: unsigned int can_free : 1; /* free this after we're done with it? */ 1414: unsigned int deja_vu : 1; /* set iff we don't want to see it again. */ 1.1.1.4 root 1415: unsigned int interface : 2; /* 0=interface 1=unknown 2=implementation */ 1.1 root 1416: }; 1417: 1418: /* in cp-method.c */ 1419: extern struct pending_inline *pending_inlines; 1420: 1421: /* 1 for -fall-virtual: make every member function (except 1422: constructors) lay down in the virtual function table. 1423: Calls can then either go through the virtual function table or not, 1.1.1.5 ! root 1424: depending on whether we know what function will actually be called. */ 1.1 root 1425: 1426: extern int flag_all_virtual; 1427: 1.1.1.2 root 1428: /* Positive values means that we cannot make optimizing assumptions about 1429: `this'. Negative values means we know `this' to be of static type. */ 1.1 root 1430: 1431: extern int flag_this_is_variable; 1432: 1.1.1.4 root 1433: /* Controls whether enums and ints freely convert. 1434: 1 means with complete freedom. 1435: 0 means enums can convert to ints, but not vice-versa. */ 1436: 1437: extern int flag_int_enum_equivalence; 1438: 1.1 root 1439: /* Nonzero means layout structures so that we can do garbage collection. */ 1440: 1441: extern int flag_gc; 1442: 1443: /* Nonzero means generate 'dossiers' that give run-time type information. */ 1444: 1445: extern int flag_dossier; 1446: 1447: /* Current end of entries in the gc obstack for stack pointer variables. */ 1448: 1449: extern int current_function_obstack_index; 1450: 1451: /* Flag saying whether we have used the obstack in this function or not. */ 1452: 1453: extern int current_function_obstack_usage; 1454: 1.1.1.4 root 1455: enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG }; 1.1 root 1456: 1457: extern tree current_class_decl, C_C_D; /* PARM_DECL: the class instance variable */ 1458: 1459: /* The following two can be derived from the previous one */ 1460: extern tree current_class_name; /* IDENTIFIER_NODE: name of current class */ 1461: extern tree current_class_type; /* _TYPE: the type of the current class */ 1462: 1463: /* Some macros for char-based bitfields. */ 1464: #define B_SET(a,x) (a[x>>3] |= (1 << (x&7))) 1465: #define B_CLR(a,x) (a[x>>3] &= ~(1 << (x&7))) 1466: #define B_TST(a,x) (a[x>>3] & (1 << (x&7))) 1467: 1468: /* These are uses as bits in flags passed to build_method_call 1469: to control its error reporting behavior. 1470: 1471: LOOKUP_PROTECT means flag visibility violations. 1472: LOOKUP_COMPLAIN mean complain if no suitable member function 1473: matching the arguments is found. 1474: LOOKUP_NORMAL is just a combination of these two. 1475: LOOKUP_AGGR requires the instance to be of aggregate type. 1476: LOOKUP_NONVIRTUAL means make a direct call to the member function found 1477: LOOKUP_GLOBAL means search through the space of overloaded functions, 1478: rather than the space of member functions. 1479: LOOKUP_HAS_IN_CHARGE means that the "in charge" variable is already 1480: in the parameter list. 1481: LOOKUP_PROTECTED_OK means that even if the constructor we find appears 1.1.1.2 root 1482: to be non-visible to current scope, call it anyway. 1.1 root 1483: LOOKUP_NO_CONVERSION means that user-defined conversions are not 1484: permitted. Built-in conversions are permitted. 1485: LOOKUP_DESTRUCTOR means explicit call to destructor. */ 1486: 1487: #define LOOKUP_PROTECT (1) 1488: #define LOOKUP_COMPLAIN (2) 1489: #define LOOKUP_NORMAL (3) 1490: #define LOOKUP_AGGR (4) 1491: #define LOOKUP_NONVIRTUAL (8) 1492: #define LOOKUP_GLOBAL (16) 1493: #define LOOKUP_HAS_IN_CHARGE (32) 1494: #define LOOKUP_SPECULATIVELY (64) 1495: #define LOOKUP_PROTECTED_OK (128) 1.1.1.5 ! root 1496: /* 256 is free */ 1.1 root 1497: #define LOOKUP_NO_CONVERSION (512) 1498: #define LOOKUP_DESTRUCTOR (512) 1499: 1500: /* Anatomy of a DECL_FRIENDLIST (which is a TREE_LIST): 1501: purpose = friend name (IDENTIFIER_NODE); 1502: value = TREE_LIST of FUNCTION_DECLS; 1503: chain, type = EMPTY; */ 1504: #define FRIEND_NAME(LIST) (TREE_PURPOSE (LIST)) 1505: #define FRIEND_DECLS(LIST) (TREE_VALUE (LIST)) 1506: 1507: /* These macros are for accessing the fields of TEMPLATE...PARM nodes. */ 1508: #define TEMPLATE_TYPE_TPARMLIST(NODE) TREE_PURPOSE (TYPE_FIELDS (NODE)) 1509: #define TEMPLATE_TYPE_IDX(NODE) TREE_INT_CST_LOW (TREE_VALUE (TYPE_FIELDS (NODE))) 1510: #define TEMPLATE_TYPE_SET_INFO(NODE,P,I) \ 1511: (TYPE_FIELDS (NODE) = build_tree_list (P, build_int_2 (I, 0))) 1512: #define TEMPLATE_CONST_TPARMLIST(NODE) (*(tree*)&TREE_INT_CST_LOW(NODE)) 1513: #define TEMPLATE_CONST_IDX(NODE) (TREE_INT_CST_HIGH(NODE)) 1514: #define TEMPLATE_CONST_SET_INFO(NODE,P,I) \ 1515: (TEMPLATE_CONST_TPARMLIST (NODE) = saved_parmlist, \ 1516: TEMPLATE_CONST_IDX (NODE) = I) 1517: 1518: /* in cp-lex.c */ 1519: /* Indexed by TREE_CODE, these tables give C-looking names to 1520: operators represented by TREE_CODES. For example, 1521: opname_tab[(int) MINUS_EXPR] == "-". */ 1522: extern char **opname_tab, **assignop_tab; 1.1.1.5 ! root 1523: ! 1524: /* in cp-call.c */ ! 1525: extern int rank_for_overload PROTO((struct candidate *, struct candidate *)); ! 1526: extern void compute_conversion_costs PROTO((tree, tree, struct candidate *, int)); ! 1527: extern int get_arglist_len_in_bytes PROTO((tree)); ! 1528: extern tree build_vfield_ref PROTO((tree, tree)); ! 1529: extern tree find_scoped_type PROTO((tree, tree, tree)); ! 1530: extern tree resolve_scope_to_name PROTO((tree, tree)); ! 1531: extern tree build_scoped_method_call PROTO((tree, tree, tree, tree)); ! 1532: extern tree build_method_call PROTO((tree, tree, tree, tree, int)); ! 1533: extern tree build_overload_call_real PROTO((tree, tree, int, struct candidate *, int)); ! 1534: extern tree build_overload_call PROTO((tree, tree, int, struct candidate *)); ! 1535: extern tree build_overload_call_maybe PROTO((tree, tree, int, struct candidate *)); 1.1 root 1536: 1.1.1.5 ! root 1537: /* in cp-class.c */ ! 1538: extern tree build_vbase_pointer PROTO((tree, tree)); ! 1539: extern tree build_vbase_path PROTO((enum tree_code, tree, tree, tree, int)); ! 1540: extern tree build_vtable_entry PROTO((tree, tree)); ! 1541: extern tree build_vfn_ref PROTO((tree *, tree, tree)); ! 1542: extern void add_method PROTO((tree, tree *, tree)); ! 1543: extern void duplicate_tag_error PROTO((tree)); ! 1544: extern tree finish_struct PROTO((tree, tree, int)); ! 1545: extern int resolves_to_fixed_type_p PROTO((tree, int *)); ! 1546: extern void init_class_processing PROTO((void)); ! 1547: extern void pushclass PROTO((tree, int)); ! 1548: extern void popclass PROTO((int)); ! 1549: extern void push_lang_context PROTO((tree)); ! 1550: extern void pop_lang_context PROTO((void)); ! 1551: extern int root_lang_context_p PROTO((void)); ! 1552: extern tree instantiate_type PROTO((tree, tree, int)); ! 1553: extern void print_class_statistics PROTO((void)); ! 1554: ! 1555: /* in cp-cvt.c */ ! 1556: extern tree convert_to_reference PROTO((tree, tree, tree, tree, int, char *, int, int)); ! 1557: extern tree convert_from_reference PROTO((tree)); ! 1558: extern tree convert_to_aggr PROTO((tree, tree, char **, int)); ! 1559: extern tree convert_pointer_to PROTO((tree, tree)); ! 1560: extern tree convert_pointer_to_vbase PROTO((tree, tree)); ! 1561: extern tree convert PROTO((tree, tree)); ! 1562: extern tree convert_force PROTO((tree, tree)); ! 1563: extern tree build_type_conversion PROTO((enum tree_code, tree, tree, int)); ! 1564: extern int build_default_binary_type_conversion PROTO((enum tree_code, tree *, tree *)); ! 1565: extern int build_default_unary_type_conversion PROTO((enum tree_code, tree *)); ! 1566: ! 1567: /* cp-decl.c */ ! 1568: #ifdef PARANOID ! 1569: extern void binding_levels_sane PROTO((void)); ! 1570: #endif ! 1571: extern int global_bindings_p PROTO((void)); ! 1572: extern void keep_next_level PROTO((void)); ! 1573: extern int kept_level_p PROTO((void)); ! 1574: extern void declare_parm_level PROTO((void)); ! 1575: extern void declare_implicit_exception PROTO((void)); ! 1576: extern int have_exceptions_p PROTO((void)); ! 1577: extern void declare_uninstantiated_type_level PROTO((void)); ! 1578: extern int uninstantiated_type_level_p PROTO((void)); ! 1579: extern void declare_pseudo_global_level PROTO((void)); ! 1580: extern int pseudo_global_level_p PROTO((void)); ! 1581: extern void pushlevel PROTO((int)); ! 1582: extern void pushlevel_temporary PROTO((int)); ! 1583: extern tree poplevel PROTO((int, int, int)); ! 1584: extern void delete_block PROTO((tree)); ! 1585: extern void insert_block PROTO((tree)); ! 1586: extern void add_block_current_level PROTO((tree)); ! 1587: extern void set_block PROTO((tree)); ! 1588: extern void pushlevel_class PROTO((void)); ! 1589: extern tree poplevel_class PROTO((void)); ! 1590: /* skip print_other_binding_stack and print_binding_level */ ! 1591: extern void print_binding_stack PROTO((void)); ! 1592: extern void push_to_top_level PROTO((void)); ! 1593: extern void pop_from_top_level PROTO((void)); ! 1594: extern void set_identifier_type_value PROTO((tree, tree)); ! 1595: extern void set_identifier_local_value PROTO((tree, tree)); ! 1596: extern tree make_type_decl PROTO((tree, tree)); ! 1597: extern void pushtag PROTO((tree, tree)); ! 1598: extern tree make_anon_name PROTO((void)); ! 1599: extern void clear_anon_tags PROTO((void)); ! 1600: extern void adjust_type_value PROTO((tree)); ! 1601: extern tree pushdecl PROTO((tree)); ! 1602: extern tree pushdecl_top_level PROTO((tree)); ! 1603: extern void push_overloaded_decl_top_level PROTO((tree, int)); ! 1604: extern tree pushdecl_class_level PROTO((tree)); ! 1605: extern int overloaded_globals_p PROTO((tree)); ! 1606: extern tree push_overloaded_decl PROTO((tree, int)); ! 1607: extern tree implicitly_declare PROTO((tree)); ! 1608: extern tree lookup_label PROTO((tree)); ! 1609: extern tree shadow_label PROTO((tree)); ! 1610: extern tree define_label PROTO((char *, int, tree)); ! 1611: extern void define_case_label PROTO((tree)); ! 1612: extern tree getdecls PROTO((void)); ! 1613: extern tree gettags PROTO((void)); ! 1614: extern void set_current_level_tags_transparency PROTO((int)); ! 1615: extern tree typedecl_for_tag PROTO((tree)); ! 1616: extern tree lookup_name PROTO((tree, int)); ! 1617: extern tree lookup_name_current_level PROTO((tree)); ! 1618: extern void init_decl_processing PROTO((void)); ! 1619: /* skipped define_function */ ! 1620: extern void shadow_tag PROTO((tree)); ! 1621: extern void grok_ctor_properties PROTO((tree, tree)); ! 1622: extern tree groktypename PROTO((tree)); ! 1623: extern tree start_decl PROTO((tree, tree, int, tree)); ! 1624: extern void finish_decl PROTO((tree, tree, tree, int)); ! 1625: extern int complete_array_type PROTO((tree, tree, int)); ! 1626: extern tree grokdeclarator (); /* PROTO((tree, tree, enum decl_context, int, tree)); */ ! 1627: extern tree xref_defn_tag PROTO((tree, tree, tree)); ! 1628: extern tree xref_tag PROTO((tree, tree, tree)); ! 1629: extern tree start_enum PROTO((tree)); ! 1630: extern tree finish_enum PROTO((tree, tree)); ! 1631: extern tree build_enumerator PROTO((tree, tree)); ! 1632: extern tree grok_enum_decls PROTO((tree, tree)); ! 1633: extern int start_function PROTO((tree, tree, tree, int)); ! 1634: extern void store_parm_decls PROTO((void)); ! 1635: extern void store_return_init PROTO((tree, tree)); ! 1636: extern void finish_function PROTO((int, int)); ! 1637: extern tree start_method PROTO((tree, tree, tree)); ! 1638: extern tree finish_method PROTO((tree)); ! 1639: extern void hack_incomplete_structures PROTO((tree)); ! 1640: extern tree maybe_build_cleanup PROTO((tree)); ! 1641: extern void cplus_expand_expr_stmt PROTO((tree)); ! 1642: extern void finish_stmt PROTO((void)); ! 1643: extern void pop_implicit_try_blocks PROTO((tree)); ! 1644: extern void push_exception_cleanup PROTO((tree)); ! 1645: extern void revert_static_member_fn PROTO((tree *, tree *, tree *)); ! 1646: ! 1647: /* in cp-decl2.c */ ! 1648: extern int lang_decode_option PROTO((char *)); ! 1649: extern tree grok_method_quals PROTO((tree, tree, tree)); ! 1650: extern void grokclassfn PROTO((tree, tree, tree, enum overload_flags, tree)); ! 1651: extern void bad_specifiers PROTO((char *, int, int, int, int)); ! 1652: extern void check_classfn PROTO((tree, tree, tree)); ! 1653: extern tree grokfield PROTO((tree, tree, tree, tree, tree)); ! 1654: extern tree grokbitfield PROTO((tree, tree, tree)); ! 1655: extern tree groktypefield PROTO((tree, tree)); ! 1656: extern tree grokoptypename PROTO((tree, int)); ! 1657: extern tree build_push_scope PROTO((tree, tree)); ! 1658: extern tree constructor_name PROTO((tree)); ! 1659: extern void setup_vtbl_ptr PROTO((void)); ! 1660: extern void mark_inline_for_output PROTO((tree)); ! 1661: extern void clear_temp_name PROTO((void)); ! 1662: extern tree get_temp_name PROTO((tree, int)); ! 1663: extern tree get_temp_regvar PROTO((tree, tree)); ! 1664: extern void finish_anon_union PROTO((tree)); ! 1665: extern tree finish_table PROTO((tree, tree, tree, int)); ! 1666: extern void finish_builtin_type PROTO((tree, char *, tree *, int, tree)); ! 1667: extern tree coerce_new_type PROTO((tree)); ! 1668: extern tree coerce_delete_type PROTO((tree)); ! 1669: extern void walk_vtables PROTO((void (*)(), void (*)())); ! 1670: extern void finish_file PROTO((void)); 1.1 root 1671: 1.1.1.5 ! root 1672: /* in cp-dem.c */ ! 1673: extern char *cplus_demangle PROTO((char *)); 1.1 root 1674: 1.1.1.5 ! root 1675: /* in cp-edsel.c */ 1.1 root 1676: 1.1.1.5 ! root 1677: /* in cp-except.c */ ! 1678: extern tree lookup_exception_cname PROTO((tree, tree, tree)); ! 1679: extern tree lookup_exception_tname PROTO((tree)); ! 1680: extern tree lookup_exception_object PROTO((tree, tree, int)); ! 1681: extern tree lookup_exception_type PROTO((tree, tree, tree)); ! 1682: extern tree finish_exception PROTO((tree, tree)); ! 1683: extern void finish_exception_decl PROTO((tree, tree)); ! 1684: extern void end_exception_decls PROTO((void)); ! 1685: extern void cplus_expand_start_try PROTO((int)); ! 1686: extern tree cplus_expand_end_try PROTO((int)); ! 1687: extern void cplus_expand_start_except PROTO((tree, tree)); ! 1688: extern void cplus_expand_end_except PROTO((tree)); ! 1689: extern void cplus_expand_raise PROTO((tree, tree, tree, int)); ! 1690: extern tree ansi_exception_object_lookup PROTO((tree)); ! 1691: extern void cplus_expand_throw PROTO((tree)); ! 1692: extern tree cplus_expand_start_catch PROTO((tree)); ! 1693: extern tree ansi_expand_start_catch PROTO((tree)); ! 1694: extern void cplus_expand_end_catch PROTO((int)); ! 1695: extern void cplus_expand_reraise PROTO((tree)); ! 1696: extern void setup_exception_throw_decl PROTO((void)); ! 1697: extern void init_exception_processing PROTO((void)); ! 1698: extern void init_exception_processing_1 PROTO((void)); ! 1699: ! 1700: /* in cp-expr.c */ ! 1701: /* skip cplus_expand_expr */ ! 1702: extern void init_cplus_expand PROTO((void)); ! 1703: extern void fixup_result_decl PROTO((tree, struct rtx_def *)); ! 1704: extern int decl_in_memory_p PROTO((tree)); ! 1705: ! 1706: /* in cp-gc.c */ ! 1707: extern int type_needs_gc_entry PROTO((tree)); ! 1708: extern int value_safe_from_gc PROTO((tree, tree)); ! 1709: extern void build_static_gc_entry PROTO((tree, tree)); ! 1710: extern tree protect_value_from_gc PROTO((tree, tree)); ! 1711: extern tree build_headof PROTO((tree)); ! 1712: extern tree build_classof PROTO((tree)); ! 1713: extern tree build_t_desc PROTO((tree, int)); ! 1714: extern tree build_i_desc PROTO((tree)); ! 1715: extern tree build_m_desc PROTO((tree)); ! 1716: extern void expand_gc_prologue_and_epilogue PROTO((void)); ! 1717: extern void lang_expand_end_bindings PROTO((struct rtx_def *, struct rtx_def *)); ! 1718: extern void init_gc_processing PROTO((void)); 1.1 root 1719: 1.1.1.5 ! root 1720: /* in cp-init.c */ ! 1721: extern void emit_base_init PROTO((tree, int)); ! 1722: extern void check_base_init PROTO((tree)); ! 1723: extern tree build_virtual_init PROTO((tree, tree, tree)); ! 1724: extern void do_member_init PROTO((tree, tree, tree)); ! 1725: extern void expand_member_init PROTO((tree, tree, tree)); ! 1726: extern void expand_aggr_init PROTO((tree, tree, int)); ! 1727: extern int is_aggr_typedef PROTO((tree, int)); ! 1728: extern tree build_member_call PROTO((tree, tree, tree)); ! 1729: extern tree build_offset_ref PROTO((tree, tree)); ! 1730: extern tree get_member_function PROTO((tree *, tree, tree)); ! 1731: extern tree resolve_offset_ref PROTO((tree)); ! 1732: extern tree decl_constant_value PROTO((tree)); ! 1733: extern int is_friend PROTO((tree, tree)); ! 1734: extern void xref_friend PROTO((tree, tree, tree)); ! 1735: extern void xref_friends PROTO((tree, tree, tree)); ! 1736: extern void make_friend_class PROTO((tree, tree)); ! 1737: extern tree do_friend PROTO((tree, tree, tree, tree, enum overload_flags, tree)); ! 1738: extern void embrace_waiting_friends PROTO((tree)); ! 1739: extern tree build_builtin_call PROTO((tree, tree, tree)); ! 1740: extern tree build_new PROTO((tree, tree, tree, int)); ! 1741: extern tree expand_vec_init PROTO((tree, tree, tree, tree, int)); ! 1742: extern tree build_x_delete PROTO((tree, tree, int, tree)); ! 1743: extern tree build_delete PROTO((tree, tree, tree, int, int, int)); ! 1744: extern tree build_vbase_delete PROTO((tree, tree)); ! 1745: extern tree build_vec_delete PROTO((tree, tree, tree, tree, tree, tree)); ! 1746: ! 1747: /* in cp-input.c */ ! 1748: ! 1749: /* in cp-lex.c */ ! 1750: extern tree make_pointer_declarator PROTO((tree, tree)); ! 1751: extern tree make_reference_declarator PROTO((tree, tree)); ! 1752: extern char *operator_name_string PROTO((tree)); ! 1753: extern void lang_init PROTO((void)); ! 1754: extern void lang_finish PROTO((void)); ! 1755: extern void init_filename_times PROTO((void)); ! 1756: extern void reinit_lang_specific PROTO((void)); ! 1757: extern void init_lex PROTO((void)); ! 1758: extern void reinit_parse_for_function PROTO((void)); ! 1759: extern int *init_parse PROTO((void)); ! 1760: extern void print_parse_statistics PROTO((void)); ! 1761: extern void extract_interface_info PROTO((void)); ! 1762: extern void set_vardecl_interface_info PROTO((tree, tree)); ! 1763: extern void do_pending_inlines PROTO((void)); ! 1764: extern void process_next_inline PROTO((tree)); ! 1765: #if 0 ! 1766: extern void consume_string PROTO((struct obstack *)); ! 1767: #endif ! 1768: /* skip restore_pending_input */ ! 1769: extern void yyungetc PROTO((int, int)); ! 1770: extern void reinit_parse_for_method PROTO((int, tree)); ! 1771: #if 0 ! 1772: extern void reinit_parse_for_block PROTO((int, struct obstack *, int)); ! 1773: #endif ! 1774: extern tree cons_up_default_function PROTO((tree, tree, int)); ! 1775: extern void check_for_missing_semicolon PROTO((tree)); ! 1776: extern void note_got_semicolon PROTO((tree)); ! 1777: extern void note_list_got_semicolon PROTO((tree)); ! 1778: extern int check_newline PROTO((void)); ! 1779: extern void dont_see_typename PROTO((void)); ! 1780: extern int identifier_type PROTO((tree)); ! 1781: extern void see_typename PROTO((void)); ! 1782: extern tree do_identifier PROTO((tree)); ! 1783: extern tree identifier_typedecl_value PROTO((tree)); ! 1784: extern int real_yylex PROTO((void)); ! 1785: extern tree build_lang_decl PROTO((enum tree_code, tree, tree)); ! 1786: extern tree build_lang_field_decl PROTO((enum tree_code, tree, tree)); ! 1787: extern void copy_lang_decl PROTO((tree)); ! 1788: extern tree make_lang_type PROTO((enum tree_code)); ! 1789: extern void copy_decl_lang_specific PROTO((tree)); ! 1790: extern void dump_time_statistics PROTO((void)); ! 1791: /* extern void compiler_error PROTO((char *, HOST_WIDE_INT, HOST_WIDE_INT)); */ ! 1792: extern void compiler_error_with_decl PROTO((tree, char *)); ! 1793: extern void yyerror PROTO((char *)); 1.1 root 1794: 1.1.1.5 ! root 1795: /* in cp-method.c */ ! 1796: extern void init_method PROTO((void)); ! 1797: extern tree make_anon_parm_name PROTO((void)); ! 1798: extern void clear_anon_parm_name PROTO((void)); ! 1799: extern char *fndecl_as_string PROTO((tree, tree, int)); ! 1800: extern char *type_as_string PROTO((tree)); ! 1801: extern char *decl_as_string PROTO((tree)); ! 1802: extern void do_inline_function_hair PROTO((tree, tree)); ! 1803: /* skip report_type_mismatch */ ! 1804: extern char *build_overload_name PROTO((tree, int, int)); ! 1805: extern tree cplus_exception_name PROTO((tree)); ! 1806: extern tree build_decl_overload PROTO((tree, tree, int)); ! 1807: extern tree build_typename_overload PROTO((tree)); ! 1808: extern tree build_t_desc_overload PROTO((tree)); ! 1809: extern void declare_overloaded PROTO((tree)); ! 1810: #ifdef NO_AUTO_OVERLOAD ! 1811: extern int is_overloaded PROTO((tree)); ! 1812: #endif ! 1813: extern tree build_opfncall PROTO((enum tree_code, int, tree, tree, tree)); ! 1814: extern tree hack_identifier PROTO((tree, tree, int)); ! 1815: extern tree build_component_type_expr PROTO((tree, tree, tree, int)); ! 1816: ! 1817: /* in cp-pt.c */ ! 1818: extern void begin_template_parm_list PROTO((void)); ! 1819: extern tree process_template_parm PROTO((tree, tree)); ! 1820: extern tree end_template_parm_list PROTO((tree)); ! 1821: extern void end_template_decl PROTO((tree, tree, tree)); ! 1822: extern tree lookup_template_class PROTO((tree, tree, tree)); ! 1823: extern void push_template_decls PROTO((tree, tree, int)); ! 1824: extern void pop_template_decls PROTO((tree, tree, int)); ! 1825: extern int uses_template_parms PROTO((tree)); ! 1826: extern void instantiate_member_templates PROTO((tree)); ! 1827: extern tree instantiate_class_template PROTO((tree, int)); ! 1828: extern tree instantiate_template PROTO((tree, tree *)); ! 1829: extern void undo_template_name_overload PROTO((tree, int)); ! 1830: extern void overload_template_name PROTO((tree, int)); ! 1831: extern void end_template_instantiation PROTO((tree, tree)); ! 1832: extern void reinit_parse_for_template PROTO((int, tree, tree)); ! 1833: extern int type_unification PROTO((tree, tree *, tree, tree, int *)); ! 1834: extern int do_pending_expansions PROTO((void)); ! 1835: extern void do_pending_templates PROTO((void)); ! 1836: ! 1837: /* in cp-search.c */ ! 1838: extern tree make_memoized_table_entry PROTO((tree, tree, int)); ! 1839: extern void push_memoized_context PROTO((tree, int)); ! 1840: extern void pop_memoized_context PROTO((int)); ! 1841: extern tree get_binfo PROTO((tree, tree, int)); ! 1842: extern int get_base_distance PROTO((tree, tree, int, tree *)); ! 1843: extern enum visibility_type check_visibility PROTO((tree, tree)); ! 1844: extern tree lookup_field PROTO((tree, tree, int, int)); ! 1845: extern tree lookup_nested_field PROTO((tree, int)); ! 1846: extern tree lookup_fnfields PROTO((tree, tree, int)); ! 1847: extern HOST_WIDE_INT breadth_first_search PROTO((tree, int (*)(), int (*)())); ! 1848: extern int tree_needs_constructor_p PROTO((tree, int)); ! 1849: extern int tree_has_any_destructor_p PROTO((tree, int)); ! 1850: extern tree get_first_matching_virtual PROTO((tree, tree, int)); ! 1851: extern tree get_abstract_virtuals PROTO((tree)); ! 1852: extern tree get_baselinks PROTO((tree, tree, tree)); ! 1853: extern tree next_baselink PROTO((tree)); ! 1854: extern tree init_vbase_pointers PROTO((tree, tree)); ! 1855: extern tree build_vbase_vtables_init PROTO((tree, tree, tree, tree, int)); ! 1856: extern void clear_search_slots PROTO((tree)); ! 1857: extern tree get_vbase_types PROTO((tree)); ! 1858: extern void build_mi_matrix PROTO((tree)); ! 1859: extern void free_mi_matrix PROTO((void)); ! 1860: extern void build_mi_virtuals PROTO((int, int)); ! 1861: extern void add_mi_virtuals PROTO((int, tree)); ! 1862: extern void report_ambiguous_mi_virtuals PROTO((int, tree)); ! 1863: extern void note_debug_info_needed PROTO((tree)); ! 1864: extern void push_class_decls PROTO((tree)); ! 1865: extern void pop_class_decls PROTO((tree)); ! 1866: extern tree build_type_pathname PROTO((char *, tree, tree)); ! 1867: extern void unmark_finished_struct PROTO((tree)); ! 1868: extern void print_search_statistics PROTO((void)); ! 1869: extern void init_search_processing PROTO((void)); ! 1870: extern void reinit_search_statistics PROTO((void)); ! 1871: ! 1872: /* in cp-spew.c */ ! 1873: extern void init_spew PROTO((void)); ! 1874: extern int yylex PROTO((void)); ! 1875: extern tree arbitrate_lookup PROTO((tree, tree, tree)); 1.1 root 1876: 1.1.1.5 ! root 1877: /* in cp-tree.c */ ! 1878: extern int lvalue_p PROTO((tree)); ! 1879: extern int lvalue_or_else PROTO((tree, char *)); ! 1880: extern tree build_cplus_new PROTO((tree, tree, int)); ! 1881: extern tree break_out_cleanups PROTO((tree)); ! 1882: extern tree break_out_calls PROTO((tree)); ! 1883: extern tree build_cplus_method_type PROTO((tree, tree, tree)); ! 1884: extern tree build_cplus_staticfn_type PROTO((tree, tree, tree)); ! 1885: extern tree build_cplus_array_type PROTO((tree, tree)); ! 1886: extern void propagate_binfo_offsets PROTO((tree, tree)); ! 1887: extern int layout_vbasetypes PROTO((tree, int)); ! 1888: extern tree layout_basetypes PROTO((tree, tree)); ! 1889: extern int list_hash PROTO((tree)); ! 1890: extern tree list_hash_lookup PROTO((int, tree)); ! 1891: extern void list_hash_add PROTO((int, tree)); ! 1892: extern tree list_hash_canon PROTO((int, tree)); ! 1893: extern tree hash_tree_cons PROTO((int, int, int, tree, tree, tree)); ! 1894: extern tree hash_tree_chain PROTO((tree, tree)); ! 1895: extern tree hash_chainon PROTO((tree, tree)); ! 1896: extern tree get_decl_list PROTO((tree)); ! 1897: extern tree list_hash_lookup_or_cons PROTO((tree)); ! 1898: extern tree make_binfo PROTO((tree, tree, tree, tree, tree)); ! 1899: extern tree copy_binfo PROTO((tree)); ! 1900: extern tree binfo_value PROTO((tree, tree)); ! 1901: extern tree reverse_path PROTO((tree)); ! 1902: extern tree virtual_member PROTO((tree, tree)); ! 1903: extern tree virtual_offset PROTO((tree, tree, tree)); ! 1904: extern void debug_binfo PROTO((tree)); ! 1905: extern int decl_list_length PROTO((tree)); ! 1906: extern tree fnaddr_from_vtable_entry PROTO((tree)); ! 1907: extern void set_fnaddr_from_vtable_entry PROTO((tree, tree)); ! 1908: extern tree function_arg_chain PROTO((tree)); ! 1909: extern int promotes_to_aggr_type PROTO((tree, enum tree_code)); ! 1910: extern int is_aggr_type_2 PROTO((tree, tree)); ! 1911: extern void message_2_types PROTO((void (*)(), char *, tree, tree)); ! 1912: extern char *lang_printable_name PROTO((tree)); ! 1913: extern tree build_exception_variant PROTO((tree, tree, tree)); ! 1914: extern tree copy_to_permanent PROTO((tree)); ! 1915: extern void print_lang_statistics PROTO((void)); ! 1916: /* skip __eprintf */ ! 1917: extern tree array_type_nelts_total PROTO((tree)); ! 1918: extern tree array_type_nelts_top PROTO((tree)); ! 1919: ! 1920: /* in cp-typeck.c */ ! 1921: extern tree target_type PROTO((tree)); ! 1922: extern tree require_complete_type PROTO((tree)); ! 1923: extern int type_unknown_p PROTO((tree)); ! 1924: extern tree require_instantiated_type PROTO((tree, tree, tree)); ! 1925: extern tree commonparms PROTO((tree, tree)); ! 1926: extern tree common_type PROTO((tree, tree)); ! 1927: extern int compexcepttypes PROTO((tree, tree, int)); ! 1928: extern int comptypes PROTO((tree, tree, int)); ! 1929: extern int comp_target_types PROTO((tree, tree, int)); ! 1930: extern tree common_base_types PROTO((tree, tree)); ! 1931: extern int compparms PROTO((tree, tree, int)); ! 1932: extern int comp_target_types PROTO((tree, tree, int)); ! 1933: extern tree unsigned_type PROTO((tree)); ! 1934: extern tree signed_type PROTO((tree)); ! 1935: extern tree signed_or_unsigned_type PROTO((int, tree)); ! 1936: extern tree c_sizeof PROTO((tree)); ! 1937: extern tree c_sizeof_nowarn PROTO((tree)); ! 1938: extern tree c_alignof PROTO((tree)); ! 1939: extern tree default_conversion PROTO((tree)); ! 1940: extern tree build_component_ref_1 PROTO((tree, tree, int)); ! 1941: extern tree build_component_ref PROTO((tree, tree, tree, int)); ! 1942: extern tree build_x_indirect_ref PROTO((tree, char *)); ! 1943: extern tree build_indirect_ref PROTO((tree, char *)); ! 1944: extern tree build_x_array_ref PROTO((tree, tree)); ! 1945: extern tree build_array_ref PROTO((tree, tree)); ! 1946: extern tree build_x_function_call PROTO((tree, tree, tree)); ! 1947: extern tree build_function_call_real PROTO((tree, tree, int)); ! 1948: extern tree build_function_call PROTO((tree, tree)); ! 1949: extern tree build_function_call_maybe PROTO((tree, tree)); ! 1950: extern tree convert_arguments PROTO((tree, tree, tree, tree, int)); ! 1951: extern tree build_x_binary_op PROTO((enum tree_code, tree, tree)); ! 1952: extern tree build_binary_op PROTO((enum tree_code, tree, tree, int)); ! 1953: extern tree build_binary_op_nodefault PROTO((enum tree_code, tree, tree, enum tree_code)); ! 1954: extern tree build_component_addr PROTO((tree, tree, char *)); ! 1955: extern tree build_x_unary_op PROTO((enum tree_code, tree)); ! 1956: extern tree build_unary_op PROTO((enum tree_code, tree, int)); ! 1957: extern tree unary_complex_lvalue PROTO((enum tree_code, tree)); ! 1958: extern int mark_addressable PROTO((tree)); ! 1959: extern tree build_x_conditional_expr PROTO((tree, tree, tree)); ! 1960: extern tree build_conditional_expr PROTO((tree, tree, tree)); ! 1961: extern tree build_x_compound_expr PROTO((tree)); ! 1962: extern tree build_compound_expr PROTO((tree)); ! 1963: extern tree build_c_cast PROTO((tree, tree)); ! 1964: extern tree build_modify_expr PROTO((tree, enum tree_code, tree)); ! 1965: extern int language_lvalue_valid PROTO((tree)); ! 1966: extern void warn_for_assignment PROTO((char *, char *, char *, tree, int, int)); ! 1967: extern tree convert_for_initialization PROTO((tree, tree, tree, int, char *, tree, int)); ! 1968: extern void c_expand_asm_operands PROTO((tree, tree, tree, tree, int, char *, int)); ! 1969: extern void c_expand_return PROTO((tree)); ! 1970: extern tree c_expand_start_case PROTO((tree)); ! 1971: extern void record_format_info PROTO((tree, int, int, int)); ! 1972: extern tree build_component_ref PROTO((tree, tree, tree, int)); ! 1973: ! 1974: /* in cp-type2.c */ ! 1975: extern tree error_not_base_type PROTO((tree, tree)); ! 1976: extern tree binfo_or_else PROTO((tree, tree)); ! 1977: extern void error_with_aggr_type (); /* PROTO((tree, char *, HOST_WIDE_INT)); */ ! 1978: extern void readonly_error PROTO((tree, char *, int)); ! 1979: extern void abstract_virtuals_error PROTO((tree, tree)); ! 1980: extern void incomplete_type_error PROTO((tree, tree)); ! 1981: extern void my_friendly_abort PROTO((int)); ! 1982: extern void my_friendly_assert PROTO((int, int)); ! 1983: extern tree store_init_value PROTO((tree, tree)); ! 1984: extern tree digest_init PROTO((tree, tree, tree *)); ! 1985: extern tree build_scoped_ref PROTO((tree, tree)); ! 1986: extern tree build_x_arrow PROTO((tree)); ! 1987: extern tree build_m_component_ref PROTO((tree, tree)); ! 1988: extern tree build_functional_cast PROTO((tree, tree)); ! 1989: extern char *enum_name_string PROTO((tree, tree)); ! 1990: extern void report_case_error PROTO((int, tree, tree, tree)); 1.1 root 1991: 1.1.1.4 root 1992: /* in cp-xref.c */ 1.1.1.5 ! root 1993: extern void GNU_xref_begin PROTO((char *)); ! 1994: extern void GNU_xref_end PROTO((int)); ! 1995: extern void GNU_xref_file PROTO((char *)); ! 1996: extern void GNU_xref_start_scope PROTO((HOST_WIDE_INT)); ! 1997: extern void GNU_xref_end_scope PROTO((HOST_WIDE_INT, HOST_WIDE_INT, int, int, int)); ! 1998: extern void GNU_xref_def PROTO((tree, char *)); ! 1999: extern void GNU_xref_decl PROTO((tree, tree)); ! 2000: extern void GNU_xref_call PROTO((tree, char *)); ! 2001: extern void GNU_xref_function PROTO((tree, tree)); ! 2002: extern void GNU_xref_assign PROTO((tree)); ! 2003: extern void GNU_xref_hier PROTO((char *, char *, int, int, int)); ! 2004: extern void GNU_xref_member PROTO((tree, tree)); 1.1.1.4 root 2005: 1.1 root 2006: /* -- end of C++ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.