OpenCores
URL https://opencores.org/ocsvn/altor32/altor32/trunk

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [lib/] [gcc/] [or1knd-elf/] [4.8.0/] [plugin/] [include/] [cp/] [cp-tree.def] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
/* 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, 2004, 2005, 2007, 2010, 2011, 2012
6
   Free Software Foundation, Inc.
7
   Hacked by Michael Tiemann (tiemann@cygnus.com)
8
 
9
This file is part of GCC.
10
 
11
GCC is free software; you can redistribute it and/or modify
12
it under the terms of the GNU General Public License as published by
13
the Free Software Foundation; either version 3, or (at your option)
14
any later version.
15
 
16
GCC is distributed in the hope that it will be useful,
17
but WITHOUT ANY WARRANTY; without even the implied warranty of
18
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
GNU General Public License for more details.
20
 
21
You should have received a copy of the GNU General Public License
22
along with GCC; see the file COPYING3.  If not see
23
.  */
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
/* AGGR_INIT_EXPRs have a variably-sized representation similar to
78
   that of CALL_EXPRs.  Operand 0 is an INTEGER_CST node containing the
79
   operand count, operand 1 is the function which performs initialization,
80
   operand 2 is the slot which was allocated for this expression, and
81
   the remaining operands are the arguments to the initialization function.  */
82
DEFTREECODE (AGGR_INIT_EXPR, "aggr_init_expr", tcc_vl_exp, 3)
83
 
84
/* Initialization of an array from another array, expressed at a high level
85
   so that it works with TARGET_EXPR.  Operand 0 is the target, operand 1
86
   is the initializer.  */
87
DEFTREECODE (VEC_INIT_EXPR, "vec_init_expr", tcc_expression, 2)
88
 
89
/* A throw expression.  operand 0 is the expression, if there was one,
90
   else it is NULL_TREE.  */
91
DEFTREECODE (THROW_EXPR, "throw_expr", tcc_expression, 1)
92
 
93
/* An empty class object.  The TREE_TYPE gives the class type.  We use
94
   these to avoid actually creating instances of the empty classes.  */
95
DEFTREECODE (EMPTY_CLASS_EXPR, "empty_class_expr", tcc_expression, 0)
96
 
97
/* A reference to a member function or member functions from a base
98
   class.  BASELINK_FUNCTIONS gives the FUNCTION_DECL,
99
   TEMPLATE_DECL, OVERLOAD, or TEMPLATE_ID_EXPR corresponding to the
100
   functions.  BASELINK_BINFO gives the base from which the functions
101
   come, i.e., the base to which the `this' pointer must be converted
102
   before the functions are called.  BASELINK_ACCESS_BINFO gives the
103
   base used to name the functions.
104
 
105
   A BASELINK is an expression; the TREE_TYPE of the BASELINK gives
106
   the type of the expression.  This type is either a FUNCTION_TYPE,
107
   METHOD_TYPE, or `unknown_type_node' indicating that the function is
108
   overloaded.  */
109
DEFTREECODE (BASELINK, "baselink", tcc_exceptional, 0)
110
 
111
/* Template definition.  The following fields have the specified uses,
112
   although there are other macros in cp-tree.h that should be used for
113
   accessing this data.
114
        DECL_ARGUMENTS          template parm vector
115
        DECL_TEMPLATE_INFO      template text &c
116
        DECL_VINDEX             list of instantiations already produced;
117
                                only done for functions so far
118
   For class template:
119
        DECL_INITIAL            associated templates (methods &c)
120
        DECL_TEMPLATE_RESULT    null
121
   For non-class templates:
122
        TREE_TYPE               type of object to be constructed
123
        DECL_TEMPLATE_RESULT    decl for object to be created
124
                                (e.g., FUNCTION_DECL with tmpl parms used)
125
 */
126
DEFTREECODE (TEMPLATE_DECL, "template_decl", tcc_declaration, 0)
127
 
