// defineclass.cc - defining a class from .class format.
-/* Copyright (C) 1999, 2000 Free Software Foundation
+/* Copyright (C) 1999, 2000, 2001 Free Software Foundation
This file is part of libgcj.
#ifdef INTERPRETER
-#include <alloca.h>
+#include <stdlib.h>
#include <java-cpool.h>
#include <gcj/cni.h>
#include <java/lang/IncompatibleClassChangeError.h>
#include <java/lang/reflect/Modifier.h>
-#define ClassClass _CL_Q34java4lang5Class
-extern java::lang::Class ClassClass;
-#define ClassObject _CL_Q34java4lang6Object
-extern java::lang::Class ClassObject;
-
// we don't verify method names that match these.
static _Jv_Utf8Const *clinit_name = _Jv_makeUtf8Const ("<clinit>", 8);
static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("<init>", 6);
__attribute__ ((__noreturn__));
static void throw_class_format_error (jstring msg)
__attribute__ ((__noreturn__));
-static void throw_class_format_error (char *msg)
- __attribute__ ((__noreturn__));
static void throw_incompatible_class_change_error (jstring msg)
__attribute__ ((__noreturn__));
static void throw_class_circularity_error (jstring msg)
throw_class_format_error ("erroneous constant pool tag");
}
+ inline void verify_identifier (_Jv_Utf8Const* name)
+ {
+ if (! _Jv_VerifyIdentifier (name))
+ throw_class_format_error ("erroneous identifier");
+ }
+
+ inline void verify_classname (unsigned char* ptr, _Jv_ushort length)
+ {
+ if (! _Jv_VerifyClassName (ptr, length))
+ throw_class_format_error ("erroneous class name");
+ }
+
+ inline void verify_classname (_Jv_Utf8Const *name)
+ {
+ if (! _Jv_VerifyClassName (name))
+ throw_class_format_error ("erroneous class name");
+ }
+
+ inline void verify_field_signature (_Jv_Utf8Const *sig)
+ {
+ if (! _Jv_VerifyFieldSignature (sig))
+ throw_class_format_error ("erroneous type descriptor");
+ }
+
+ inline void verify_method_signature (_Jv_Utf8Const *sig)
+ {
+ if (! _Jv_VerifyMethodSignature (sig))
+ throw_class_format_error ("erroneous type descriptor");
+ }
+
_Jv_ClassReader (jclass klass, jbyteArray data, jint offset, jint length)
{
if (klass == 0 || length < 0 || offset+length > data->length)
void read_one_method_attribute (int method);
void read_one_code_attribute (int method);
void read_one_field_attribute (int field);
+ void throw_class_format_error (char *msg);
/** check an utf8 entry, without creating a Utf8Const object */
bool is_attribute_name (int index, char *name);
void _Jv_ClassReader::read_constpool ()
{
- tags = (unsigned char*) _Jv_AllocBytesChecked (pool_count);
- offsets = (unsigned int *) _Jv_AllocBytesChecked (sizeof (int)
+ tags = (unsigned char*) _Jv_AllocBytes (pool_count);
+ offsets = (unsigned int *) _Jv_AllocBytes (sizeof (int)
* pool_count) ;
/** first, we scan the constant pool, collecting tags and offsets */
/** now, we actually define the class' constant pool */
// the pool is scanned explicitly by the collector
- jbyte *pool_tags = (jbyte*) _Jv_AllocBytesChecked (pool_count);
+ jbyte *pool_tags = (jbyte*) _Jv_AllocBytes (pool_count);
_Jv_word *pool_data
- = (_Jv_word*) _Jv_AllocBytesChecked (pool_count * sizeof (_Jv_word));
+ = (_Jv_word*) _Jv_AllocBytes (pool_count * sizeof (_Jv_word));
def->constants.tags = pool_tags;
def->constants.data = pool_data;
// order to accomondate gcj's internal representation.
int len = get2u (this_data);
- char *buffer = (char*) alloca (len);
+ char *buffer = (char*) __builtin_alloca (len);
char *s = ((char*) this_data)+2;
/* FIXME: avoid using a buffer here */
prepare_pool_entry (utf_index, JV_CONSTANT_Utf8);
if (verify)
- _Jv_VerifyClassName (pool_data[utf_index].utf8);
+ verify_classname (pool_data[utf_index].utf8);
pool_data[index].utf8 = pool_data[utf_index].utf8;
pool_tags[index] = JV_CONSTANT_Class;
|| _Jv_equalUtf8Consts (name, init_name)))
/* ignore */;
else
- _Jv_VerifyIdentifier (pool_data[name_index].utf8);
+ verify_identifier (pool_data[name_index].utf8);
}
_Jv_storeIndexes (&pool_data[index], class_index, nat_index);
// interfaces have java.lang.Object as super.
if (access_flags & Modifier::INTERFACE)
{
- def->superclass = (jclass)&ClassObject;
+ def->superclass = (jclass)&java::lang::Class::class$;
}
// FIXME: Consider this carefully!
- else if (!_Jv_equalUtf8Consts (def->name, ClassObject.name))
+ else if (!_Jv_equalUtf8Consts (def->name,
+ java::lang::Class::class$.name))
{
throw_no_class_def_found_error ("loading java.lang.Object");
}
void _Jv_ClassReader::handleInterfacesBegin (int count)
{
- def->interfaces = (jclass*) _Jv_AllocBytesChecked (count*sizeof (jclass));
+ def->interfaces = (jclass*) _Jv_AllocBytes (count*sizeof (jclass));
def->interface_count = count;
}
void _Jv_ClassReader::handleFieldsBegin (int count)
{
def->fields = (_Jv_Field*)
- _Jv_AllocBytesChecked (count * sizeof (_Jv_Field));
+ _Jv_AllocBytes (count * sizeof (_Jv_Field));
def->field_count = count;
def->field_initializers = (_Jv_ushort*)
- _Jv_AllocBytesChecked (count * sizeof (_Jv_ushort));
+ _Jv_AllocBytes (count * sizeof (_Jv_ushort));
for (int i = 0; i < count; i++)
def->field_initializers[i] = (_Jv_ushort) 0;
}
#endif
if (verify)
- _Jv_VerifyIdentifier (field_name);
+ verify_identifier (field_name);
// ignore flags we don't know about.
field->flags = flags & Modifier::ALL_FLAGS;
_Jv_ClassReader::handleMethodsBegin (int count)
{
def->methods = (_Jv_Method*)
- _Jv_AllocBytesChecked (sizeof (_Jv_Method)*count);
+ _Jv_AllocBytes (sizeof (_Jv_Method)*count);
def->interpreted_methods
- = (_Jv_MethodBase **) _Jv_AllocBytesChecked (sizeof (_Jv_MethodBase *)
- * count);
+ = (_Jv_MethodBase **) _Jv_AllocBytes (sizeof (_Jv_MethodBase *)
+ * count);
for (int i = 0; i < count; i++)
def->interpreted_methods[i] = 0;
|| _Jv_equalUtf8Consts (method->name, init_name))
/* ignore */;
else
- _Jv_VerifyIdentifier (method->name);
+ verify_identifier (method->name);
_Jv_VerifyMethodSignature (method->signature);
{
int size = _Jv_InterpMethod::size (exc_table_length, code_length);
_Jv_InterpMethod *method =
- (_Jv_InterpMethod*) (_Jv_AllocBytesChecked (size));
+ (_Jv_InterpMethod*) (_Jv_AllocBytes (size));
method->max_stack = max_stack;
method->max_locals = max_locals;
else
{
_Jv_JNIMethod *m = (_Jv_JNIMethod *)
- _Jv_AllocBytesChecked (sizeof (_Jv_JNIMethod));
+ _Jv_AllocBytes (sizeof (_Jv_JNIMethod));
m->defining_class = def;
m->self = method;
m->function = NULL;
}
+void _Jv_ClassReader::throw_class_format_error (char *msg)
+{
+ jstring str;
+ if (def->name != NULL)
+ {
+ jsize mlen = strlen (msg);
+ unsigned char* data = (unsigned char*) def->name->data;
+ int ulen = def->name->length;
+ unsigned char* limit = data + ulen;
+ jsize nlen = _Jv_strLengthUtf8 ((char *) data, ulen);
+ jsize len = nlen + mlen + 3;
+ str = JvAllocString(len);
+ jchar *chrs = JvGetStringChars(str);
+ while (data < limit)
+ *chrs++ = UTF8_GET(data, limit);
+ *chrs++ = ' ';
+ *chrs++ = '(';
+ for (;;)
+ {
+ char c = *msg++;
+ if (c == 0)
+ break;
+ *chrs++ = c & 0xFFFF;
+ }
+ *chrs++ = ')';
+ }
+ else
+ str = JvNewStringLatin1 (msg);
+ ::throw_class_format_error (str);
+}
\f
/** This section takes care of verifying integrity of identifiers,
signatures, field ddescriptors, and class names */
return 0;
} while (ch != ';');
- _Jv_VerifyClassName (start, (unsigned short) (end-start));
+ if (! _Jv_VerifyClassName (start, (unsigned short) (end-start)))
+ return 0;
}
break;
/** verification and loading procedures **/
-void
+bool
_Jv_VerifyFieldSignature (_Jv_Utf8Const*sig)
{
unsigned char* ptr = (unsigned char*) sig->data;
ptr = _Jv_VerifyOne (ptr, limit, false);
- if (ptr != limit)
- throw_class_format_error ("erroneous type descriptor");
+ return ptr == limit;
}
-void
+bool
_Jv_VerifyMethodSignature (_Jv_Utf8Const*sig)
{
unsigned char* ptr = (unsigned char*) sig->data;
unsigned char* limit = ptr + sig->length;
- if (ptr == limit)
- throw_class_format_error ("erroneous type descriptor");
-
- if (UTF8_GET(ptr,limit) != '(')
- throw_class_format_error ("erroneous type descriptor");
+ if (ptr == limit || UTF8_GET(ptr,limit) != '(')
+ return false;
while (ptr && UTF8_PEEK (ptr, limit) != ')')
ptr = _Jv_VerifyOne (ptr, limit, false);
if (UTF8_GET (ptr, limit) != ')')
- throw_class_format_error ("erroneous type descriptor");
+ return false;
// get the return type
ptr = _Jv_VerifyOne (ptr, limit, true);
- if (ptr != limit)
- throw_class_format_error ("erroneous type descriptor");
-
- return;
-
+ return ptr == limit;
}
/* we try to avoid calling the Character methods all the time,
return character->isJavaIdentifierStart ((jchar) ch);
}
-void
+bool
_Jv_VerifyIdentifier (_Jv_Utf8Const* name)
{
unsigned char *ptr = (unsigned char*) name->data;
if ((ch = UTF8_GET (ptr, limit))==-1
|| ! is_identifier_start (ch))
- throw_class_format_error ("erroneous identifier");
+ return false;
while (ptr != limit)
{
if ((ch = UTF8_GET (ptr, limit))==-1
|| ! is_identifier_part (ch))
- throw_class_format_error ("erroneous identifier");
+ return false;
}
+ return true;
}
-
-void
+bool
_Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length)
{
unsigned char *limit = ptr+length;
if ('[' == UTF8_PEEK (ptr, limit))
{
if (! _Jv_VerifyOne (++ptr, limit, false))
- throw_class_format_error ("erroneous class name");
+ return false;
else
- return;
+ return true;
}
next_level:
- do {
+ for (;;) {
if ((ch = UTF8_GET (ptr, limit))==-1)
- throw_class_format_error ("erroneous class name");
+ return false;
if (! is_identifier_start (ch))
- throw_class_format_error ("erroneous class name");
- do {
+ return false;
+ for (;;) {
if (ptr == limit)
- return;
+ return true;
else if ((ch = UTF8_GET (ptr, limit))==-1)
- throw_class_format_error ("erroneous class name");
+ return false;
else if (ch == '.')
goto next_level;
else if (! is_identifier_part (ch))
- throw_class_format_error ("erroneous class name");
- } while (true);
- } while (true);
-
+ return false;
+ }
+ }
}
-void
+bool
_Jv_VerifyClassName (_Jv_Utf8Const *name)
{
- _Jv_VerifyClassName ((unsigned char*)&name->data[0],
- (_Jv_ushort) name->length);
+ return _Jv_VerifyClassName ((unsigned char*)&name->data[0],
+ (_Jv_ushort) name->length);
}
-
/** returns true, if name1 and name2 represents classes in the same
package. */
static void
throw_no_class_def_found_error (jstring msg)
{
- if (msg == 0)
- JvThrow (new java::lang::NoClassDefFoundError);
- else
- JvThrow (new java::lang::NoClassDefFoundError (msg));
+ throw (msg
+ ? new java::lang::NoClassDefFoundError (msg)
+ : new java::lang::NoClassDefFoundError);
}
static void
static void
throw_class_format_error (jstring msg)
{
- if (msg == 0)
- JvThrow (new java::lang::ClassFormatError);
- else
- JvThrow (new java::lang::ClassFormatError (msg));
-}
-
-static void
-throw_class_format_error (char *msg)
-{
- throw_class_format_error (JvNewStringLatin1 (msg));
+ throw (msg
+ ? new java::lang::ClassFormatError (msg)
+ : new java::lang::ClassFormatError);
}
static void
throw_internal_error (char *msg)
{
- JvThrow
- (new java::lang::InternalError (JvNewStringLatin1 (msg)));
+ throw new java::lang::InternalError (JvNewStringLatin1 (msg));
}
static jfloat int_bits_to_float (jint value)
static void throw_incompatible_class_change_error (jstring msg)
{
- JvThrow (new java::lang::IncompatibleClassChangeError (msg));
+ throw new java::lang::IncompatibleClassChangeError (msg);
}
static void throw_class_circularity_error (jstring msg)
{
- JvThrow (new java::lang::ClassCircularityError (msg));
+ throw new java::lang::ClassCircularityError (msg);
}
#endif /* INTERPRETER */
OSDN Git Service
