[kaffe] CVS kaffe (guilhem): More serialization fixes.
Kaffe CVS
Kaffe Mailing List <kaffe@kaffe.org>
Thu Feb 26 09:31:02 2004
PatchSet 4464
Date: 2004/02/26 17:08:08
Author: guilhem
Branch: HEAD
Tag: (none)
Log:
More serialization fixes.
* java/io/ObjectInputStream.java
(readClassDescriptor): Keep elements of the mapping non null.
(checkTypeConsistency): New method.
(readFields): Fixed main loop and base logic. Small reindentation.
* java/io/ObjectStreamField.java
(lookupField): New method to update the field reference.
(checkFieldType): New method.
* java/io/ObjectStreamClass.java
(setClass, setFields): Call lookupField when building the field
database. Check the real field type.
Members:
ChangeLog:1.2044->1.2045
libraries/javalib/java/io/ObjectInputStream.java:1.33->1.34
libraries/javalib/java/io/ObjectStreamClass.java:1.20->1.21
libraries/javalib/java/io/ObjectStreamField.java:1.7->1.8
Index: kaffe/ChangeLog
diff -u kaffe/ChangeLog:1.2044 kaffe/ChangeLog:1.2045
--- kaffe/ChangeLog:1.2044 Wed Feb 25 19:28:24 2004
+++ kaffe/ChangeLog Thu Feb 26 17:08:08 2004
@@ -1,3 +1,18 @@
+2004-02-26 Guilhem Lavaux <guilhem@kaffe.org>
+
+ * java/io/ObjectInputStream.java
+ (readClassDescriptor): Keep elements of the mapping non null.
+ (checkTypeConsistency): New method.
+ (readFields): Fixed main loop and base logic. Small reindentation.
+
+ * java/io/ObjectStreamField.java
+ (lookupField): New method to update the field reference.
+ (checkFieldType): New method.
+
+ * java/io/ObjectStreamClass.java
+ (setClass, setFields): Call lookupField when building the field
+ database. Check the real field type.
+
2004-02-24 Dalibor Topic <robilad@kaffe.org>
Resynced with GNU Classpath
Index: kaffe/libraries/javalib/java/io/ObjectInputStream.java
diff -u kaffe/libraries/javalib/java/io/ObjectInputStream.java:1.33 kaffe/libraries/javalib/java/io/ObjectInputStream.java:1.34
--- kaffe/libraries/javalib/java/io/ObjectInputStream.java:1.33 Sun Feb 22 08:33:10 2004
+++ kaffe/libraries/javalib/java/io/ObjectInputStream.java Thu Feb 26 17:08:11 2004
@@ -412,6 +412,65 @@
}
/**
+ * This method makes a partial check of types for the fields
+ * contained given in arguments. It checks primitive types of
+ * fields1 against non primitive types of fields2. This method
+ * assumes the two lists has already been sorted according to
+ * the Java specification.
+ *
+ * @param name Name of the class owning the given fields.
+ * @param fields1 First list to check.
+ * @param fields2 Second list to check.
+ * @throws InvalidClassException if a field in fields1, which has a primitive type, is a present
+ * in the non primitive part in fields2.
+ */
+ private void checkTypeConsistency(String name, ObjectStreamField[] fields1, ObjectStreamField[] fields2)
+ throws InvalidClassException
+ {
+ int nonPrimitive = 0;
+
+ for (nonPrimitive = 0;
+ nonPrimitive < fields1.length
+ && fields1[nonPrimitive].isPrimitive(); nonPrimitive++)
+ {
+ }
+
+ if (nonPrimitive == fields1.length)
+ return;
+
+ int i = 0;
+ ObjectStreamField f1;
+ ObjectStreamField f2;
+
+ while (i < fields2.length
+ && nonPrimitive < fields1.length)
+ {
+ f1 = fields1[nonPrimitive];
+ f2 = fields2[i];
+
+ if (!f2.isPrimitive())
+ break;
+
+ int compVal = f1.getName().compareTo (f2.getName());
+
+ if (compVal < 0)
+ {
+ nonPrimitive++;
+ }
+ else if (compVal > 0)
+ {
+ i++;
+ }
+ else
+ {
+ throw new InvalidClassException
+ ("invalid field type for " + f2.getName() +
+ " in class " + name);
+ }
+ }
+ }
+
+ /**
* This method reads a class descriptor from the real input stream
* and use these data to create a new instance of ObjectStreamClass.
* Fields are sorted and ordered for the real read which occurs for
@@ -496,6 +555,15 @@
int real_idx = 0;
int map_idx = 0;
+ /*
+ * Check that there is no type inconsistencies between the lists.
+ * A special checking must be done for the two groups: primitive types and
+ * not primitive types.
+ */
+ checkTypeConsistency(name, real_fields, stream_fields);
+ checkTypeConsistency(name, stream_fields, real_fields);
+
+
while (stream_idx < stream_fields.length
|| real_idx < real_fields.length)
{
@@ -513,7 +581,7 @@
else
{
int comp_val =
- real_fields[real_idx].getName().compareTo (stream_fields[stream_idx].getName());
+ real_fields[real_idx].compareTo (stream_fields[stream_idx]);
if (comp_val < 0)
{
@@ -1671,8 +1739,8 @@
{
Object value =
read_value ? readObject() : null;
- if (set_value && stream_field != null)
- real_field.setObjectField(obj, stream_field.getTypeString(), value);
+ if (set_value)
+ real_field.setObjectField(obj, value);
break;
}
default:
Index: kaffe/libraries/javalib/java/io/ObjectStreamClass.java
diff -u kaffe/libraries/javalib/java/io/ObjectStreamClass.java:1.20 kaffe/libraries/javalib/java/io/ObjectStreamClass.java:1.21
--- kaffe/libraries/javalib/java/io/ObjectStreamClass.java:1.20 Sun Feb 22 08:33:10 2004
+++ kaffe/libraries/javalib/java/io/ObjectStreamClass.java Thu Feb 26 17:08:11 2004
@@ -327,7 +327,7 @@
i = 0; j = 0; k = 0;
while (i < fields.length && j < exportedFields.length)
{
- int comp = fields[i].getName().compareTo(exportedFields[j].getName());
+ int comp = fields[i].compareTo(exportedFields[j]);
if (comp < 0)
{
@@ -344,11 +344,27 @@
newFieldList[k] = exportedFields[j];
newFieldList[k].setPersistent(true);
newFieldList[k].setToSet(false);
- newFieldList[k].lookupField(clazz);
+ try
+ {
+ newFieldList[k].lookupField(clazz);
+ newFieldList[k].checkFieldType();
+ }
+ catch (NoSuchFieldException _)
+ {
+ }
j++;
}
else
{
+ try
+ {
+ exportedFields[j].lookupField(clazz);
+ exportedFields[j].checkFieldType();
+ }
+ catch (NoSuchFieldException _)
+ {
+ }
+
if (!fields[i].getType().equals(exportedFields[j].getType()))
throw new InvalidClassException
("serialPersistentFields must be compatible with" +
Index: kaffe/libraries/javalib/java/io/ObjectStreamField.java
diff -u kaffe/libraries/javalib/java/io/ObjectStreamField.java:1.7 kaffe/libraries/javalib/java/io/ObjectStreamField.java:1.8
--- kaffe/libraries/javalib/java/io/ObjectStreamField.java:1.7 Sun Feb 22 08:33:10 2004
+++ kaffe/libraries/javalib/java/io/ObjectStreamField.java Thu Feb 26 17:08:11 2004
@@ -329,162 +329,128 @@
this.field = f;
}
+ /**
+ * This method check whether the field described by this
+ * instance of ObjectStreamField is compatible with the
+ * actual implementation of this field.
+ *
+ * @throws NullPointerException if this field does not exist
+ * in the real class.
+ * @throws InvalidClassException if the types are incompatible.
+ */
+ void checkFieldType() throws InvalidClassException
+ {
+ Class ftype = field.getType();
+
+ if (!ftype.isAssignableFrom(type))
+ throw new InvalidClassException
+ ("invalid field type for " + name +
+ " in class " + field.getDeclaringClass());
+ }
+
public String toString ()
{
return "ObjectStreamField< " + type + " " + name + " >";
}
- /*
- * These methods set the required field in the class instance obj.
- * They may throw NullPointerException if the field does not really exist.
- */
-
- final void setBooleanField(Object obj, boolean val) throws IOException
+ final void setBooleanField(Object obj, boolean val)
{
try
{
field.setBoolean(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
}
- final void setByteField(Object obj, byte val) throws IOException
+ final void setByteField(Object obj, byte val)
{
try
{
field.setByte(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
}
- final void setCharField(Object obj, char val) throws IOException
+ final void setCharField(Object obj, char val)
{
try
{
field.setChar(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
}
- final void setShortField(Object obj, short val) throws IOException
+ final void setShortField(Object obj, short val)
{
try
{
field.setShort(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
}
- final void setIntField(Object obj, int val) throws IOException
+ final void setIntField(Object obj, int val)
{
try
{
field.setInt(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
- catch (Exception _)
- {
- }
}
- final void setLongField(Object obj, long val) throws IOException
+ final void setLongField(Object obj, long val)
{
try
{
field.setLong(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
}
- final void setFloatField(Object obj, float val) throws IOException
+ final void setFloatField(Object obj, float val)
{
try
{
field.setFloat(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
}
- final void setDoubleField(Object obj, double val) throws IOException
+ final void setDoubleField(Object obj, double val)
{
try
{
field.setDouble(obj, val);
}
- catch (IllegalArgumentException _)
- {
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
- }
catch(IllegalAccessException x)
{
throw new InternalError(x.getMessage());
}
}
- final void setObjectField(Object obj, String valtype, Object val) throws IOException
- {
- if (valtype == null ||
- !typename.equals(valtype))
- throw new InvalidClassException("incompatible field type for " +
- obj.getClass().getName() + "." + name);
-
+ final void setObjectField(Object obj, Object val)
+ {
try
{
field.set(obj, val);