re PR java/4230 (gcj -C segfaults on static string continuation '+' in gcj 3.1 expermental.)

2001-09-05 Alexandre Petit-Bianco  <apbianco@redhat.com>

	* jcf-write.c (generate_classfile): Issue an error in case of
	field/initial value mismatch.
	* parse.y (analyze_clinit_body): Keep <clinit> if an array is
	being initialized and we're generating bytecode.
	(java_complete_lhs): In MODIFY_EXPR section: added comments,
	set DECL_INITIAL properly when appropriate.
	Fixes PR java/4230
	Fixes PR java/4204

(http://gcc.gnu.org/ml/gcc-patches/2001-09/msg00247.html )

From-SVN: r45474

gcc/java/ChangeLog

@@ -17,6 +17,17 @@
 	resource files.
 	* gcj.texi (Code Generation): Add documentation for -R flag.
 
+2001-09-05 Alexandre Petit-Bianco  <apbianco@redhat.com>
+
+	* jcf-write.c (generate_classfile): Issue an error in case of
+	field/initial value mismatch.
+	* parse.y (analyze_clinit_body): Keep <clinit> if an array is
+	being initialized and we're generating bytecode.
+	(java_complete_lhs): In MODIFY_EXPR section: added comments,
+	set DECL_INITIAL properly when appropriate.
+	Fixes PR java/4230
+	Fixes PR java/4204
+
 2001-09-01  Per Bothner  <per@bothner.com>
 
 	* parse.y (maybe_yank_clinit):  A field without an initializer is not

gcc/java/jcf-write.c

@@ -2899,8 +2899,8 @@ generate_classfile (clas, state)
 	{
 	  tree init = DECL_INITIAL (part);
 	  static tree ConstantValue_node = NULL_TREE;
-	  // This conversion is a work-around for front-end bug.
-	  init = convert (TREE_TYPE (part), init);
+	  if (TREE_TYPE (part) != TREE_TYPE (init))
+	    fatal_error ("field initializer type mismatch.");
 	  ptr = append_chunk (NULL, 8, state);
 	  if (ConstantValue_node == NULL_TREE)
 	    ConstantValue_node = get_identifier ("ConstantValue");

gcc/java/parse.y

@@ -7813,6 +7813,11 @@ analyze_clinit_body (bbody)
 	break;
 	
       case MODIFY_EXPR:
+	/* If we're generating to class file and we're dealing with an
+	   array initialization, we return 1 to keep <clinit> */
+	if (TREE_CODE (TREE_OPERAND (bbody, 1)) == NEW_ARRAY_INIT
+	    && flag_emit_class_files)
+	  return 1;
 	/* Return 0 if the operand is constant, 1 otherwise.  */
 	return ! TREE_CONSTANT (TREE_OPERAND (bbody, 1));
 
@@ -11898,16 +11903,31 @@ java_complete_lhs (node)
 	  
 	  value = fold_constant_for_init (nn, nn);
 
+	  /* When we have a primitype type, or a string and we're not
+             emitting a class file, we actually don't want to generate
+             anything for the assignment. */
 	  if (value != NULL_TREE &&
 	      (JPRIMITIVE_TYPE_P (TREE_TYPE (value)) || 
 	       (TREE_TYPE (value) == string_ptr_type_node &&
 		! flag_emit_class_files)))
 	    {
+	      /* Prepare node for patch_assignment */
 	      TREE_OPERAND (node, 1) = value;
+	      /* Call patch assignment to verify the assignment */
 	      if (patch_assignment (node, wfl_op1, value) == error_mark_node)
 		return error_mark_node;
+	      /* Set DECL_INITIAL properly (a conversion might have
+                 been decided by patch_assignment) and return the
+                 empty statement. */
 	      else
-		return empty_stmt_node;
+		{
+		  tree patched = patch_string (TREE_OPERAND (node, 1));
+		  if (patched)
+		    DECL_INITIAL (nn) = patched;
+		  else
+		    DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
+		  return empty_stmt_node;
+		}
 	    }
 	  if (! flag_emit_class_files)
 	    DECL_INITIAL (nn) = NULL_TREE;
@@ -11999,7 +12019,18 @@ java_complete_lhs (node)
 		       || JSTRING_P (TREE_TYPE (node))))
 	    node = java_refold (node);
 	}
-      
+
+      /* Seek to set DECL_INITIAL to a proper value, since it might have
+	 undergone a conversion in patch_assignment. We do that only when
+	 it's necessary to have DECL_INITIAL properly set. */
+      nn = TREE_OPERAND (node, 0);
+      if (TREE_CODE (nn) == VAR_DECL 
+	  && DECL_INITIAL (nn) && CONSTANT_VALUE_P (DECL_INITIAL (nn))
+	  && FIELD_STATIC (nn) && FIELD_FINAL (nn) 
+	  && (JPRIMITIVE_TYPE_P (TREE_TYPE (nn))
+	      || TREE_TYPE (nn) == string_ptr_type_node))
+	DECL_INITIAL (nn) = TREE_OPERAND (node, 1);
+
       CAN_COMPLETE_NORMALLY (node) = 1;
       return node;