128
/* Index into a template parameter list.  The TEMPLATE_PARM_IDX gives
129
   the index (from 0) of the parameter, while the TEMPLATE_PARM_LEVEL
130
   gives the level (from 1) of the parameter.
131
 
132
   Here's an example:
133
 
134
   template  // Index 0, Level 1.
135
   struct S
136
   {
137
      template 
138
                class V> // Index 1, Level 2.
139
      void f();
140
   };
141
 
142
   The DESCENDANTS will be a chain of TEMPLATE_PARM_INDEXs descended
143
   from this one.  The first descendant will have the same IDX, but
144
   its LEVEL will be one less.  The TREE_CHAIN field is used to chain
145
   together the descendants.  The TEMPLATE_PARM_DECL is the
146
   declaration of this parameter, either a TYPE_DECL or CONST_DECL.
147
   The TEMPLATE_PARM_ORIG_LEVEL is the LEVEL of the most distant
148
   parent, i.e., the LEVEL that the parameter originally had when it
149
   was declared.  For example, if we instantiate S, we will have:
150
 
151
   struct S
152
   {
153
     template 
154
               class V> // Index 1, Level 1, Orig Level 2
155
     void f();
156
   };
157
 
158
   The LEVEL is the level of the parameter when we are worrying about
159
   the types of things; the ORIG_LEVEL is the level when we are
160
   worrying about instantiating things.  */
161
DEFTREECODE (TEMPLATE_PARM_INDEX, "template_parm_index", tcc_exceptional, 0)
162
 
163
/* Index into a template parameter list for template template parameters.
164
   This parameter must be a type.  The TYPE_FIELDS value will be a
165
   TEMPLATE_PARM_INDEX.
166
 
167
   It is used without template arguments like TT in C,
168
   TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO is NULL_TREE
169
   and TYPE_NAME is a TEMPLATE_DECL.  */
170
DEFTREECODE (TEMPLATE_TEMPLATE_PARM, "template_template_parm", tcc_type, 0)
171
 
172
/* The ordering of the following codes is optimized for the checking
173
   macros in tree.h.  Changing the order will degrade the speed of the
174
   compiler.  TEMPLATE_TYPE_PARM, TYPENAME_TYPE, TYPEOF_TYPE,
175
   BOUND_TEMPLATE_TEMPLATE_PARM.  */
176
 
177
/* Index into a template parameter list.  This parameter must be a type.
178
   The type.values field will be a TEMPLATE_PARM_INDEX.  */
179
DEFTREECODE (TEMPLATE_TYPE_PARM, "template_type_parm", tcc_type, 0)
180
 
181
/* A type designated by `typename T::t'.  TYPE_CONTEXT is `T',
182
   TYPE_NAME is an IDENTIFIER_NODE for `t'.  If the type was named via
183
   template-id, TYPENAME_TYPE_FULLNAME will hold the TEMPLATE_ID_EXPR.
184
   TREE_TYPE is always NULL.  */
185
DEFTREECODE (TYPENAME_TYPE, "typename_type", tcc_type, 0)
186
 
187
/* A type designated by `__typeof (expr)'.  TYPEOF_TYPE_EXPR is the
188
   expression in question.  */
189
DEFTREECODE (TYPEOF_TYPE, "typeof_type", tcc_type, 0)
190
 
191
/* Like TEMPLATE_TEMPLATE_PARM it is used with bound template arguments
192
   like TT.
193
   In this case, TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO contains the
194
   template name and its bound arguments.  TYPE_NAME is a TYPE_DECL.  */
195
DEFTREECODE (BOUND_TEMPLATE_TEMPLATE_PARM, "bound_template_template_parm",
196
             tcc_type, 0)
197
 
198
/* For template template argument of the form `T::template C'.
199
   TYPE_CONTEXT is `T', the template parameter dependent object.
200
   TYPE_NAME is an IDENTIFIER_NODE for `C', the member class template.  */
201
DEFTREECODE (UNBOUND_CLASS_TEMPLATE, "unbound_class_template", tcc_type, 0)
202
 
