diff options
36 files changed, 1633 insertions, 141 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d7b85b7..83c65d1 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,14 @@ +2006-12-13 Ian Lance Taylor <iant@google.com> + + PR c++/19564 + PR c++/19756 + * c-typeck.c (parser_build_binary_op): Move parentheses warnings + to warn_about_parentheses in c-common.c. + * c-common.c (warn_about_parentheses): New function. + * c-common.h (warn_about_parentheses): Declare. + * doc/invoke.texi (Warning Options): Update -Wparentheses + description. + 2006-12-13 Zdenek Dvorak <dvorakz@suse.cz> * tree-ssa-loop-ivopts.c: Include tree-affine.h. diff --git a/gcc/c-common.c b/gcc/c-common.c index d2c39bd..4771a53 100644 --- a/gcc/c-common.c +++ b/gcc/c-common.c @@ -6606,5 +6606,87 @@ warn_array_subscript_with_type_char (tree index) warning (OPT_Wchar_subscripts, "array subscript has type %<char%>"); } +/* Implement -Wparentheses for the unexpected C precedence rules, to + cover cases like x + y << z which readers are likely to + misinterpret. We have seen an expression in which CODE is a binary + operator used to combine expressions headed by CODE_LEFT and + CODE_RIGHT. CODE_LEFT and CODE_RIGHT may be ERROR_MARK, which + means that that side of the expression was not formed using a + binary operator, or it was enclosed in parentheses. */ + +void +warn_about_parentheses (enum tree_code code, enum tree_code code_left, + enum tree_code code_right) +{ + if (!warn_parentheses) + return; + + if (code == LSHIFT_EXPR || code == RSHIFT_EXPR) + { + if (code_left == PLUS_EXPR || code_left == MINUS_EXPR + || code_right == PLUS_EXPR || code_right == MINUS_EXPR) + warning (OPT_Wparentheses, + "suggest parentheses around + or - inside shift"); + } + + if (code == TRUTH_ORIF_EXPR) + { + if (code_left == TRUTH_ANDIF_EXPR + || code_right == TRUTH_ANDIF_EXPR) + warning (OPT_Wparentheses, + "suggest parentheses around && within ||"); + } + + if (code == BIT_IOR_EXPR) + { + if (code_left == BIT_AND_EXPR || code_left == BIT_XOR_EXPR + || code_left == PLUS_EXPR || code_left == MINUS_EXPR + || code_right == BIT_AND_EXPR || code_right == BIT_XOR_EXPR + || code_right == PLUS_EXPR || code_right == MINUS_EXPR) + warning (OPT_Wparentheses, + "suggest parentheses around arithmetic in operand of |"); + /* Check cases like x|y==z */ + if (TREE_CODE_CLASS (code_left) == tcc_comparison + || TREE_CODE_CLASS (code_right) == tcc_comparison) + warning (OPT_Wparentheses, + "suggest parentheses around comparison in operand of |"); + } + + if (code == BIT_XOR_EXPR) + { + if (code_left == BIT_AND_EXPR + || code_left == PLUS_EXPR || code_left == MINUS_EXPR + || code_right == BIT_AND_EXPR + || code_right == PLUS_EXPR || code_right == MINUS_EXPR) + warning (OPT_Wparentheses, + "suggest parentheses around arithmetic in operand of ^"); + /* Check cases like x^y==z */ + if (TREE_CODE_CLASS (code_left) == tcc_comparison + || TREE_CODE_CLASS (code_right) == tcc_comparison) + warning (OPT_Wparentheses, + "suggest parentheses around comparison in operand of ^"); + } + + if (code == BIT_AND_EXPR) + { + if (code_left == PLUS_EXPR || code_left == MINUS_EXPR + || code_right == PLUS_EXPR || code_right == MINUS_EXPR) + warning (OPT_Wparentheses, + "suggest parentheses around + or - in operand of &"); + /* Check cases like x&y==z */ + if (TREE_CODE_CLASS (code_left) == tcc_comparison + || TREE_CODE_CLASS (code_right) == tcc_comparison) + warning (OPT_Wparentheses, + "suggest parentheses around comparison in operand of &"); + } + + /* Similarly, check for cases like 1<=i<=10 that are probably errors. */ + if (TREE_CODE_CLASS (code) == tcc_comparison + && (TREE_CODE_CLASS (code_left) == tcc_comparison + || TREE_CODE_CLASS (code_right) == tcc_comparison)) + warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not " + "have their mathematical meaning"); +} + #include "gt-c-common.h" diff --git a/gcc/c-common.h b/gcc/c-common.h index 03cf400..b2b10bd 100644 --- a/gcc/c-common.h +++ b/gcc/c-common.h @@ -859,6 +859,9 @@ extern int complete_array_type (tree *, tree, bool); extern tree builtin_type_for_size (int, bool); extern void warn_array_subscript_with_type_char (tree); +extern void warn_about_parentheses (enum tree_code, enum tree_code, + enum tree_code); + /* In c-gimplify.c */ extern void c_genericize (tree); diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c index ec14533..08f7d4a 100644 --- a/gcc/c-typeck.c +++ b/gcc/c-typeck.c @@ -2629,73 +2629,7 @@ parser_build_binary_op (enum tree_code code, struct c_expr arg1, /* Check for cases such as x+y<<z which users are likely to misinterpret. */ if (warn_parentheses) - { - if (code == LSHIFT_EXPR || code == RSHIFT_EXPR) - { - if (code1 == PLUS_EXPR || code1 == MINUS_EXPR - || code2 == PLUS_EXPR || code2 == MINUS_EXPR) - warning (OPT_Wparentheses, - "suggest parentheses around + or - inside shift"); - } - - if (code == TRUTH_ORIF_EXPR) - { - if (code1 == TRUTH_ANDIF_EXPR - || code2 == TRUTH_ANDIF_EXPR) - warning (OPT_Wparentheses, - "suggest parentheses around && within ||"); - } - - if (code == BIT_IOR_EXPR) - { - if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR - || code1 == PLUS_EXPR || code1 == MINUS_EXPR - || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR - || code2 == PLUS_EXPR || code2 == MINUS_EXPR) - warning (OPT_Wparentheses, - "suggest parentheses around arithmetic in operand of |"); - /* Check cases like x|y==z */ - if (TREE_CODE_CLASS (code1) == tcc_comparison - || TREE_CODE_CLASS (code2) == tcc_comparison) - warning (OPT_Wparentheses, - "suggest parentheses around comparison in operand of |"); - } - - if (code == BIT_XOR_EXPR) - { - if (code1 == BIT_AND_EXPR - || code1 == PLUS_EXPR || code1 == MINUS_EXPR - || code2 == BIT_AND_EXPR - || code2 == PLUS_EXPR || code2 == MINUS_EXPR) - warning (OPT_Wparentheses, - "suggest parentheses around arithmetic in operand of ^"); - /* Check cases like x^y==z */ - if (TREE_CODE_CLASS (code1) == tcc_comparison - || TREE_CODE_CLASS (code2) == tcc_comparison) - warning (OPT_Wparentheses, - "suggest parentheses around comparison in operand of ^"); - } - - if (code == BIT_AND_EXPR) - { - if (code1 == PLUS_EXPR || code1 == MINUS_EXPR - || code2 == PLUS_EXPR || code2 == MINUS_EXPR) - warning (OPT_Wparentheses, - "suggest parentheses around + or - in operand of &"); - /* Check cases like x&y==z */ - if (TREE_CODE_CLASS (code1) == tcc_comparison - || TREE_CODE_CLASS (code2) == tcc_comparison) - warning (OPT_Wparentheses, - "suggest parentheses around comparison in operand of &"); - } - /* Similarly, check for cases like 1<=i<=10 that are probably errors. */ - if (TREE_CODE_CLASS (code) == tcc_comparison - && (TREE_CODE_CLASS (code1) == tcc_comparison - || TREE_CODE_CLASS (code2) == tcc_comparison)) - warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not " - "have their mathematical meaning"); - - } + warn_about_parentheses (code, code1, code2); /* Warn about comparisons against string literals, with the exception of testing for equality or inequality of a string literal with NULL. */ diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index e6cdbcb..5f8b607 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,19 @@ +2006-12-13 Ian Lance Taylor <iant@google.com> + + PR c++/19564 + PR c++/19756 + * parser.c (cp_parser_expression_stack_entry): Add field + lhs_type. + (cp_parser_binary_expression): Track tree code of left hand side + of expression. Use it when calling build_x_binary_op. + (cp_parser_selection_statement): Add if_p parameter. Change all + callers. Warn about ambiguous else. + (cp_parser_statement): Add if_p parameter. Change all callers. + (cp_parser_implicitly_scoped_statement): Likewise. + * typeck.c (build_x_binary_op): Add parameters arg1_code and + arg2_code. Change all callers. Call warn_about_parentheses. + * cp-tree.h (build_x_binary_op): Update declaration. + 2006-12-12 Manuel Lopez-Ibanez <manu@gcc.gnu.org> * decl.c (build_enumerator): Update error message to match C diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index e59586b..3f63b8f 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -4458,8 +4458,9 @@ extern tree build_x_indirect_ref (tree, const char *); extern tree build_indirect_ref (tree, const char *); extern tree build_array_ref (tree, tree); extern tree get_member_function_from_ptrfunc (tree *, tree); -extern tree build_x_binary_op (enum tree_code, tree, tree, - bool *); +extern tree build_x_binary_op (enum tree_code, tree, + enum tree_code, tree, + enum tree_code, bool *); extern tree build_x_unary_op (enum tree_code, tree); extern tree unary_complex_lvalue (enum tree_code, tree); extern tree build_x_conditional_expr (tree, tree, tree); diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 98bc2e0..0521136 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -1158,8 +1158,15 @@ typedef enum cp_parser_status_kind typedef struct cp_parser_expression_stack_entry { + /* Left hand side of the binary operation we are currently + parsing. */ tree lhs; + /* Original tree code for left hand side, if it was a binary + expression itself (used for -Wparentheses). */ + enum tree_code lhs_type; + /* Tree code for the binary operation we are parsing. */ enum tree_code tree_type; + /* Precedence of the binary operation we are parsing. */ int prec; } cp_parser_expression_stack_entry; @@ -1517,7 +1524,7 @@ static tree cp_parser_builtin_offsetof /* Statements [gram.stmt.stmt] */ static void cp_parser_statement - (cp_parser *, tree, bool); + (cp_parser *, tree, bool, bool *); static void cp_parser_label_for_labeled_statement (cp_parser *); static tree cp_parser_expression_statement @@ -1527,7 +1534,7 @@ static tree cp_parser_compound_statement static void cp_parser_statement_seq_opt (cp_parser *, tree); static tree cp_parser_selection_statement - (cp_parser *); + (cp_parser *, bool *); static tree cp_parser_condition (cp_parser *); static tree cp_parser_iteration_statement @@ -1540,7 +1547,7 @@ static void cp_parser_declaration_statement (cp_parser *); static tree cp_parser_implicitly_scoped_statement - (cp_parser *); + (cp_parser *, bool *); static void cp_parser_already_scoped_statement (cp_parser *); @@ -5685,12 +5692,13 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p) cp_parser_expression_stack_entry *sp = &stack[0]; tree lhs, rhs; cp_token *token; - enum tree_code tree_type; + enum tree_code tree_type, lhs_type, rhs_type; enum cp_parser_prec prec = PREC_NOT_OPERATOR, new_prec, lookahead_prec; bool overloaded_p; /* Parse the first expression. */ lhs = cp_parser_cast_expression (parser, /*address_p=*/false, cast_p); + lhs_type = ERROR_MARK; for (;;) { @@ -5723,6 +5731,7 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p) /* Extract another operand. It may be the RHS of this expression or the LHS of a new, higher priority expression. */ rhs = cp_parser_simple_cast_expression (parser); + rhs_type = ERROR_MARK; /* Get another operator token. Look up its precedence to avoid building a useless (immediately popped) stack entry for common @@ -5738,8 +5747,10 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p) sp->prec = prec; sp->tree_type = tree_type; sp->lhs = lhs; + sp->lhs_type = lhs_type; sp++; lhs = rhs; + lhs_type = rhs_type; prec = new_prec; new_prec = lookahead_prec; goto get_rhs; @@ -5756,11 +5767,15 @@ cp_parser_binary_expression (cp_parser* parser, bool cast_p) prec = sp->prec; tree_type = sp->tree_type; rhs = lhs; + rhs_type = lhs_type; lhs = sp->lhs; + lhs_type = sp->lhs_type; } overloaded_p = false; - lhs = build_x_binary_op (tree_type, lhs, rhs, &overloaded_p); + lhs = build_x_binary_op (tree_type, lhs, lhs_type, rhs, rhs_type, + &overloaded_p); + lhs_type = tree_type; /* If the binary operator required the use of an overloaded operator, then this expression cannot be an integral constant-expression. @@ -6177,17 +6192,23 @@ cp_parser_builtin_offsetof (cp_parser *parser) try-block IN_COMPOUND is true when the statement is nested inside a - cp_parser_compound_statement; this matters for certain pragmas. */ + cp_parser_compound_statement; this matters for certain pragmas. + + If IF_P is not NULL, *IF_P is set to indicate whether the statement + is a (possibly labeled) if statement which is not enclosed in braces + and has an else clause. This is used to implement -Wparentheses. */ static void cp_parser_statement (cp_parser* parser, tree in_statement_expr, - bool in_compound) + bool in_compound, bool *if_p) { tree statement; cp_token *token; location_t statement_location; restart: + if (if_p != NULL) + *if_p = false; /* There is no statement yet. */ statement = NULL_TREE; /* Peek at the next token. */ @@ -6212,7 +6233,7 @@ cp_parser_statement (cp_parser* parser, tree in_statement_expr, case RID_IF: case RID_SWITCH: - statement = cp_parser_selection_statement (parser); + statement = cp_parser_selection_statement (parser, if_p); break; case RID_WHILE: @@ -6477,7 +6498,7 @@ cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr) break; /* Parse the statement. */ - cp_parser_statement (parser, in_statement_expr, true); + cp_parser_statement (parser, in_statement_expr, true, NULL); } } @@ -6488,14 +6509,22 @@ cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr) if ( condition ) statement else statement switch ( condition ) statement - Returns the new IF_STMT or SWITCH_STMT. */ + Returns the new IF_STMT or SWITCH_STMT. + + If IF_P is not NULL, *IF_P is set to indicate whether the statement + is a (possibly labeled) if statement which is not enclosed in + braces and has an else clause. This is used to implement + -Wparentheses. */ static tree -cp_parser_selection_statement (cp_parser* parser) +cp_parser_selection_statement (cp_parser* parser, bool *if_p) { cp_token *token; enum rid keyword; + if (if_p != NULL) + *if_p = false; + /* Peek at the next token. */ token = cp_parser_require (parser, CPP_KEYWORD, "selection-statement"); @@ -6531,11 +6560,13 @@ cp_parser_selection_statement (cp_parser* parser) if (keyword == RID_IF) { + bool nested_if; + /* Add the condition. */ finish_if_stmt_cond (condition, statement); /* Parse the then-clause. */ - cp_parser_implicitly_scoped_statement (parser); + cp_parser_implicitly_scoped_statement (parser, &nested_if); finish_then_clause (statement); /* If the next token is `else', parse the else-clause. */ @@ -6546,8 +6577,28 @@ cp_parser_selection_statement (cp_parser* parser) cp_lexer_consume_token (parser->lexer); begin_else_clause (statement); /* Parse the else-clause. */ - cp_parser_implicitly_scoped_statement (parser); + cp_parser_implicitly_scoped_statement (parser, NULL); finish_else_clause (statement); + + /* If we are currently parsing a then-clause, then + IF_P will not be NULL. We set it to true to + indicate that this if statement has an else clause. + This may trigger the Wparentheses warning below + when we get back up to the parent if statement. */ + if (if_p != NULL) + *if_p = true; + } + else + { + /* This if statement does not have an else clause. If + NESTED_IF is true, then the then-clause is an if + statement which does have an else clause. We warn + about the potential ambiguity. */ + if (nested_if) + warning (OPT_Wparentheses, + ("%Hsuggest explicit braces " + "to avoid ambiguous %<else%>"), + EXPR_LOCUS (statement)); } /* Now we're all done with the if-statement. */ @@ -6566,7 +6617,7 @@ cp_parser_selection_statement (cp_parser* parser) in_statement = parser->in_statement; parser->in_switch_statement_p = true; parser->in_statement |= IN_SWITCH_STMT; - cp_parser_implicitly_scoped_statement (parser); + cp_parser_implicitly_scoped_statement (parser, NULL); parser->in_switch_statement_p = in_switch_statement_p; parser->in_statement = in_statement; @@ -6744,7 +6795,7 @@ cp_parser_iteration_statement (cp_parser* parser) statement = begin_do_stmt (); /* Parse the body of the do-statement. */ parser->in_statement = IN_ITERATION_STMT; - cp_parser_implicitly_scoped_statement (parser); + cp_parser_implicitly_scoped_statement (parser, NULL); parser->in_statement = in_statement; finish_do_body (statement); /* Look for the `while' keyword. */ @@ -6986,13 +7037,21 @@ cp_parser_declaration_statement (cp_parser* parser) but ensures that is in its own scope, even if it is not a compound-statement. + If IF_P is not NULL, *IF_P is set to indicate whether the statement + is a (possibly labeled) if statement which is not enclosed in + braces and has an else clause. This is used to implement + -Wparentheses. + Returns the new statement. */ static tree -cp_parser_implicitly_scoped_statement (cp_parser* parser) +cp_parser_implicitly_scoped_statement (cp_parser* parser, bool *if_p) { tree statement; + if (if_p != NULL) + *if_p = false; + /* Mark if () ; with a special NOP_EXPR. */ if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) { @@ -7008,7 +7067,7 @@ cp_parser_implicitly_scoped_statement (cp_parser* parser) /* Create a compound-statement. */ statement = begin_compound_stmt (0); /* Parse the dependent-statement. */ - cp_parser_statement (parser, NULL_TREE, false); + cp_parser_statement (parser, NULL_TREE, false, if_p); /* Finish the dummy compound-statement. */ finish_compound_stmt (statement); } @@ -7027,7 +7086,7 @@ cp_parser_already_scoped_statement (cp_parser* parser) { /* 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, NULL_TREE, false); + cp_parser_statement (parser, NULL_TREE, false, NULL); else { /* Avoid calling cp_parser_compound_statement, so that we @@ -18654,7 +18713,7 @@ cp_parser_omp_structured_block (cp_parser *parser) tree stmt = begin_omp_structured_block (); unsigned int save = cp_parser_begin_omp_structured_block (parser); - cp_parser_statement (parser, NULL_TREE, false); + cp_parser_statement (parser, NULL_TREE, false, NULL); cp_parser_end_omp_structured_block (parser, save); return finish_omp_structured_block (stmt); @@ -18899,7 +18958,7 @@ cp_parser_omp_for_loop (cp_parser *parser) /* Note that the grammar doesn't call for a structured block here, though the loop as a whole is a structured block. */ body = push_stmt_list (); - cp_parser_statement (parser, NULL_TREE, false); + cp_parser_statement (parser, NULL_TREE, false, NULL); body = pop_stmt_list (body); return finish_omp_for (loc, decl, init, cond, incr, body, pre_body); @@ -18992,7 +19051,7 @@ cp_parser_omp_sections_scope (cp_parser *parser) while (1) { - cp_parser_statement (parser, NULL_TREE, false); + cp_parser_statement (parser, NULL_TREE, false, NULL); tok = cp_lexer_peek_token (parser->lexer); if (tok->pragma_kind == PRAGMA_OMP_SECTION) diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 2cfcce5..f9a728f 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -9105,7 +9105,13 @@ tsubst_copy_and_build (tree t, return build_x_binary_op (TREE_CODE (t), RECUR (TREE_OPERAND (t, 0)), + (TREE_NO_WARNING (TREE_OPERAND (t, 0)) + ? ERROR_MARK + : TREE_CODE (TREE_OPERAND (t, 0))), RECUR (TREE_OPERAND (t, 1)), + (TREE_NO_WARNING (TREE_OPERAND (t, 1)) + ? ERROR_MARK + : TREE_CODE (TREE_OPERAND (t, 1))), /*overloaded_p=*/NULL); case SCOPE_REF: @@ -9114,7 +9120,14 @@ tsubst_copy_and_build (tree t, case ARRAY_REF: op1 = tsubst_non_call_postfix_expression (TREE_OPERAND (t, 0), args, complain, in_decl); - return build_x_binary_op (ARRAY_REF, op1, RECUR (TREE_OPERAND (t, 1)), + return build_x_binary_op (ARRAY_REF, op1, + (TREE_NO_WARNING (TREE_OPERAND (t, 0)) + ? ERROR_MARK + : TREE_CODE (TREE_OPERAND (t, 0))), + RECUR (TREE_OPERAND (t, 1)), + (TREE_NO_WARNING (TREE_OPERAND (t, 1)) + ? ERROR_MARK + : TREE_CODE (TREE_OPERAND (t, 1))), /*overloaded_p=*/NULL); case SIZEOF_EXPR: diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 1acd1ff..cb09d4c 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -1648,17 +1648,20 @@ rationalize_conditional_expr (enum tree_code code, tree t) are equal, so we know what conditional expression this used to be. */ if (TREE_CODE (t) == MIN_EXPR || TREE_CODE (t) == MAX_EXPR) { + tree op0 = TREE_OPERAND (t, 0); + tree op1 = TREE_OPERAND (t, 1); + /* The following code is incorrect if either operand side-effects. */ - gcc_assert (!TREE_SIDE_EFFECTS (TREE_OPERAND (t, 0)) - && !TREE_SIDE_EFFECTS (TREE_OPERAND (t, 1))); + gcc_assert (!TREE_SIDE_EFFECTS (op0) + && !TREE_SIDE_EFFECTS (op1)); return build_conditional_expr (build_x_binary_op ((TREE_CODE (t) == MIN_EXPR ? LE_EXPR : GE_EXPR), - TREE_OPERAND (t, 0), - TREE_OPERAND (t, 1), + op0, TREE_CODE (op0), + op1, TREE_CODE (op1), /*overloaded_p=*/NULL), - build_unary_op (code, TREE_OPERAND (t, 0), 0), - build_unary_op (code, TREE_OPERAND (t, 1), 0)); + build_unary_op (code, op0, 0), + build_unary_op (code, op1, 0)); } return @@ -2865,11 +2868,19 @@ convert_arguments (tree typelist, tree values, tree fndecl, int flags) } /* Build a binary-operation expression, after performing default - conversions on the operands. CODE is the kind of expression to build. */ + conversions on the operands. CODE is the kind of expression to + build. ARG1 and ARG2 are the arguments. ARG1_CODE and ARG2_CODE + are the tree codes which correspond to ARG1 and ARG2 when issuing + warnings about possibly misplaced parentheses. They may differ + from the TREE_CODE of ARG1 and ARG2 if the parser has done constant + folding (e.g., if the parser sees "a | 1 + 1", it may call this + routine with ARG2 being an INTEGER_CST and ARG2_CODE == PLUS_EXPR). + To avoid issuing any parentheses warnings, pass ARG1_CODE and/or + ARG2_CODE as ERROR_MARK. */ tree -build_x_binary_op (enum tree_code code, tree arg1, tree arg2, - bool *overloaded_p) +build_x_binary_op (enum tree_code code, tree arg1, enum tree_code arg1_code, + tree arg2, enum tree_code arg2_code, bool *overloaded_p) { tree orig_arg1; tree orig_arg2; @@ -2893,6 +2904,17 @@ build_x_binary_op (enum tree_code code, tree arg1, tree arg2, expr = build_new_op (code, LOOKUP_NORMAL, arg1, arg2, NULL_TREE, overloaded_p); + /* Check for cases such as x+y<<z which users are likely to + misinterpret. But don't warn about obj << x + y, since that is a + common idiom for I/O. */ + if (warn_parentheses + && !processing_template_decl + && !error_operand_p (arg1) + && !error_operand_p (arg2) + && (code != LSHIFT_EXPR + || !CLASS_TYPE_P (TREE_TYPE (arg1)))) + warn_about_parentheses (code, arg1_code, arg2_code); + if (processing_template_decl && expr != error_mark_node) return build_min_non_dep (code, expr, orig_arg1, orig_arg2); diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 2d28e85..4a803b3 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -2531,9 +2531,7 @@ Warn if a user-supplied include directory does not exist. Warn if parentheses are omitted in certain contexts, such as when there is an assignment in a context where a truth value is expected, or when operators are nested whose precedence people -often get confused about. Only the warning for an assignment used as -a truth value is supported when compiling C++; the other warnings are -only supported when compiling C@. +often get confused about. Also warn if a comparison like @samp{x<=y<=z} appears; this is equivalent to @samp{(x<=y ? 1 : 0) <= z}, which is a different @@ -2555,14 +2553,15 @@ such a case: @end group @end smallexample -In C, every @code{else} branch belongs to the innermost possible @code{if} -statement, which in this example is @code{if (b)}. This is often not -what the programmer expected, as illustrated in the above example by -indentation the programmer chose. When there is the potential for this -confusion, GCC will issue a warning when this flag is specified. -To eliminate the warning, add explicit braces around the innermost -@code{if} statement so there is no way the @code{else} could belong to -the enclosing @code{if}. The resulting code would look like this: +In C/C++, every @code{else} branch belongs to the innermost possible +@code{if} statement, which in this example is @code{if (b)}. This is +often not what the programmer expected, as illustrated in the above +example by indentation the programmer chose. When there is the +potential for this confusion, GCC will issue a warning when this flag +is specified. To eliminate the warning, add explicit braces around +the innermost @code{if} statement so there is no way the @code{else} +could belong to the enclosing @code{if}. The resulting code would +look like this: @smallexample @group diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index bb665d3..3a23698 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,25 @@ +2006-12-13 Ian Lance Taylor <iant@google.com> + + PR c++/19564 + PR c++/19756 + * g++.dg/warn/Wparentheses-5.C: New test. + * g++.dg/warn/Wparentheses-6.C: New test. + * g++.dg/warn/Wparentheses-7.C: New test. + * g++.dg/warn/Wparentheses-8.C: New test. + * g++.dg/warn/Wparentheses-9.C: New test. + * g++.dg/warn/Wparentheses-10.C: New test. + * g++.dg/warn/Wparentheses-11.C: New test. + * g++.dg/warn/Wparentheses-12.C: New test. + * g++.dg/warn/Wparentheses-13.C: New test. + * g++.dg/warn/Wparentheses-14.C: New test. + * g++.dg/warn/Wparentheses-15.C: New test. + * g++.dg/warn/Wparentheses-16.C: New test. + * g++.dg/warn/Wparentheses-17.C: New test. + * g++.dg/warn/Wparentheses-18.C: New test. + * g++.dg/warn/Wparentheses-19.C: New test. + * g++.dg/warn/Wparentheses-20.C: New test. + * g++.dg/warn/Wparentheses-21.C: New test. + 2006-12-13 John David Anglin <dave.anglin@nrc-cnrc.gc.ca> PR testsuite/30157 diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-10.C b/gcc/testsuite/g++.dg/warn/Wparentheses-10.C new file mode 100644 index 0000000..c30df090 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-10.C @@ -0,0 +1,119 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// C++ version of gcc.dg/Wparentheses-7.c + +int foo (int); + +int +bar (int a, int b, int c) +{ + foo (a & b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) ^ c); + foo (a & (b ^ c)); + foo (1 & 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) ^ c); + foo (1 & (2 ^ c)); + foo (1 & 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) ^ 3); + foo (1 & (2 ^ 3)); + foo (a ^ b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) & c); + foo (a ^ (b & c)); + foo (1 ^ 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) & c); + foo (1 ^ (2 & c)); + foo (1 ^ 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) & 3); + foo (1 ^ (2 & 3)); + foo (a + b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) ^ c); + foo (a + (b ^ c)); + foo (1 + 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) ^ c); + foo (1 + (2 ^ c)); + foo (1 + 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) ^ 3); + foo (1 + (2 ^ 3)); + foo (a ^ b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) + c); + foo (a ^ (b + c)); + foo (1 ^ 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) + c); + foo (1 ^ (2 + c)); + foo (1 ^ 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) + 3); + foo (1 ^ (2 + 3)); + foo (a - b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) ^ c); + foo (a - (b ^ c)); + foo (1 - 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) ^ c); + foo (1 - (2 ^ c)); + foo (1 - 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) ^ 3); + foo (1 - (2 ^ 3)); + foo (a ^ b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) - c); + foo (a ^ (b - c)); + foo (1 ^ 2 - c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) - c); + foo (1 ^ (2 - c)); + foo (1 ^ 2 - 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) - 3); + foo (1 ^ (2 - 3)); + foo (a >= b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a >= b) ^ c); + foo (a >= (b ^ c)); + foo (1 >= 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 >= 2) ^ c); + foo (1 >= (2 ^ c)); + foo (1 >= 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 >= 2) ^ 3); + foo (1 >= (2 ^ 3)); + foo (a ^ b >= c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) >= c); + foo (a ^ (b >= c)); + foo (1 ^ 2 >= c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) >= c); + foo (1 ^ (2 >= c)); + foo (1 ^ 2 >= 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) >= 3); + foo (1 ^ (2 >= 3)); + foo (a == b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a == b) ^ c); + foo (a == (b ^ c)); + foo (1 == 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) ^ c); + foo (1 == (2 ^ c)); + foo (1 == 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) ^ 3); + foo (1 == (2 ^ 3)); + foo (a ^ b == c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) == c); + foo (a ^ (b == c)); + foo (1 ^ 2 == c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) == c); + foo (1 ^ (2 == c)); + foo (1 ^ 2 == 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) == 3); + foo (1 ^ (2 == 3)); + foo (a < b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a < b) ^ c); + foo (a < (b ^ c)); + foo (1 < 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) ^ c); + foo (1 < (2 ^ c)); + foo (1 < 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) ^ 3); + foo (1 < (2 ^ 3)); + foo (a ^ b < c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) < c); + foo (a ^ (b < c)); + foo (1 ^ 2 < c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) < c); + foo (1 ^ (2 < c)); + foo (1 ^ 2 < 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) < 3); + foo (1 ^ (2 < 3)); +} diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-11.C b/gcc/testsuite/g++.dg/warn/Wparentheses-11.C new file mode 100644 index 0000000..912c3b7 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-11.C @@ -0,0 +1,101 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// C++ version of gcc.dg/Wparentheses-8.c + +int foo (int); + +int +bar (int a, int b, int c) +{ + foo (a + b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) & c); + foo (a + (b & c)); + foo (1 + 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) & c); + foo (1 + (2 & c)); + foo (1 + 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) & 3); + foo (1 + (2 & 3)); + foo (a & b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) + c); + foo (a & (b + c)); + foo (1 & 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) + c); + foo (1 & (2 + c)); + foo (1 & 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) + 3); + foo (1 & (2 + 3)); + foo (a - b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) & c); + foo (a - (b & c)); + foo (1 - 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) & c); + foo (1 - (2 & c)); + foo (1 - 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) & 3); + foo (1 - (2 & 3)); + foo (a & b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) - c); + foo (a & (b - c)); + foo (1 & 2 - c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) - c); + foo (1 & (2 - c)); + foo (1 & 2 - 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) - 3); + foo (1 & (2 - 3)); + foo (a < b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a < b) & c); + foo (a < (b & c)); + foo (1 < 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) & c); + foo (1 < (2 & c)); + foo (1 < 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) & 3); + foo (1 < (2 & 3)); + foo (a & b < c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) < c); + foo (a & (b < c)); + foo (1 & 2 < c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) < c); + foo (1 & (2 < c)); + foo (1 & 2 < 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) < 3); + foo (1 & (2 < 3)); + foo (a == b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a == b) & c); + foo (a == (b & c)); + foo (1 == 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) & c); + foo (1 == (2 & c)); + foo (1 == 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) & 3); + foo (1 == (2 & 3)); + foo (a & b == c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) == c); + foo (a & (b == c)); + foo (1 & 2 == c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) == c); + foo (1 & (2 == c)); + foo (1 & 2 == 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) == 3); + foo (1 & (2 == 3)); + foo (a != b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a != b) & c); + foo (a != (b & c)); + foo (1 != 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 != 2) & c); + foo (1 != (2 & c)); + foo (1 != 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 != 2) & 3); + foo (1 != (2 & 3)); + foo (a & b != c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) != c); + foo (a & (b != c)); + foo (1 & 2 != c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) != c); + foo (1 & (2 != c)); + foo (1 & 2 != 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) != 3); + foo (1 & (2 != 3)); +} diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-12.C b/gcc/testsuite/g++.dg/warn/Wparentheses-12.C new file mode 100644 index 0000000..b045298 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-12.C @@ -0,0 +1,60 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// C++ version of gcc.dg/Wparentheses-9.c + +int foo (int); + +int a, b, c; + +int +bar (void) +{ + if (a) + foo (0); + if (b) + foo (1); + else + foo (2); + if (c) // { dg-warning "ambiguous" "correct warning" } + if (a) + foo (3); + else + foo (4); + if (a) + if (c) + foo (5); + if (a) + if (b) // { dg-warning "ambiguous" "correct warning" } + if (c) + foo (6); + else + foo (7); + if (a) // { dg-warning "ambiguous" "correct warning" } + if (b) + if (c) + foo (8); + else + foo (9); + else + foo (10); + if (a) + if (b) + if (c) + foo (11); + else + foo (12); + else + foo (13); + else + foo (14); + if (a) { + if (b) + if (c) + foo (15); + else + foo (16); + else + foo (17); + } +} diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-13.C b/gcc/testsuite/g++.dg/warn/Wparentheses-13.C new file mode 100644 index 0000000..22525cd --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-13.C @@ -0,0 +1,69 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-1.C. + +int foo (int); + +int a, b, c; +bool d; + +template<class T> +void +bar (T) +{ + if (a = b) // { dg-warning "assignment" "correct warning" } + foo (0); + if ((a = b)) + foo (1); + if (a = a) // { dg-warning "assignment" "correct warning" } + foo (2); + if ((a = a)) + foo (3); + if (b = c) // { dg-warning "assignment" "correct warning" } + foo (4); + else + foo (5); + if ((b = c)) + foo (6); + else + foo (7); + if (b = b) // { dg-warning "assignment" "correct warning" } + foo (8); + else + foo (9); + if ((b = b)) + foo (10); + else + foo (11); + while (c = b) // { dg-warning "assignment" "correct warning" } + foo (12); + while ((c = b)) + foo (13); + while (c = c) // { dg-warning "assignment" "correct warning" } + foo (14); + while ((c = c)) + foo (15); + do foo (16); while (a = b); // { dg-warning "assignment" "correct warning" } + do foo (17); while ((a = b)); + do foo (18); while (a = a); // { dg-warning "assignment" "correct warning" } + do foo (19); while ((a = a)); + for (;c = b;) // { dg-warning "assignment" "correct warning" } + foo (20); + for (;(c = b);) + foo (21); + for (;c = c;) // { dg-warning "assignment" "correct warning" } + foo (22); + for (;(c = c);) + foo (23); + d = a = b; // { dg-warning "assignment" "correct warning" } + foo (24); + d = (a = b); + foo (25); + d = a = a; // { dg-warning "assignment" "correct warning" } + foo (26); + d = (a = a); + foo (27); +} + +template void bar<int> (int); // { dg-warning "instantiated" } diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-14.C b/gcc/testsuite/g++.dg/warn/Wparentheses-14.C new file mode 100644 index 0000000..67bd43e --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-14.C @@ -0,0 +1,43 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-2.C. + +int foo (int); + +int a, b, c; +bool d; + +template<class T> +void +bar (T) +{ + if (a += b) + foo (0); + if (a -= a) + foo (1); + if (b *= c) + foo (2); + else + foo (3); + if (b /= b) + foo (4); + else + foo (5); + while (c %= b) + foo (6); + while (c <<= c) + foo (7); + do foo (8); while (a >>= b); + do foo (9); while (a &= a); + for (;c ^= b;) + foo (10); + for (;c |= c;) + foo (11); + d = a += b; + foo (12); + d = a -= a; + foo (13); +} + +template void bar<int> (int); diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-15.C b/gcc/testsuite/g++.dg/warn/Wparentheses-15.C new file mode 100644 index 0000000..ab156b7 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-15.C @@ -0,0 +1,68 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-6.C. + +int foo (int); + +template<class T> +void +bar (T a, T b, T c) +{ + foo (a <= b <= c); // { dg-warning "comparison" "correct warning" } + foo ((a <= b) <= c); + foo (a <= (b <= c)); + foo (1 <= 2 <= c); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) <= c); + foo (1 <= (2 <= c)); + foo (1 <= 2 <= 3); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) <= 3); + foo (1 <= (2 <= 3)); + foo (a > b > c); // { dg-warning "comparison" "correct warning" } + foo ((a > b) > c); + foo (a > (b > c)); + foo (1 > 2 > c); // { dg-warning "comparison" "correct warning" } + foo ((1 > 2) > c); + foo (1 > (2 > c)); + foo (1 > 2 > 3); // { dg-warning "comparison" "correct warning" } + foo ((1 > 2) > 3); + foo (1 > (2 > 3)); + foo (a < b <= c); // { dg-warning "comparison" "correct warning" } + foo ((a < b) <= c); + foo (a < (b <= c)); + foo (1 < 2 <= c); // { dg-warning "comparison" "correct warning" } + foo ((1 < 2) <= c); + foo (1 < (2 <= c)); + foo (1 < 2 <= 3); // { dg-warning "comparison" "correct warning" } + foo ((1 < 2) <= 3); + foo (1 < (2 <= 3)); + foo (a <= b > c); // { dg-warning "comparison" "correct warning" } + foo ((a <= b) > c); + foo (a <= (b > c)); + foo (1 <= 2 > c); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) > c); + foo (1 <= (2 > c)); + foo (1 <= 2 > 3); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) > 3); + foo (1 <= (2 > 3)); + foo (a <= b == c); // { dg-warning "comparison" "correct warning" } + foo ((a <= b) == c); + foo (a <= (b == c)); + foo (1 <= 2 == c); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) == c); + foo (1 <= (2 == c)); + foo (1 <= 2 == 3); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) == 3); + foo (1 <= (2 == 3)); + foo (a != b != c); // { dg-warning "comparison" "correct warning" } + foo ((a != b) != c); + foo (a != (b != c)); + foo (1 != 2 != c); // { dg-warning "comparison" "correct warning" } + foo ((1 != 2) != c); + foo (1 != (2 != c)); + foo (1 != 2 != 3); // { dg-warning "comparison" "correct warning" } + foo ((1 != 2) != 3); + foo (1 != (2 != 3)); +} + +template void bar<int> (int, int, int); // { dg-warning "instantiated" } diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-16.C b/gcc/testsuite/g++.dg/warn/Wparentheses-16.C new file mode 100644 index 0000000..d8151ae --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-16.C @@ -0,0 +1,86 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-7.C. + +int foo (int); + +template<class T> +void +bar (T a, T b, T c) +{ + foo (a + b << c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) << c); + foo (a + (b << c)); + foo (1 + 2 << c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) << c); + foo (1 + (2 << c)); + foo (1 + 2 << 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) << 3); + foo (1 + (2 << 3)); + foo (a << b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a << b) + c); + foo (a << (b + c)); + foo (1 << 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 << 2) + c); + foo (1 << (2 + c)); + foo (1 << 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 << 2) + 3); + foo (1 << (2 + 3)); + foo (a + b >> c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) >> c); + foo (a + (b >> c)); + foo (1 + 2 >> c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) >> c); + foo (1 + (2 >> c)); + foo (1 + 2 >> 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) >> 3); + foo (1 + (2 >> 3)); + foo (a >> b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a >> b) + c); + foo (a >> (b + c)); + foo (1 >> 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 >> 2) + c); + foo (1 >> (2 + c)); + foo (1 >> 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 >> 2) + 3); + foo (1 >> (2 + 3)); + foo (a - b << c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) << c); + foo (a - (b << c)); + foo (6 - 5 << c); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) << c); + foo (6 - (5 << c)); + foo (6 - 5 << 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) << 4); + foo (6 - (5 << 4)); + foo (a << b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a << b) - c); + foo (a << (b - c)); + foo (6 << 5 - c); // { dg-warning "parentheses" "correct warning" } + foo ((6 << 5) - c); + foo (6 << (5 - c)); + foo (6 << 5 - 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 << 5) - 4); + foo (6 << (5 - 4)); + foo (a - b >> c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) >> c); + foo (a - (b >> c)); + foo (6 - 5 >> c); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) >> c); + foo (6 - (5 >> c)); + foo (6 - 5 >> 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) >> 4); + foo (6 - (5 >> 4)); + foo (a >> b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a >> b) - c); + foo (a >> (b - c)); + foo (6 >> 5 - c); // { dg-warning "parentheses" "correct warning" } + foo ((6 >> 5) - c); + foo (6 >> (5 - c)); + foo (6 >> 5 - 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 >> 5) - 4); + foo (6 >> (5 - 4)); +} + +template void bar<int> (int, int, int); // { dg-warning "instantiated" } diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-17.C b/gcc/testsuite/g++.dg/warn/Wparentheses-17.C new file mode 100644 index 0000000..def181a --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-17.C @@ -0,0 +1,32 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-8.C. + +int foo (int); + +template<class T> +void +bar (T a, T b, T c) +{ + foo (a && b || c); // { dg-warning "parentheses" "correct warning" } + foo ((a && b) || c); + foo (a && (b || c)); + foo (1 && 2 || c); // { dg-warning "parentheses" "correct warning" } + foo ((1 && 2) || c); + foo (1 && (2 || c)); + foo (1 && 2 || 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 && 2) || 3); + foo (1 && (2 || 3)); + foo (a || b && c); // { dg-warning "parentheses" "correct warning" } + foo ((a || b) && c); + foo (a || (b && c)); + foo (1 || 2 && c); // { dg-warning "parentheses" "correct warning" } + foo ((1 || 2) && c); + foo (1 || (2 && c)); + foo (1 || 2 && 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 || 2) && 3); + foo (1 || (2 && 3)); +} + +template void bar<int> (int, int, int); // { dg-warning "instantiated" } diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-18.C b/gcc/testsuite/g++.dg/warn/Wparentheses-18.C new file mode 100644 index 0000000..32fa1fe --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-18.C @@ -0,0 +1,122 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-9.C. + +int foo (int); + +template<class T> +void +bar (T a, T b, T c) +{ + foo (a & b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) | c); + foo (a & (b | c)); + foo (1 & 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) | c); + foo (1 & (2 | c)); + foo (1 & 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) | 3); + foo (1 & (2 | 3)); + foo (a | b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) & c); + foo (a | (b & c)); + foo (1 | 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) & c); + foo (1 | (2 & c)); + foo (1 | 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) & 3); + foo (1 | (2 & 3)); + foo (a ^ b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) | c); + foo (a ^ (b | c)); + foo (1 ^ 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) | c); + foo (1 ^ (2 | c)); + foo (1 ^ 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) | 3); + foo (1 ^ (2 | 3)); + foo (a | b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) ^ c); + foo (a | (b ^ c)); + foo (1 | 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) ^ c); + foo (1 | (2 ^ c)); + foo (1 | 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) ^ 3); + foo (1 | (2 ^ 3)); + foo (a + b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) | c); + foo (a + (b | c)); + foo (1 + 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) | c); + foo (1 + (2 | c)); + foo (1 + 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) | 3); + foo (1 + (2 | 3)); + foo (a | b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) + c); + foo (a | (b + c)); + foo (1 | 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) + c); + foo (1 | (2 + c)); + foo (1 | 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) + 3); + foo (1 | (2 + 3)); + foo (a - b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) | c); + foo (a - (b | c)); + foo (1 - 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) | c); + foo (1 - (2 | c)); + foo (1 - 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) | 3); + foo (1 - (2 | 3)); + foo (a | b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) - c); + foo (a | (b - c)); + foo (1 | 2 - c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) - c); + foo (1 | (2 - c)); + foo (1 | 2 - 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) - 3); + foo (1 | (2 - 3)); + foo (a > b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a > b) | c); + foo (a > (b | c)); + foo (1 > 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 > 2) | c); + foo (1 > (2 | c)); + foo (1 > 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 > 2) | 3); + foo (1 > (2 | 3)); + foo (a | b > c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) > c); + foo (a | (b > c)); + foo (1 | 2 > c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) > c); + foo (1 | (2 > c)); + foo (1 | 2 > 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) > 3); + foo (1 | (2 > 3)); + foo (a <= b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a <= b) | c); + foo (a <= (b | c)); + foo (1 <= 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 <= 2) | c); + foo (1 <= (2 | c)); + foo (1 <= 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 <= 2) | 3); + foo (1 <= (2 | 3)); + foo (a | b <= c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) <= c); + foo (a | (b <= c)); + foo (1 | 2 <= c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) <= c); + foo (1 | (2 <= c)); + foo (1 | 2 <= 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) <= 3); + foo (1 | (2 <= 3)); +} + +template void bar<int> (int, int, int); // { dg-warning "instantiated" } diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-19.C b/gcc/testsuite/g++.dg/warn/Wparentheses-19.C new file mode 100644 index 0000000..c7e45cf --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-19.C @@ -0,0 +1,122 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-10.C. + +int foo (int); + +template<class T> +void +bar (T a, T b, T c) +{ + foo (a & b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) ^ c); + foo (a & (b ^ c)); + foo (1 & 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) ^ c); + foo (1 & (2 ^ c)); + foo (1 & 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) ^ 3); + foo (1 & (2 ^ 3)); + foo (a ^ b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) & c); + foo (a ^ (b & c)); + foo (1 ^ 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) & c); + foo (1 ^ (2 & c)); + foo (1 ^ 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) & 3); + foo (1 ^ (2 & 3)); + foo (a + b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) ^ c); + foo (a + (b ^ c)); + foo (1 + 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) ^ c); + foo (1 + (2 ^ c)); + foo (1 + 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) ^ 3); + foo (1 + (2 ^ 3)); + foo (a ^ b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) + c); + foo (a ^ (b + c)); + foo (1 ^ 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) + c); + foo (1 ^ (2 + c)); + foo (1 ^ 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) + 3); + foo (1 ^ (2 + 3)); + foo (a - b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) ^ c); + foo (a - (b ^ c)); + foo (1 - 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) ^ c); + foo (1 - (2 ^ c)); + foo (1 - 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) ^ 3); + foo (1 - (2 ^ 3)); + foo (a ^ b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) - c); + foo (a ^ (b - c)); + foo (1 ^ 2 - c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) - c); + foo (1 ^ (2 - c)); + foo (1 ^ 2 - 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) - 3); + foo (1 ^ (2 - 3)); + foo (a >= b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a >= b) ^ c); + foo (a >= (b ^ c)); + foo (1 >= 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 >= 2) ^ c); + foo (1 >= (2 ^ c)); + foo (1 >= 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 >= 2) ^ 3); + foo (1 >= (2 ^ 3)); + foo (a ^ b >= c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) >= c); + foo (a ^ (b >= c)); + foo (1 ^ 2 >= c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) >= c); + foo (1 ^ (2 >= c)); + foo (1 ^ 2 >= 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) >= 3); + foo (1 ^ (2 >= 3)); + foo (a == b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a == b) ^ c); + foo (a == (b ^ c)); + foo (1 == 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) ^ c); + foo (1 == (2 ^ c)); + foo (1 == 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) ^ 3); + foo (1 == (2 ^ 3)); + foo (a ^ b == c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) == c); + foo (a ^ (b == c)); + foo (1 ^ 2 == c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) == c); + foo (1 ^ (2 == c)); + foo (1 ^ 2 == 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) == 3); + foo (1 ^ (2 == 3)); + foo (a < b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a < b) ^ c); + foo (a < (b ^ c)); + foo (1 < 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) ^ c); + foo (1 < (2 ^ c)); + foo (1 < 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) ^ 3); + foo (1 < (2 ^ 3)); + foo (a ^ b < c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) < c); + foo (a ^ (b < c)); + foo (1 ^ 2 < c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) < c); + foo (1 ^ (2 < c)); + foo (1 ^ 2 < 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) < 3); + foo (1 ^ (2 < 3)); +} + +template void bar<int> (int, int, int); // { dg-warning "instantiated" } diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-20.C b/gcc/testsuite/g++.dg/warn/Wparentheses-20.C new file mode 100644 index 0000000..8789d59 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-20.C @@ -0,0 +1,104 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-11.C. + +int foo (int); + +template<class T> +void +bar (T a, T b, T c) +{ + foo (a + b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) & c); + foo (a + (b & c)); + foo (1 + 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) & c); + foo (1 + (2 & c)); + foo (1 + 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) & 3); + foo (1 + (2 & 3)); + foo (a & b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) + c); + foo (a & (b + c)); + foo (1 & 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) + c); + foo (1 & (2 + c)); + foo (1 & 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) + 3); + foo (1 & (2 + 3)); + foo (a - b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) & c); + foo (a - (b & c)); + foo (1 - 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) & c); + foo (1 - (2 & c)); + foo (1 - 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) & 3); + foo (1 - (2 & 3)); + foo (a & b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) - c); + foo (a & (b - c)); + foo (1 & 2 - c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) - c); + foo (1 & (2 - c)); + foo (1 & 2 - 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) - 3); + foo (1 & (2 - 3)); + foo (a < b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a < b) & c); + foo (a < (b & c)); + foo (1 < 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) & c); + foo (1 < (2 & c)); + foo (1 < 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 < 2) & 3); + foo (1 < (2 & 3)); + foo (a & b < c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) < c); + foo (a & (b < c)); + foo (1 & 2 < c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) < c); + foo (1 & (2 < c)); + foo (1 & 2 < 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) < 3); + foo (1 & (2 < 3)); + foo (a == b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a == b) & c); + foo (a == (b & c)); + foo (1 == 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) & c); + foo (1 == (2 & c)); + foo (1 == 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 == 2) & 3); + foo (1 == (2 & 3)); + foo (a & b == c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) == c); + foo (a & (b == c)); + foo (1 & 2 == c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) == c); + foo (1 & (2 == c)); + foo (1 & 2 == 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) == 3); + foo (1 & (2 == 3)); + foo (a != b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a != b) & c); + foo (a != (b & c)); + foo (1 != 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 != 2) & c); + foo (1 != (2 & c)); + foo (1 != 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 != 2) & 3); + foo (1 != (2 & 3)); + foo (a & b != c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) != c); + foo (a & (b != c)); + foo (1 & 2 != c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) != c); + foo (1 & (2 != c)); + foo (1 & 2 != 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) != 3); + foo (1 & (2 != 3)); +} + +template void bar<int> (int, int, int); // { dg-warning "instantiated" } diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-21.C b/gcc/testsuite/g++.dg/warn/Wparentheses-21.C new file mode 100644 index 0000000..588b4fd --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-21.C @@ -0,0 +1,66 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// Template version of Wparentheses-12.C. Note that we currently warn +// when we initially parse the template, not when we are instantiating +// it. That seems reasonable since the template parameters can not +// affect the syntax parsing. + +int foo (int); + +int a, b, c; + +template<class T> +void +bar (T) +{ + if (a) + foo (0); + if (b) + foo (1); + else + foo (2); + if (c) // { dg-warning "ambiguous" "correct warning" } + if (a) + foo (3); + else + foo (4); + if (a) + if (c) + foo (5); + if (a) + if (b) // { dg-warning "ambiguous" "correct warning" } + if (c) + foo (6); + else + foo (7); + if (a) // { dg-warning "ambiguous" "correct warning" } + if (b) + if (c) + foo (8); + else + foo (9); + else + foo (10); + if (a) + if (b) + if (c) + foo (11); + else + foo (12); + else + foo (13); + else + foo (14); + if (a) { + if (b) + if (c) + foo (15); + else + foo (16); + else + foo (17); + } +} + +template void bar<int> (int); diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-5.C b/gcc/testsuite/g++.dg/warn/Wparentheses-5.C new file mode 100644 index 0000000..2cd05aa --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-5.C @@ -0,0 +1,12 @@ +// { dg-do compile } +// { dg-options -Wparentheses } + +// C++ version of gcc.dg/Wparentheses-1.c. + +int foo (int a, int b) +{ + int c = (a && b) || 0; // { dg-bogus "suggest parentheses" } + c = a && b || 0; // { dg-warning "suggest parentheses" } + + return (a && b && 1) || 0; // { dg-bogus "suggest parentheses" } +} diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-6.C b/gcc/testsuite/g++.dg/warn/Wparentheses-6.C new file mode 100644 index 0000000..9963d82 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-6.C @@ -0,0 +1,65 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// C++ version of gcc.dg/Wparentheses-2.c. + +int foo (int); + +int +bar (int a, int b, int c) +{ + foo (a <= b <= c); // { dg-warning "comparison" "correct warning" } + foo ((a <= b) <= c); + foo (a <= (b <= c)); + foo (1 <= 2 <= c); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) <= c); + foo (1 <= (2 <= c)); + foo (1 <= 2 <= 3); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) <= 3); + foo (1 <= (2 <= 3)); + foo (a > b > c); // { dg-warning "comparison" "correct warning" } + foo ((a > b) > c); + foo (a > (b > c)); + foo (1 > 2 > c); // { dg-warning "comparison" "correct warning" } + foo ((1 > 2) > c); + foo (1 > (2 > c)); + foo (1 > 2 > 3); // { dg-warning "comparison" "correct warning" } + foo ((1 > 2) > 3); + foo (1 > (2 > 3)); + foo (a < b <= c); // { dg-warning "comparison" "correct warning" } + foo ((a < b) <= c); + foo (a < (b <= c)); + foo (1 < 2 <= c); // { dg-warning "comparison" "correct warning" } + foo ((1 < 2) <= c); + foo (1 < (2 <= c)); + foo (1 < 2 <= 3); // { dg-warning "comparison" "correct warning" } + foo ((1 < 2) <= 3); + foo (1 < (2 <= 3)); + foo (a <= b > c); // { dg-warning "comparison" "correct warning" } + foo ((a <= b) > c); + foo (a <= (b > c)); + foo (1 <= 2 > c); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) > c); + foo (1 <= (2 > c)); + foo (1 <= 2 > 3); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) > 3); + foo (1 <= (2 > 3)); + foo (a <= b == c); // { dg-warning "comparison" "correct warning" } + foo ((a <= b) == c); + foo (a <= (b == c)); + foo (1 <= 2 == c); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) == c); + foo (1 <= (2 == c)); + foo (1 <= 2 == 3); // { dg-warning "comparison" "correct warning" } + foo ((1 <= 2) == 3); + foo (1 <= (2 == 3)); + foo (a != b != c); // { dg-warning "comparison" "correct warning" } + foo ((a != b) != c); + foo (a != (b != c)); + foo (1 != 2 != c); // { dg-warning "comparison" "correct warning" } + foo ((1 != 2) != c); + foo (1 != (2 != c)); + foo (1 != 2 != 3); // { dg-warning "comparison" "correct warning" } + foo ((1 != 2) != 3); + foo (1 != (2 != 3)); +} diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-7.C b/gcc/testsuite/g++.dg/warn/Wparentheses-7.C new file mode 100644 index 0000000..7d549c3 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-7.C @@ -0,0 +1,83 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// C++ copy of gcc.dg/Wparentheses-4.c + +int foo (int); + +int +bar (int a, int b, int c) +{ + foo (a + b << c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) << c); + foo (a + (b << c)); + foo (1 + 2 << c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) << c); + foo (1 + (2 << c)); + foo (1 + 2 << 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) << 3); + foo (1 + (2 << 3)); + foo (a << b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a << b) + c); + foo (a << (b + c)); + foo (1 << 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 << 2) + c); + foo (1 << (2 + c)); + foo (1 << 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 << 2) + 3); + foo (1 << (2 + 3)); + foo (a + b >> c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) >> c); + foo (a + (b >> c)); + foo (1 + 2 >> c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) >> c); + foo (1 + (2 >> c)); + foo (1 + 2 >> 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) >> 3); + foo (1 + (2 >> 3)); + foo (a >> b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a >> b) + c); + foo (a >> (b + c)); + foo (1 >> 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 >> 2) + c); + foo (1 >> (2 + c)); + foo (1 >> 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 >> 2) + 3); + foo (1 >> (2 + 3)); + foo (a - b << c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) << c); + foo (a - (b << c)); + foo (6 - 5 << c); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) << c); + foo (6 - (5 << c)); + foo (6 - 5 << 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) << 4); + foo (6 - (5 << 4)); + foo (a << b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a << b) - c); + foo (a << (b - c)); + foo (6 << 5 - c); // { dg-warning "parentheses" "correct warning" } + foo ((6 << 5) - c); + foo (6 << (5 - c)); + foo (6 << 5 - 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 << 5) - 4); + foo (6 << (5 - 4)); + foo (a - b >> c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) >> c); + foo (a - (b >> c)); + foo (6 - 5 >> c); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) >> c); + foo (6 - (5 >> c)); + foo (6 - 5 >> 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 - 5) >> 4); + foo (6 - (5 >> 4)); + foo (a >> b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a >> b) - c); + foo (a >> (b - c)); + foo (6 >> 5 - c); // { dg-warning "parentheses" "correct warning" } + foo ((6 >> 5) - c); + foo (6 >> (5 - c)); + foo (6 >> 5 - 4); // { dg-warning "parentheses" "correct warning" } + foo ((6 >> 5) - 4); + foo (6 >> (5 - 4)); +} diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-8.C b/gcc/testsuite/g++.dg/warn/Wparentheses-8.C new file mode 100644 index 0000000..ddb5e64 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-8.C @@ -0,0 +1,29 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// C++ version of gcc.dg/Wparentheses-5.c + +int foo (int); + +int +bar (int a, int b, int c) +{ + foo (a && b || c); // { dg-warning "parentheses" "correct warning" } + foo ((a && b) || c); + foo (a && (b || c)); + foo (1 && 2 || c); // { dg-warning "parentheses" "correct warning" } + foo ((1 && 2) || c); + foo (1 && (2 || c)); + foo (1 && 2 || 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 && 2) || 3); + foo (1 && (2 || 3)); + foo (a || b && c); // { dg-warning "parentheses" "correct warning" } + foo ((a || b) && c); + foo (a || (b && c)); + foo (1 || 2 && c); // { dg-warning "parentheses" "correct warning" } + foo ((1 || 2) && c); + foo (1 || (2 && c)); + foo (1 || 2 && 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 || 2) && 3); + foo (1 || (2 && 3)); +} diff --git a/gcc/testsuite/g++.dg/warn/Wparentheses-9.C b/gcc/testsuite/g++.dg/warn/Wparentheses-9.C new file mode 100644 index 0000000..bad6fb1 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wparentheses-9.C @@ -0,0 +1,119 @@ +// { dg-do compile } +// { dg-options "-Wparentheses" } + +// C++ version of gcc.dg/Wparentheses-6.c + +int foo (int); + +int +bar (int a, int b, int c) +{ + foo (a & b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a & b) | c); + foo (a & (b | c)); + foo (1 & 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) | c); + foo (1 & (2 | c)); + foo (1 & 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 & 2) | 3); + foo (1 & (2 | 3)); + foo (a | b & c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) & c); + foo (a | (b & c)); + foo (1 | 2 & c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) & c); + foo (1 | (2 & c)); + foo (1 | 2 & 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) & 3); + foo (1 | (2 & 3)); + foo (a ^ b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a ^ b) | c); + foo (a ^ (b | c)); + foo (1 ^ 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) | c); + foo (1 ^ (2 | c)); + foo (1 ^ 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 ^ 2) | 3); + foo (1 ^ (2 | 3)); + foo (a | b ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) ^ c); + foo (a | (b ^ c)); + foo (1 | 2 ^ c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) ^ c); + foo (1 | (2 ^ c)); + foo (1 | 2 ^ 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) ^ 3); + foo (1 | (2 ^ 3)); + foo (a + b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a + b) | c); + foo (a + (b | c)); + foo (1 + 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) | c); + foo (1 + (2 | c)); + foo (1 + 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 + 2) | 3); + foo (1 + (2 | 3)); + foo (a | b + c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) + c); + foo (a | (b + c)); + foo (1 | 2 + c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) + c); + foo (1 | (2 + c)); + foo (1 | 2 + 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) + 3); + foo (1 | (2 + 3)); + foo (a - b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a - b) | c); + foo (a - (b | c)); + foo (1 - 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) | c); + foo (1 - (2 | c)); + foo (1 - 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 - 2) | 3); + foo (1 - (2 | 3)); + foo (a | b - c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) - c); + foo (a | (b - c)); + foo (1 | 2 - c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) - c); + foo (1 | (2 - c)); + foo (1 | 2 - 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) - 3); + foo (1 | (2 - 3)); + foo (a > b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a > b) | c); + foo (a > (b | c)); + foo (1 > 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 > 2) | c); + foo (1 > (2 | c)); + foo (1 > 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 > 2) | 3); + foo (1 > (2 | 3)); + foo (a | b > c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) > c); + foo (a | (b > c)); + foo (1 | 2 > c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) > c); + foo (1 | (2 > c)); + foo (1 | 2 > 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) > 3); + foo (1 | (2 > 3)); + foo (a <= b | c); // { dg-warning "parentheses" "correct warning" } + foo ((a <= b) | c); + foo (a <= (b | c)); + foo (1 <= 2 | c); // { dg-warning "parentheses" "correct warning" } + foo ((1 <= 2) | c); + foo (1 <= (2 | c)); + foo (1 <= 2 | 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 <= 2) | 3); + foo (1 <= (2 | 3)); + foo (a | b <= c); // { dg-warning "parentheses" "correct warning" } + foo ((a | b) <= c); + foo (a | (b <= c)); + foo (1 | 2 <= c); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) <= c); + foo (1 | (2 <= c)); + foo (1 | 2 <= 3); // { dg-warning "parentheses" "correct warning" } + foo ((1 | 2) <= 3); + foo (1 | (2 <= 3)); +} diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index dd70b8e..5b692ea 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,25 @@ +2006-12-13 Ian Lance Taylor <iant@google.com> + + PR c++/19564 + PR c++/19756 + * include/bits/locale_facets.tcc (num_get<>::_M_extract_float): + Add parentheses around && within || to avoid warning. + (num_get<>::_M_extract_int): Likewise. + (money_get<>::_M_extract): Likewise. + (num_get<>::do_get(iter_type, iter_type, ios_base&, + ios_base::iostate&, void*&)): Add parentheses around & within | to + avoid warning. + (num_put<>::do_put(iter_type, ios_base&, char_type, const void*)): + Likewise. + * include/bits/streambuf_iterator.h (istreambuf_iterator::equal): + Add parentheses around && within || to avoid warning. + * libsupc++/tinfo.cc (__do_dyncast): Likewise. + * src/locale.cc (locale::_S_normalize_category): Likewise. + * include/bits/stl_tree.h (_Rb_tree<>::_M_insert_unique): Add + braces to avoid ambiguous else warning. + * src/strstream.cc (strstreambuf::_M_free): Likewise. + * src/tree.cc (_Rb_tree_rebalance_for_erase): Likewise. + 2006-12-12 Benjamin Kosnik <bkoz@redhat.com> PR libstdc++/28265 diff --git a/libstdc++-v3/include/bits/locale_facets.tcc b/libstdc++-v3/include/bits/locale_facets.tcc index d3c47ff..1eba5ae 100644 --- a/libstdc++-v3/include/bits/locale_facets.tcc +++ b/libstdc++-v3/include/bits/locale_facets.tcc @@ -314,7 +314,7 @@ _GLIBCXX_BEGIN_LDBL_NAMESPACE int __sep_pos = 0; while (!__testeof) { - if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) || __c == __lc->_M_decimal_point) break; else if (__c == __lit[__num_base::_S_izero]) @@ -556,7 +556,7 @@ _GLIBCXX_BEGIN_LDBL_NAMESPACE int __sep_pos = 0; while (!__testeof) { - if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) || __c == __lc->_M_decimal_point) break; else if (__c == __lit[__num_base::_S_izero] @@ -883,7 +883,7 @@ _GLIBCXX_BEGIN_LDBL_NAMESPACE // Prepare for hex formatted input. typedef ios_base::fmtflags fmtflags; const fmtflags __fmt = __io.flags(); - __io.flags(__fmt & ~ios_base::basefield | ios_base::hex); + __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); unsigned long __ul; __beg = _M_extract_int(__beg, __end, __io, __err, __ul); @@ -1305,7 +1305,7 @@ _GLIBCXX_BEGIN_LDBL_NAMESPACE const ios_base::fmtflags __fmt = ~(ios_base::basefield | ios_base::uppercase | ios_base::internal); - __io.flags(__flags & __fmt | (ios_base::hex | ios_base::showbase)); + __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); __s = _M_insert_int(__s, __io, __fill, reinterpret_cast<unsigned long>(__v)); @@ -1377,9 +1377,9 @@ _GLIBCXX_BEGIN_LDBL_NAMESPACE == money_base::space))) || (__i == 2 && ((static_cast<part>(__p.field[3]) == money_base::value) - || __mandatory_sign - && (static_cast<part>(__p.field[3]) - == money_base::sign)))) + || (__mandatory_sign + && (static_cast<part>(__p.field[3]) + == money_base::sign))))) { const size_type __len = __lc->_M_curr_symbol_size; size_type __j = 0; diff --git a/libstdc++-v3/include/bits/stl_tree.h b/libstdc++-v3/include/bits/stl_tree.h index d2efb3a..bbfb252 100644 --- a/libstdc++-v3/include/bits/stl_tree.h +++ b/libstdc++-v3/include/bits/stl_tree.h @@ -1055,10 +1055,12 @@ _GLIBCXX_BEGIN_NAMESPACE(std) } iterator __j = iterator(__y); if (__comp) - if (__j == begin()) - return pair<iterator, bool>(_M_insert_(__x, __y, __v), true); - else - --__j; + { + if (__j == begin()) + return pair<iterator, bool>(_M_insert_(__x, __y, __v), true); + else + --__j; + } if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v))) return pair<iterator, bool>(_M_insert_(__x, __y, __v), true); return pair<iterator, bool>(__j, false); diff --git a/libstdc++-v3/include/bits/streambuf_iterator.h b/libstdc++-v3/include/bits/streambuf_iterator.h index a1cf234..c743bb3 100644 --- a/libstdc++-v3/include/bits/streambuf_iterator.h +++ b/libstdc++-v3/include/bits/streambuf_iterator.h @@ -160,7 +160,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) { const bool __thiseof = _M_at_eof(); const bool __beof = __b._M_at_eof(); - return (__thiseof && __beof || (!__thiseof && !__beof)); + return ((__thiseof && __beof) || (!__thiseof && !__beof)); } private: diff --git a/libstdc++-v3/libsupc++/tinfo.cc b/libstdc++-v3/libsupc++/tinfo.cc index a153c2d4..89d9e16 100644 --- a/libstdc++-v3/libsupc++/tinfo.cc +++ b/libstdc++-v3/libsupc++/tinfo.cc @@ -490,9 +490,9 @@ __do_dyncast (ptrdiff_t src2dst, result.whole2dst = __sub_kind (result.whole2dst | result2.whole2dst); } - else if ((result.dst_ptr != 0 & result2.dst_ptr != 0) - || (result.dst_ptr != 0 & result2_ambig) - || (result2.dst_ptr != 0 & result_ambig)) + else if ((result.dst_ptr != 0 && result2.dst_ptr != 0) + || (result.dst_ptr != 0 && result2_ambig) + || (result2.dst_ptr != 0 && result_ambig)) { // Found two different DST_TYPE bases, or a valid one and a set of // ambiguous ones, must disambiguate. See whether SRC_PTR is diff --git a/libstdc++-v3/src/locale.cc b/libstdc++-v3/src/locale.cc index 12070eb..a760994 100644 --- a/libstdc++-v3/src/locale.cc +++ b/libstdc++-v3/src/locale.cc @@ -146,7 +146,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) locale::_S_normalize_category(category __cat) { int __ret = 0; - if (__cat == none || (__cat & all) && !(__cat & ~all)) + if (__cat == none || ((__cat & all) && !(__cat & ~all))) __ret = __cat; else { diff --git a/libstdc++-v3/src/strstream.cc b/libstdc++-v3/src/strstream.cc index 5bbb33a4..f221454 100644 --- a/libstdc++-v3/src/strstream.cc +++ b/libstdc++-v3/src/strstream.cc @@ -311,10 +311,12 @@ _GLIBCXX_BEGIN_NAMESPACE(std) strstreambuf::_M_free(char* p) { if (p) - if (_M_free_fun) - _M_free_fun(p); - else - delete[] p; + { + if (_M_free_fun) + _M_free_fun(p); + else + delete[] p; + } } void diff --git a/libstdc++-v3/src/tree.cc b/libstdc++-v3/src/tree.cc index 38a3037..b23ca8e 100644 --- a/libstdc++-v3/src/tree.cc +++ b/libstdc++-v3/src/tree.cc @@ -316,17 +316,21 @@ _GLIBCXX_BEGIN_NAMESPACE(std) else __z->_M_parent->_M_right = __x; if (__leftmost == __z) - if (__z->_M_right == 0) // __z->_M_left must be null also - __leftmost = __z->_M_parent; - // makes __leftmost == _M_header if __z == __root - else - __leftmost = _Rb_tree_node_base::_S_minimum(__x); + { + if (__z->_M_right == 0) // __z->_M_left must be null also + __leftmost = __z->_M_parent; + // makes __leftmost == _M_header if __z == __root + else + __leftmost = _Rb_tree_node_base::_S_minimum(__x); + } if (__rightmost == __z) - if (__z->_M_left == 0) // __z->_M_right must be null also - __rightmost = __z->_M_parent; - // makes __rightmost == _M_header if __z == __root - else // __x == __z->_M_left - __rightmost = _Rb_tree_node_base::_S_maximum(__x); + { + if (__z->_M_left == 0) // __z->_M_right must be null also + __rightmost = __z->_M_parent; + // makes __rightmost == _M_header if __z == __root + else // __x == __z->_M_left + __rightmost = _Rb_tree_node_base::_S_maximum(__x); + } } if (__y->_M_color != _S_red) { |