FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

javaprims.h (_Jv_Utf8Const): Change struct to a class, with private fields and access methods.

Browse source 
* gcj/javaprims.h (_Jv_Utf8Const): Change struct to a class,
	with private fields and access methods.
	(_Jv_NewStringUTF, _Jv_hashUtf8String): New function declarations.
	* gcj/cni.h (_Jv_NewStringUTF): Move to javaprims.h.
	* prims.cc (_Jv_Utf8COnst::init): New method implementation.
	( _Jv_makeUtf8Const): Rewrite using new constructors.
	(hashUtf8String): Rename to +_Jv_hashUtf8String and make non-static.
	* defineclass.cc: Use new _Utf8Const access/convenience methods.
	* jni.cc: Likewise.
	* resolve.cc: Likewise.
	* gcj/field.h: Likewise.
	* include/jvm.h: Likewise.
	* java/lang/Class.h: Likewise.
	* java/lang/natClass.cc: Likwise.
	* java/lang/natClassLoader.cc: Likewise
	* java/lang/reflect/natMethod.cc: Likewise
	* verify.cc: Likewise.
	(_Jv_BytecodeVerifier::make_utf8_const):  Optimize.
	(~_Jv_BytecodeVerifier):  Don't need second _Jv_Free call.

From-SVN: r85854
This commit is contained in:
Per Bothner 2004-08-11 23:53:42 -07:00 • committed by Per Bothner
parent fbac6f3cf5
commit b4d49f49bf
14 changed files with 163 additions and 117 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
libjava/ChangeLog
View file

@ -1,3 +1,25 @@
2004-08-09 Per Bothner <per@bothner.com>
* gcj/javaprims.h (_Jv_Utf8Const): Change struct to a class,
with private fields and access methods.
(_Jv_NewStringUTF, _Jv_hashUtf8String): New function declarations.
* gcj/cni.h (_Jv_NewStringUTF): Move to javaprims.h.
* prims.cc (_Jv_Utf8COnst::init): New method implementation.
( _Jv_makeUtf8Const): Rewrite using new constructors.
(hashUtf8String): Rename to +_Jv_hashUtf8String and make non-static.
* defineclass.cc: Use new _Utf8Const access/convenience methods.
* jni.cc: Likewise.
* resolve.cc: Likewise.
* gcj/field.h: Likewise.
* include/jvm.h: Likewise.
* java/lang/Class.h: Likewise.
* java/lang/natClass.cc: Likwise.
* java/lang/natClassLoader.cc: Likewise
* java/lang/reflect/natMethod.cc: Likewise
* verify.cc: Likewise.
(_Jv_BytecodeVerifier::make_utf8_const): Optimize.
(~_Jv_BytecodeVerifier): Don't need second _Jv_Free call.
2004-08-10 Andrew Haley <aph@redhat.com>
* testsuite/libjava.lang/err14.java: New file.

38
libjava/defineclass.cc
View file