203
/* A using declaration.  USING_DECL_SCOPE contains the specified
204
   scope.  In a member using decl, unless DECL_DEPENDENT_P is true,
205
   USING_DECL_DECLS contains the _DECL or OVERLOAD so named.  This is
206
   not an alias, but is later expanded into multiple aliases.  */
207
DEFTREECODE (USING_DECL, "using_decl", tcc_declaration, 0)
208
 
209
/* A using directive. The operand is USING_STMT_NAMESPACE.  */
210
DEFTREECODE (USING_STMT, "using_stmt", tcc_statement, 1)
211
 
212
/* An un-parsed default argument.  Holds a vector of input tokens and
213
   a vector of places where the argument was instantiated before
214
   parsing had occurred.  */
215
DEFTREECODE (DEFAULT_ARG, "default_arg", tcc_exceptional, 0)
216
 
217
/* An uninstantiated noexcept-specification.  DEFERRED_NOEXCEPT_PATTERN is
218
   the pattern from the template, and DEFERRED_NOEXCEPT_ARGS are the
219
   template arguments to substitute into the pattern when needed.  */
220
DEFTREECODE (DEFERRED_NOEXCEPT, "deferred_noexcept", tcc_exceptional, 0)
221
 
222
/* A template-id, like foo.  The first operand is the template.
223
   The second is NULL if there are no explicit arguments, or a
224
   TREE_VEC of arguments.  The template will be a FUNCTION_DECL,
225
   TEMPLATE_DECL, or an OVERLOAD.  If the template-id refers to a
226
   member template, the template may be an IDENTIFIER_NODE.  */
227
DEFTREECODE (TEMPLATE_ID_EXPR, "template_id_expr", tcc_expression, 2)
228
 
229
/* A list-like node for chaining overloading candidates. TREE_TYPE is
230
   the original name, and the parameter is the FUNCTION_DECL.  */
231
DEFTREECODE (OVERLOAD, "overload", tcc_exceptional, 0)
232
 
233
/* A pseudo-destructor, of the form "OBJECT.~DESTRUCTOR" or
234
   "OBJECT.SCOPE::~DESTRUCTOR.  The first operand is the OBJECT.  The
235
   second operand (if non-NULL) is the SCOPE.  The third operand is
236
   the TYPE node corresponding to the DESTRUCTOR.  The type of the
237
   first operand will always be a scalar type.
238
 
239
   The type of a PSEUDO_DTOR_EXPR is always "void", even though it can
240
   be used as if it were a zero-argument function.  We handle the
241
   function-call case specially, and giving it "void" type prevents it
242
   being used in expressions in ways that are not permitted.  */
243
DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", tcc_expression, 3)
244
 
245
/* A whole bunch of tree codes for the initial, superficial parsing of
246
   templates.  */
247
DEFTREECODE (MODOP_EXPR, "modop_expr", tcc_expression, 3)
248
DEFTREECODE (CAST_EXPR, "cast_expr", tcc_unary, 1)
249
DEFTREECODE (REINTERPRET_CAST_EXPR, "reinterpret_cast_expr", tcc_unary, 1)
250
DEFTREECODE (CONST_CAST_EXPR, "const_cast_expr", tcc_unary, 1)
251
DEFTREECODE (STATIC_CAST_EXPR, "static_cast_expr", tcc_unary, 1)
252
DEFTREECODE (DYNAMIC_CAST_EXPR, "dynamic_cast_expr", tcc_unary, 1)
253
DEFTREECODE (IMPLICIT_CONV_EXPR, "implicit_conv_expr", tcc_unary, 1)
254
DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", tcc_expression, 2)
255
DEFTREECODE (TYPEID_EXPR, "typeid_expr", tcc_expression, 1)
256
DEFTREECODE (NOEXCEPT_EXPR, "noexcept_expr", tcc_unary, 1)
257
 
