Jumbo patch:
* Imported beans and serialization * Updated IA-64 port * Miscellaneous bug fixes From-SVN: r34028
This commit is contained in:
Tom Tromey
parent
021c89ed68
commit
6c80c45e30
125 changed files with 18458 additions and 560 deletions
|
|
@ -130,6 +130,9 @@ private:
|
|||
java::lang::reflect::Field *getField (jstring, jint);
|
||||
jint _getMethods (JArray<java::lang::reflect::Method *> *result,
|
||||
jint offset);
|
||||
java::lang::reflect::Field *getPrivateField (jstring);
|
||||
java::lang::reflect::Method *getPrivateMethod (jstring, JArray<jclass> *);
|
||||
|
||||
public:
|
||||
JArray<java::lang::reflect::Field *> *getFields (void);
|
||||
|
||||
|
|
@ -234,6 +237,10 @@ private:
|
|||
// Friends classes and functions to implement the ClassLoader
|
||||
friend class java::lang::ClassLoader;
|
||||
|
||||
friend class java::io::ObjectOutputStream;
|
||||
friend class java::io::ObjectInputStream;
|
||||
friend class java::io::ObjectStreamClass;
|
||||
|
||||
friend void _Jv_WaitForState (jclass, int);
|
||||
friend void _Jv_RegisterClasses (jclass *classes);
|
||||
friend void _Jv_RegisterInitiatingLoader (jclass,java::lang::ClassLoader*);
|
||||
|
|
|
|||
|
|
@ -110,6 +110,11 @@ public abstract class SecurityManager
|
|||
throw new SecurityException();
|
||||
}
|
||||
|
||||
public void checkPermission (java.security.Permission perm)
|
||||
{
|
||||
throw new SecurityException();
|
||||
}
|
||||
|
||||
public void checkPrintJobAccess ()
|
||||
{
|
||||
throw new SecurityException();
|
||||
|
|
|
|||
|
|
@ -8,6 +8,8 @@ details. */
|
|||
|
||||
package java.lang;
|
||||
import java.io.UnsupportedEncodingException;
|
||||
import java.io.Serializable;
|
||||
import java.lang.Comparable;
|
||||
|
||||
/**
|
||||
* @author Per Bothner <bothner@cygnus.com>
|
||||
|
|
@ -18,7 +20,7 @@ import java.io.UnsupportedEncodingException;
|
|||
* Status: Complete to 1.1, but see FIXMEs. Also see testsuite results.
|
||||
*/
|
||||
|
||||
public final class String
|
||||
public final class String implements Serializable, Comparable
|
||||
{
|
||||
private Object data;
|
||||
private int boffset; // Note this is a byte offset - don't use in Java code!
|
||||
|
|
@ -172,6 +174,11 @@ public final class String
|
|||
|
||||
public native int compareTo (String anotherString);
|
||||
|
||||
public int compareTo (Object obj)
|
||||
{
|
||||
return compareTo ((String)obj);
|
||||
}
|
||||
|
||||
public native boolean regionMatches (int toffset,
|
||||
String other, int ooffset, int len);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,6 +1,6 @@
|
|||
// StringBuffer.java - Growable strings.
|
||||
|
||||
/* Copyright (C) 1998, 1999, 2000 Red Hat
|
||||
/* Copyright (C) 1998, 1999, 2000 Free Software Foundation
|
||||
|
||||
This file is part of libgcj.
|
||||
|
||||
|
|
|
|||
|
|
@ -918,11 +918,27 @@ _Jv_IsAssignableFrom (jclass target, jclass source)
|
|||
return _Jv_IsAssignableFrom(target->getComponentType(),
|
||||
source->getComponentType());
|
||||
}
|
||||
|
||||
|
||||
if (target->isInterface())
|
||||
{
|
||||
// Abstract classes have no IDTs, so compare superclasses instead.
|
||||
if (java::lang::reflect::Modifier::isAbstract (source->accflags))
|
||||
{
|
||||
jclass super = source->getSuperclass();
|
||||
return super ? _Jv_IsAssignableFrom (target, super) : false;
|
||||
}
|
||||
|
||||
if (source->state != JV_STATE_DONE)
|
||||
source->initializeClass ();
|
||||
if (target->state != JV_STATE_DONE)
|
||||
target->initializeClass ();
|
||||
|
||||
_Jv_IDispatchTable *cl_idt = source->idt;
|
||||
_Jv_IDispatchTable *if_idt = target->idt;
|
||||
|
||||
if (if_idt == NULL) // The interface has no implementations
|
||||
return false;
|
||||
|
||||
if (__builtin_expect ((if_idt == NULL), false))
|
||||
return false; // No class implementing TARGET has been loaded.
|
||||
jshort cl_iindex = cl_idt->cls.iindex;
|
||||
|
|
@ -1305,3 +1321,61 @@ _Jv_FindIIndex (jclass *ifaces, jshort *offsets, jshort num)
|
|||
|
||||
return i;
|
||||
}
|
||||
|
||||
// Only used by serialization
|
||||
java::lang::reflect::Field *
|
||||
java::lang::Class::getPrivateField (jstring name)
|
||||
{
|
||||
int hash = name->hashCode ();
|
||||
|
||||
java::lang::reflect::Field* rfield;
|
||||
for (int i = 0; i < field_count; i++)
|
||||
{
|
||||
_Jv_Field *field = &fields[i];
|
||||
if (! _Jv_equal (field->name, name, hash))
|
||||
continue;
|
||||
rfield = new java::lang::reflect::Field ();
|
||||
rfield->offset = (char*) field - (char*) fields;
|
||||
rfield->declaringClass = this;
|
||||
rfield->name = name;
|
||||
return rfield;
|
||||
}
|
||||
jclass superclass = getSuperclass();
|
||||
if (superclass == NULL)
|
||||
return NULL;
|
||||
rfield = superclass->getPrivateField(name);
|
||||
for (int i = 0; i < interface_count && rfield == NULL; ++i)
|
||||
rfield = interfaces[i]->getPrivateField (name);
|
||||
return rfield;
|
||||
}
|
||||
|
||||
// Only used by serialization
|
||||
java::lang::reflect::Method *
|
||||
java::lang::Class::getPrivateMethod (jstring name, JArray<jclass> *param_types)
|
||||
{
|
||||
jstring partial_sig = getSignature (param_types, false);
|
||||
jint p_len = partial_sig->length();
|
||||
_Jv_Utf8Const *utf_name = _Jv_makeUtf8Const (name);
|
||||
for (Class *klass = this; klass; klass = klass->getSuperclass())
|
||||
{
|
||||
int i = klass->isPrimitive () ? 0 : klass->method_count;
|
||||
while (--i >= 0)
|
||||
{
|
||||
// FIXME: access checks.
|
||||
if (_Jv_equalUtf8Consts (klass->methods[i].name, utf_name)
|
||||
&& _Jv_equaln (klass->methods[i].signature, partial_sig, p_len))
|
||||
{
|
||||
// Found it.
|
||||
using namespace java::lang::reflect;
|
||||
|
||||
Method *rmethod = new Method ();
|
||||
rmethod->offset = ((char *) (&klass->methods[i])
|
||||
- (char *) klass->methods);
|
||||
rmethod->declaringClass = klass;
|
||||
return rmethod;
|
||||
}
|
||||
}
|
||||
}
|
||||
JvThrow (new java::lang::NoSuchMethodException);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -46,7 +46,8 @@ extern java::lang::Class ClassClass;
|
|||
extern java::lang::Class VMClassLoader;
|
||||
#define ClassLoaderClass _CL_Q34java4lang11ClassLoader
|
||||
extern java::lang::Class ClassLoaderClass;
|
||||
|
||||
#define SerializableClass _CL_Q34java2io12Serializable
|
||||
extern java::lang::Class SerializableClass;
|
||||
/////////// java.lang.ClassLoader native methods ////////////
|
||||
|
||||
java::lang::ClassLoader *
|
||||
|
|
@ -579,10 +580,9 @@ _Jv_FindArrayClass (jclass element, java::lang::ClassLoader *loader)
|
|||
array_class->methods = (_Jv_Method *) element;
|
||||
|
||||
// Register our interfaces.
|
||||
// FIXME: for JDK 1.2 we need Serializable.
|
||||
static jclass interfaces[] = { &CloneableClass };
|
||||
static jclass interfaces[] = { &CloneableClass, &SerializableClass };
|
||||
array_class->interfaces = interfaces;
|
||||
array_class->interface_count = 1;
|
||||
array_class->interface_count = sizeof interfaces / sizeof interfaces[0];
|
||||
|
||||
// Generate the interface dispatch table.
|
||||
_Jv_PrepareConstantTimeTables (array_class);
|
||||
|
|
|
|||
|
|
@ -46,12 +46,12 @@ _Jv_StringFindSlot (jchar* data, jint len, jint hash)
|
|||
int start_index = hash & (strhash_size - 1);
|
||||
int deleted_index = -1;
|
||||
|
||||
register int index = start_index;
|
||||
int index = start_index;
|
||||
/* step must be non-zero, and relatively prime with strhash_size. */
|
||||
int step = 8 * hash + 7;
|
||||
for (;;)
|
||||
{
|
||||
register jstring* ptr = &strhash[index];
|
||||
jstring* ptr = &strhash[index];
|
||||
if (*ptr == NULL)
|
||||
{
|
||||
if (deleted_index >= 0)
|
||||
|
|
@ -75,7 +75,7 @@ _Jv_StringFindSlot (jchar* data, jint len, jint hash)
|
|||
static jint
|
||||
hashChars (jchar* ptr, jint length)
|
||||
{
|
||||
register jchar* limit = ptr + length;
|
||||
jchar* limit = ptr + length;
|
||||
jint hash = 0;
|
||||
// Updated specification from
|
||||
// http://www.javasoft.com/docs/books/jls/clarify.html.
|
||||
|
|
@ -111,8 +111,8 @@ java::lang::String::rehash()
|
|||
}
|
||||
else
|
||||
{
|
||||
register int i = strhash_size;
|
||||
register jstring* ptr = strhash + i;
|
||||
int i = strhash_size;
|
||||
jstring* ptr = strhash + i;
|
||||
strhash_size *= 2;
|
||||
strhash = (jstring *) _Jv_AllocBytes (strhash_size * sizeof (jstring));
|
||||
memset (strhash, 0, strhash_size * sizeof (jstring));
|
||||
|
|
@ -198,8 +198,8 @@ _Jv_NewStringUtf8Const (Utf8Const* str)
|
|||
jchar *chrs;
|
||||
jchar buffer[100];
|
||||
jstring jstr;
|
||||
register unsigned char* data = (unsigned char*) str->data;
|
||||
register unsigned char* limit = data + str->length;
|
||||
unsigned char* data = (unsigned char*) str->data;
|
||||
unsigned char* limit = data + str->length;
|
||||
int length = _Jv_strLengthUtf8(str->data, str->length);
|
||||
|
||||
if (length <= (int) (sizeof(buffer) / sizeof(jchar)))
|
||||
|
|
@ -239,12 +239,12 @@ _Jv_NewStringUtf8Const (Utf8Const* str)
|
|||
jsize
|
||||
_Jv_GetStringUTFLength (jstring string)
|
||||
{
|
||||
register jsize len = 0;
|
||||
register jchar *ptr = JvGetStringChars (string);
|
||||
register jsize i = string->length();
|
||||
jsize len = 0;
|
||||
jchar *ptr = JvGetStringChars (string);
|
||||
jsize i = string->length();
|
||||
while (--i >= 0)
|
||||
{
|
||||
register jchar ch = *ptr++;
|
||||
jchar ch = *ptr++;
|
||||
if (ch > 0 && ch <= 0x7F)
|
||||
len += 1;
|
||||
else if (ch <= 0x7FF)
|
||||
|
|
@ -260,9 +260,9 @@ _Jv_GetStringUTFLength (jstring string)
|
|||
jsize
|
||||
_Jv_GetStringUTFRegion (jstring str, jsize start, jsize len, char *buf)
|
||||
{
|
||||
register jchar *sptr = JvGetStringChars (str) + start;
|
||||
register jsize i = len;
|
||||
register char *dptr = buf;
|
||||
jchar *sptr = JvGetStringChars (str) + start;
|
||||
jsize i = len;
|
||||
char *dptr = buf;
|
||||
while (--i >= 0)
|
||||
{
|
||||
jchar ch = *sptr++;
|
||||
|
|
@ -429,9 +429,9 @@ java::lang::String::equals(jobject anObject)
|
|||
if (count != other->count)
|
||||
return false;
|
||||
/* if both are interned, return false. */
|
||||
register jint i = count;
|
||||
register jchar *xptr = JvGetStringChars (this);
|
||||
register jchar *yptr = JvGetStringChars (other);
|
||||
jint i = count;
|
||||
jchar *xptr = JvGetStringChars (this);
|
||||
jchar *yptr = JvGetStringChars (other);
|
||||
while (--i >= 0)
|
||||
{
|
||||
if (*xptr++ != *yptr++)
|
||||
|
|
@ -456,9 +456,9 @@ java::lang::String::getChars(jint srcBegin, jint srcEnd,
|
|||
if (srcBegin < 0 || srcBegin > srcEnd || srcEnd > count
|
||||
|| dstBegin < 0 || dstBegin + (srcEnd-srcBegin) > dst_length)
|
||||
JvThrow (new java::lang::StringIndexOutOfBoundsException());
|
||||
register jchar *dPtr = elements (dst) + dstBegin;
|
||||
register jchar *sPtr = JvGetStringChars (this) + srcBegin;
|
||||
register jint i = srcEnd-srcBegin;
|
||||
jchar *dPtr = elements (dst) + dstBegin;
|
||||
jchar *sPtr = JvGetStringChars (this) + srcBegin;
|
||||
jint i = srcEnd-srcBegin;
|
||||
while (--i >= 0)
|
||||
*dPtr++ = *sPtr++;
|
||||
}
|
||||
|
|
@ -506,9 +506,9 @@ java::lang::String::getBytes(jint srcBegin, jint srcEnd,
|
|||
if (srcBegin < 0 || srcBegin > srcEnd || srcEnd > count
|
||||
|| dstBegin < 0 || dstBegin + (srcEnd-srcBegin) > dst_length)
|
||||
JvThrow (new java::lang::StringIndexOutOfBoundsException());
|
||||
register jbyte *dPtr = elements (dst) + dstBegin;
|
||||
register jchar *sPtr = JvGetStringChars (this) + srcBegin;
|
||||
register jint i = srcEnd-srcBegin;
|
||||
jbyte *dPtr = elements (dst) + dstBegin;
|
||||
jchar *sPtr = JvGetStringChars (this) + srcBegin;
|
||||
jint i = srcEnd-srcBegin;
|
||||
while (--i >= 0)
|
||||
*dPtr++ = (jbyte) *sPtr++;
|
||||
}
|
||||
|
|
@ -517,9 +517,9 @@ jcharArray
|
|||
java::lang::String::toCharArray()
|
||||
{
|
||||
jcharArray array = JvNewCharArray(count);
|
||||
register jchar *dPtr = elements (array);
|
||||
register jchar *sPtr = JvGetStringChars (this);
|
||||
register jint i = count;
|
||||
jchar *dPtr = elements (array);
|
||||
jchar *sPtr = JvGetStringChars (this);
|
||||
jint i = count;
|
||||
while (--i >= 0)
|
||||
*dPtr++ = *sPtr++;
|
||||
return array;
|
||||
|
|
@ -530,9 +530,9 @@ java::lang::String::equalsIgnoreCase (jstring anotherString)
|
|||
{
|
||||
if (anotherString == NULL || count != anotherString->count)
|
||||
return false;
|
||||
register jchar *tptr = JvGetStringChars (this);
|
||||
register jchar *optr = JvGetStringChars (anotherString);
|
||||
register jint i = count;
|
||||
jchar *tptr = JvGetStringChars (this);
|
||||
jchar *optr = JvGetStringChars (anotherString);
|
||||
jint i = count;
|
||||
while (--i >= 0)
|
||||
{
|
||||
jchar tch = *tptr++;
|
||||
|
|
@ -555,9 +555,9 @@ java::lang::String::regionMatches (jint toffset,
|
|||
|| toffset + len > count
|
||||
|| ooffset + len > other->count)
|
||||
return false;
|
||||
register jchar *tptr = JvGetStringChars (this) + toffset;
|
||||
register jchar *optr = JvGetStringChars (other) + ooffset;
|
||||
register jint i = len;
|
||||
jchar *tptr = JvGetStringChars (this) + toffset;
|
||||
jchar *optr = JvGetStringChars (other) + ooffset;
|
||||
jint i = len;
|
||||
while (--i >= 0)
|
||||
{
|
||||
if (*tptr++ != *optr++)
|
||||
|
|
@ -569,11 +569,11 @@ java::lang::String::regionMatches (jint toffset,
|
|||
jint
|
||||
java::lang::String::compareTo (jstring anotherString)
|
||||
{
|
||||
register jchar *tptr = JvGetStringChars (this);
|
||||
register jchar *optr = JvGetStringChars (anotherString);
|
||||
jchar *tptr = JvGetStringChars (this);
|
||||
jchar *optr = JvGetStringChars (anotherString);
|
||||
jint tlen = this->count;
|
||||
jint olen = anotherString->count;
|
||||
register jint i = tlen > olen ? olen : tlen;
|
||||
jint i = tlen > olen ? olen : tlen;
|
||||
while (--i >= 0)
|
||||
{
|
||||
jchar tch = *tptr++;
|
||||
|
|
@ -592,9 +592,9 @@ java::lang::String::regionMatches (jboolean ignoreCase, jint toffset,
|
|||
|| toffset + len > count
|
||||
|| ooffset + len > other->count)
|
||||
return false;
|
||||
register jchar *tptr = JvGetStringChars (this) + toffset;
|
||||
register jchar *optr = JvGetStringChars (other) + ooffset;
|
||||
register jint i = len;
|
||||
jchar *tptr = JvGetStringChars (this) + toffset;
|
||||
jchar *optr = JvGetStringChars (other) + ooffset;
|
||||
jint i = len;
|
||||
if (ignoreCase)
|
||||
while (--i >= 0)
|
||||
{
|
||||
|
|
@ -620,11 +620,11 @@ java::lang::String::regionMatches (jboolean ignoreCase, jint toffset,
|
|||
jboolean
|
||||
java::lang::String::startsWith (jstring prefix, jint toffset)
|
||||
{
|
||||
register jint i = prefix->count;
|
||||
jint i = prefix->count;
|
||||
if (toffset < 0 || toffset + i > count)
|
||||
return false;
|
||||
register jchar *xptr = JvGetStringChars (this) + toffset;
|
||||
register jchar *yptr = JvGetStringChars (prefix);
|
||||
jchar *xptr = JvGetStringChars (this) + toffset;
|
||||
jchar *yptr = JvGetStringChars (prefix);
|
||||
while (--i >= 0)
|
||||
{
|
||||
if (*xptr++ != *yptr++)
|
||||
|
|
@ -638,7 +638,7 @@ java::lang::String::indexOf (jint ch, jint fromIndex)
|
|||
{
|
||||
if (fromIndex < 0)
|
||||
fromIndex = 0;
|
||||
register jchar *ptr = JvGetStringChars(this);
|
||||
jchar *ptr = JvGetStringChars(this);
|
||||
for (;; ++fromIndex)
|
||||
{
|
||||
if (fromIndex >= count)
|
||||
|
|
@ -682,7 +682,7 @@ java::lang::String::lastIndexOf (jint ch, jint fromIndex)
|
|||
{
|
||||
if (fromIndex >= count)
|
||||
fromIndex = count - 1;
|
||||
register jchar *ptr = JvGetStringChars(this);
|
||||
jchar *ptr = JvGetStringChars(this);
|
||||
for (;; --fromIndex)
|
||||
{
|
||||
if (fromIndex < 0)
|
||||
|
|
@ -716,9 +716,9 @@ java::lang::String::concat(jstring str)
|
|||
if (str_count == 0)
|
||||
return this;
|
||||
jstring result = JvAllocString(count + str_count);
|
||||
register jchar *dstPtr = JvGetStringChars(result);
|
||||
register jchar *srcPtr = JvGetStringChars(this);
|
||||
register jint i = count;
|
||||
jchar *dstPtr = JvGetStringChars(result);
|
||||
jchar *srcPtr = JvGetStringChars(this);
|
||||
jint i = count;
|
||||
while (--i >= 0)
|
||||
*dstPtr++ = *srcPtr++;
|
||||
srcPtr = JvGetStringChars(str);
|
||||
|
|
@ -834,9 +834,9 @@ java::lang::String::valueOf(jcharArray data, jint offset, jint count)
|
|||
jint data_length = JvGetArrayLength (data);
|
||||
if (offset < 0 || count < 0 || offset+count > data_length)
|
||||
JvThrow (new java::lang::IndexOutOfBoundsException());
|
||||
register jstring result = JvAllocString(count);
|
||||
register jchar *sPtr = elements (data) + offset;
|
||||
register jchar *dPtr = JvGetStringChars(result);
|
||||
jstring result = JvAllocString(count);
|
||||
jchar *sPtr = elements (data) + offset;
|
||||
jchar *dPtr = JvGetStringChars(result);
|
||||
while (--count >= 0)
|
||||
*dPtr++ = *sPtr++;
|
||||
return result;
|
||||
|
|
@ -845,7 +845,7 @@ java::lang::String::valueOf(jcharArray data, jint offset, jint count)
|
|||
jstring
|
||||
java::lang::String::valueOf(jchar c)
|
||||
{
|
||||
register jstring result = JvAllocString(1);
|
||||
jstring result = JvAllocString(1);
|
||||
JvGetStringChars (result)[0] = c;
|
||||
return result;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -39,6 +39,10 @@ details. */
|
|||
|
||||
#include <name-finder.h>
|
||||
|
||||
#ifdef __ia64__
|
||||
extern "C" int _Jv_ia64_backtrace (void **array, int size);
|
||||
#endif
|
||||
|
||||
/* FIXME: size of the stack trace is limited to 128 elements. It's
|
||||
undoubtedly sensible to limit the stack trace, but 128 is rather
|
||||
arbitrary. It may be better to configure this. */
|
||||
|
|
@ -46,16 +50,21 @@ details. */
|
|||
java::lang::Throwable *
|
||||
java::lang::Throwable::fillInStackTrace (void)
|
||||
{
|
||||
#ifdef HAVE_BACKTRACE
|
||||
#if defined (HAVE_BACKTRACE) || defined (__ia64__)
|
||||
void *p[128];
|
||||
|
||||
// We subtract 1 from the number of elements because we don't want
|
||||
// to include the call to fillInStackTrace in the trace.
|
||||
#if defined (__ia64__)
|
||||
int n = _Jv_ia64_backtrace (p, 128) - 1;
|
||||
#else
|
||||
int n = backtrace (p, 128) - 1;
|
||||
#endif
|
||||
|
||||
// ??? Might this cause a problem if the byte array isn't aligned?
|
||||
stackTrace = JvNewByteArray (n * sizeof p[0]);
|
||||
memcpy (elements (stackTrace), p+1, (n * sizeof p[0]));
|
||||
|
||||
#endif
|
||||
|
||||
return this;
|
||||
|
|
@ -83,11 +92,15 @@ java::lang::Throwable::printRawStackTrace (java::io::PrintWriter *wr)
|
|||
{
|
||||
wr->print (JvNewStringLatin1 (": "));
|
||||
wr->print (JvNewStringLatin1 (finder.method_name));
|
||||
wr->print (JvNewStringLatin1 (" ("));
|
||||
wr->print (JvNewStringLatin1 (finder.file_name));
|
||||
wr->print (JvNewStringLatin1 (")"));
|
||||
if (finder.file_name[0])
|
||||
{
|
||||
wr->print (JvNewStringLatin1 (" ("));
|
||||
wr->print (JvNewStringLatin1 (finder.file_name));
|
||||
wr->print (JvNewStringLatin1 (")"));
|
||||
}
|
||||
}
|
||||
wr->println ();
|
||||
}
|
||||
#endif /* HAVE_BACKTRACE */
|
||||
wr->flush ();
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue