aboutsummaryrefslogtreecommitdiff
path: root/libjava/java/lang
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/java/lang')
-rw-r--r--libjava/java/lang/Class.h7
-rw-r--r--libjava/java/lang/SecurityManager.java5
-rw-r--r--libjava/java/lang/String.java9
-rw-r--r--libjava/java/lang/StringBuffer.java2
-rw-r--r--libjava/java/lang/natClass.cc76
-rw-r--r--libjava/java/lang/natClassLoader.cc8
-rw-r--r--libjava/java/lang/natString.cc100
-rw-r--r--libjava/java/lang/natThrowable.cc21
8 files changed, 167 insertions, 61 deletions
diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h
index d685a1b..03fa439 100644
--- a/libjava/java/lang/Class.h
+++ b/libjava/java/lang/Class.h
@@ -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*);
diff --git a/libjava/java/lang/SecurityManager.java b/libjava/java/lang/SecurityManager.java
index 4f1d152..9c14552 100644
--- a/libjava/java/lang/SecurityManager.java
+++ b/libjava/java/lang/SecurityManager.java
@@ -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();
diff --git a/libjava/java/lang/String.java b/libjava/java/lang/String.java
index 54be314..12f8789 100644
--- a/libjava/java/lang/String.java
+++ b/libjava/java/lang/String.java
@@ -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);
diff --git a/libjava/java/lang/StringBuffer.java b/libjava/java/lang/StringBuffer.java
index cf82540..6e00fa7 100644
--- a/libjava/java/lang/StringBuffer.java
+++ b/libjava/java/lang/StringBuffer.java
@@ -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.
diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc
index 93e8210..dfc3840 100644
--- a/libjava/java/lang/natClass.cc
+++ b/libjava/java/lang/natClass.cc
@@ -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);
+}
+
diff --git a/libjava/java/lang/natClassLoader.cc b/libjava/java/lang/natClassLoader.cc
index 896873a..aa8782d 100644
--- a/libjava/java/lang/natClassLoader.cc
+++ b/libjava/java/lang/natClassLoader.cc
@@ -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);
diff --git a/libjava/java/lang/natString.cc b/libjava/java/lang/natString.cc
index 376a016..5a28c1e 100644
--- a/libjava/java/lang/natString.cc
+++ b/libjava/java/lang/natString.cc
@@ -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;
}
diff --git a/libjava/java/lang/natThrowable.cc b/libjava/java/lang/natThrowable.cc
index bbe18c2..eeb4e41e 100644
--- a/libjava/java/lang/natThrowable.cc
+++ b/libjava/java/lang/natThrowable.cc
@@ -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 ();
}
generated by cgit v1.1 at 2025-04-24 03:35:08 +0000