@ -337,7 +337,7 @@ _Jv_ClassReader::parse ()
// tell everyone we're done.
def->state = JV_STATE_LOADED;
if (gcj::verbose_class_flag)
fprintf (stderr, "[Loaded (bytecode) %s]\n", (const char*)(def->name->data));
fprintf (stderr, "[Loaded (bytecode) %s]\n", def->name->chars());
def->notifyAll ();
}
@ -890,7 +890,7 @@ _Jv_ClassReader::handleClassBegin
jstring msg = JvNewStringUTF ("loaded class ");
msg = msg->concat (def->getName ());
msg = msg->concat (_Jv_NewStringUTF (" was in fact named "));
jstring klass_name = _Jv_NewStringUTF (loadedName->data);
jstring klass_name = loadedName->toString();
msg = msg->concat (klass_name);
throw_no_class_def_found_error (msg);
@ -1367,8 +1367,8 @@ void _Jv_ClassReader::throw_class_format_error (char *msg)
if (def->name != NULL)
{
jsize mlen = strlen (msg);
unsigned char* data = (unsigned char*) def->name->data;
int ulen = def->name->length;
unsigned char* data = (unsigned char*) def->name->chars();
int ulen = def->name->len();
unsigned char* limit = data + ulen;
jsize nlen = _Jv_strLengthUtf8 ((char *) data, ulen);
jsize len = nlen + mlen + 3;
@ -1500,8 +1500,8 @@ _Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok)
bool
_Jv_VerifyFieldSignature (_Jv_Utf8Const*sig)
{
unsigned char* ptr = (unsigned char*) sig->data;
unsigned char* limit = ptr + sig->length;
unsigned char* ptr = (unsigned char*) sig->chars();
unsigned char* limit = ptr + sig->len();
ptr = _Jv_VerifyOne (ptr, limit, false);
@ -1511,8 +1511,8 @@ _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig)
bool
_Jv_VerifyMethodSignature (_Jv_Utf8Const*sig)
{
unsigned char* ptr = (unsigned char*) sig->data;
unsigned char* limit = ptr + sig->length;
unsigned char* ptr = (unsigned char*) sig->chars();
unsigned char* limit = ptr + sig->len();
if (ptr == limit || UTF8_GET(ptr,limit) != '(')
return false;
@ -1566,8 +1566,8 @@ is_identifier_part (int c)
bool
_Jv_VerifyIdentifier (_Jv_Utf8Const* name)
{
unsigned char *ptr = (unsigned char*) name->data;
unsigned char *limit = ptr + name->length;
unsigned char *ptr = (unsigned char*) name->chars();
unsigned char *limit = (unsigned char*) name->limit();
int ch;
if ((ch = UTF8_GET (ptr, limit))==-1
@ -1622,8 +1622,7 @@ _Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length)
bool
_Jv_VerifyClassName (_Jv_Utf8Const *name)
{
return _Jv_VerifyClassName ((unsigned char*)&name->data[0],
(_Jv_ushort) name->length);
return _Jv_VerifyClassName ((unsigned char*)name->chars(), name->len());
}
/* Returns true, if NAME1 and NAME2 represent classes in the same
@ -1631,8 +1630,8 @@ _Jv_VerifyClassName (_Jv_Utf8Const *name)
bool
_Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2)
{
unsigned char* ptr1 = (unsigned char*) name1->data;
unsigned char* limit1 = ptr1 + name1->length;
unsigned char* ptr1 = (unsigned char*) name1->chars();
unsigned char* limit1 = (unsigned char*) name1->limit();
unsigned char* last1 = ptr1;
@ -1648,20 +1647,19 @@ _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2)
}
// Now the length of NAME1's package name is LEN.
int len = last1 - (unsigned char*) name1->data;
int len = last1 - (unsigned char*) name1->chars();
// If this is longer than NAME2, then we're off.
if (len > name2->length)
if (len > name2->len())
return false;
// Then compare the first len bytes for equality.
if (memcmp ((void*) name1->data, (void*) name2->data, len) == 0)
if (memcmp ((void*) name1->chars(), (void*) name2->chars(), len) == 0)
{
// Check that there are no .'s after position LEN in NAME2.
unsigned char* ptr2 = (unsigned char*) name2->data + len;
unsigned char* limit2 =
(unsigned char*) name2->data + name2->length;
unsigned char* ptr2 = (unsigned char*) name2->chars() + len;
unsigned char* limit2 = (unsigned char*) name2->limit();
while (ptr2 < limit2)
{

1
libjava/gcj/cni.h
View file

@ -20,7 +20,6 @@ details. */
#include <string.h>
extern "C" jstring _Jv_NewStringUTF (const char *bytes);
extern "C" void _Jv_InitClass (jclass);
extern "C" void *_Jv_AllocBytes (jsize size) __attribute__((__malloc__));

2
libjava/gcj/field.h
View file

@ -68,7 +68,7 @@ struct _Jv_Field
{
if (!isResolved ())
{
char first = ((_Jv_Utf8Const*)type)->data[0];
char first = ((_Jv_Utf8Const*)type)->first();
return first == '[' || first == 'L';
}
else

34
libjava/gcj/javaprims.h
View file

@ -472,10 +472,13 @@ extern jint _Jv_FormatInt (jchar* bufend, jint num);
extern "C" jchar* _Jv_GetStringChars (jstring str);
extern "C" void _Jv_MonitorEnter (jobject);
extern "C" void _Jv_MonitorExit (jobject);
extern "C" jstring _Jv_NewStringUTF (const char *bytes)
__attribute__((__malloc__));
extern "C" jstring _Jv_NewStringLatin1(const char*, jsize)
__attribute__((__malloc__));
extern "C" jsize _Jv_GetStringUTFLength (jstring);
extern "C" jsize _Jv_GetStringUTFRegion (jstring, jsize, jsize, char *);
extern "C" jint _Jv_hashUtf8String (char*, int);
extern jint _Jv_CreateJavaVM (void* /*vm_args*/);
@ -500,11 +503,40 @@ typedef unsigned short _Jv_ushort __attribute__((__mode__(__HI__)));
typedef unsigned int _Jv_uint __attribute__((__mode__(__SI__)));
typedef unsigned int _Jv_ulong __attribute__((__mode__(__DI__)));
struct _Jv_Utf8Const
class _Jv_Utf8Const
{
_Jv_ushort hash;
_Jv_ushort length; /* In bytes, of data portion, without final '\0'. */
char data[1]; /* In Utf8 format, with final '\0'. */
public:
/** Return same value of java.lang.String's hashCode. */
jint hash32() { return _Jv_hashUtf8String(data, length); }
/** Return a hash code that has at least 16 bits of information. */
_Jv_ushort hash16 () { return hash; }
/** Return a hash code that has at least 8 bits of information. */
_Jv_ushort hash8 () { return hash; }
/** Length in bytes of the UTF8-encoding. */
_Jv_ushort len () const { return length; }
/** Pointer to the first byte in the NUL-terminated UTF8-encoding. */
char* chars() { return data; }
/** Pointer to the NUL byte that terminated the UTF8-encoding. */
char* limit() { return data+length; }
/** Return the first byte in the UTF8-encoding. */
char first() const { return data[0]; }
/** Create a (non-interned) java.lang.String from this UTF8Const. */
jstring toString() { return _Jv_NewStringUTF(data); }
/** Given an UTF8 string, how many bytes needed for a UTF8Const,
including struct header, and final NUL. I.e. what to pas to malloc. */
static int space_needed (char *, int len)
{ return sizeof (_Jv_Utf8Const) + len + 1; }
/** Given an allocated _Jv_Utf8Const, copy / fill it in. */
void init (char *s, int len);
friend jboolean _Jv_equalUtf8Consts (const _Jv_Utf8Const*, const _Jv_Utf8Const *);
friend jboolean _Jv_equal (_Jv_Utf8Const*, jstring, jint);
friend jboolean _Jv_equaln (_Jv_Utf8Const*, jstring, jint);
friend _Jv_Utf8Const *_Jv_makeUtf8Const (char*, int);
friend _Jv_Utf8Const *_Jv_makeUtf8Const (jstring);
friend jstring _Jv_NewStringUtf8Const (_Jv_Utf8Const*);
};

2
libjava/include/jvm.h
View file

@ -352,7 +352,7 @@ static inline jboolean _Jv_isVirtualMethod (_Jv_Method *meth)
{
using namespace java::lang::reflect;
return (((meth->accflags & (Modifier::STATIC | Modifier::PRIVATE)) == 0)
&& meth->name->data[0] != '<');
&& meth->name->first() != '<');
}
// This function is used to determine the hash code of an object.

2
libjava/java/lang/Class.h
View file

@ -212,7 +212,7 @@ public:
inline jboolean isArray (void)
{
return name->data[0] == '[';
return name->first() == '[';
}
inline jclass getComponentType (void)

28
libjava/java/lang/natClass.cc
View file

@ -83,7 +83,7 @@ java::lang::Class::forName (jstring className, jboolean initialize,
throw new java::lang::ClassNotFoundException (className);
jclass klass = (buffer[0] == '['
? _Jv_FindClassFromSignature (name->data, loader)
? _Jv_FindClassFromSignature (name->chars(), loader)
: _Jv_FindClass (name, loader));
if (klass == NULL)
@ -443,10 +443,7 @@ java::lang::Class::getDeclaredMethods (void)
jstring
java::lang::Class::getName (void)
{
char buffer[name->length + 1];
memcpy (buffer, name->data, name->length);
buffer[name->length] = '\0';
return _Jv_NewStringUTF (buffer);
return name->toString();
}
JArray<jclass> *
@ -889,7 +886,7 @@ _Jv_FindMethodInCache (jclass klass,
_Jv_Utf8Const *name,
_Jv_Utf8Const *signature)
{
int index = name->hash & MCACHE_SIZE;
int index = name->hash16() & MCACHE_SIZE;
_Jv_mcache *mc = method_cache + index;
_Jv_Method *m = mc->method;
@ -907,7 +904,7 @@ _Jv_AddMethodToCache (jclass klass,
{
_Jv_MonitorEnter (&java::lang::Class::class$);
int index = method->name->hash & MCACHE_SIZE;
int index = method->name->hash16() & MCACHE_SIZE;
method_cache[index].method = method;
method_cache[index].klass = klass;
@ -1285,9 +1282,9 @@ _Jv_GenerateITable (jclass klass, _Jv_ifaces *ifaces, jshort *itable_offsets)
jstring
_Jv_GetMethodString (jclass klass, _Jv_Utf8Const *name)
{
jstring r = JvNewStringUTF (klass->name->data);
jstring r = klass->name->toString();
r = r->concat (JvNewStringUTF ("."));
r = r->concat (JvNewStringUTF (name->data));
r = r->concat (name->toString());
return r;
}
@ -1329,7 +1326,7 @@ _Jv_AppendPartialITable (jclass klass, jclass iface, void **itable,
break;
}
if (meth && (meth->name->data[0] == '<'))
if (meth && (meth->name->first() == '<'))
{
// leave a placeholder in the itable for hidden init methods.
itable[pos] = NULL;
@ -1588,8 +1585,7 @@ _Jv_LinkSymbolTable(jclass klass)
// We're looking for a field or a method, and we can tell
// which is needed by looking at the signature.
if (signature->length >= 2
&& signature->data[0] == '(')
if (signature->first() == '(' && signature->len() >= 2)
{
// If the target class does not have a vtable_method_count yet,
// then we can't tell the offsets for its methods, so we must lay
@ -1683,8 +1679,7 @@ _Jv_LinkSymbolTable(jclass klass)
// We're looking for a static field or a static method, and we
// can tell which is needed by looking at the signature.
if (signature->length >= 2
&& signature->data[0] == '(')
if (signature->first() == '(' && signature->len() >= 2)
{
// If the target class does not have a vtable_method_count yet,
// then we can't tell the offsets for its methods, so we must lay
@ -1695,7 +1690,7 @@ _Jv_LinkSymbolTable(jclass klass)
_Jv_LayoutVTableMethods (target_class);
}
meth = _Jv_LookupDeclaredMethod(target_class, sym.name,
meth = _Jv_LookupDeclaredMethod(target_class, sym.name,
sym.signature);
if (meth != NULL)
@ -1829,8 +1824,7 @@ _Jv_LayoutVTableMethods (jclass klass)
superclass = _Jv_FindClass (name, klass->loader);
if (! superclass)
{
jstring str = _Jv_NewStringUTF (name->data);
throw new java::lang::NoClassDefFoundError (str);
throw new java::lang::NoClassDefFoundError (name->toString());
}
}
else

22
libjava/java/lang/natClassLoader.cc
View file

@ -52,7 +52,7 @@ _Jv_WaitForState (jclass klass, int state)
{
klass->state = JV_STATE_LOADED;
if (gcj::verbose_class_flag)
fprintf (stderr, "[Loaded (pre-compiled) %s]\n", (const char*)(klass->name->data));
fprintf (stderr, "[Loaded (pre-compiled) %s]\n", klass->name->chars());
}
if (state == JV_STATE_LINKED)
{
@ -110,15 +110,15 @@ _Jv_PrepareCompiledClass (jclass klass)
_Jv_Utf8Const *name = pool->data[index].utf8;
jclass found;
if (name->data[0] == '[')
found = _Jv_FindClassFromSignature (&name->data[0],
if (name->first() == '[')
found = _Jv_FindClassFromSignature (name->chars(),
klass->loader);
else
found = _Jv_FindClass (name, klass->loader);
if (! found)
{
jstring str = _Jv_NewStringUTF (name->data);
jstring str = name->toString();
throw new java::lang::NoClassDefFoundError (str);
}
@ -182,7 +182,7 @@ _Jv_PrepareCompiledClass (jclass klass)
if (state == JV_STATE_COMPILED && gcj::verbose_class_flag)
fprintf (stderr, "[Loaded (pre-compiled) %s]\n",
(const char*)(klass->name->data));
klass->name->chars());
klass->notifyAll ();
@ -207,7 +207,7 @@ _Jv_PrepareCompiledClass (jclass klass)
#define HASH_LEN 1013
// Hash function for Utf8Consts.
#define HASH_UTF(Utf) (((Utf)->hash) % HASH_LEN)
#define HASH_UTF(Utf) ((Utf)->hash16() % HASH_LEN)
struct _Jv_LoaderInfo
{
@ -348,7 +348,7 @@ _Jv_RegisterClassHookDefault (jclass klass)
// We size-limit MESSAGE so that you can't trash the stack.
char message[200];
strcpy (message, TEXT);
strncpy (message + sizeof (TEXT) - 1, klass->name->data,
strncpy (message + sizeof (TEXT) - 1, klass->name->chars(),
sizeof (message) - sizeof (TEXT));
message[sizeof (message) - 1] = '\0';
if (! gcj::runtimeInitialized)
@ -390,7 +390,7 @@ _Jv_FindClass (_Jv_Utf8Const *name, java::lang::ClassLoader *loader)
if (! klass)
{
jstring sname = _Jv_NewStringUTF (name->data);
jstring sname = name->toString();
java::lang::ClassLoader *sys
= java::lang::ClassLoader::getSystemClassLoader ();
@ -470,7 +470,7 @@ _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader,
len = 3;
}
else
len = element->name->length + 5;
len = element->name->len() + 5;
{
char signature[len];
@ -483,8 +483,8 @@ _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader,
}
else
{
size_t length = element->name->length;
const char *const name = element->name->data;
size_t length = element->name->len();
const char *const name = element->name->chars();
if (name[0] != '[')
signature[index++] = 'L';
memcpy (&signature[index], name, length);

4
libjava/java/lang/reflect/natMethod.cc
View file

@ -246,7 +246,7 @@ _Jv_GetTypesFromSignature (jmethodID method,
_Jv_Utf8Const* sig = method->signature;
java::lang::ClassLoader *loader = declaringClass->getClassLoaderInternal();
char *ptr = sig->data;
char *ptr = sig->chars();
int numArgs = 0;
/* First just count the number of parameters. */
for (; ; ptr++)
@ -283,7 +283,7 @@ _Jv_GetTypesFromSignature (jmethodID method,
JArray<jclass> *args = (JArray<jclass> *)
JvNewObjectArray (numArgs, &java::lang::Class::class$, NULL);
jclass* argPtr = elements (args);
for (ptr = sig->data; *ptr != '\0'; ptr++)
for (ptr = sig->chars(); *ptr != '\0'; ptr++)
{
int num_arrays = 0;
jclass type;

28
libjava/jni.cc
View file

@ -1880,8 +1880,8 @@ _Jv_JNI_RegisterNatives (JNIEnv *env, jclass klass,
{
_Jv_Method *self = &imeths[i];
if (! strcmp (self->name->data, methods[j].name)
&& ! strcmp (self->signature->data, methods[j].signature))
if (! strcmp (self->name->chars (), methods[j].name)
&& ! strcmp (self->signature->chars (), methods[j].signature))
{
if (! (self->accflags
& java::lang::reflect::Modifier::NATIVE))
@ -1985,8 +1985,8 @@ mangled_name (jclass klass, _Jv_Utf8Const *func_name,
// Don't use add_char because we need a literal `_'.
buf[here++] = '_';
const unsigned char *fn = (const unsigned char *) func_name->data;
const unsigned char *limit = fn + func_name->length;
const unsigned char *fn = (const unsigned char *) func_name->chars ();
const unsigned char *limit = fn + func_name->len ();
for (int i = 0; ; ++i)
{
int ch = UTF8_GET (fn, limit);
@ -2000,8 +2000,8 @@ mangled_name (jclass klass, _Jv_Utf8Const *func_name,
buf[here++] = '_';
buf[here++] = '_';
const unsigned char *sig = (const unsigned char *) signature->data;
limit = sig + signature->length;
const unsigned char *sig = (const unsigned char *) signature->chars ();
limit = sig + signature->len ();
JvAssert (sig[0] == '(');
++sig;
while (1)
@ -2058,7 +2058,9 @@ extern "C" void *
_Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name,
_Jv_Utf8Const *signature, MAYBE_UNUSED int args_size)
{
char buf[10 + 6 * (name->length + signature->length) + 12];
int name_length = name->len();
int sig_length = signature->len();
char buf[10 + 6 * (name_length + sig_length) + 12];
int long_start;
void *function;
@ -2066,13 +2068,13 @@ _Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name,
JvSynchronize sync (global_ref_table);
// First see if we have an override in the hash table.
strncpy (buf, name->data, name->length);
buf[name->length] = '\0';
strncpy (buf + name->length + 1, signature->data, signature->length);
buf[name->length + signature->length + 1] = '\0';
strncpy (buf, name->chars (), name_length);
buf[name_length] = '\0';
strncpy (buf + name_length + 1, signature->chars (), sig_length);
buf[name_length + sig_length + 1] = '\0';
JNINativeMethod meth;
meth.name = buf;
meth.signature = buf + name->length + 1;
meth.signature = buf + name_length + 1;
function = nathash_find (&meth);
if (function != NULL)
return function;
@ -2139,7 +2141,7 @@ _Jv_LookupJNIMethod (jclass klass, _Jv_Utf8Const *name,
if (function == NULL)
#endif /* WIN32 */
{
jstring str = JvNewStringUTF (name->data);
jstring str = JvNewStringUTF (name->chars ());
throw new java::lang::UnsatisfiedLinkError (str);
}
}

23
libjava/prims.cc
View file

@ -255,8 +255,8 @@ _Jv_strLengthUtf8(char* str, int len)
/* Calculate a hash value for a string encoded in Utf8 format.
* This returns the same hash value as specified or java.lang.String.hashCode.
*/
static jint
hashUtf8String (char* str, int len)
jint
_Jv_hashUtf8String (char* str, int len)
{
unsigned char* ptr = (unsigned char*) str;
unsigned char* limit = ptr + len;
@ -272,17 +272,24 @@ hashUtf8String (char* str, int len)
return hash;
}
void
_Jv_Utf8Const::init(char *s, int len)
{
::memcpy (data, s, len);
data[len] = 0;
length = len;
hash = _Jv_hashUtf8String (s, len) & 0xFFFF;
}
_Jv_Utf8Const *
_Jv_makeUtf8Const (char* s, int len)
{
if (len < 0)
len = strlen (s);
Utf8Const* m = (Utf8Const*) _Jv_AllocBytes (sizeof(Utf8Const) + len + 1);
memcpy (m->data, s, len);
m->data[len] = 0;
m->length = len;
m->hash = hashUtf8String (s, len) & 0xFFFF;
return (m);
Utf8Const* m
= (Utf8Const*) _Jv_AllocBytes (_Jv_Utf8Const::space_needed(s, len));
m->init(s, len);
return m;
}
_Jv_Utf8Const *

26
libjava/resolve.cc
View file

@ -43,7 +43,7 @@ _Jv_ResolveField (_Jv_Field *field, java::lang::ClassLoader *loader)
if (! field->isResolved ())
{
_Jv_Utf8Const *sig = (_Jv_Utf8Const*)field->type;
field->type = _Jv_FindClassFromSignature (sig->data, loader);
field->type = _Jv_FindClassFromSignature (sig->chars(), loader);
field->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG;
}
}
@ -87,15 +87,15 @@ _Jv_ResolvePoolEntry (jclass klass, int index)
_Jv_Utf8Const *name = pool->data[index].utf8;
jclass found;
if (name->data[0] == '[')
found = _Jv_FindClassFromSignature (&name->data[0],
if (name->first() == '[')
found = _Jv_FindClassFromSignature (name->chars(),
klass->loader);
else
found = _Jv_FindClass (name, klass->loader);
if (! found)
{
jstring str = _Jv_NewStringUTF (name->data);
jstring str = name->toString();
// This exception is specified in JLS 2nd Ed, section 5.1.
throw new java::lang::NoClassDefFoundError (str);
}
@ -154,7 +154,7 @@ _Jv_ResolvePoolEntry (jclass klass, int index)
jclass field_type = 0;
if (owner->loader != klass->loader)
field_type = _Jv_FindClassFromSignature (field_type_name->data,
field_type = _Jv_FindClassFromSignature (field_type_name->chars(),
klass->loader);
_Jv_Field* the_field = 0;
@ -204,7 +204,7 @@ _Jv_ResolvePoolEntry (jclass klass, int index)
sb->append(JvNewStringLatin1("field "));
sb->append(owner->getName());
sb->append(JvNewStringLatin1("."));
sb->append(_Jv_NewStringUTF(field_name->data));
sb->append(field_name->toString());
sb->append(JvNewStringLatin1(" was not found."));
throw_incompatible_class_change_error(sb->toString());
}
@ -306,7 +306,7 @@ _Jv_ResolvePoolEntry (jclass klass, int index)
sb->append(JvNewStringLatin1("method "));
sb->append(owner->getName());
sb->append(JvNewStringLatin1("."));
sb->append(_Jv_NewStringUTF(method_name->data));
sb->append(method_name->toString());
sb->append(JvNewStringLatin1(" was not found."));
throw new java::lang::NoSuchMethodError (sb->toString());
}
@ -356,8 +356,8 @@ _Jv_SearchMethodInClass (jclass cls, jclass klass,
sb->append(JvNewStringLatin1(": "));
sb->append(cls->getName());
sb->append(JvNewStringLatin1("."));
sb->append(_Jv_NewStringUTF(method_name->data));
sb->append(_Jv_NewStringUTF(method_signature->data));
sb->append(method_name->toString());
sb->append(method_signature->toString());
throw new java::lang::IllegalAccessError (sb->toString());
}
}
@ -376,7 +376,7 @@ _Jv_PrepareMissingMethods (jclass base, jclass iface_class)
{
_Jv_Method *meth = &iface_class->interfaces[i]->methods[j];
// Don't bother with <clinit>.
if (meth->name->data[0] == '<')
if (meth->name->first() == '<')
continue;
_Jv_Method *new_meth = _Jv_LookupDeclaredMethod (base, meth->name,
meth->signature);
@ -859,7 +859,7 @@ int
_Jv_count_arguments (_Jv_Utf8Const *signature,
jboolean staticp)
{
unsigned char *ptr = (unsigned char*) signature->data;
unsigned char *ptr = (unsigned char*) signature->chars();
int arg_count = staticp ? 0 : 1;
/* first, count number of arguments */
@ -890,7 +890,7 @@ init_cif (_Jv_Utf8Const* signature,
ffi_type **arg_types,
ffi_type **rtype_p)
{
unsigned char *ptr = (unsigned char*) signature->data;
unsigned char *ptr = (unsigned char*) signature->chars();
int arg_index = 0; // arg number
int item_count = 0; // stack-item count
@ -923,7 +923,7 @@ init_cif (_Jv_Utf8Const* signature,
ffi_type *rtype = get_ffi_type_from_signature (ptr);
ptr = skip_one_type (ptr);
if (ptr != (unsigned char*)signature->data + signature->length)
if (ptr != (unsigned char*)signature->chars() + signature->len())
throw_internal_error ("did not find end of signature");
if (ffi_prep_cif (cif, FFI_DEFAULT_ABI,

48
libjava/verify.cc
View file

@ -179,28 +179,21 @@ private:
// This method.
_Jv_InterpMethod *current_method;
// A linked list of utf8 objects we allocate. This is really ugly,
// but without this our utf8 objects would be collected.
// A linked list of utf8 objects we allocate.
linked<_Jv_Utf8Const> *utf8_list;
// A linked list of all ref_intersection objects we allocate.
ref_intersection *isect_list;
// Create a new Utf-8 constant and return it. We do this to avoid
// having our Utf-8 constants prematurely collected. FIXME this is
// ugly.
// having our Utf-8 constants prematurely collected.
_Jv_Utf8Const *make_utf8_const (char *s, int len)
{
_Jv_Utf8Const *val = _Jv_makeUtf8Const (s, len);
_Jv_Utf8Const *r = (_Jv_Utf8Const *) _Jv_Malloc (sizeof (_Jv_Utf8Const)
+ val->length
+ 1);
r->length = val->length;
r->hash = val->hash;
memcpy (r->data, val->data, val->length + 1);
linked<_Jv_Utf8Const> *lu
= (linked<_Jv_Utf8Const> *) _Jv_Malloc (sizeof (linked<_Jv_Utf8Const>));
linked<_Jv_Utf8Const> *lu = (linked<_Jv_Utf8Const> *)
_Jv_Malloc (sizeof (linked<_Jv_Utf8Const>)
+ _Jv_Utf8Const::space_needed(s, len));
_Jv_Utf8Const *r = (_Jv_Utf8Const *) (lu + 1);
r->init(s, len);
lu->val = r;
lu->next = utf8_list;
utf8_list = lu;
@ -226,9 +219,9 @@ private:
buf->append (JvNewStringLatin1 (" in "));
buf->append (current_class->getName());
buf->append ((jchar) ':');
buf->append (JvNewStringUTF (method->get_method()->name->data));
buf->append (method->get_method()->name->toString());
buf->append ((jchar) '(');
buf->append (JvNewStringUTF (method->get_method()->signature->data));
buf->append (method->get_method()->signature->toString());
buf->append ((jchar) ')');
buf->append (JvNewStringLatin1 (": "));
@ -372,9 +365,8 @@ private:
java::lang::ClassLoader *loader
= verifier->current_class->getClassLoaderInternal();
// We might see either kind of name. Sigh.
if (data.name->data[0] == 'L'
&& data.name->data[data.name->length - 1] == ';')
data.klass = _Jv_FindClassFromSignature (data.name->data, loader);
if (data.name->first() == 'L' && data.name->limit()[-1] == ';')
data.klass = _Jv_FindClassFromSignature (data.name->chars(), loader);
else
data.klass = Class::forName (_Jv_NewStringUtf8Const (data.name),
false, loader);
@ -422,7 +414,7 @@ private:
if (is_resolved)
return data.klass->isArray ();
else
return data.name->data[0] == '[';
return data.name->first() == '[';
}
bool isinterface (_Jv_BytecodeVerifier *verifier)
@ -463,7 +455,7 @@ private:
}
else
{
char *p = data.name->data;
char *p = data.name->chars();
while (*p++ == '[')
++ndims;
}
@ -1992,9 +1984,9 @@ private:
&name, &field_type);
if (class_type)
*class_type = ct;
if (field_type->data[0] == '[' || field_type->data[0] == 'L')
if (field_type->first() == '[' || field_type->first() == 'L')
return type (field_type, this);
return get_type_val_for_signature (field_type->data[0]);
return get_type_val_for_signature (field_type->first());
}
type check_method_constant (int index, bool is_interface,
@ -2050,7 +2042,8 @@ private:
void compute_argument_types (_Jv_Utf8Const *signature,
type *types)
{
char *p = signature->data;
char *p = signature->chars();
// Skip `('.
++p;
@ -2061,7 +2054,7 @@ private:
type compute_return_type (_Jv_Utf8Const *signature)
{
char *p = signature->data;
char *p = signature->chars();
while (*p != ')')
++p;
++p;
@ -2845,7 +2838,7 @@ private:
if (opcode != op_invokespecial)
verify_fail ("can't invoke <init>");
}
else if (method_name->data[0] == '<')
else if (method_name->first() == '<')
verify_fail ("can't invoke method starting with `<'");
// Pop arguments and check types.
@ -3060,7 +3053,7 @@ public:
// We just print the text as utf-8. This is just for debugging
// anyway.
debug_print ("--------------------------------\n");
debug_print ("-- Verifying method `%s'\n", m->self->name->data);
debug_print ("-- Verifying method `%s'\n", m->self->name->chars());
current_method = m;
bytecode = m->bytecode ();
@ -3081,7 +3074,6 @@ public:
while (utf8_list != NULL)
{
linked<_Jv_Utf8Const> *n = utf8_list->next;
_Jv_Free (utf8_list->val);
_Jv_Free (utf8_list);
utf8_list = n;
}