return 1;
}
- if (!(field_decl =
- lookup_field_wrapper (type, EXPR_WFL_NODE (qual_wfl))))
+ field_decl = lookup_field_wrapper (type,
+ EXPR_WFL_NODE (qual_wfl));
+ if (field_decl == NULL_TREE)
{
parse_error_context
(qual_wfl, "No variable `%s' defined in class `%s'",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type))));
return 1;
}
+ if (field_decl == error_mark_node)
+ return 1;
/* Layout the type of field_decl, since we may need
it. Don't do primitive types or loaded classes. The
/* Now do the actual complete, without deep recursion for
long blocks. */
ptr = &BLOCK_EXPR_BODY (node);
- while (TREE_CODE (*ptr) == COMPOUND_EXPR)
+ while (TREE_CODE (*ptr) == COMPOUND_EXPR
+ && TREE_OPERAND (*ptr, 1) != empty_stmt_node)
{
tree cur = java_complete_tree (TREE_OPERAND (*ptr, 0));
tree *next = &TREE_OPERAND (*ptr, 1);
break;
}
if (TREE_CODE (wfl_op2) != CASE_EXPR
- && TREE_CODE (wfl_op2) != DEFAULT_EXPR
- && wfl_op2 != empty_stmt_node)
+ && TREE_CODE (wfl_op2) != DEFAULT_EXPR)
unreachable_stmt_error (*ptr);
}
ptr = next;
wfl_op2 = TREE_OPERAND (node, 1);
TREE_OPERAND (node, 0) = nn =
java_complete_tree (TREE_OPERAND (node, 0));
- if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK
- && wfl_op2 != empty_stmt_node)
- {
- /* An unreachable condition in a do-while statement
- is *not* (technically) an unreachable statement. */
- nn = wfl_op2;
- if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
- nn = EXPR_WFL_NODE (nn);
- if (TREE_CODE (nn) != EXIT_EXPR)
+ if (wfl_op2 == empty_stmt_node)
+ CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (nn);
+ else
+ {
+ if (! CAN_COMPLETE_NORMALLY (nn) && TREE_CODE (nn) != ERROR_MARK)
{
- SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
- parse_error_context (wfl_operator, "Unreachable statement");
+ /* An unreachable condition in a do-while statement
+ is *not* (technically) an unreachable statement. */
+ nn = wfl_op2;
+ if (TREE_CODE (nn) == EXPR_WITH_FILE_LOCATION)
+ nn = EXPR_WFL_NODE (nn);
+ if (TREE_CODE (nn) != EXIT_EXPR)
+ {
+ SET_WFL_OPERATOR (wfl_operator, node, wfl_op2);
+ parse_error_context (wfl_operator, "Unreachable statement");
+ }
}
+ TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
+ if (TREE_OPERAND (node, 1) == error_mark_node)
+ return error_mark_node;
+ CAN_COMPLETE_NORMALLY (node)
+ = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
}
- TREE_OPERAND (node, 1) = java_complete_tree (TREE_OPERAND (node, 1));
- if (TREE_OPERAND (node, 1) == error_mark_node)
- return error_mark_node;
TREE_TYPE (node) = TREE_TYPE (TREE_OPERAND (node, 1));
- CAN_COMPLETE_NORMALLY (node)
- = CAN_COMPLETE_NORMALLY (TREE_OPERAND (node, 1));
break;
case RETURN_EXPR:
|| TREE_CODE (EXPR_WFL_NODE (node)) == IDENTIFIER_NODE)
{
node = resolve_expression_name (node, NULL);
+ if (node == error_mark_node)
+ return node;
CAN_COMPLETE_NORMALLY (node) = 1;
}
else
body = java_complete_tree (EXPR_WFL_NODE (node));
lineno = save_lineno;
EXPR_WFL_NODE (node) = body;
- TREE_SIDE_EFFECTS (node) = 1;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (body);
CAN_COMPLETE_NORMALLY (node) = CAN_COMPLETE_NORMALLY (body);
- if (EXPR_WFL_NODE (node) == error_mark_node)
+ if (body == error_mark_node)
{
/* Its important for the evaluation of assignment that
this mark on the TREE_TYPE is propagated. */
tree_cons (wfl, decl,
DECL_CONSTRUCTOR_CALLS (current_function_decl));
CAN_COMPLETE_NORMALLY (node) = 1;
- return node;
+ return force_evaluation_order (node);
}
case MODIFY_EXPR:
if (TREE_OPERAND (node, 1) == error_mark_node)
return error_mark_node;
}
- return patch_binop (node, wfl_op1, wfl_op2);
+ return force_evaluation_order (patch_binop (node, wfl_op1, wfl_op2));
case INSTANCEOF_EXPR:
wfl_op1 = TREE_OPERAND (node, 0);
return error_mark_node;
if (!flag_emit_class_files)
TREE_OPERAND (node, 1) = save_expr (TREE_OPERAND (node, 1));
- return patch_array_ref (node);
+ return force_evaluation_order (patch_array_ref (node));
case RECORD_TYPE:
return node;;
{
tree mod = build_java_binop (TRUNC_MOD_EXPR, prom_type, op1, op2);
COMPOUND_ASSIGN_P (mod) = COMPOUND_ASSIGN_P (node);
+ TREE_SIDE_EFFECTS (mod)
+ = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
return mod;
}
break;
to_return = convert (prom_type, node);
/* Copy the original value of the COMPOUND_ASSIGN_P flag */
COMPOUND_ASSIGN_P (to_return) = COMPOUND_ASSIGN_P (node);
+ TREE_SIDE_EFFECTS (to_return)
+ = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
return to_return;
}
break;
else if (flag_emit_class_files)
{
TREE_OPERAND (node, 1) = op2_type;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1);
return node;
}
/* Otherwise we have to invoke instance of to figure it out */
build_tree_list (NULL_TREE,
build_class_ref (op2_type))),
NULL_TREE);
- TREE_SIDE_EFFECTS (call) = 1;
+ TREE_SIDE_EFFECTS (call) = TREE_SIDE_EFFECTS (op1);
return call;
}
}
TREE_OPERAND (node, 0) = op1;
TREE_OPERAND (node, 1) = op2;
TREE_TYPE (node) = prom_type;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
+
return fold (node);
}
tree op1, op2;
{
tree result;
+ int side_effects = TREE_SIDE_EFFECTS (op1) | TREE_SIDE_EFFECTS (op2);
+
/* Try to do some static optimization */
if ((result = string_constant_concatenation (op1, op2)))
/* Mark the last node holding a crafted StringBuffer */
IS_CRAFTED_STRING_BUFFER_P (op1) = 1;
-
+
+ TREE_SIDE_EFFECTS (op1) = side_effects;
return op1;
}
error_found = 1;
}
else
- return fold (value);
+ {
+ value = fold (value);
+ TREE_SIDE_EFFECTS (value) = TREE_SIDE_EFFECTS (op);
+ return value;
+ }
break;
}
CONVERT_EXPR, {POST,PRE}{INCR,DECR}EMENT_EXPR. */
TREE_OPERAND (node, 0) = fold (op);
TREE_TYPE (node) = prom_type;
+ TREE_SIDE_EFFECTS (node) = TREE_SIDE_EFFECTS (op);
return fold (node);
}