* cp-tree.def (VEC_INIT_EXPR): Remove.
* cp-tree.h (struct stmt_tree): New type.
(struct saved_scope): Remove firstobj. Add x_saved_tree,
x_stmt_tree.
(class_cache_firstobj): Remove.
(struct language_function): Remove stmts_are_full_exprs_p,
x_last_tree, and x_last_expr_type. Add x_stmt_tree.
(current_stmt_tree): New macro.
(last_tree): Adjust.
(last_expr_type): Likewise.
(doing_semantic_analysis_p): Simplify.
(stmts_are_full_exprs_p): Adjust.
(begin_tree): Remove prototype.
(end_tree): Likewise.
(begin_stmt_tree): Change prototype.
(finish_stmt_tree): Likewise.
(building_stmt_tree): Simplify.
* decl.c (mark_stmt_tree): New function.
(mark_saved_scope): Use it.
(start_function): Rearrange slightly to call begin_stmt_tree
earlier.
(save_function_data): Tweak.
(finish_function): Adjust call to finish_stmt_tree.
(mark_lang_function): Use mark_stmt_tree.
* expr.c (cplus_expand_expr): Don't handle VEC_INIT_EXPR.
* init.c (build_new_1): Remove creation of VEC_INIT_EXPR.
(build_vec_init): Remove creation of stand-in intializer.
* pt.c (begin_tree): Remove.
(end_tree): Likewise.
* semantics.c (SET_LAST_STMT): New macro. Use it throughout.
(begin_compound_stmt): Handle a compound-statement outside of a
function.
(begin_stmt_expr): Handle a statement-expression outsidef of a
function.
(finish_stmt_expr): Likewise.
(begin_class_definition): Don't call begin_tree.
(finish_inline_definitions): Don't call end_tree.
(begin_stmt_tree): Take a pointer to tree, not a function as input.
(finish_stmt_tree): Likewise.
* tree.c (search_tree): Don't handle VEC_INIT_EXPR.
(mapcar): Likewise.
* parse.y (simple_stmt): Don't call finish_stmt unnecessarily.
* parse.c: Regenerated.
* dump.c (dqueue_and_dump): Dump bitfieldness.
From-SVN: r29786
1999-10-03 Mark Mitchell <mark@codesourcery.com>
+ * cp-tree.def (VEC_INIT_EXPR): Remove.
+ * cp-tree.h (struct stmt_tree): New type.
+ (struct saved_scope): Remove firstobj. Add x_saved_tree,
+ x_stmt_tree.
+ (class_cache_firstobj): Remove.
+ (struct language_function): Remove stmts_are_full_exprs_p,
+ x_last_tree, and x_last_expr_type. Add x_stmt_tree.
+ (current_stmt_tree): New macro.
+ (last_tree): Adjust.
+ (last_expr_type): Likewise.
+ (doing_semantic_analysis_p): Simplify.
+ (stmts_are_full_exprs_p): Adjust.
+ (begin_tree): Remove prototype.
+ (end_tree): Likewise.
+ (begin_stmt_tree): Change prototype.
+ (finish_stmt_tree): Likewise.
+ (building_stmt_tree): Simplify.
+ * decl.c (mark_stmt_tree): New function.
+ (mark_saved_scope): Use it.
+ (start_function): Rearrange slightly to call begin_stmt_tree
+ earlier.
+ (save_function_data): Tweak.
+ (finish_function): Adjust call to finish_stmt_tree.
+ (mark_lang_function): Use mark_stmt_tree.
+ * expr.c (cplus_expand_expr): Don't handle VEC_INIT_EXPR.
+ * init.c (build_new_1): Remove creation of VEC_INIT_EXPR.
+ (build_vec_init): Remove creation of stand-in intializer.
+ * pt.c (begin_tree): Remove.
+ (end_tree): Likewise.
+ * semantics.c (SET_LAST_STMT): New macro. Use it throughout.
+ (begin_compound_stmt): Handle a compound-statement outside of a
+ function.
+ (begin_stmt_expr): Handle a statement-expression outsidef of a
+ function.
+ (finish_stmt_expr): Likewise.
+ (begin_class_definition): Don't call begin_tree.
+ (finish_inline_definitions): Don't call end_tree.
+ (begin_stmt_tree): Take a pointer to tree, not a function as input.
+ (finish_stmt_tree): Likewise.
+ * tree.c (search_tree): Don't handle VEC_INIT_EXPR.
+ (mapcar): Likewise.
+
+ * parse.y (simple_stmt): Don't call finish_stmt unnecessarily.
+ * parse.c: Regenerated.
+
+ * dump.c (dqueue_and_dump): Dump bitfieldness.
+
* tree.c (lvalue_p_1): Use DECL_C_BIT_FIELD to check for
bitfields, rather than DECL_BIT_FIELD.
* ir.texi: Document how to tell whether or not a field is a
else it is NULL_TREE. */
DEFTREECODE (THROW_EXPR, "throw_expr", 'e', 1)
-/* Initialization of a vector, used in build_new. Operand 0 is the target
- of the initialization, operand 1 is the initializer, and operand 2 is
- the number of elements. */
-DEFTREECODE (VEC_INIT_EXPR, "vec_init_expr", 'e', 3)
-
/* Template definition. The following fields have the specified uses,
although there are other macros in cp-tree.h that should be used for
accessing this data.
/* Global state. */
+struct stmt_tree {
+ tree x_last_stmt;
+ tree x_last_expr_type;
+ int stmts_are_full_exprs_p;
+};
+
struct saved_scope {
tree old_bindings;
tree old_namespace;
tree template_parms;
tree x_previous_class_type;
tree x_previous_class_values;
+ tree x_saved_tree;
HOST_WIDE_INT x_processing_template_decl;
int x_processing_specialization;
int x_processing_explicit_instantiation;
int need_pop_function_context;
- char *firstobj;
+ struct stmt_tree x_stmt_tree;
struct binding_level *class_bindings;
struct binding_level *bindings;
#define previous_class_values scope_chain->x_previous_class_values
-/* The low-water mark on the class-cache obstack. */
-
-#define class_cache_firstobj scope_chain->firstobj
-
extern struct saved_scope *scope_chain;
/* Global state pertinent to the current function. */
tree x_member_init_list;
tree x_current_class_ptr;
tree x_current_class_ref;
- tree x_last_tree;
- tree x_last_expr_type;
tree x_eh_spec_try_block;
tree x_scope_stmt_stack;
tree x_in_charge_parm;
int static_labelno;
int in_function_try_handler;
int x_expanding_p;
- int stmts_are_full_exprs_p;
int name_declared;
int vtbls_set_up_p;
+ struct stmt_tree x_stmt_tree;
+
struct named_label_list *x_named_label_uses;
struct binding_level *bindings;
#define current_class_ref \
(current_function ? cp_function_chain->x_current_class_ref : NULL_TREE)
-/* When building a statement-tree, this is the last node added to the
- tree. */
+/* Information about the current statement tree. */
+
+#define current_stmt_tree \
+ (current_function \
+ ? &cp_function_chain->x_stmt_tree \
+ : &scope_chain->x_stmt_tree)
+
+/* When building a statement-tree, this is the last statement added to
+ the tree. */
-#define last_tree cp_function_chain->x_last_tree
+#define last_tree current_stmt_tree->x_last_stmt
/* The type of the last expression-statement we have seen. This is
required because the type of a statement-expression is the type of
the last expression statement. */
-#define last_expr_type cp_function_chain->x_last_expr_type
+#define last_expr_type current_stmt_tree->x_last_expr_type
/* The TRY_BLOCK for the exception-specifiers for the current
function, if any. */
/* Non-zero if we are in the semantic analysis phase for the current
function. */
-#define doing_semantic_analysis_p() \
- (!expanding_p || !current_function->x_whole_function_mode_p)
+#define doing_semantic_analysis_p() (!expanding_p)
/* Non-zero if we should treat statements as full expressions. In
particular, this variable is no-zero if at the end of a statement
within the statement expression should not result in cleanups being
run until the entire enclosing statement is complete. */
-#define stmts_are_full_exprs_p cp_function_chain->stmts_are_full_exprs_p
+#define stmts_are_full_exprs_p \
+ current_stmt_tree->stmts_are_full_exprs_p
#define in_function_try_handler cp_function_chain->in_function_try_handler
extern tree instantiate_decl PROTO((tree));
extern tree get_bindings PROTO((tree, tree, tree));
extern void add_tree PROTO((tree));
-extern void begin_tree PROTO((void));
-extern void end_tree PROTO((void));
extern void add_maybe_template PROTO((tree, tree));
extern void pop_tinst_level PROTO((void));
extern int more_specialized_class PROTO((tree, tree));
extern void finish_named_return_value PROTO((tree, tree));
extern tree expand_stmt PROTO((tree));
extern void expand_body PROTO((tree));
-extern void begin_stmt_tree PROTO((tree));
-extern void finish_stmt_tree PROTO((tree));
+extern void begin_stmt_tree PROTO((tree *));
+extern void finish_stmt_tree PROTO((tree *));
extern void prep_stmt PROTO((tree));
extern void do_pushlevel PROTO((void));
extern tree do_poplevel PROTO((void));
/* Non-zero if we are presently building a statement tree, rather
than expanding each statement as we encounter it. */
-#define building_stmt_tree() \
- (current_function && (processing_template_decl || !expanding_p))
+#define building_stmt_tree() (last_tree != NULL_TREE)
/* in spew.c */
extern void init_spew PROTO((void));
static void mark_cp_function_context PROTO((struct function *));
static void mark_saved_scope PROTO((void *));
static void mark_lang_function PROTO((struct language_function *));
+static void mark_stmt_tree PROTO((struct stmt_tree *));
static void save_function_data PROTO((tree));
static void check_function_type PROTO((tree));
static void destroy_local_static PROTO((tree));
scope isn't enough, because more binding levels may be pushed. */
struct saved_scope *scope_chain;
+/* Mark ST for GC. */
+
+static void
+mark_stmt_tree (st)
+ struct stmt_tree *st;
+{
+ ggc_mark_tree (st->x_last_stmt);
+ ggc_mark_tree (st->x_last_expr_type);
+}
+
/* Mark ARG (which is really a struct saved_scope **) for GC. */
static void
ggc_mark_tree (t->template_parms);
ggc_mark_tree (t->x_previous_class_type);
ggc_mark_tree (t->x_previous_class_values);
+ ggc_mark_tree (t->x_saved_tree);
+
+ mark_stmt_tree (&t->x_stmt_tree);
mark_binding_level (&t->bindings);
t = t->prev;
}
immediate_size_expand = 0;
current_function->x_dont_save_pending_sizes_p = 1;
+ /* If we're building a statement-tree, start the tree now. */
+ if (processing_template_decl || !expanding_p)
+ begin_stmt_tree (&DECL_SAVED_TREE (decl1));
+
/* Let the user know we're compiling this function. */
if (processing_template_decl || !building_stmt_tree ())
announce_function (decl1);
function body. */
push_momentary ();
- if (building_stmt_tree ())
- begin_stmt_tree (decl1);
-
++function_depth;
if (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (decl1))
/* Clear out the bits we don't need. */
f->x_base_init_list = NULL_TREE;
f->x_member_init_list = NULL_TREE;
- f->x_last_tree = NULL_TREE;
- f->x_last_expr_type = NULL_TREE;
+ f->x_stmt_tree.x_last_stmt = NULL_TREE;
+ f->x_stmt_tree.x_last_expr_type = NULL_TREE;
f->x_last_dtor_insn = NULL_RTX;
f->x_last_parm_cleanup_insn = NULL_RTX;
f->x_result_rtx = NULL_RTX;
/* If we're saving up tree structure, tie off the function now. */
if (!expand_p)
- finish_stmt_tree (fndecl);
+ finish_stmt_tree (&DECL_SAVED_TREE (fndecl));
/* This must come after expand_function_end because cleanups might
have declarations (from inline functions) that need to go into
ggc_mark_tree (p->x_member_init_list);
ggc_mark_tree (p->x_current_class_ptr);
ggc_mark_tree (p->x_current_class_ref);
- ggc_mark_tree (p->x_last_tree);
- ggc_mark_tree (p->x_last_expr_type);
ggc_mark_tree (p->x_eh_spec_try_block);
ggc_mark_tree (p->x_scope_stmt_stack);
ggc_mark_rtx (p->x_last_parm_cleanup_insn);
ggc_mark_rtx (p->x_result_rtx);
+ mark_stmt_tree (&p->x_stmt_tree);
mark_binding_level (&p->bindings);
}
dump_int (di, "algn", DECL_ALIGN (t));
if (TREE_CODE (t) == FIELD_DECL && dump_children_p)
- dump_child ("bpos", DECL_FIELD_BITPOS (t));
+ {
+ if (DECL_C_BIT_FIELD (t))
+ dump_string (di, "bitfield");
+ dump_child ("bpos", DECL_FIELD_BITPOS (t));
+ }
break;
case FUNCTION_DECL:
expand_internal_throw ();
return NULL;
- case VEC_INIT_EXPR:
- return expand_expr
- (build_vec_init
- (NULL_TREE, TREE_OPERAND (exp, 0),
- build_binary_op (MINUS_EXPR, TREE_OPERAND (exp, 2),
- integer_one_node),
- TREE_OPERAND (exp, 1), 0), target, tmode, modifier);
-
case STMT_EXPR:
{
tree rtl_expr = begin_stmt_expr ();
rval = newrval;
TREE_HAS_CONSTRUCTOR (rval) = 1;
}
- else if (current_function_decl)
+ else
rval = (build_vec_init
(NULL_TREE,
save_expr (rval),
build_binary_op (MINUS_EXPR, nelts, integer_one_node),
init,
/*from_array=*/0));
- else
- rval = build (VEC_INIT_EXPR, TREE_TYPE (rval),
- save_expr (rval), init, nelts);
/* If any part of the object initialization terminates by throwing an
exception and a suitable deallocation function can be found, the
if (maxindex == error_mark_node)
return error_mark_node;
- if (current_function_decl == NULL_TREE)
- {
- rval = make_tree_vec (3);
- TREE_VEC_ELT (rval, 0) = base;
- TREE_VEC_ELT (rval, 1) = maxindex;
- TREE_VEC_ELT (rval, 2) = init;
- return rval;
- }
-
type = TREE_TYPE (TREE_TYPE (base));
ptype = build_pointer_type (type);
size = size_in_bytes (type);
3216, 3219, 3222, 3225, 3228, 3230, 3233, 3237, 3239, 3245,
3247, 3248, 3250, 3255, 3257, 3259, 3261, 3263, 3266, 3267,
3269, 3272, 3273, 3276, 3276, 3279, 3279, 3282, 3282, 3284,
- 3286, 3288, 3290, 3296, 3302, 3305, 3308, 3314, 3316, 3318,
- 3322, 3324, 3325, 3326, 3328, 3331, 3334, 3337, 3343, 3347,
- 3349, 3352, 3354, 3357, 3361, 3363, 3366, 3368, 3371, 3388,
- 3396, 3399, 3401, 3403, 3407, 3410, 3411, 3419, 3423, 3427,
- 3430, 3431, 3437, 3440, 3443, 3445, 3449, 3454, 3457, 3467,
- 3472, 3473, 3480, 3483, 3486, 3488, 3491, 3493, 3503, 3517,
- 3521, 3524, 3526, 3530, 3534, 3537, 3540, 3542, 3546, 3548,
- 3555, 3562, 3565, 3569, 3573, 3577, 3583, 3587, 3592, 3594,
- 3597, 3602, 3608, 3619, 3622, 3624, 3628, 3636, 3639, 3643,
- 3646, 3648, 3650, 3656, 3661, 3664, 3666, 3668, 3670, 3672,
- 3674, 3676, 3678, 3680, 3682, 3684, 3686, 3688, 3690, 3692,
- 3694, 3696, 3698, 3700, 3702, 3704, 3706, 3708, 3710, 3712,
- 3714, 3716, 3718, 3720, 3722, 3724, 3726, 3729, 3731
+ 3286, 3288, 3290, 3296, 3302, 3305, 3308, 3314, 3316, 3317,
+ 3320, 3322, 3323, 3324, 3326, 3329, 3332, 3335, 3341, 3345,
+ 3347, 3350, 3352, 3355, 3359, 3361, 3364, 3366, 3369, 3386,
+ 3394, 3397, 3399, 3401, 3405, 3408, 3409, 3417, 3421, 3425,
+ 3428, 3429, 3435, 3438, 3441, 3443, 3447, 3452, 3455, 3465,
+ 3470, 3471, 3478, 3481, 3484, 3486, 3489, 3491, 3501, 3515,
+ 3519, 3522, 3524, 3528, 3532, 3535, 3538, 3540, 3544, 3546,
+ 3553, 3560, 3563, 3567, 3571, 3575, 3581, 3585, 3590, 3592,
+ 3595, 3600, 3606, 3617, 3620, 3622, 3626, 3634, 3637, 3641,
+ 3644, 3646, 3648, 3654, 3659, 3662, 3664, 3666, 3668, 3670,
+ 3672, 3674, 3676, 3678, 3680, 3682, 3684, 3686, 3688, 3690,
+ 3692, 3694, 3696, 3698, 3700, 3702, 3704, 3706, 3708, 3710,
+ 3712, 3714, 3716, 3718, 3720, 3722, 3724, 3727, 3729
};
#endif
#line 3315 "parse.y"
{ finish_goto_stmt (yyvsp[-1].ttype); ;
break;}
-case 759:
-#line 3317 "parse.y"
-{ finish_stmt (); ;
- break;}
case 760:
-#line 3319 "parse.y"
+#line 3318 "parse.y"
{ error ("label must be followed by statement");
- yyungetc ('}', 0);
- finish_stmt (); ;
+ yyungetc ('}', 0); ;
break;}
case 761:
-#line 3323 "parse.y"
+#line 3321 "parse.y"
{ finish_stmt (); ;
break;}
case 764:
-#line 3327 "parse.y"
+#line 3325 "parse.y"
{ do_local_using_decl (yyvsp[0].ttype); ;
break;}
case 766:
-#line 3333 "parse.y"
+#line 3331 "parse.y"
{ yyval.ttype = begin_function_try_block (); ;
break;}
case 767:
-#line 3335 "parse.y"
+#line 3333 "parse.y"
{ finish_function_try_block (yyvsp[-2].ttype); ;
break;}
case 768:
-#line 3337 "parse.y"
+#line 3335 "parse.y"
{
finish_function_handler_sequence (yyvsp[-4].ttype);
yyval.itype = yyvsp[-3].itype;
;
break;}
case 769:
-#line 3345 "parse.y"
+#line 3343 "parse.y"
{ yyval.ttype = begin_try_block (); ;
break;}
case 770:
-#line 3347 "parse.y"
+#line 3345 "parse.y"
{ finish_try_block (yyvsp[-1].ttype); ;
break;}
case 771:
-#line 3349 "parse.y"
+#line 3347 "parse.y"
{ finish_handler_sequence (yyvsp[-3].ttype); ;
break;}
case 774:
-#line 3359 "parse.y"
+#line 3357 "parse.y"
{ yyval.ttype = begin_handler(); ;
break;}
case 775:
-#line 3361 "parse.y"
+#line 3359 "parse.y"
{ yyval.ttype = finish_handler_parms (yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 776:
-#line 3363 "parse.y"
+#line 3361 "parse.y"
{ finish_handler (yyvsp[-1].ttype, yyvsp[-3].ttype); ;
break;}
case 779:
-#line 3373 "parse.y"
+#line 3371 "parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 780:
-#line 3389 "parse.y"
+#line 3387 "parse.y"
{
check_for_new_type ("inside exception declarations", yyvsp[-1].ftype);
yyval.ttype = start_handler_parms (TREE_PURPOSE (yyvsp[-1].ftype.t),
;
break;}
case 781:
-#line 3398 "parse.y"
+#line 3396 "parse.y"
{ finish_label_stmt (yyvsp[-1].ttype); ;
break;}
case 782:
-#line 3400 "parse.y"
+#line 3398 "parse.y"
{ finish_label_stmt (yyvsp[-1].ttype); ;
break;}
case 783:
-#line 3402 "parse.y"
+#line 3400 "parse.y"
{ finish_label_stmt (yyvsp[-1].ttype); ;
break;}
case 784:
-#line 3404 "parse.y"
+#line 3402 "parse.y"
{ finish_label_stmt (yyvsp[-1].ttype); ;
break;}
case 785:
-#line 3409 "parse.y"
+#line 3407 "parse.y"
{ finish_expr_stmt (yyvsp[-1].ttype); ;
break;}
case 787:
-#line 3412 "parse.y"
+#line 3410 "parse.y"
{ if (pedantic)
pedwarn ("ANSI C++ forbids compound statements inside for initializations");
;
break;}
case 788:
-#line 3421 "parse.y"
+#line 3419 "parse.y"
{ emit_line_note (input_filename, lineno);
yyval.ttype = NULL_TREE; ;
break;}
case 789:
-#line 3424 "parse.y"
+#line 3422 "parse.y"
{ emit_line_note (input_filename, lineno); ;
break;}
case 790:
-#line 3429 "parse.y"
+#line 3427 "parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 792:
-#line 3432 "parse.y"
+#line 3430 "parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 793:
-#line 3439 "parse.y"
+#line 3437 "parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 796:
-#line 3446 "parse.y"
+#line 3444 "parse.y"
{ yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ;
break;}
case 797:
-#line 3451 "parse.y"
+#line 3449 "parse.y"
{ yyval.ttype = build_tree_list (yyval.ttype, yyvsp[-1].ttype); ;
break;}
case 798:
-#line 3456 "parse.y"
+#line 3454 "parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, NULL_TREE); ;
break;}
case 799:
-#line 3458 "parse.y"
+#line 3456 "parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
break;}
case 800:
-#line 3469 "parse.y"
+#line 3467 "parse.y"
{
yyval.ttype = empty_parms();
;
break;}
case 802:
-#line 3474 "parse.y"
+#line 3472 "parse.y"
{ yyval.ttype = finish_parmlist (build_tree_list (NULL_TREE, yyvsp[0].ftype.t), 0);
check_for_new_type ("inside parameter list", yyvsp[0].ftype); ;
break;}
case 803:
-#line 3482 "parse.y"
+#line 3480 "parse.y"
{ yyval.ttype = finish_parmlist (yyval.ttype, 0); ;
break;}
case 804:
-#line 3484 "parse.y"
+#line 3482 "parse.y"
{ yyval.ttype = finish_parmlist (yyvsp[-1].ttype, 1); ;
break;}
case 805:
-#line 3487 "parse.y"
+#line 3485 "parse.y"
{ yyval.ttype = finish_parmlist (yyvsp[-1].ttype, 1); ;
break;}
case 806:
-#line 3489 "parse.y"
+#line 3487 "parse.y"
{ yyval.ttype = finish_parmlist (build_tree_list (NULL_TREE,
yyvsp[-1].ftype.t), 1); ;
break;}
case 807:
-#line 3492 "parse.y"
+#line 3490 "parse.y"
{ yyval.ttype = finish_parmlist (NULL_TREE, 1); ;
break;}
case 808:
-#line 3494 "parse.y"
+#line 3492 "parse.y"
{
/* This helps us recover from really nasty
parse errors, for example, a missing right
;
break;}
case 809:
-#line 3504 "parse.y"
+#line 3502 "parse.y"
{
/* This helps us recover from really nasty
parse errors, for example, a missing right
;
break;}
case 810:
-#line 3519 "parse.y"
+#line 3517 "parse.y"
{ maybe_snarf_defarg (); ;
break;}
case 811:
-#line 3521 "parse.y"
+#line 3519 "parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 814:
-#line 3532 "parse.y"
+#line 3530 "parse.y"
{ check_for_new_type ("in a parameter list", yyvsp[0].ftype);
yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ftype.t); ;
break;}
case 815:
-#line 3535 "parse.y"
+#line 3533 "parse.y"
{ check_for_new_type ("in a parameter list", yyvsp[-1].ftype);
yyval.ttype = build_tree_list (yyvsp[0].ttype, yyvsp[-1].ftype.t); ;
break;}
case 816:
-#line 3538 "parse.y"
+#line 3536 "parse.y"
{ check_for_new_type ("in a parameter list", yyvsp[0].ftype);
yyval.ttype = chainon (yyval.ttype, yyvsp[0].ftype.t); ;
break;}
case 817:
-#line 3541 "parse.y"
+#line 3539 "parse.y"
{ yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
break;}
case 818:
-#line 3543 "parse.y"
+#line 3541 "parse.y"
{ yyval.ttype = chainon (yyval.ttype, build_tree_list (yyvsp[0].ttype, yyvsp[-2].ttype)); ;
break;}
case 820:
-#line 3549 "parse.y"
+#line 3547 "parse.y"
{ check_for_new_type ("in a parameter list", yyvsp[-1].ftype);
yyval.ttype = build_tree_list (NULL_TREE, yyvsp[-1].ftype.t); ;
break;}
case 821:
-#line 3559 "parse.y"
+#line 3557 "parse.y"
{ tree specs = strip_attrs (yyvsp[-1].ftype.t);
yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag;
yyval.ftype.t = build_tree_list (specs, yyvsp[0].ttype); ;
break;}
case 822:
-#line 3563 "parse.y"
+#line 3561 "parse.y"
{ yyval.ftype.t = build_tree_list (yyvsp[-1].ftype.t, yyvsp[0].ttype);
yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag; ;
break;}
case 823:
-#line 3566 "parse.y"
+#line 3564 "parse.y"
{ yyval.ftype.t = build_tree_list (build_decl_list (NULL_TREE, yyvsp[-1].ftype.t),
yyvsp[0].ttype);
yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag; ;
break;}
case 824:
-#line 3570 "parse.y"
+#line 3568 "parse.y"
{ tree specs = strip_attrs (yyvsp[-1].ftype.t);
yyval.ftype.t = build_tree_list (specs, yyvsp[0].ttype);
yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag; ;
break;}
case 825:
-#line 3574 "parse.y"
+#line 3572 "parse.y"
{ tree specs = strip_attrs (yyvsp[0].ftype.t);
yyval.ftype.t = build_tree_list (specs, NULL_TREE);
yyval.ftype.new_type_flag = yyvsp[0].ftype.new_type_flag; ;
break;}
case 826:
-#line 3578 "parse.y"
+#line 3576 "parse.y"
{ tree specs = strip_attrs (yyvsp[-1].ttype);
yyval.ftype.t = build_tree_list (specs, yyvsp[0].ttype);
yyval.ftype.new_type_flag = 0; ;
break;}
case 827:
-#line 3585 "parse.y"
+#line 3583 "parse.y"
{ yyval.ftype.t = build_tree_list (NULL_TREE, yyvsp[0].ftype.t);
yyval.ftype.new_type_flag = yyvsp[0].ftype.new_type_flag; ;
break;}
case 828:
-#line 3588 "parse.y"
+#line 3586 "parse.y"
{ yyval.ftype.t = build_tree_list (yyvsp[0].ttype, yyvsp[-1].ftype.t);
yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag; ;
break;}
case 831:
-#line 3599 "parse.y"
+#line 3597 "parse.y"
{ see_typename (); ;
break;}
case 832:
-#line 3604 "parse.y"
+#line 3602 "parse.y"
{
error ("type specifier omitted for parameter");
yyval.ttype = build_tree_list (integer_type_node, NULL_TREE);
;
break;}
case 833:
-#line 3609 "parse.y"
+#line 3607 "parse.y"
{
error ("type specifier omitted for parameter");
if (TREE_CODE (yyval.ttype) == SCOPE_REF
;
break;}
case 834:
-#line 3621 "parse.y"
+#line 3619 "parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 835:
-#line 3623 "parse.y"
+#line 3621 "parse.y"
{ yyval.ttype = yyvsp[-1].ttype; ;
break;}
case 836:
-#line 3625 "parse.y"
+#line 3623 "parse.y"
{ yyval.ttype = empty_except_spec; ;
break;}
case 837:
-#line 3630 "parse.y"
+#line 3628 "parse.y"
{
check_for_new_type ("exception specifier", yyvsp[0].ftype);
yyval.ttype = groktypename (yyvsp[0].ftype.t);
;
break;}
case 838:
-#line 3638 "parse.y"
+#line 3636 "parse.y"
{ yyval.ttype = add_exception_specifier (NULL_TREE, yyvsp[0].ttype, 1); ;
break;}
case 839:
-#line 3640 "parse.y"
+#line 3638 "parse.y"
{ yyval.ttype = add_exception_specifier (yyvsp[-2].ttype, yyvsp[0].ttype, 1); ;
break;}
case 840:
-#line 3645 "parse.y"
+#line 3643 "parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 841:
-#line 3647 "parse.y"
+#line 3645 "parse.y"
{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 842:
-#line 3649 "parse.y"
+#line 3647 "parse.y"
{ yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 843:
-#line 3651 "parse.y"
+#line 3649 "parse.y"
{ tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype);
yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg);
;
break;}
case 844:
-#line 3658 "parse.y"
+#line 3656 "parse.y"
{ got_scope = NULL_TREE; ;
break;}
case 845:
-#line 3663 "parse.y"
+#line 3661 "parse.y"
{ yyval.ttype = ansi_opname[MULT_EXPR]; ;
break;}
case 846:
-#line 3665 "parse.y"
+#line 3663 "parse.y"
{ yyval.ttype = ansi_opname[TRUNC_DIV_EXPR]; ;
break;}
case 847:
-#line 3667 "parse.y"
+#line 3665 "parse.y"
{ yyval.ttype = ansi_opname[TRUNC_MOD_EXPR]; ;
break;}
case 848:
-#line 3669 "parse.y"
+#line 3667 "parse.y"
{ yyval.ttype = ansi_opname[PLUS_EXPR]; ;
break;}
case 849:
-#line 3671 "parse.y"
+#line 3669 "parse.y"
{ yyval.ttype = ansi_opname[MINUS_EXPR]; ;
break;}
case 850:
-#line 3673 "parse.y"
+#line 3671 "parse.y"
{ yyval.ttype = ansi_opname[BIT_AND_EXPR]; ;
break;}
case 851:
-#line 3675 "parse.y"
+#line 3673 "parse.y"
{ yyval.ttype = ansi_opname[BIT_IOR_EXPR]; ;
break;}
case 852:
-#line 3677 "parse.y"
+#line 3675 "parse.y"
{ yyval.ttype = ansi_opname[BIT_XOR_EXPR]; ;
break;}
case 853:
-#line 3679 "parse.y"
+#line 3677 "parse.y"
{ yyval.ttype = ansi_opname[BIT_NOT_EXPR]; ;
break;}
case 854:
-#line 3681 "parse.y"
+#line 3679 "parse.y"
{ yyval.ttype = ansi_opname[COMPOUND_EXPR]; ;
break;}
case 855:
-#line 3683 "parse.y"
+#line 3681 "parse.y"
{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
break;}
case 856:
-#line 3685 "parse.y"
+#line 3683 "parse.y"
{ yyval.ttype = ansi_opname[LT_EXPR]; ;
break;}
case 857:
-#line 3687 "parse.y"
+#line 3685 "parse.y"
{ yyval.ttype = ansi_opname[GT_EXPR]; ;
break;}
case 858:
-#line 3689 "parse.y"
+#line 3687 "parse.y"
{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
break;}
case 859:
-#line 3691 "parse.y"
+#line 3689 "parse.y"
{ yyval.ttype = ansi_assopname[yyvsp[0].code]; ;
break;}
case 860:
-#line 3693 "parse.y"
+#line 3691 "parse.y"
{ yyval.ttype = ansi_opname [MODIFY_EXPR]; ;
break;}
case 861:
-#line 3695 "parse.y"
+#line 3693 "parse.y"
{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
break;}
case 862:
-#line 3697 "parse.y"
+#line 3695 "parse.y"
{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
break;}
case 863:
-#line 3699 "parse.y"
+#line 3697 "parse.y"
{ yyval.ttype = ansi_opname[POSTINCREMENT_EXPR]; ;
break;}
case 864:
-#line 3701 "parse.y"
+#line 3699 "parse.y"
{ yyval.ttype = ansi_opname[PREDECREMENT_EXPR]; ;
break;}
case 865:
-#line 3703 "parse.y"
+#line 3701 "parse.y"
{ yyval.ttype = ansi_opname[TRUTH_ANDIF_EXPR]; ;
break;}
case 866:
-#line 3705 "parse.y"
+#line 3703 "parse.y"
{ yyval.ttype = ansi_opname[TRUTH_ORIF_EXPR]; ;
break;}
case 867:
-#line 3707 "parse.y"
+#line 3705 "parse.y"
{ yyval.ttype = ansi_opname[TRUTH_NOT_EXPR]; ;
break;}
case 868:
-#line 3709 "parse.y"
+#line 3707 "parse.y"
{ yyval.ttype = ansi_opname[COND_EXPR]; ;
break;}
case 869:
-#line 3711 "parse.y"
+#line 3709 "parse.y"
{ yyval.ttype = ansi_opname[yyvsp[0].code]; ;
break;}
case 870:
-#line 3713 "parse.y"
+#line 3711 "parse.y"
{ yyval.ttype = ansi_opname[COMPONENT_REF]; ;
break;}
case 871:
-#line 3715 "parse.y"
+#line 3713 "parse.y"
{ yyval.ttype = ansi_opname[MEMBER_REF]; ;
break;}
case 872:
-#line 3717 "parse.y"
+#line 3715 "parse.y"
{ yyval.ttype = ansi_opname[CALL_EXPR]; ;
break;}
case 873:
-#line 3719 "parse.y"
+#line 3717 "parse.y"
{ yyval.ttype = ansi_opname[ARRAY_REF]; ;
break;}
case 874:
-#line 3721 "parse.y"
+#line 3719 "parse.y"
{ yyval.ttype = ansi_opname[NEW_EXPR]; ;
break;}
case 875:
-#line 3723 "parse.y"
+#line 3721 "parse.y"
{ yyval.ttype = ansi_opname[DELETE_EXPR]; ;
break;}
case 876:
-#line 3725 "parse.y"
+#line 3723 "parse.y"
{ yyval.ttype = ansi_opname[VEC_NEW_EXPR]; ;
break;}
case 877:
-#line 3727 "parse.y"
+#line 3725 "parse.y"
{ yyval.ttype = ansi_opname[VEC_DELETE_EXPR]; ;
break;}
case 878:
-#line 3730 "parse.y"
+#line 3728 "parse.y"
{ yyval.ttype = grokoptypename (yyvsp[-1].ftype.t, yyvsp[0].ttype); ;
break;}
case 879:
-#line 3732 "parse.y"
+#line 3730 "parse.y"
{ yyval.ttype = ansi_opname[ERROR_MARK]; ;
break;}
}
}
return 1;
}
-#line 3735 "parse.y"
+#line 3733 "parse.y"
#ifdef SPEW_DEBUG
| GOTO identifier ';'
{ finish_goto_stmt ($2); }
| label_colon stmt
- { finish_stmt (); }
| label_colon '}'
{ error ("label must be followed by statement");
- yyungetc ('}', 0);
- finish_stmt (); }
+ yyungetc ('}', 0); }
| ';'
{ finish_stmt (); }
| try_block
return first;
}
-void
-begin_tree ()
-{
- if (current_function)
- {
- saved_trees = tree_cons (NULL_TREE, last_tree, saved_trees);
- last_tree = NULL_TREE;
- }
- else
- saved_trees = tree_cons (NULL_TREE, NULL_TREE, saved_trees);
-}
-
-
-void
-end_tree ()
-{
- my_friendly_assert (saved_trees != NULL_TREE, 0);
-
- if (current_function)
- last_tree = TREE_VALUE (saved_trees);
- saved_trees = TREE_CHAIN (saved_trees);
-}
-
/* D is an undefined function declaration in the presence of templates with
the same name, listed in FNS. If one of them can produce D as an
instantiation, remember this so we can instantiate it at EOF if D has
static tree expand_cond PROTO((tree));
static tree maybe_convert_cond PROTO((tree));
+/* Record the fact that STMT was the last statement added to the
+ statement tree. */
+
+#define SET_LAST_STMT(stmt) \
+ (current_stmt_tree->x_last_stmt = (stmt))
+
/* When parsing a template, LAST_TREE contains the last statement
parsed. These are chained together through the TREE_CHAIN field,
but often need to be re-organized since the parse is performed
do { \
substmt = TREE_CHAIN (stmt); \
TREE_CHAIN (stmt) = NULL_TREE; \
- last_tree = stmt; \
+ SET_LAST_STMT (stmt); \
} while (0)
/* Finish processing the COND, the SUBSTMT condition for STMT. */
tree t;
{
/* Add T to the statement-tree. */
- last_tree = TREE_CHAIN (last_tree) = t;
+ TREE_CHAIN (last_tree) = t;
+ SET_LAST_STMT (t);
/* When we expand a statement-tree, we must know whether or not the
statements are full-expresions. We record that fact here. */
if (building_stmt_tree ())
{
RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
- last_tree = if_stmt;
+ SET_LAST_STMT (if_stmt);
return if_stmt;
}
else
/* If this is the outermost block of the function, declare the
variables __FUNCTION__, __PRETTY_FUNCTION__, and so forth. */
- if (!current_function_name_declared
+ if (current_function
+ && !current_function_name_declared
&& !processing_template_decl
&& !has_no_scope)
{
tree
begin_stmt_expr ()
{
+ /* If we're outside a function, we won't have a statement-tree to
+ work with. But, if we see a statement-expression we need to
+ create one. */
+ if (!current_function && !last_tree)
+ begin_stmt_tree (&scope_chain->x_saved_tree);
+
keep_next_level (1);
/* If we're building a statement tree, then the upcoming compound
statement will be chained onto the tree structure, starting at
/* Remove the compound statement from the tree structure; it is
now saved in the STMT_EXPR. */
- last_tree = rtl_expr;
+ SET_LAST_STMT (rtl_expr);
TREE_CHAIN (last_tree) = NULL_TREE;
}
else
result = rtl_expr;
+ /* If we created a statement-tree for this statement-expression,
+ remove it now. */
+ if (!current_function
+ && TREE_CHAIN (scope_chain->x_saved_tree) == NULL_TREE)
+ finish_stmt_tree (&scope_chain->x_saved_tree);
+
return result;
}
#endif
reset_specialization();
- /* In case this is a local class within a template
- function, we save the current tree structure so
- that we can get it back later. */
- begin_tree ();
-
/* Make a declaration for this class in its own scope. */
build_self_reference ();
{
if (current_class_type == NULL_TREE)
clear_inline_text_obstack ();
-
- /* Undo the begin_tree in begin_class_definition. */
- end_tree ();
}
/* Finish processing the declaration of a member class template
return TREE_TYPE (expr);
}
-/* Create an empty statement tree for FN. */
+/* Create an empty statement tree rooted at T. */
void
-begin_stmt_tree (fn)
- tree fn;
+begin_stmt_tree (t)
+ tree *t;
{
/* We create a trivial EXPR_STMT so that last_tree is never NULL in
what follows. We remove the extraneous statement in
finish_stmt_tree. */
- DECL_SAVED_TREE (fn) = build_nt (EXPR_STMT, void_zero_node);
- last_tree = DECL_SAVED_TREE (fn);
+ *t = build_nt (EXPR_STMT, void_zero_node);
+ SET_LAST_STMT (*t);
last_expr_type = NULL_TREE;
}
-/* Finish the statement tree for FN. */
+/* Finish the statement tree rooted at T. */
void
-finish_stmt_tree (fn)
- tree fn;
+finish_stmt_tree (t)
+ tree *t;
{
tree stmt;
/* Remove the fake extra statement added in begin_stmt_tree. */
- stmt = TREE_CHAIN (DECL_SAVED_TREE (fn));
- DECL_SAVED_TREE (fn) = stmt;
+ stmt = TREE_CHAIN (*t);
+ *t = stmt;
+ SET_LAST_STMT (NULL_TREE);
- /* The line-number recorded in the outermost statement in a function
- is the line number of the end of the function. */
- STMT_LINENO (stmt) = lineno;
- STMT_LINENO_FOR_FN_P (stmt) = 1;
+ if (current_function)
+ {
+ /* The line-number recorded in the outermost statement in a function
+ is the line number of the end of the function. */
+ STMT_LINENO (stmt) = lineno;
+ STMT_LINENO_FOR_FN_P (stmt) = 1;
+ }
}
/* We're about to expand T, a statement. Set up appropriate context
case TARGET_EXPR:
case AGGR_INIT_EXPR:
case NEW_EXPR:
- case VEC_INIT_EXPR:
TRY (TREE_OPERAND (t, 0));
TRY (TREE_OPERAND (t, 1));
TRY (TREE_OPERAND (t, 2));
return t;
case NEW_EXPR:
- case VEC_INIT_EXPR:
t = copy_node (t);
TREE_OPERAND (t, 0) = mapcar (TREE_OPERAND (t, 0), func);
TREE_OPERAND (t, 1) = mapcar (TREE_OPERAND (t, 1), func);
--- /dev/null
+// Build don't link:
+// Origin: Mark Mitchell <mark@codesourcery.com>
+// Special g++ Options:
+
+void f ()
+{
+ int i = ({ l: 3; });
+}
projects / gcc.git / commitdiff