258
/* A placeholder for an expression that is not type-dependent, but
259
   does occur in a template.  When an expression that is not
260
   type-dependent appears in a larger expression, we must compute the
261
   type of that larger expression.  That computation would normally
262
   modify the original expression, which would change the mangling of
263
   that expression if it appeared in a template argument list.  In
264
   that situation, we create a NON_DEPENDENT_EXPR to take the place of
265
   the original expression.  The expression is the only operand -- it
266
   is only needed for diagnostics.  */
267
DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", tcc_expression, 1)
268
 
269
/* CTOR_INITIALIZER is a placeholder in template code for a call to
270
   setup_vtbl_pointer (and appears in all functions, not just ctors).  */
271
DEFTREECODE (CTOR_INITIALIZER, "ctor_initializer", tcc_expression, 1)
272
 
273
DEFTREECODE (TRY_BLOCK, "try_block", tcc_statement, 2)
274
 
275
DEFTREECODE (EH_SPEC_BLOCK, "eh_spec_block", tcc_statement, 2)
276
 
277
/* A HANDLER wraps a catch handler for the HANDLER_TYPE.  If this is
278
   CATCH_ALL_TYPE, then the handler catches all types.  The declaration of
279
   the catch variable is in HANDLER_PARMS, and the body block in
280
   HANDLER_BODY.  */
281
DEFTREECODE (HANDLER, "handler", tcc_statement, 2)
282
 
283
/* A MUST_NOT_THROW_EXPR wraps an expression that may not
284
   throw, and must call terminate if it does.  The second argument
285
   is a condition, used in templates to express noexcept (condition).  */
286
DEFTREECODE (MUST_NOT_THROW_EXPR, "must_not_throw_expr", tcc_expression, 2)
287
 
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
290
   when CLEANUP_BODY completes.  */
291
DEFTREECODE (CLEANUP_STMT, "cleanup_stmt", tcc_statement, 3)
292
 
293
/* Represents an 'if' statement. The operands are IF_COND,
294
   THEN_CLAUSE, and ELSE_CLAUSE, and the current scope, respectively.  */
295
/* ??? It is currently still necessary to distinguish between IF_STMT
296
   and COND_EXPR for the benefit of templates.  */
297
DEFTREECODE (IF_STMT, "if_stmt", tcc_statement, 4)
298
 
299
/* Used to represent a `for' statement. The operands are
300
   FOR_INIT_STMT, FOR_COND, FOR_EXPR, and FOR_BODY, respectively.  */
301
DEFTREECODE (FOR_STMT, "for_stmt", tcc_statement, 5)
302
 
303
/* Used to represent a range-based `for' statement. The operands are
304
   RANGE_FOR_DECL, RANGE_FOR_EXPR, RANGE_FOR_BODY, and RANGE_FOR_SCOPE,
305
   respectively.  Only used in templates.  */
306
DEFTREECODE (RANGE_FOR_STMT, "range_for_stmt", tcc_statement, 4)
307
 
308
/* Used to represent a 'while' statement. The operands are WHILE_COND
309
   and WHILE_BODY, respectively.  */
310
DEFTREECODE (WHILE_STMT, "while_stmt", tcc_statement, 2)
311
 
312
/* Used to represent a 'do' statement. The operands are DO_BODY and
313
   DO_COND, respectively.  */
314
DEFTREECODE (DO_STMT, "do_stmt", tcc_statement, 2)
315
 
316
/* Used to represent a 'break' statement.  */
317
DEFTREECODE (BREAK_STMT, "break_stmt", tcc_statement, 0)
318
 
319
/* Used to represent a 'continue' statement.  */
320
DEFTREECODE (CONTINUE_STMT, "continue_stmt", tcc_statement, 0)
321
 
322
/* Used to represent a 'switch' statement. The operands are
323
   SWITCH_STMT_COND, SWITCH_STMT_BODY, SWITCH_STMT_TYPE, and
324
   SWITCH_STMT_SCOPE, respectively.  */
325
DEFTREECODE (SWITCH_STMT, "switch_stmt", tcc_statement, 4)
326
 
327
/* Used to represent an expression statement.  Use `EXPR_STMT_EXPR' to
328
   obtain the expression.  */
