contrib/gcc-4.0/gcc/cp/cp-tree.def

   1 /* This file contains the definitions and documentation for the
   2    additional tree codes used in the GNU C++ compiler (see tree.def
   3    for the standard codes).
   4    Copyright (C) 1987, 1988, 1990, 1993, 1997, 1998, 2003, 2004, 2005,
   5    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   6    Hacked by Michael Tiemann (tiemann@cygnus.com)
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2, or (at your option)
  13 any later version.
  14
  15 GCC is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING.  If not, write to
  22 the Free Software Foundation, 59 Temple Place - Suite 330,
  23 Boston, MA 02111-1307, USA.  */
  24
  25
  26 /* An OFFSET_REF is used in two situations:
  27
  28    1. An expression of the form `A::m' where `A' is a class and `m' is
  29       a non-static member.  In this case, operand 0 will be a TYPE
  30       (corresponding to `A') and operand 1 will be a FIELD_DECL,
  31       BASELINK, or TEMPLATE_ID_EXPR (corresponding to `m').
  32
  33       The expression is a pointer-to-member if its address is taken,
  34       but simply denotes a member of the object if its address is not
  35       taken.
  36
  37       This form is only used during the parsing phase; once semantic
  38       analysis has taken place they are eliminated.
  39
  40    2. An expression of the form `x.*p'.  In this case, operand 0 will
  41       be an expression corresponding to `x' and operand 1 will be an
  42       expression with pointer-to-member type.  */
  43 DEFTREECODE (OFFSET_REF, "offset_ref", tcc_reference, 2)
  44
  45 /* A pointer-to-member constant.  For a pointer-to-member constant
  46    `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
  47    PTRMEM_CST_MEMBER is the _DECL for `Y'.  */
  48 DEFTREECODE (PTRMEM_CST, "ptrmem_cst", tcc_constant, 0)
  49
  50 /* For NEW_EXPR, operand 0 is the placement list.
  51    Operand 1 is the new-declarator.
  52    Operand 2 is the number of elements in the array.
  53    Operand 3 is the initializer.  */
  54 DEFTREECODE (NEW_EXPR, "nw_expr", tcc_expression, 4)
  55 DEFTREECODE (VEC_NEW_EXPR, "vec_nw_expr", tcc_expression, 3)
  56
  57 /* For DELETE_EXPR, operand 0 is the store to be destroyed.
  58    Operand 1 is the value to pass to the destroying function
  59    saying whether the store should be deallocated as well.  */
  60 DEFTREECODE (DELETE_EXPR, "dl_expr", tcc_expression, 2)
  61 DEFTREECODE (VEC_DELETE_EXPR, "vec_dl_expr", tcc_expression, 2)
  62
  63 /* Value is reference to particular overloaded class method.
  64    Operand 0 is the class, operand 1 is the field
  65    The COMPLEXITY field holds the class level (usually 0).  */
  66 DEFTREECODE (SCOPE_REF, "scope_ref", tcc_reference, 2)
  67
  68 /* When composing an object with a member, this is the result.
  69    Operand 0 is the object.  Operand 1 is the member (usually
  70    a dereferenced pointer to member).  */
  71 DEFTREECODE (MEMBER_REF, "member_ref", tcc_reference, 2)
  72
  73 /* Type conversion operator in C++.  TREE_TYPE is type that this
  74    operator converts to.  Operand is expression to be converted.  */
  75 DEFTREECODE (TYPE_EXPR, "type_expr", tcc_expression, 1)
  76
  77 /* For AGGR_INIT_EXPR, operand 0 is function which performs initialization,
  78    operand 1 is argument list to initialization function,
  79    and operand 2 is the slot which was allocated for this expression.  */
  80 DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_expression, 3)
  81
  82 /* A throw expression.  operand 0 is the expression, if there was one,
  83    else it is NULL_TREE.  */
  84 DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
  85
  86 /* An empty class object.  The TREE_TYPE gives the class type.  We use
  87    these to avoid actually creating instances of the empty classes.  */
  88 DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
  89
  90 /* A DECL which is really just a placeholder for an expression.  Used to
  91    implement non-class scope anonymous unions.  */
  92 DEFTREECODE (ALIAS_DECL, "alias_decl", tcc_declaration, 0)
  93
  94 /* A reference to a member function or member functions from a base
  95    class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
  96    TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
  97    functions.  BASELINK_BINFO gives the base from which the functions
  98    come, i.e., the base to which the `this' pointer must be converted
  99    before the functions are called.  BASELINK_ACCESS_BINFO gives the
 100    base used to name the functions.
 101
 102    A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
 103    the type of the expression.  This type is either a FUNCTION_TYPE,
 104    METHOD_TYPE, or `unknown_type_node' indicating that the function is
 105    overloaded.  */
 106 DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
 107
 108 /* Template definition.  The following fields have the specified uses,
 109    although there are other macros in cp-tree.h that should be used for
 110    accessing this data.
 111         DECL_ARGUMENTS          template parm vector
 112         DECL_TEMPLATE_INFO      template text &c
 113         DECL_VINDEX             list of instantiations already produced;
 114                                 only done for functions so far
 115    For class template:
 116         DECL_INITIAL            associated templates (methods &c)
 117         DECL_TEMPLATE_RESULT    null
 118    For non-class templates:
 119         TREE_TYPE               type of object to be constructed
 120         DECL_TEMPLATE_RESULT    decl for object to be created
 121                                 (e.g., FUNCTION_DECL with tmpl parms used)
 122  */
 123 DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
 124
 125 /* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
 126    the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
 127    gives the level (from 1) of the parameter.
 128
 129    Here's an example:
 130
 131    template <class T> // Index 0, Level 1.
 132    struct S
 133    {
 134       template <class U, // Index 0, Level 2.
 135                 class V> // Index 1, Level 2.
 136       void f();
 137    };
 138
 139    The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
 140    from this one.  The first descendant will have the same IDX, but
 141    its LEVEL will be one less.  The TREE_CHAIN field is used to chain
 142    together the descendants.  The TEMPLATE_PARM_DECL is the
 143    declaration of this parameter, either a TYPE_DECL or CONST_DECL.
 144    The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
 145    parent, i.e., the LEVEL that the parameter originally had when it
 146    was declared.  For example, if we instantiate S<int>, we will have:
 147
 148    struct S<int>
 149    {
 150      template <class U, // Index 0, Level 1, Orig Level 2
 151                class V> // Index 1, Level 1, Orig Level 2
 152      void f();
 153    };
 154
 155    The LEVEL is the level of the parameter when we are worrying about
 156    the types of things; the ORIG_LEVEL is the level when we are
 157    worrying about instantiating things.  */
 158 DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
 159
 160 /* Index into a template parameter list for template template parameters.
 161    This parameter must be a type.  The TYPE_FIELDS value will be a
 162    TEMPLATE_PARM_INDEX.
 163
 164    It is used without template arguments like TT in C<TT>,
 165    TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
 166    and TYPE_NAME is a TEMPLATE_DECL.  */
 167 DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
 168
 169 /* The ordering of the following codes is optimized for the checking
 170    macros in tree.h.  Changing the order will degrade the speed of the
 171    compiler.  TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
 172    BOUND_TEMPLATE_TEMPLATE_PARM.  */
 173
 174 /* Index into a template parameter list.  This parameter must be a type.
 175    The type.value field will be a TEMPLATE_PARM_INDEX.  */
 176 DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
 177
 178 /* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
 179    TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
 180    template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
 181    TREE_TYPE is always NULL.  */
 182 DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
 183
 184 /* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
 185    expression in question.  */
 186 DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
 187
 188 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
 189    like TT<int>.
 190    In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
 191    template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
 192 DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
 193              tcc_type, 0)
 194
 195 /* For template template argument of the form `T::template C'.
 196    TYPE_CONTEXT is `T', the template parameter dependent object.
 197    TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
 198 DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
 199
 200 /* A using declaration.  DECL_INITIAL contains the specified scope.
 201    This is not an alias, but is later expanded into multiple aliases.
 202    The decl will have a NULL_TYPE iff the scope is a dependent scope,
 203    otherwise it will have a void type.  */
 204 DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
 205
 206 /* A using directive. The operand is USING_STMT_NAMESPACE.  */
 207 DEFTREECODE (USING_STMT, "using_directive", tcc_expression, 1)
 208
 209 /* An un-parsed default argument.  Looks like an IDENTIFIER_NODE.  */
 210 DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
 211
 212 /* A template-id, like foo<int>.  The first operand is the template.
 213    The second is NULL if there are no explicit arguments, or a
 214    TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
 215    TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
 216    member template, the template may be an IDENTIFIER_NODE.  */
 217 DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
 218
 219 /* A list-like node for chaining overloading candidates. TREE_TYPE is
 220    the original name, and the parameter is the FUNCTION_DECL.  */
 221 DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
 222
 223 /* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
 224    "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
 225    second operand (if non-NULL) is the SCOPE.  The third operand is
 226    the TYPE node corresponding to the DESTRUCTOR.  The type of the
 227    first operand will always be a scalar type.
 228
 229    The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
 230    be used as if it were a zero-argument function.  We handle the
 231    function-call case specially, and giving it "void" type prevents it
 232    being used in expressions in ways that are not permitted.  */
 233 DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
 234
 235 /* A whole bunch of tree codes for the initial, superficial parsing of
 236    templates.  */
 237 DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
 238 DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
 239 DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
 240 DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
 241 DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
 242 DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
 243 DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
 244 DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
 245
 246 /* A placeholder for an expression that is not type-dependent, but
 247    does occur in a template.  When an expression that is not
 248    type-dependent appears in a larger expression, we must compute the
 249    type of that larger expression.  That computation would normally
 250    modify the original expression, which would change the mangling of
 251    that expression if it appeared in a template argument list.  In
 252    that situation, we create a NON_DEPENDENT_EXPR to take the place of
 253    the original expression.  The expression is the only operand -- it
 254    is only needed for diagnostics.  */
 255 DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
 256
 257 /* CTOR_INITIALIZER is a placeholder in template code for a call to
 258    setup_vtbl_pointer (and appears in all functions, not just ctors).  */
 259 DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
 260
 261 DEFTREECODE (TRY_BLOCK, "try_block", tcc_expression, 2)
 262
 263 DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_expression, 2)
 264
 265 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
 266    CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
 267    the catch variable is in HANDLER_PARMS, and the body block in
 268    HANDLER_BODY.  */
 269 DEFTREECODE (HANDLER, "handler", tcc_expression, 2)
 270
 271 /* A MUST_NOT_THROW_EXPR wraps an expression that may not
 272    throw, and must call terminate if it does.  */
 273 DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 1)
 274
 275 /* A CLEANUP_STMT marks the point at which a declaration is fully
 276    constructed.  The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
 277    when CLEANUP_BODY completes.  */
 278 DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_expression, 3)
 279
 280 /* Represents an 'if' statement. The operands are IF_COND,
 281    THEN_CLAUSE, and ELSE_CLAUSE, respectively.  */
 282 /* ??? It is currently still necessary to distinguish between IF_STMT
 283    and COND_EXPR for the benefit of templates.  */
 284 DEFTREECODE (IF_STMT, "if_stmt", tcc_expression, 3)
 285
 286 DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
 287
 288 /* Template instantiation level node.
 289
 290    TINST_DECL contains the original DECL node.
 291    TINST_LOCATION contains the location where the template is instantiated.
 292    TINST_IN_SYSTEM_HEADER_P is true if the location is in a system header.
 293
 294    A stack of template instantiation nodes is kept through the TREE_CHAIN
 295    fields of these nodes.  */
 296
 297 DEFTREECODE (TINST_LEVEL, "TINST_LEVEL", tcc_exceptional, 0)
 298
 299 /* Represents an 'offsetof' expression during template expansion.  */
 300 DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1)
 301
 302 /*
 303 Local variables:
 304 mode:c
 305 End:
 306 */