gcc/cp/cp-tree.def

7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
14 GCC is distributed in the hope that it will be useful,
24 /* An OFFSET_REF is used in two situations:
26    1. An expression of the form `A::m' where `A' is a class and `m' is
31       The expression is a pointer-to-member if its address is taken,
32       but simply denotes a member of the object if its address is not
35       This form is only used during the parsing phase; once semantic
44    `X::Y' The PTRMEM_CST_CLASS is the RECORD_TYPE for `X' and the
45    PTRMEM_CST_MEMBER is the _DECL for `Y'.  */
48 /* For NEW_EXPR, operand 0 is the placement list.
49    Operand 1 is the new-declarator.
50    Operand 2 is the number of elements in the array.
51    Operand 3 is the initializer.  */
55 /* For DELETE_EXPR, operand 0 is the store to be destroyed.
56    Operand 1 is the value to pass to the destroying function
61 /* Value is reference to particular overloaded class method.
62    Operand 0 is the class, operand 1 is the field
66 /* When composing an object with a member, this is the result.
67    Operand 0 is the object.  Operand 1 is the member (usually
71 /* Type conversion operator in C++.  TREE_TYPE is type that this
72    operator converts to.  Operand is expression to be converted.  */
76    that of CALL_EXPRs.  Operand 0 is an INTEGER_CST node containing the
77    operand count, operand 1 is the function which performs initialization,
78    operand 2 is the slot which was allocated for this expression, and
83    so that it works with TARGET_EXPR.  Operand 0 is the target, operand 1
84    is the initializer.  */
87 /* A throw expression.  operand 0 is the expression, if there was one,
88    else it is NULL_TREE.  */
103    A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
104    the type of the expression.  This type is either a FUNCTION_TYPE,
105    METHOD_TYPE, or `unknown_type_node' indicating that the function is
142    its LEVEL will be one less.  The TREE_CHAIN field is used to chain
143    together the descendants.  The TEMPLATE_PARM_DECL is the
145    The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
156    The LEVEL is the level of the parameter when we are worrying about
157    the types of things; the ORIG_LEVEL is the level when we are
165    It is used without template arguments like TT in C<TT>,
166    TYPE_NAME is a TEMPLATE_DECL.  */
169 /* The ordering of the following codes is optimized for the checking
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
181    TREE_TYPE is always NULL.  */
184 /* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
188 /* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
191    template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
196    TYPE_CONTEXT is `T', the template parameter dependent object.
197    TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
201    scope.  In a variadic using-declaration, this is a TYPE_PACK_EXPANSION.
202    In a member using decl, unless DECL_DEPENDENT_P is true,
203    USING_DECL_DECLS contains the _DECL or OVERLOAD so named.  This is
204    not an alias, but is later expanded into multiple aliases.  */
207 /* A using directive. The operand is USING_STMT_NAMESPACE.  */
216    uninstantiated case, DEFERRED_NOEXCEPT_PATTERN is the pattern from the
223 /* A template-id, like foo<int>.  The first operand is the template.
224    The second is NULL if there are no explicit arguments, or a
234    "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
235    second operand (if non-NULL) is the SCOPE.  The third operand is
239    The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
258 /* A placeholder for an expression that is not type-dependent, but
259    does occur in a template.  When an expression that is not
265    the original expression.  The expression is the only operand -- it
266    is only needed for diagnostics.  */
269 /* CTOR_INITIALIZER is a placeholder in template code for a call to
277 /* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
279    the catch variable is in HANDLER_PARMS, and the body block in
285    is a condition, used in templates to express noexcept (condition).  */
288 /* A CLEANUP_STMT marks the point at which a declaration is fully
289    constructed.  The CLEANUP_EXPR is run on behalf of CLEANUP_DECL
295 /* ??? It is currently still necessary to distinguish between IF_STMT
337    expansion.  This is similar to ADDR_EXPR, but it doesn't invoke
353    expansion.  This is the GCC extension { ( ... ) }.  The
354    STMT_EXPR_STMT is the statement given by the expression.  */
357 /* Unary plus. Operand 0 is the expression to which the unary plus
358    is applied.  */
363 /* A static assertion.  This is a C++11 extension.
364    STATIC_ASSERT_CONDITION contains the condition that is being
382    Values is a (template) parameter pack. When tuple<int, float,
383    double> is instantiated, the Values parameter pack is instantiated
400    PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
416    template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
436    index is a machine integer.  */
442    FOLD_EXPR_MOD_P is true when the fold operation is a compound assignment
445    FOLD_EXPR_OP is an INTEGER_CST storing the tree code for the folded
446    expression. Note that when FOLDEXPR_MOD_P is true, the operator is
449    FOLD_EXPR_PACK is an expression containing an unexpanded parameter pack;
452    In a BINARY_FOLD_EXPRESSION, FOLD_EXPR_INIT is the non-pack argument. */
464 /* A lambda expression.  This is a C++0x extension.
465    LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
469    LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
474 /* The declared type of an expression.  This is a C++0x extension.
475    DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
479    DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
480    DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction.  */
484    UNDERLYING_TYPE_TYPE is the type in question.  */
488    BASES_TYPE is the type in question.  */
497    the pattern of the template for which access check is needed at template
506 /* A wildcard declaration is a placeholder for a template parameter
508    resolution, the matching argument is saved as the TREE_TYPE
512 /* A requires-expr is a binary expression. The first operand is
513    its parameter list (possibly NULL). The second is a list of
525    first operand is the expression, and the 2nd is its type.
561    E is implicitly convertible to a type T. Note that T may
579    noexcept(E) is true.