329
DEFTREECODE (EXPR_STMT, "expr_stmt", tcc_expression, 1)
330
 
331
DEFTREECODE (TAG_DEFN, "tag_defn", tcc_expression, 0)
332
 
333
/* Represents an 'offsetof' expression during template expansion.  */
334
DEFTREECODE (OFFSETOF_EXPR, "offsetof_expr", tcc_expression, 1)
335
 
336
/* Represents the -> operator during template expansion.  */
337
DEFTREECODE (ARROW_EXPR, "arrow_expr", tcc_expression, 1)
338
 
339
/* Represents an '__alignof__' expression during template
340
   expansion.  */
341
DEFTREECODE (ALIGNOF_EXPR, "alignof_expr", tcc_expression, 1)
342
 
343
/* Represents an Objective-C++ '@encode' expression during template
344
   expansion.  */
345
DEFTREECODE (AT_ENCODE_EXPR, "at_encode_expr", tcc_expression, 1)
346
 
347
/* A STMT_EXPR represents a statement-expression during template
348
   expansion.  This is the GCC extension { ( ... ) }.  The
349
   STMT_EXPR_STMT is the statement given by the expression.  */
350
DEFTREECODE (STMT_EXPR, "stmt_expr", tcc_expression, 1)
351
 
352
/* Unary plus. Operand 0 is the expression to which the unary plus
353
   is applied.  */
354
DEFTREECODE (UNARY_PLUS_EXPR, "unary_plus_expr", tcc_unary, 1)
355
 
356
/** C++0x extensions. */
357
 
358
/* A static assertion.  This is a C++0x extension.
359
   STATIC_ASSERT_CONDITION contains the condition that is being
360
   checked.  STATIC_ASSERT_MESSAGE contains the message (a string
361
   literal) to be displayed if the condition fails to hold.  */
362
DEFTREECODE (STATIC_ASSERT, "static_assert", tcc_exceptional, 0)
363
 
364
/* Represents an argument pack of types (or templates). An argument
365
   pack stores zero or more arguments that will be used to instantiate
366
   a parameter pack.
367
 
368
   ARGUMENT_PACK_ARGS retrieves the arguments stored in the argument
369
   pack.
370
 
371
   Example:
372
     template
373
     class tuple { ... };
374
 
375
     tuple t;
376
 
377
   Values is a (template) parameter pack. When tuple
378
   double> is instantiated, the Values parameter pack is instantiated
379
   with the argument pack . ARGUMENT_PACK_ARGS will
380
   be a TREE_VEC containing int, float, and double.  */
381
DEFTREECODE (TYPE_ARGUMENT_PACK, "type_argument_pack", tcc_type, 0)
382
 
383
/* Represents an argument pack of values, which can be used either for
384
   non-type template arguments or function call arguments.
385
 
386
   NONTYPE_ARGUMENT_PACK plays precisely the same role as
387
   TYPE_ARGUMENT_PACK, but will be used for packing non-type template
388
   arguments (e.g., "int... Dimensions") or function arguments ("const
389
   Args&... args"). */
390
DEFTREECODE (NONTYPE_ARGUMENT_PACK, "nontype_argument_pack", tcc_expression, 1)
391
 
392
/* Represents a type expression that will be expanded into a list of
393
   types when instantiated with one or more argument packs.
394
 
395
   PACK_EXPANSION_PATTERN retrieves the expansion pattern. This is
396
   the type or expression that we will substitute into with each
397
   argument in an argument pack.
398
 
399
   SET_PACK_EXPANSION_PATTERN sets the expansion pattern.
400
 
401
   PACK_EXPANSION_PARAMETER_PACKS contains a TREE_LIST of the parameter
402
   packs that are used in this pack expansion.
403
 
404
   Example:
405
     template
406
     struct tied : tuple {
407
       // ...
408
     };
409
 
410
   The derivation from tuple contains a TYPE_PACK_EXPANSION for the
411
   template arguments. Its PACK_EXPANSION_PATTERN is "Values&" and its
412
   PACK_EXPANSION_PARAMETER_PACKS will contain "Values".  */
