X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;ds=sidebyside;f=libjava%2Fdefineclass.cc;h=95e671f42a39d1efa6ecb2e6df1c35e679741edb;hb=d9cbfcb620294212c5082753c141da7b5c7d3eaa;hp=7ddead0965bc88e99f321a7525c166679937ae96;hpb=ec99c8245dcc12f9590c367a445bbe53bb3fb615;p=pf3gnuchains%2Fgcc-fork.git diff --git a/libjava/defineclass.cc b/libjava/defineclass.cc index 7ddead0965b..95e671f42a3 100644 --- a/libjava/defineclass.cc +++ b/libjava/defineclass.cc @@ -1,6 +1,6 @@ // defineclass.cc - defining a class from .class format. -/* Copyright (C) 1999, 2000 Free Software Foundation +/* Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation This file is part of libgcj. @@ -22,11 +22,7 @@ details. */ #include -#ifdef INTERPRETER - -#if HAVE_ALLOCA_H -#include -#endif +#include #include #include @@ -43,17 +39,11 @@ details. */ #include #include -#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 ("", 8); -static _Jv_Utf8Const *init_name = _Jv_makeUtf8Const ("", 6); +using namespace gcj; +#ifdef INTERPRETER -// these go in some seperate functions, to avoid having _Jv_InitClass +// these go in some separate functions, to avoid having _Jv_InitClass // inserted all over the place. static void throw_internal_error (char *msg) __attribute__ ((__noreturn__)); @@ -63,16 +53,11 @@ static void throw_no_class_def_found_error (char *msg) __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) __attribute__ ((__noreturn__)); -static jdouble long_bits_to_double (jlong); -static jfloat int_bits_to_float (jint); - /** * We define class reading using a class. It is practical, since then * the entire class-reader can be a friend of class Class (it needs to @@ -198,6 +183,36 @@ struct _Jv_ClassReader { 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) @@ -220,6 +235,7 @@ struct _Jv_ClassReader { 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); @@ -252,30 +268,15 @@ struct _Jv_ClassReader { */ }; -/* This is used for the isJavaIdentifierStart & isJavaIdentifierPart - methods, so we avoid doing _Jv_InitClass all the time */ - -static const java::lang::Character *character = 0; -static void prepare_character (); - void _Jv_DefineClass (jclass klass, jbyteArray data, jint offset, jint length) { - if (character == 0) - prepare_character (); - _Jv_ClassReader reader (klass, data, offset, length); reader.parse(); /* that's it! */ } -/** put it after _Jv_DefineClass, so it doesn't get inlined */ -static void prepare_character () -{ - character = new java::lang::Character ('!'); -} - /** This section defines the parsing/scanning of the class data */ @@ -338,8 +339,8 @@ _Jv_ClassReader::parse () 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 */ @@ -484,10 +485,10 @@ void _Jv_ClassReader::read_methods () check_tag (name_index, JV_CONSTANT_Utf8); prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8); - + handleMethod (i, access_flags, name_index, descriptor_index); - + for (int j = 0; j < attributes_count; j++) { read_one_method_attribute (i); @@ -504,10 +505,42 @@ void _Jv_ClassReader::read_one_method_attribute (int method_index) if (is_attribute_name (name, "Exceptions")) { - /* we ignore this for now */ - skip (length); + _Jv_Method *method = reinterpret_cast<_Jv_Method *> + (&def->methods[method_index]); + if (method->throws != NULL) + throw_class_format_error ("only one Exceptions attribute allowed per method"); + + int num_exceptions = read2u (); + // We use malloc here because the GC won't scan the method + // objects. FIXME this means a memory leak if we GC a class. + // (Currently we never do.) + _Jv_Utf8Const **exceptions = + (_Jv_Utf8Const **) _Jv_Malloc ((num_exceptions + 1) * sizeof (_Jv_Utf8Const *)); + + int out = 0; + _Jv_word *pool_data = def->constants.data; + for (int i = 0; i < num_exceptions; ++i) + { + try + { + int ndx = read2u (); + // JLS 2nd Ed. 4.7.5 requires that the tag not be 0. + if (ndx != 0) + { + check_tag (ndx, JV_CONSTANT_Class); + exceptions[out++] = pool_data[ndx].utf8; + } + } + catch (java::lang::Throwable *exc) + { + _Jv_Free (exceptions); + throw exc; + } + } + exceptions[out] = NULL; + method->throws = exceptions; } - + else if (is_attribute_name (name, "Code")) { int start_off = pos; @@ -534,7 +567,9 @@ void _Jv_ClassReader::read_one_method_attribute (int method_index) if (start_pc > end_pc || start_pc < 0 - || end_pc >= code_length + // END_PC can be equal to CODE_LENGTH. + // See JVM Spec 4.7.4. + || end_pc > code_length || handler_pc >= code_length) throw_class_format_error ("erroneous exception handler info"); @@ -603,9 +638,9 @@ void _Jv_ClassReader::handleConstantPool () /** 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; @@ -682,7 +717,7 @@ _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag) // 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 */ @@ -706,7 +741,7 @@ _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag) 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; @@ -749,7 +784,7 @@ _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag) || _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); @@ -775,7 +810,7 @@ _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag) case JV_CONSTANT_Float: { - jfloat f = int_bits_to_float ((jint) get4 (this_data)); + jfloat f = java::lang::Float::intBitsToFloat ((jint) get4 (this_data)); _Jv_storeFloat (&pool_data[index], f); pool_tags[index] = JV_CONSTANT_Float; } @@ -791,7 +826,8 @@ _Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag) case JV_CONSTANT_Double: { - jdouble d = long_bits_to_double ((jlong) get8 (this_data)); + jdouble d + = java::lang::Double::longBitsToDouble ((jlong) get8 (this_data)); _Jv_storeDouble (&pool_data[index], d); pool_tags[index] = JV_CONSTANT_Double; } @@ -859,19 +895,11 @@ _Jv_ClassReader::handleClassBegin pool_data[this_class].clazz = def; pool_tags[this_class] = JV_CONSTANT_ResolvedClass; - if (super_class == 0) + if (super_class == 0 && ! (access_flags & Modifier::INTERFACE)) { - // interfaces have java.lang.Object as super. - if (access_flags & Modifier::INTERFACE) - { - def->superclass = (jclass)&ClassObject; - } - // FIXME: Consider this carefully! - else if (!_Jv_equalUtf8Consts (def->name, ClassObject.name)) - { - throw_no_class_def_found_error ("loading java.lang.Object"); - } + if (! _Jv_equalUtf8Consts (def->name, java::lang::Object::class$.name)) + throw_no_class_def_found_error ("loading java.lang.Object"); } // In the pre-loading state, it can be looked up in the @@ -879,29 +907,38 @@ _Jv_ClassReader::handleClassBegin // to include references to this class. def->state = JV_STATE_PRELOADING; - _Jv_RegisterClass (def); + + { + JvSynchronize sync (&java::lang::Class::class$); + _Jv_RegisterClass (def); + } if (super_class != 0) { - // load the super class + // Load the superclass. check_tag (super_class, JV_CONSTANT_Class); _Jv_Utf8Const* super_name = pool_data[super_class].utf8; - // load the super class using our defining loader + // Load the superclass using our defining loader. jclass the_super = _Jv_FindClass (super_name, def->loader); // This will establish that we are allowed to be a subclass, - // and check for class circularity error + // and check for class circularity error. checkExtends (def, the_super); - def->superclass = the_super; + // Note: for an interface we will find Object as the + // superclass. We still check it above to ensure class file + // validity, but we simply assign `null' to the actual field in + // this case. + def->superclass = (((access_flags & Modifier::INTERFACE)) + ? NULL : the_super); pool_data[super_class].clazz = the_super; pool_tags[super_class] = JV_CONSTANT_ResolvedClass; } - - // now we've come past the circularity problem, we can - // now say that we're loading... + + // Now we've come past the circularity problem, we can + // now say that we're loading. def->state = JV_STATE_LOADING; def->notifyAll (); @@ -942,7 +979,7 @@ _Jv_ClassReader::checkExtends (jclass sub, jclass super) 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; } @@ -1009,10 +1046,10 @@ _Jv_ClassReader::checkImplements (jclass sub, jclass super) 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; } @@ -1036,7 +1073,7 @@ void _Jv_ClassReader::handleField (int field_no, #endif if (verify) - _Jv_VerifyIdentifier (field_name); + verify_identifier (field_name); // ignore flags we don't know about. field->flags = flags & Modifier::ALL_FLAGS; @@ -1149,11 +1186,11 @@ void _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; @@ -1183,6 +1220,7 @@ void _Jv_ClassReader::handleMethod // intialize... method->ncode = 0; + method->throws = NULL; if (verify) { @@ -1190,7 +1228,7 @@ void _Jv_ClassReader::handleMethod || _Jv_equalUtf8Consts (method->name, init_name)) /* ignore */; else - _Jv_VerifyIdentifier (method->name); + verify_identifier (method->name); _Jv_VerifyMethodSignature (method->signature); @@ -1212,7 +1250,7 @@ void _Jv_ClassReader::handleCodeAttribute { 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; @@ -1220,18 +1258,17 @@ void _Jv_ClassReader::handleCodeAttribute method->exc_count = exc_table_length; method->defining_class = def; method->self = &def->methods[method_index]; + method->prepared = NULL; // grab the byte code! memcpy ((void*) method->bytecode (), (void*) (bytes+code_start), code_length); - - def->interpreted_methods[method_index] = method; - /* that's all we do for now */ + def->interpreted_methods[method_index] = method; } -void _Jv_ClassReader::handleExceptionTableEntry +void _Jv_ClassReader::handleExceptionTableEntry (int method_index, int exc_index, int start_pc, int end_pc, int handler_pc, int catch_type) { @@ -1239,10 +1276,10 @@ void _Jv_ClassReader::handleExceptionTableEntry (def->interpreted_methods[method_index]); _Jv_InterpException *exc = method->exceptions (); - exc[exc_index].start_pc = start_pc; - exc[exc_index].end_pc = end_pc; - exc[exc_index].handler_pc = handler_pc; - exc[exc_index].handler_type = catch_type; + exc[exc_index].start_pc.i = start_pc; + exc[exc_index].end_pc.i = end_pc; + exc[exc_index].handler_pc.i = handler_pc; + exc[exc_index].handler_type.i = catch_type; } void _Jv_ClassReader::handleMethodsEnd () @@ -1259,7 +1296,7 @@ void _Jv_ClassReader::handleMethodsEnd () 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; @@ -1277,10 +1314,83 @@ void _Jv_ClassReader::handleMethodsEnd () throw_class_format_error ("method with no code"); } } +} + +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); +} + +/** Here we define the exceptions that can be thrown */ + +static void +throw_no_class_def_found_error (jstring msg) +{ + throw (msg + ? new java::lang::NoClassDefFoundError (msg) + : new java::lang::NoClassDefFoundError); +} + +static void +throw_no_class_def_found_error (char *msg) +{ + throw_no_class_def_found_error (JvNewStringLatin1 (msg)); +} +static void +throw_class_format_error (jstring msg) +{ + throw (msg + ? new java::lang::ClassFormatError (msg) + : new java::lang::ClassFormatError); } +static void +throw_internal_error (char *msg) +{ + throw new java::lang::InternalError (JvNewStringLatin1 (msg)); +} + +static void throw_incompatible_class_change_error (jstring msg) +{ + throw new java::lang::IncompatibleClassChangeError (msg); +} + +static void throw_class_circularity_error (jstring msg) +{ + throw new java::lang::ClassCircularityError (msg); +} + +#endif /* INTERPRETER */ + + /** This section takes care of verifying integrity of identifiers, signatures, field ddescriptors, and class names */ @@ -1289,7 +1399,7 @@ void _Jv_ClassReader::handleMethodsEnd () int xxch = UTF8_GET(PTR,LIMIT); \ PTR = xxkeep; xxch; }) -/* verify one element of a type descriptor or signature */ +/* Verify one element of a type descriptor or signature. */ static unsigned char* _Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok) { @@ -1301,7 +1411,8 @@ _Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok) switch (ch) { case 'V': - if (! void_ok) return 0; + if (! void_ok) + return 0; case 'S': case 'B': case 'I': case 'J': case 'Z': case 'C': case 'F': case 'D': @@ -1310,36 +1421,36 @@ _Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok) case 'L': { unsigned char *start = ptr, *end; - do { - if (ptr > limit) - return 0; - - end = ptr; - - if ((ch = UTF8_GET (ptr, limit)) == -1) - return 0; - - } while (ch != ';'); - _Jv_VerifyClassName (start, (unsigned short) (end-start)); + do + { + if (ptr > limit) + return 0; + + end = ptr; + + if ((ch = UTF8_GET (ptr, limit)) == -1) + return 0; + + } + while (ch != ';'); + if (! _Jv_VerifyClassName (start, (unsigned short) (end-start))) + return 0; } break; case '[': return _Jv_VerifyOne (ptr, limit, false); break; - + default: return 0; } return ptr; - } - -/** verification and loading procedures **/ - -void +/* Verification and loading procedures. */ +bool _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig) { unsigned char* ptr = (unsigned char*) sig->data; @@ -1347,41 +1458,32 @@ _Jv_VerifyFieldSignature (_Jv_Utf8Const*sig) 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, - in fact, they will only be called for non-standard things */ - +/* We try to avoid calling the Character methods all the time, in + fact, they will only be called for non-standard things. */ static __inline__ int is_identifier_start (int c) { @@ -1394,7 +1496,7 @@ is_identifier_start (int c) if (ch == 0x5FU) /* _ */ return 1; - return character->isJavaIdentifierStart ((jchar) ch); + return java::lang::Character::isJavaIdentifierStart ((jchar) ch); } static __inline__ int @@ -1411,10 +1513,10 @@ is_identifier_part (int c) if (ch == 0x5FU || ch == 0x24U) /* _ $ */ return 1; - return character->isJavaIdentifierStart ((jchar) ch); + return java::lang::Character::isJavaIdentifierStart ((jchar) ch); } -void +bool _Jv_VerifyIdentifier (_Jv_Utf8Const* name) { unsigned char *ptr = (unsigned char*) name->data; @@ -1423,18 +1525,18 @@ _Jv_VerifyIdentifier (_Jv_Utf8Const* name) 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; @@ -1442,43 +1544,43 @@ _Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length) if ('[' == UTF8_PEEK (ptr, limit)) { - if (! _Jv_VerifyOne (++ptr, limit, false)) - throw_class_format_error ("erroneous class name"); + unsigned char *end = _Jv_VerifyOne (++ptr, limit, false); + // _Jv_VerifyOne must leave us looking at the terminating nul + // byte. + if (! end || *end) + 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. */ - +/* Returns true, if NAME1 and NAME2 represent classes in the same + package. */ bool _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2) { @@ -1493,22 +1595,22 @@ _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2) if (ch1 == '.') last1 = ptr1; - + else if (ch1 == -1) return false; } - // now the length of name1's package name is len + // Now the length of NAME1's package name is LEN. int len = last1 - (unsigned char*) name1->data; - // if this is longer than name2, then we're off + // If this is longer than NAME2, then we're off. if (len > name2->length) return false; - // then compare the first len bytes for equality + // Then compare the first len bytes for equality. if (memcmp ((void*) name1->data, (void*) name2->data, len) == 0) { - // check that there are no .'s after position len in name2 + // Check that there are no .'s after position LEN in NAME2. unsigned char* ptr2 = (unsigned char*) name2->data + len; unsigned char* limit2 = @@ -1524,67 +1626,3 @@ _Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2) } return false; } - - - -/** Here we define the exceptions that can be thrown */ - -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)); -} - -static void -throw_no_class_def_found_error (char *msg) -{ - throw_no_class_def_found_error (JvNewStringLatin1 (msg)); -} - -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)); -} - -static void -throw_internal_error (char *msg) -{ - JvThrow - (new java::lang::InternalError (JvNewStringLatin1 (msg))); -} - -static jfloat int_bits_to_float (jint value) -{ - return java::lang::Float::intBitsToFloat (value); -} - -static jdouble long_bits_to_double (jlong value) -{ - return java::lang::Double::longBitsToDouble (value); -} - -static void throw_incompatible_class_change_error (jstring msg) -{ - JvThrow (new java::lang::IncompatibleClassChangeError (msg)); -} - -static void throw_class_circularity_error (jstring msg) -{ - JvThrow (new java::lang::ClassCircularityError (msg)); -} - -#endif /* INTERPRETER */ -