mirror of
git://gcc.gnu.org/git/gcc.git
synced 2024-12-25 19:39:56 +08:00
4480b3dcf6
* Makefile.am (nat_source_files): Remove
java/io/natObjectOutputStream.cc.
* Makefile.in: Regenerated.
* mauve-libgcj: Don't exclude java.io.ObjectInputOutput tests.
* java/io/ObjectStreamField.java (typename): New field.
(ObjectStreamField(String, Class)): Initialize new field.
(ObjectStreamField(String, String)): New Constructor.
(getTypeCode): Use new field.
(getTypeString): Use new field.
* java/io/ObjectOutputStream.java (writeObject): Rethrow fatal
ObjectStreamExceptions. Remember and reset old BlockDataMode.
Handle reading of Proxy classes. Never drain(), just write
TC_ENDBLOCKDATA. Rethrow ObjectStreamExceptions.
(drain): Check writeDataAsBlocks before calling writeBlockDataHeader.
(flush): Call flush(), not just drain().
(writeBoolean): Always use blockDataOutput.
(writeByte): Likewise.
(writeShort): Likewise.
(writeChar): Likewise.
(writeInt): Likewise.
(writeLong): Likewise.
(writeFloat): Likewise.
(writeDouble): Likewise.
(writeBytes): Likewise.
(putfield (put(String,Object))): Throw IllegalArgumentException if
field cannot be found.
(putfield (write(ObjectOutput))): Remember old BlockDataMode.
(writeArraySizeAndElements): Write byte[] in one go.
(writeFields): Write TC_ENDBLOCKDATA when call_write_method, otherwise
set BlockDataMode to false.
(annotateProxyClass): New method.
(defaultProtocolVersion): Now defaults to PROTOCOL_VERSION_2
(getField): No longer native.
(getMethod): Likewise.
(setBlockDataMode): Always drain() on switch, return old mode.
(static): New static code block.
* java/io/natObjectOutputStream.cc: Removed.
* java/io/ObjectInputStream.java (getField): No longer native.
(getMethod): Likewise.
(readObject): Remember and reset old BlockDataMode. Track whether
object is consumed. Handle TC_ENDBLOCKDATA, TC_PROXYCLASSDESC and
TC_LONGSTRING.
(defaultReadObject): Set BlockDataMode to false during readFields.
(resolveClass): Create new SecurityManager if necessary.
Use Class.forName() if null ClassLoader found.
(read(byte[],int,int): Copy remaining bytes to data before calling
readNextBlock().
(readFields): Set and reset BlockDataMode on call_read_method.
Catch NoSuchFieldErrors.
(setBlockDataMode): Return old mode.
(static): New static code block.
* java/io/natObjectInputStream.cc (getField): Removed.
(getMethod): Likewise.
From-SVN: r63556
72 lines
1.9 KiB
C++
72 lines
1.9 KiB
C++
// natObjectInputStream.cc - Native part of ObjectInputStream class.
|
|
|
|
/* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
|
|
|
|
This ObjectInputStream is part of libgcj.
|
|
|
|
This software is copyrighted work licensed under the terms of the
|
|
Libgcj License. Please consult the ObjectInputStream "LIBGCJ_LICENSE" for
|
|
details. */
|
|
|
|
#include <config.h>
|
|
|
|
#include <gcj/cni.h>
|
|
#include <jvm.h>
|
|
|
|
#include <java/io/ObjectInputStream$GetField.h>
|
|
#include <java/io/ObjectInputStream.h>
|
|
#include <java/io/IOException.h>
|
|
#include <java/lang/Class.h>
|
|
#include <java/lang/reflect/Modifier.h>
|
|
#include <java/lang/reflect/Method.h>
|
|
|
|
#ifdef DEBUG
|
|
#include <java/lang/System.h>
|
|
#include <java/io/PrintStream.h>
|
|
#endif
|
|
|
|
jobject
|
|
java::io::ObjectInputStream::allocateObject (jclass klass)
|
|
{
|
|
jobject obj = NULL;
|
|
using namespace java::lang::reflect;
|
|
|
|
try
|
|
{
|
|
JvAssert (klass && ! klass->isArray ());
|
|
if (klass->isInterface() || Modifier::isAbstract(klass->getModifiers()))
|
|
obj = NULL;
|
|
else
|
|
{
|
|
obj = JvAllocObject (klass);
|
|
}
|
|
}
|
|
catch (jthrowable t)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
|
|
void
|
|
java::io::ObjectInputStream::callConstructor (jclass klass, jobject obj)
|
|
{
|
|
jstring init_name = JvNewStringLatin1 ("<init>");
|
|
// This is a bit inefficient, and a bit of a hack, since we don't
|
|
// actually use the Method and since what is returned isn't
|
|
// technically a Method. We can't use Method.invoke as it looks up
|
|
// the declared method.
|
|
JArray<jclass> *arg_types
|
|
= (JArray<jclass> *) JvNewObjectArray (0, &java::lang::Class::class$,
|
|
NULL);
|
|
java::lang::reflect::Method *m = klass->getPrivateMethod (init_name,
|
|
arg_types);
|
|
// We lie about this being a constructor. If we put `true' here
|
|
// then _Jv_CallAnyMethodA would try to allocate the object for us.
|
|
jmethodID meth = (jmethodID) ((char *) (klass->methods)
|
|
+ m->offset);
|
|
_Jv_CallAnyMethodA (obj, JvPrimClass (void), meth, false, arg_types, NULL);
|
|
}
|