413
DEFTREECODE (TYPE_PACK_EXPANSION, "type_pack_expansion", tcc_type, 0)
414
 
415
/* Represents an expression that will be expanded into a list of
416
   expressions when instantiated with one or more argument packs.
417
 
418
   EXPR_PACK_EXPANSION plays precisely the same role as TYPE_PACK_EXPANSION,
419
   but will be used for expressions.  */
420
DEFTREECODE (EXPR_PACK_EXPANSION, "expr_pack_expansion", tcc_expression, 3)
421
 
422
/* Selects the Ith parameter out of an argument pack. This node will
423
   be used when instantiating pack expansions; see
424
   tsubst_pack_expansion.
425
 
426
   ARGUMENT_PACK_SELECT_FROM_PACK contains the *_ARGUMENT_PACK node
427
   from which the argument will be selected.
428
 
429
   ARGUMENT_PACK_SELECT_INDEX contains the index into the argument
430
   pack that will be returned by this ARGUMENT_PACK_SELECT node. The
431
   index is a machine integer.  */
432
DEFTREECODE (ARGUMENT_PACK_SELECT, "argument_pack_select", tcc_exceptional, 0)
433
 
434
/** C++ extensions. */
435
 
436
/* Represents a trait expression during template expansion.  */
437
DEFTREECODE (TRAIT_EXPR, "trait_expr", tcc_exceptional, 0)
438
 
439
/* A lambda expression.  This is a C++0x extension.
440
   LAMBDA_EXPR_DEFAULT_CAPTURE_MODE is an enum for the default, which may be
441
   none.
442
   LAMBDA_EXPR_CAPTURE_LIST holds the capture-list, including `this'.
443
   LAMBDA_EXPR_THIS_CAPTURE goes straight to the capture of `this', if it exists.
444
   LAMBDA_EXPR_PENDING_PROXIES is a vector of capture proxies which need to
445
   be pushed once scope returns to the lambda.
446
   LAMBDA_EXPR_MUTABLE_P signals whether this lambda was declared mutable.
447
   LAMBDA_EXPR_RETURN_TYPE holds the return type, if it was specified.  */
448
DEFTREECODE (LAMBDA_EXPR, "lambda_expr", tcc_exceptional, 0)
449
 
450
/* The declared type of an expression.  This is a C++0x extension.
451
   DECLTYPE_TYPE_EXPR is the expression whose type we are computing.
452
   DECLTYPE_TYPE_ID_EXPR_OR_MEMBER_ACCESS_P states whether the
453
   expression was parsed as an id-expression or a member access
454
   expression. When false, it was parsed as a full expression.
455
   DECLTYPE_FOR_LAMBDA_CAPTURE is set if we want lambda capture semantics.
456
   DECLTYPE_FOR_LAMBDA_RETURN is set if we want lambda return deduction.  */
457
DEFTREECODE (DECLTYPE_TYPE, "decltype_type", tcc_type, 0)
458
 
459
/* A type designated by `__underlying_type (type)'.
460
   UNDERLYING_TYPE_TYPE is the type in question.  */
461
DEFTREECODE (UNDERLYING_TYPE, "underlying_type", tcc_type, 0)
462
 
463
/* A type designated by one of the bases type traits.
464
   BASES_TYPE is the type in question.  */
465
DEFTREECODE (BASES, "bases", tcc_type, 0)
466
 
467
/* Used to represent the template information stored by template
468
   specializations.
469
   The accessors are:
470
   TI_TEMPLATE the template declaration associated to the specialization
471
   TI_ARGS the arguments of the template specialization
472
   TI_TYPEDEFS_NEEDING_ACCESS_CHECKING the vector of typedefs used in
473
   the pattern of the template for which access check is needed at template
474
   instantiation time.  */
475
DEFTREECODE (TEMPLATE_INFO, "template_info", tcc_exceptional, 0)
476
 
477
/*
478
Local variables:
479
mode:c
480
End:
481
*/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.