From 325c36911589375105e5437c513bf880aeffdc75 Mon Sep 17 00:00:00 2001 From: Richard Henderson Date: Tue, 15 Jun 2004 18:21:38 -0700 Subject: c-common.c (lang_gimplify_stmt): Remove next_p argument. * c-common.c (lang_gimplify_stmt): Remove next_p argument. (if_elt, if_stack, if_stack_space, c_expand_start_cond, c_finish_then, c_expand_end_cond, c_expand_start_else, c_finish_else, c_begin_if_stmt, c_begin_while_stmt, c_finish_while_stmt_cond): Move to c-typeck.c. (finish_fname_decls, fname_decl): Use statement_lists. (c_expand_expr_stmt): Don't set last_expr_type. (c_type_hash): Fix indentation. (c_safe_from_p): Don't follow TREE_CHAIN. (c_tree_chain_matters_p): Remove. * c-common.def (SCOPE_STMT): Remove. (CLEANUP_STMT): Redefine to contain its own body. * c-common.h (struct stmt_tree_s): Remove x_last_stmt, x_last_expr_type, x_last_expr_filename, x_scope_stmt_stack. Add x_cur_stmt_list. (last_tree, last_expr_type, last_expr_filename, RECHAIN_STMTS): Remove. (cur_stmt_list): New. (STATEMENT_LIST_STMT_EXPR): New. (SCOPE_BEGIN_P, SCOPE_END_P, SCOPE_STMT_BLOCK, SCOPE_NULLIFIED_P, SCOPE_NO_CLEANUPS_P, SCOPE_PARTIAL_P, NEW_FOR_SCOPE_P): Remove. (CLEANUP_BODY): New. (CLEANUP_DECL): Move to operand 2. (c_common_stmt_codes): Remove SCOPE_STMT. (COMPOUND_STMT_NO_SCOPE, COMPOUND_STMT_BODY_BLOCK): Remove. * c-decl.c (c_scope_stmt_stack, current_scope_stmt_stack): Remove. (c_push_function_context, c_pop_function_context): Don't save it. (finish_decl): Set TREE_USED on the decl for a cleanup. Use push_cleanup. (store_parm_decls): Use statement lists. (finish_function): Remove compstmt rule workaround. Use statement lists. Call finish_fname_decls after finalizing the body. (c_begin_compound_stmt): Move to c-typeck.c. * c-dump.c (c_dump_tree): Remove SCOPE_STMT. * c-gimplify.c (gimplify_cleanup_stmt, gimplify_cleanup_stmts): New. (c_genericize): Invoke them. (c_gimplify_stmt): Don't look through TREE_CHAIN. Kill SCOPE_STMT. (c_build_bind_expr): Export. (gimplify_block, gimplify_cleanup): Remove. (gimplify_condition): Use gimplify_stmt. (gimplify_for_stmt): Remove FOR_INIT_STMT chaining hack. (gimplify_if_stmt): Remove recursion hack. (c_gimplify_expr): Remove STMT_EXPR handling. (stmt_expr_last_stmt, gimplify_stmt_expr): Remove. (is_last_stmt_of_scope): Remove. * c-lang.c (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P): Remove. * c-mudflap.c (mflang_flush_calls): Use c_begin_compound_stmt, c_end_compound_stmt. * c-objc-common.c (build_cdtor): Likewise. * c-parse.in (primary): Use c_finish_stmt_expr. (push_scope, pop_scope): Remove. (c99_block_start, compstmt_start): Use c_begin_compound_stmt. (c99_block_end, compstmt): Use c_end_compound_stmt. (c99_block_lineno_labeled_stmt): Likewise. (compstmt_primary_start): Use c_begin_stmt_expr. (simple_if, select_or_iter_stmt): Update calls to stmt builders. (do_stmt_start): Fill in body directly. (lineno_stmt): Avoid setting lineno on constants. * c-pretty-print.c (pp_c_statement): Handle STATEMENT_LIST. Remove SCOPE_STMT. * c-semantics.c (begin_stmt_tree): Remove. (push_stmt_list, re_push_stmt_list, pop_stmt_list): New. (add_stmt): Use statement lists. (add_scope_stmt, finish_stmt_tree): Remove. (push_cleanup): New. * c-tree.h: Move some decls from c-common.h. * c-typeck.c (c_tree_expr_nonnegative_p): Simplify for statement lists. (do_case, c_finish_case): Likewise. (c_finish_then): Take body for then as argument. (c_finish_else): Similarly. (c_begin_for_stmt, c_finish_for_stmt_init, c_finish_for_stmt_cond, c_finish_for_stmt_incr, c_finish_for_stmt): New. (c_begin_stmt_expr, c_finish_stmt_expr): New. (c_begin_compound_stmt): Do scope management. (c_end_compound_stmt): New. * fold-const.c (tree_expr_nonnegative_p): Fix BIND_EXPR. * gimplify.c (voidify_wrapper_expr): Accept temporary argument. Look through exception handling constructs. (gimplify_bind_expr): Accept temporary argument. (gimplify_target_expr): Special case BIND_EXPR bodies. (gimplify_expr): Handle fallback == fb_none like a statement. * langhooks-def.h (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P): Kill. * langhooks.c (lhd_tree_inlining_tree_chain_matters_p): Remove. * langhooks.h (tree_chain_matters_p): Remove. * stub-objc.c (objc_clear_super_receiver): New. * tree-gimple.h (voidify_wrapper_expr): Update decl. (append_to_statement_list, append_to_statement_list_force): Move to tree-iterator.h. * tree-inline.c (expand_call_inline): Update call. (clone_body): Use statement lists. (walk_tree): Don't check tree_chain_matters_p. (copy_tree_r): Likewise. * tree-iterator.c (alloc_stmt_list): Clear lang bits. (tsi_link_before, tsi_link_after): Set TREE_SIDE_EFFECTS properly. * tree-iterator.h (append_to_statement_list, append_to_statement_list_force): Moved from tree-gimple.h. * tree-pretty-print.c (dump_generic_node): Clean up TARGET_EXPR dump. * objc/objc-act.c (build_module_descriptor): Use c_begin_compound_stmt. (objc_enter_block): Likewise. (objc_exit_block): Use c_end_compound_stmt. (objc_build_try_enter_fragment): Add #error and comment for rewriting for OBJCPLUS. (objc_build_extract_fragment, objc_build_try_epilogue, objc_build_catch_stmt, objc_build_finally_prologue, objc_build_finally_epilogue): Update for C statement builders. * objc/objc-lang.c (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P): Remove. cp/ * call.c (initialize_reference): Don't build CLEANUP_STMT here. * cp-gimplify.c (cp_gimplify_stmt): Remove next_p argument. (genericize_try_block): Use gimplify_stmt. (genericize_catch_block, genericize_eh_spec_block): Likewise. (cp_gimplify_init_expr): Remove STMT_EXPR special case. (gimplify_must_not_throw_expr): Update voidify_wrapper_expr call. * cp-lang.c (LANG_HOOKS_TREE_INLINING_TREE_CHAIN_MATTERS_P): Remove. (cp_tree_chain_matters_p): Remove. * cp-tree.h (COMPOUND_STMT_TRY_BLOCK): New. (COMPOUND_STMT_BODY_BLOCK): New. (STATEMENT_LIST_NO_SCOPE, STATEMENT_LIST_TRY_BLOCK): New. (EXPR_STMT_STMT_EXPR_RESULT): New. (building_stmt_tree): Check cur_stmt_list. (tf_stmt_expr_cmpd, tf_stmt_expr_body): Remove. (BCS_NO_SCOPE, BCS_TRY_BLOCK, BCS_FN_BODY): New. * decl.c (poplevel): Use pop_stmt_list for minding cleanups. (cp_finish_decl): Use push_cleanup. (start_function, finish_function): Use statement lists. (finish_stmt): Do nothing. * except.c (begin_eh_spec_block): Use statement lists. (check_handlers_1, check_handlers): Likewise. * init.c (construct_virtual_base): Don't add extra compound stmts. (build_vec_init): Likewise. * name-lookup.c (maybe_push_cleanup_level): Use statement lists. * name-lookup.h (struct cp_binding_level): Add statement_list. * parser.c (cp_parser_statement): Take the STMT_EXPR node, not a bool. (cp_parser_labeled_statement, cp_parser_expression_statement, cp_parser_statement_seq_opt): Likewise. (cp_parser_compound_statement): Likewise. Take bool for try block. (cp_parser_selection_statement): Tidy if processing. (cp_parser_already_scoped_statement): Rewrite to do what it says. * pt.c (tsubst_copy): Move STMT_EXPR to tsubst_expr. (tsubst_expr): Rewrite STMT_EXPR processing. Handle STATEMENT_LIST. Mind COMPOUND_STMT_TRY_BLOCK, EXPR_STMT_STMT_EXPR_RESULT. * semantics.c (do_poplevel, do_pushlevel): Use statement lists. (finish_cond): New, rewritten from FINISH_COND. (simplify_loop_decl_cond): New. (finish_expr_stmt): Avoid nested EXPR_STMTs. (begin_if_stmt, finish_if_stmt_cond, finish_then_clause, begin_else_clause, finish_else_clause, finish_if_stmt, begin_while_stmt, finish_while_stmt_cond, finish_while_stmt, begin_do_stmt, finish_do_body, begin_for_stmt, finish_for_init_stmt, finish_for_cond, finish_for_stmt, begin_switch_stmt, finish_switch_cond, finish_switch_stmt, begin_try_block, finish_try_block, finish_cleanup_try_block, finish_function_try_block, finish_handler_sequence, finish_function_handler_sequence, begin_handler, finish_handler_parms, finish_handler, begin_stmt_expr, finish_stmt_expr_expr, finish_stmt_expr): Rewrite using statement lists. (begin_compound_stmt): Replace has_no_scope argument with flags. Update all callers. Use statement lists. (finish_compound_stmt): Likewise. (finish_decl_cleanup, finish_eh_cleanup): Use push_cleanup. (current_scope_stmt_stack): Remove. (simplify_aggr_init_expr): Don't muck with TREE_CHAIN. * typeck2.c (split_nonconstant_init_1, split_nonconstant_init): Rewrite with statement lists. testsuite/ * g++.dg/ext/stmtexpr1.C: XFAIL. * gcc.dg/20030612-1.c: XFAIL. From-SVN: r83221 --- gcc/cp/parser.c | 90 ++++++++++++++++++++++++++------------------------------- 1 file changed, 41 insertions(+), 49 deletions(-) (limited to 'gcc/cp/parser.c') diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index bc73689..428762c 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -1415,15 +1415,15 @@ static tree cp_parser_builtin_offsetof /* Statements [gram.stmt.stmt] */ static void cp_parser_statement - (cp_parser *, bool); + (cp_parser *, tree); static tree cp_parser_labeled_statement - (cp_parser *, bool); + (cp_parser *, tree); static tree cp_parser_expression_statement - (cp_parser *, bool); + (cp_parser *, tree); static tree cp_parser_compound_statement - (cp_parser *, bool); + (cp_parser *, tree, bool); static void cp_parser_statement_seq_opt - (cp_parser *, bool); + (cp_parser *, tree); static tree cp_parser_selection_statement (cp_parser *); static tree cp_parser_condition @@ -2542,7 +2542,7 @@ cp_parser_primary_expression (cp_parser *parser, /* Start the statement-expression. */ expr = begin_stmt_expr (); /* Parse the compound-statement. */ - cp_parser_compound_statement (parser, true); + cp_parser_compound_statement (parser, expr, false); /* Finish up. */ expr = finish_stmt_expr (expr, false); } @@ -5615,7 +5615,7 @@ cp_parser_builtin_offsetof (cp_parser *parser) try-block */ static void -cp_parser_statement (cp_parser* parser, bool in_statement_expr_p) +cp_parser_statement (cp_parser* parser, tree in_statement_expr) { tree statement; cp_token *token; @@ -5638,7 +5638,7 @@ cp_parser_statement (cp_parser* parser, bool in_statement_expr_p) case RID_CASE: case RID_DEFAULT: statement = cp_parser_labeled_statement (parser, - in_statement_expr_p); + in_statement_expr); break; case RID_IF: @@ -5675,11 +5675,11 @@ cp_parser_statement (cp_parser* parser, bool in_statement_expr_p) labeled-statement. */ token = cp_lexer_peek_nth_token (parser->lexer, 2); if (token->type == CPP_COLON) - statement = cp_parser_labeled_statement (parser, in_statement_expr_p); + statement = cp_parser_labeled_statement (parser, in_statement_expr); } /* Anything that starts with a `{' must be a compound-statement. */ else if (token->type == CPP_OPEN_BRACE) - statement = cp_parser_compound_statement (parser, false); + statement = cp_parser_compound_statement (parser, NULL, false); /* Everything else must be a declaration-statement or an expression-statement. Try for the declaration-statement @@ -5697,7 +5697,7 @@ cp_parser_statement (cp_parser* parser, bool in_statement_expr_p) return; } /* Look for an expression-statement instead. */ - statement = cp_parser_expression_statement (parser, in_statement_expr_p); + statement = cp_parser_expression_statement (parser, in_statement_expr); } /* Set the line number for the statement. */ @@ -5724,7 +5724,7 @@ cp_parser_statement (cp_parser* parser, bool in_statement_expr_p) an ordinary label, returns a LABEL_STMT. */ static tree -cp_parser_labeled_statement (cp_parser* parser, bool in_statement_expr_p) +cp_parser_labeled_statement (cp_parser* parser, tree in_statement_expr) { cp_token *token; tree statement = error_mark_node; @@ -5792,7 +5792,7 @@ cp_parser_labeled_statement (cp_parser* parser, bool in_statement_expr_p) /* Require the `:' token. */ cp_parser_require (parser, CPP_COLON, "`:'"); /* Parse the labeled statement. */ - cp_parser_statement (parser, in_statement_expr_p); + cp_parser_statement (parser, in_statement_expr); /* Return the label, in the case of a `case' or `default' label. */ return statement; @@ -5809,7 +5809,7 @@ cp_parser_labeled_statement (cp_parser* parser, bool in_statement_expr_p) expression statement. */ static tree -cp_parser_expression_statement (cp_parser* parser, bool in_statement_expr_p) +cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr) { tree statement = NULL_TREE; @@ -5821,12 +5821,12 @@ cp_parser_expression_statement (cp_parser* parser, bool in_statement_expr_p) /* Consume the final `;'. */ cp_parser_consume_semicolon_at_end_of_statement (parser); - if (in_statement_expr_p + if (in_statement_expr && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE)) { /* This is the final expression statement of a statement expression. */ - statement = finish_stmt_expr_expr (statement); + statement = finish_stmt_expr_expr (statement, in_statement_expr); } else if (statement) statement = finish_expr_stmt (statement); @@ -5844,7 +5844,8 @@ cp_parser_expression_statement (cp_parser* parser, bool in_statement_expr_p) Returns a COMPOUND_STMT representing the statement. */ static tree -cp_parser_compound_statement (cp_parser *parser, bool in_statement_expr_p) +cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr, + bool in_try) { tree compound_stmt; @@ -5852,9 +5853,9 @@ cp_parser_compound_statement (cp_parser *parser, bool in_statement_expr_p) if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'")) return error_mark_node; /* Begin the compound-statement. */ - compound_stmt = begin_compound_stmt (/*has_no_scope=*/false); + compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0); /* Parse an (optional) statement-seq. */ - cp_parser_statement_seq_opt (parser, in_statement_expr_p); + cp_parser_statement_seq_opt (parser, in_statement_expr); /* Finish the compound-statement. */ finish_compound_stmt (compound_stmt); /* Consume the `}'. */ @@ -5870,7 +5871,7 @@ cp_parser_compound_statement (cp_parser *parser, bool in_statement_expr_p) statement-seq [opt] statement */ static void -cp_parser_statement_seq_opt (cp_parser* parser, bool in_statement_expr_p) +cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr) { /* Scan statements until there aren't any more. */ while (true) @@ -5881,7 +5882,7 @@ cp_parser_statement_seq_opt (cp_parser* parser, bool in_statement_expr_p) break; /* Parse the statement. */ - cp_parser_statement (parser, in_statement_expr_p); + cp_parser_statement (parser, in_statement_expr); } } @@ -5935,35 +5936,30 @@ cp_parser_selection_statement (cp_parser* parser) if (keyword == RID_IF) { - tree then_stmt; - /* Add the condition. */ finish_if_stmt_cond (condition, statement); /* Parse the then-clause. */ - then_stmt = cp_parser_implicitly_scoped_statement (parser); + cp_parser_implicitly_scoped_statement (parser); finish_then_clause (statement); /* If the next token is `else', parse the else-clause. */ if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ELSE)) { - tree else_stmt; - /* Consume the `else' keyword. */ cp_lexer_consume_token (parser->lexer); + begin_else_clause (statement); /* Parse the else-clause. */ - else_stmt - = cp_parser_implicitly_scoped_statement (parser); + cp_parser_implicitly_scoped_statement (parser); finish_else_clause (statement); } /* Now we're all done with the if-statement. */ - finish_if_stmt (); + finish_if_stmt (statement); } else { - tree body; bool in_switch_statement_p; /* Add the condition. */ @@ -5972,7 +5968,7 @@ cp_parser_selection_statement (cp_parser* parser) /* Parse the body of the switch-statement. */ in_switch_statement_p = parser->in_switch_statement_p; parser->in_switch_statement_p = true; - body = cp_parser_implicitly_scoped_statement (parser); + cp_parser_implicitly_scoped_statement (parser); parser->in_switch_statement_p = in_switch_statement_p; /* Now we're all done with the switch-statement. */ @@ -6365,7 +6361,7 @@ cp_parser_implicitly_scoped_statement (cp_parser* parser) if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)) { /* Create a compound-statement. */ - statement = begin_compound_stmt (/*has_no_scope=*/false); + statement = begin_compound_stmt (0); /* Parse the dependent-statement. */ cp_parser_statement (parser, false); /* Finish the dummy compound-statement. */ @@ -6373,7 +6369,7 @@ cp_parser_implicitly_scoped_statement (cp_parser* parser) } /* Otherwise, we simply parse the statement directly. */ else - statement = cp_parser_compound_statement (parser, false); + statement = cp_parser_compound_statement (parser, NULL, false); /* Return the statement. */ return statement; @@ -6387,21 +6383,17 @@ cp_parser_implicitly_scoped_statement (cp_parser* parser) static void cp_parser_already_scoped_statement (cp_parser* parser) { - /* If the token is not a `{', then we must take special action. */ - if (cp_lexer_next_token_is_not(parser->lexer, CPP_OPEN_BRACE)) + /* If the token is a `{', then we must take special action. */ + if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)) + cp_parser_statement (parser, false); + else { - tree statement; - - /* Create a compound-statement. */ - statement = begin_compound_stmt (/*has_no_scope=*/true); - /* Parse the dependent-statement. */ - cp_parser_statement (parser, false); - /* Finish the dummy compound-statement. */ - finish_compound_stmt (statement); + /* Avoid calling cp_parser_compound_statement, so that we + don't create a new scope. Do everything else by hand. */ + cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"); + cp_parser_statement_seq_opt (parser, false); + cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); } - /* Otherwise, we simply parse the statement directly. */ - else - cp_parser_statement (parser, false); } /* Declarations [gram.dcl.dcl] */ @@ -11618,7 +11610,7 @@ cp_parser_parameter_declaration (cp_parser *parser, static void cp_parser_function_body (cp_parser *parser) { - cp_parser_compound_statement (parser, false); + cp_parser_compound_statement (parser, NULL, false); } /* Parse a ctor-initializer-opt followed by a function-body. Return @@ -13265,7 +13257,7 @@ cp_parser_try_block (cp_parser* parser) cp_parser_require_keyword (parser, RID_TRY, "`try'"); try_block = begin_try_block (); - cp_parser_compound_statement (parser, false); + cp_parser_compound_statement (parser, NULL, true); finish_try_block (try_block); cp_parser_handler_seq (parser); finish_handler_sequence (try_block); @@ -13341,7 +13333,7 @@ cp_parser_handler (cp_parser* parser) declaration = cp_parser_exception_declaration (parser); finish_handler_parms (declaration, handler); cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - cp_parser_compound_statement (parser, false); + cp_parser_compound_statement (parser, NULL, false); finish_handler (handler); } -- cgit v1.1