// defineclass.cc - defining a class from .class format.
|
// defineclass.cc - defining a class from .class format.
|
|
|
/* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
/* Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
|
Free Software Foundation
|
Free Software Foundation
|
|
|
This file is part of libgcj.
|
This file is part of libgcj.
|
|
|
This software is copyrighted work licensed under the terms of the
|
This software is copyrighted work licensed under the terms of the
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
details. */
|
details. */
|
|
|
/*
|
/*
|
Author: Kresten Krab Thorup <krab@gnu.org>
|
Author: Kresten Krab Thorup <krab@gnu.org>
|
|
|
Written using the online versions of Java Language Specification (1st
|
Written using the online versions of Java Language Specification (1st
|
ed.) and The Java Virtual Machine Specification (2nd ed.).
|
ed.) and The Java Virtual Machine Specification (2nd ed.).
|
|
|
Future work may include reading (and handling) attributes which are
|
Future work may include reading (and handling) attributes which are
|
currently being ignored ("InnerClasses", "LineNumber", etc...).
|
currently being ignored ("InnerClasses", "LineNumber", etc...).
|
*/
|
*/
|
|
|
#include <config.h>
|
#include <config.h>
|
|
|
#include <java-interp.h>
|
#include <java-interp.h>
|
|
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <stdio.h>
|
#include <java-cpool.h>
|
#include <java-cpool.h>
|
#include <gcj/cni.h>
|
#include <gcj/cni.h>
|
#include <execution.h>
|
#include <execution.h>
|
|
|
#include <java/lang/Class.h>
|
#include <java/lang/Class.h>
|
#include <java/lang/Float.h>
|
#include <java/lang/Float.h>
|
#include <java/lang/Double.h>
|
#include <java/lang/Double.h>
|
#include <java/lang/Character.h>
|
#include <java/lang/Character.h>
|
#include <java/lang/LinkageError.h>
|
#include <java/lang/LinkageError.h>
|
#include <java/lang/InternalError.h>
|
#include <java/lang/InternalError.h>
|
#include <java/lang/ClassFormatError.h>
|
#include <java/lang/ClassFormatError.h>
|
#include <java/lang/NoClassDefFoundError.h>
|
#include <java/lang/NoClassDefFoundError.h>
|
#include <java/lang/ClassCircularityError.h>
|
#include <java/lang/ClassCircularityError.h>
|
#include <java/lang/IncompatibleClassChangeError.h>
|
#include <java/lang/IncompatibleClassChangeError.h>
|
#include <java/lang/reflect/Modifier.h>
|
#include <java/lang/reflect/Modifier.h>
|
#include <java/lang/reflect/Field.h>
|
#include <java/lang/reflect/Field.h>
|
#include <java/lang/reflect/Method.h>
|
#include <java/lang/reflect/Method.h>
|
#include <java/security/ProtectionDomain.h>
|
#include <java/security/ProtectionDomain.h>
|
#include <java/io/DataOutputStream.h>
|
#include <java/io/DataOutputStream.h>
|
#include <java/io/ByteArrayOutputStream.h>
|
#include <java/io/ByteArrayOutputStream.h>
|
|
|
using namespace gcj;
|
using namespace gcj;
|
|
|
#ifdef INTERPRETER
|
#ifdef INTERPRETER
|
|
|
// these go in some separate functions, to avoid having _Jv_InitClass
|
// these go in some separate functions, to avoid having _Jv_InitClass
|
// inserted all over the place.
|
// inserted all over the place.
|
static void throw_internal_error (const char *msg)
|
static void throw_internal_error (const char *msg)
|
__attribute__ ((__noreturn__));
|
__attribute__ ((__noreturn__));
|
static void throw_no_class_def_found_error (jstring msg)
|
static void throw_no_class_def_found_error (jstring msg)
|
__attribute__ ((__noreturn__));
|
__attribute__ ((__noreturn__));
|
static void throw_no_class_def_found_error (const char *msg)
|
static void throw_no_class_def_found_error (const char *msg)
|
__attribute__ ((__noreturn__));
|
__attribute__ ((__noreturn__));
|
static void throw_class_format_error (jstring msg)
|
static void throw_class_format_error (jstring msg)
|
__attribute__ ((__noreturn__));
|
__attribute__ ((__noreturn__));
|
static void throw_incompatible_class_change_error (jstring msg)
|
static void throw_incompatible_class_change_error (jstring msg)
|
__attribute__ ((__noreturn__));
|
__attribute__ ((__noreturn__));
|
static void throw_class_circularity_error (jstring msg)
|
static void throw_class_circularity_error (jstring msg)
|
__attribute__ ((__noreturn__));
|
__attribute__ ((__noreturn__));
|
|
|
/**
|
/**
|
* We define class reading using a class. It is practical, since then
|
* 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
|
* the entire class-reader can be a friend of class Class (it needs to
|
* write all it's different structures); but also because this makes it
|
* write all it's different structures); but also because this makes it
|
* easy to make class definition reentrant, and thus two threads can be
|
* easy to make class definition reentrant, and thus two threads can be
|
* defining classes at the same time. This class (_Jv_ClassReader) is
|
* defining classes at the same time. This class (_Jv_ClassReader) is
|
* never exposed outside this file, so we don't have to worry about
|
* never exposed outside this file, so we don't have to worry about
|
* public or private members here.
|
* public or private members here.
|
*/
|
*/
|
|
|
struct _Jv_ClassReader
|
struct _Jv_ClassReader
|
{
|
{
|
|
|
// do verification? Currently, there is no option to disable this.
|
// do verification? Currently, there is no option to disable this.
|
// This flag just controls the verificaiton done by the class loader;
|
// This flag just controls the verificaiton done by the class loader;
|
// i.e., checking the integrity of the constant pool; and it is
|
// i.e., checking the integrity of the constant pool; and it is
|
// allways on. You always want this as far as I can see, but it also
|
// allways on. You always want this as far as I can see, but it also
|
// controls weither identifiers and type descriptors/signatures are
|
// controls weither identifiers and type descriptors/signatures are
|
// verified as legal. This could be somewhat more expensive since it
|
// verified as legal. This could be somewhat more expensive since it
|
// will call Character.isJavaIdentifier{Start,Part} for each character
|
// will call Character.isJavaIdentifier{Start,Part} for each character
|
// in any identifier (field name or method name) it comes by. Thus,
|
// in any identifier (field name or method name) it comes by. Thus,
|
// it might be useful to turn off this verification for classes that
|
// it might be useful to turn off this verification for classes that
|
// come from a trusted source. However, for GCJ, trusted classes are
|
// come from a trusted source. However, for GCJ, trusted classes are
|
// most likely to be linked in.
|
// most likely to be linked in.
|
|
|
bool verify;
|
bool verify;
|
|
|
// original input data.
|
// original input data.
|
jbyteArray input_data;
|
jbyteArray input_data;
|
jint input_offset;
|
jint input_offset;
|
|
|
// input data.
|
// input data.
|
unsigned char *bytes;
|
unsigned char *bytes;
|
int len;
|
int len;
|
|
|
// current input position
|
// current input position
|
int pos;
|
int pos;
|
|
|
// the constant pool data
|
// the constant pool data
|
int pool_count;
|
int pool_count;
|
unsigned char *tags;
|
unsigned char *tags;
|
unsigned int *offsets;
|
unsigned int *offsets;
|
|
|
// the class to define (see java-interp.h)
|
// the class to define (see java-interp.h)
|
jclass def;
|
jclass def;
|
|
|
// the classes associated interpreter data.
|
// the classes associated interpreter data.
|
_Jv_InterpClass *def_interp;
|
_Jv_InterpClass *def_interp;
|
|
|
// The name we found.
|
// The name we found.
|
_Jv_Utf8Const **found_name;
|
_Jv_Utf8Const **found_name;
|
|
|
// True if this is a 1.5 class file.
|
// True if this is a 1.5 class file.
|
bool is_15;
|
bool is_15;
|
|
|
// Buffer holding extra reflection data.
|
// Buffer holding extra reflection data.
|
::java::io::ByteArrayOutputStream *reflection_data;
|
::java::io::ByteArrayOutputStream *reflection_data;
|
::java::io::DataOutputStream *data_stream;
|
::java::io::DataOutputStream *data_stream;
|
|
|
|
|
/* check that the given number of input bytes are available */
|
/* check that the given number of input bytes are available */
|
inline void check (int num)
|
inline void check (int num)
|
{
|
{
|
if (pos + num > len)
|
if (pos + num > len)
|
throw_class_format_error ("Premature end of data");
|
throw_class_format_error ("Premature end of data");
|
}
|
}
|
|
|
/* skip a given number of bytes in input */
|
/* skip a given number of bytes in input */
|
inline void skip (int num)
|
inline void skip (int num)
|
{
|
{
|
check (num);
|
check (num);
|
pos += num;
|
pos += num;
|
}
|
}
|
|
|
/* read an unsigned 1-byte unit */
|
/* read an unsigned 1-byte unit */
|
inline static jint get1u (unsigned char* bytes)
|
inline static jint get1u (unsigned char* bytes)
|
{
|
{
|
return bytes[0];
|
return bytes[0];
|
}
|
}
|
|
|
/* read an unsigned 1-byte unit */
|
/* read an unsigned 1-byte unit */
|
inline jint read1u ()
|
inline jint read1u ()
|
{
|
{
|
skip (1);
|
skip (1);
|
return get1u (bytes+pos-1);
|
return get1u (bytes+pos-1);
|
}
|
}
|
|
|
/* read an unsigned 2-byte unit */
|
/* read an unsigned 2-byte unit */
|
inline static jint get2u (unsigned char *bytes)
|
inline static jint get2u (unsigned char *bytes)
|
{
|
{
|
return (((jint)bytes[0]) << 8) | ((jint)bytes[1]);
|
return (((jint)bytes[0]) << 8) | ((jint)bytes[1]);
|
}
|
}
|
|
|
/* read an unsigned 2-byte unit */
|
/* read an unsigned 2-byte unit */
|
inline jint read2u ()
|
inline jint read2u ()
|
{
|
{
|
skip (2);
|
skip (2);
|
return get2u (bytes+pos-2);
|
return get2u (bytes+pos-2);
|
}
|
}
|
|
|
/* read a 4-byte unit */
|
/* read a 4-byte unit */
|
static jint get4 (unsigned char *bytes)
|
static jint get4 (unsigned char *bytes)
|
{
|
{
|
return (((jint)bytes[0]) << 24)
|
return (((jint)bytes[0]) << 24)
|
| (((jint)bytes[1]) << 16)
|
| (((jint)bytes[1]) << 16)
|
| (((jint)bytes[2]) << 8)
|
| (((jint)bytes[2]) << 8)
|
| (((jint)bytes[3]) << 0);
|
| (((jint)bytes[3]) << 0);
|
}
|
}
|
|
|
/* read a 4-byte unit, (we don't do that quite so often) */
|
/* read a 4-byte unit, (we don't do that quite so often) */
|
inline jint read4 ()
|
inline jint read4 ()
|
{
|
{
|
skip (4);
|
skip (4);
|
return get4 (bytes+pos-4);
|
return get4 (bytes+pos-4);
|
}
|
}
|
|
|
/* read a 8-byte unit */
|
/* read a 8-byte unit */
|
static jlong get8 (unsigned char* bytes)
|
static jlong get8 (unsigned char* bytes)
|
{
|
{
|
return (((jlong)bytes[0]) << 56)
|
return (((jlong)bytes[0]) << 56)
|
| (((jlong)bytes[1]) << 48)
|
| (((jlong)bytes[1]) << 48)
|
| (((jlong)bytes[2]) << 40)
|
| (((jlong)bytes[2]) << 40)
|
| (((jlong)bytes[3]) << 32)
|
| (((jlong)bytes[3]) << 32)
|
| (((jlong)bytes[4]) << 24)
|
| (((jlong)bytes[4]) << 24)
|
| (((jlong)bytes[5]) << 16)
|
| (((jlong)bytes[5]) << 16)
|
| (((jlong)bytes[6]) << 8)
|
| (((jlong)bytes[6]) << 8)
|
| (((jlong)bytes[7]) << 0);
|
| (((jlong)bytes[7]) << 0);
|
}
|
}
|
|
|
/* read a 8-byte unit */
|
/* read a 8-byte unit */
|
inline jlong read8 ()
|
inline jlong read8 ()
|
{
|
{
|
skip (8);
|
skip (8);
|
return get8 (bytes+pos-8);
|
return get8 (bytes+pos-8);
|
}
|
}
|
|
|
inline void check_tag (int index, char expected_tag)
|
inline void check_tag (int index, char expected_tag)
|
{
|
{
|
if (index < 0
|
if (index < 0
|
|| index > pool_count
|
|| index > pool_count
|
|| tags[index] != expected_tag)
|
|| tags[index] != expected_tag)
|
throw_class_format_error ("erroneous constant pool tag");
|
throw_class_format_error ("erroneous constant pool tag");
|
}
|
}
|
|
|
inline void verify_identifier (_Jv_Utf8Const* name)
|
inline void verify_identifier (_Jv_Utf8Const* name)
|
{
|
{
|
if (! _Jv_VerifyIdentifier (name))
|
if (! _Jv_VerifyIdentifier (name))
|
throw_class_format_error ("erroneous identifier");
|
throw_class_format_error ("erroneous identifier");
|
}
|
}
|
|
|
inline void verify_classname (unsigned char* ptr, _Jv_ushort length)
|
inline void verify_classname (unsigned char* ptr, _Jv_ushort length)
|
{
|
{
|
if (! _Jv_VerifyClassName (ptr, length))
|
if (! _Jv_VerifyClassName (ptr, length))
|
throw_class_format_error ("erroneous class name");
|
throw_class_format_error ("erroneous class name");
|
}
|
}
|
|
|
inline void verify_classname (_Jv_Utf8Const *name)
|
inline void verify_classname (_Jv_Utf8Const *name)
|
{
|
{
|
if (! _Jv_VerifyClassName (name))
|
if (! _Jv_VerifyClassName (name))
|
throw_class_format_error ("erroneous class name");
|
throw_class_format_error ("erroneous class name");
|
}
|
}
|
|
|
inline void verify_field_signature (_Jv_Utf8Const *sig)
|
inline void verify_field_signature (_Jv_Utf8Const *sig)
|
{
|
{
|
if (! _Jv_VerifyFieldSignature (sig))
|
if (! _Jv_VerifyFieldSignature (sig))
|
throw_class_format_error ("erroneous type descriptor");
|
throw_class_format_error ("erroneous type descriptor");
|
}
|
}
|
|
|
inline void verify_method_signature (_Jv_Utf8Const *sig)
|
inline void verify_method_signature (_Jv_Utf8Const *sig)
|
{
|
{
|
if (! _Jv_VerifyMethodSignature (sig))
|
if (! _Jv_VerifyMethodSignature (sig))
|
throw_class_format_error ("erroneous type descriptor");
|
throw_class_format_error ("erroneous type descriptor");
|
}
|
}
|
|
|
::java::io::DataOutputStream *get_reflection_stream ()
|
::java::io::DataOutputStream *get_reflection_stream ()
|
{
|
{
|
if (reflection_data == NULL)
|
if (reflection_data == NULL)
|
{
|
{
|
reflection_data = new ::java::io::ByteArrayOutputStream();
|
reflection_data = new ::java::io::ByteArrayOutputStream();
|
data_stream = new ::java::io::DataOutputStream(reflection_data);
|
data_stream = new ::java::io::DataOutputStream(reflection_data);
|
}
|
}
|
return data_stream;
|
return data_stream;
|
}
|
}
|
|
|
_Jv_ClassReader (jclass klass, jbyteArray data, jint offset, jint length,
|
_Jv_ClassReader (jclass klass, jbyteArray data, jint offset, jint length,
|
java::security::ProtectionDomain *pd,
|
java::security::ProtectionDomain *pd,
|
_Jv_Utf8Const **name_result)
|
_Jv_Utf8Const **name_result)
|
{
|
{
|
if (klass == 0 || length < 0 || offset+length > data->length)
|
if (klass == 0 || length < 0 || offset+length > data->length)
|
throw_internal_error ("arguments to _Jv_DefineClass");
|
throw_internal_error ("arguments to _Jv_DefineClass");
|
|
|
verify = true;
|
verify = true;
|
input_data = data;
|
input_data = data;
|
input_offset = offset;
|
input_offset = offset;
|
bytes = (unsigned char*) (elements (data)+offset);
|
bytes = (unsigned char*) (elements (data)+offset);
|
len = length;
|
len = length;
|
pos = 0;
|
pos = 0;
|
is_15 = false;
|
is_15 = false;
|
|
|
def = klass;
|
def = klass;
|
found_name = name_result;
|
found_name = name_result;
|
reflection_data = NULL;
|
reflection_data = NULL;
|
data_stream = NULL;
|
data_stream = NULL;
|
|
|
def->size_in_bytes = -1;
|
def->size_in_bytes = -1;
|
def->vtable_method_count = -1;
|
def->vtable_method_count = -1;
|
def->engine = &_Jv_soleInterpreterEngine;
|
def->engine = &_Jv_soleInterpreterEngine;
|
def->protectionDomain = pd;
|
def->protectionDomain = pd;
|
}
|
}
|
|
|
/** and here goes the parser members defined out-of-line */
|
/** and here goes the parser members defined out-of-line */
|
void parse ();
|
void parse ();
|
void read_constpool ();
|
void read_constpool ();
|
void prepare_pool_entry (int index, unsigned char tag,
|
void prepare_pool_entry (int index, unsigned char tag,
|
bool rewrite = true);
|
bool rewrite = true);
|
void read_fields ();
|
void read_fields ();
|
void read_methods ();
|
void read_methods ();
|
void read_one_class_attribute ();
|
void read_one_class_attribute ();
|
void read_one_method_attribute (int method);
|
void read_one_method_attribute (int method);
|
void read_one_code_attribute (int method);
|
void read_one_code_attribute (int method);
|
void read_one_field_attribute (int field, bool *);
|
void read_one_field_attribute (int field, bool *);
|
void throw_class_format_error (const char *msg);
|
void throw_class_format_error (const char *msg);
|
|
|
void handleEnclosingMethod(int);
|
void handleEnclosingMethod(int);
|
void handleGenericSignature(jv_attr_type, unsigned short, int);
|
void handleGenericSignature(jv_attr_type, unsigned short, int);
|
void handleAnnotationElement();
|
void handleAnnotationElement();
|
void handleAnnotation();
|
void handleAnnotation();
|
void handleAnnotations();
|
void handleAnnotations();
|
void handleMemberAnnotations(jv_attr_type, int, int);
|
void handleMemberAnnotations(jv_attr_type, int, int);
|
void handleAnnotationDefault(int, int);
|
void handleAnnotationDefault(int, int);
|
void handleParameterAnnotations(int, int);
|
void handleParameterAnnotations(int, int);
|
void finish_reflection_data ();
|
void finish_reflection_data ();
|
|
|
/** check an utf8 entry, without creating a Utf8Const object */
|
/** check an utf8 entry, without creating a Utf8Const object */
|
bool is_attribute_name (int index, const char *name);
|
bool is_attribute_name (int index, const char *name);
|
|
|
/** return the value of a utf8 entry in the passed array */
|
/** return the value of a utf8 entry in the passed array */
|
int pool_Utf8_to_char_arr (int index, char **entry);
|
int pool_Utf8_to_char_arr (int index, char **entry);
|
|
|
/** here goes the class-loader members defined out-of-line */
|
/** here goes the class-loader members defined out-of-line */
|
void handleConstantPool ();
|
void handleConstantPool ();
|
void handleClassBegin (int, int, int);
|
void handleClassBegin (int, int, int);
|
void handleInterfacesBegin (int);
|
void handleInterfacesBegin (int);
|
void handleInterface (int, int);
|
void handleInterface (int, int);
|
void handleFieldsBegin (int);
|
void handleFieldsBegin (int);
|
void handleField (int, int, int, int, int *);
|
void handleField (int, int, int, int, int *);
|
void handleConstantValueAttribute (int, int, bool *);
|
void handleConstantValueAttribute (int, int, bool *);
|
void handleMethodsBegin (int);
|
void handleMethodsBegin (int);
|
void handleMethod (int, int, int, int);
|
void handleMethod (int, int, int, int);
|
void handleMethodsEnd ();
|
void handleMethodsEnd ();
|
void handleCodeAttribute (int, int, int, int, int, int);
|
void handleCodeAttribute (int, int, int, int, int, int);
|
void handleExceptionTableEntry (int, int, int, int, int, int);
|
void handleExceptionTableEntry (int, int, int, int, int, int);
|
|
|
void checkExtends (jclass sub, jclass super);
|
void checkExtends (jclass sub, jclass super);
|
void checkImplements (jclass sub, jclass super);
|
void checkImplements (jclass sub, jclass super);
|
|
|
/*
|
/*
|
* FIXME: we should keep a hash table of utf8-strings, since many will
|
* FIXME: we should keep a hash table of utf8-strings, since many will
|
* be the same. It's a little tricky, however, because the hash table
|
* be the same. It's a little tricky, however, because the hash table
|
* needs to interact gracefully with the garbage collector. Much
|
* needs to interact gracefully with the garbage collector. Much
|
* memory is to be saved by this, however! perhaps the improvement
|
* memory is to be saved by this, however! perhaps the improvement
|
* could be implemented in prims.cc (_Jv_makeUtf8Const), since it
|
* could be implemented in prims.cc (_Jv_makeUtf8Const), since it
|
* computes the hash value anyway.
|
* computes the hash value anyway.
|
*/
|
*/
|
};
|
};
|
|
|
// Note that *NAME_RESULT will only be set if the class is registered
|
// Note that *NAME_RESULT will only be set if the class is registered
|
// with the class loader. This is how the caller can know whether
|
// with the class loader. This is how the caller can know whether
|
// unregistration is require.
|
// unregistration is require.
|
void
|
void
|
_Jv_DefineClass (jclass klass, jbyteArray data, jint offset, jint length,
|
_Jv_DefineClass (jclass klass, jbyteArray data, jint offset, jint length,
|
java::security::ProtectionDomain *pd,
|
java::security::ProtectionDomain *pd,
|
_Jv_Utf8Const **name_result)
|
_Jv_Utf8Const **name_result)
|
{
|
{
|
_Jv_ClassReader reader (klass, data, offset, length, pd, name_result);
|
_Jv_ClassReader reader (klass, data, offset, length, pd, name_result);
|
reader.parse();
|
reader.parse();
|
|
|
/* that's it! */
|
/* that's it! */
|
}
|
}
|
|
|
|
|
/** This section defines the parsing/scanning of the class data */
|
/** This section defines the parsing/scanning of the class data */
|
|
|
// Major and minor version numbers for various releases.
|
// Major and minor version numbers for various releases.
|
#define MAJOR_1_1 45
|
#define MAJOR_1_1 45
|
#define MINOR_1_1 3
|
#define MINOR_1_1 3
|
#define MAJOR_1_2 46
|
#define MAJOR_1_2 46
|
#define MINOR_1_2 0
|
#define MINOR_1_2 0
|
#define MAJOR_1_3 47
|
#define MAJOR_1_3 47
|
#define MINOR_1_3 0
|
#define MINOR_1_3 0
|
#define MAJOR_1_4 48
|
#define MAJOR_1_4 48
|
#define MINOR_1_4 0
|
#define MINOR_1_4 0
|
#define MAJOR_1_5 49
|
#define MAJOR_1_5 49
|
#define MINOR_1_5 0
|
#define MINOR_1_5 0
|
#define MAJOR_1_6 50
|
#define MAJOR_1_6 50
|
#define MINOR_1_6 0
|
#define MINOR_1_6 0
|
|
|
void
|
void
|
_Jv_ClassReader::parse ()
|
_Jv_ClassReader::parse ()
|
{
|
{
|
int magic = read4 ();
|
int magic = read4 ();
|
if (magic != (int) 0xCAFEBABE)
|
if (magic != (int) 0xCAFEBABE)
|
throw_class_format_error ("bad magic number");
|
throw_class_format_error ("bad magic number");
|
|
|
int minor_version = read2u ();
|
int minor_version = read2u ();
|
int major_version = read2u ();
|
int major_version = read2u ();
|
if (major_version < MAJOR_1_1 || major_version > MAJOR_1_6
|
if (major_version < MAJOR_1_1 || major_version > MAJOR_1_6
|
|| (major_version == MAJOR_1_6 && minor_version > MINOR_1_6))
|
|| (major_version == MAJOR_1_6 && minor_version > MINOR_1_6))
|
throw_class_format_error ("unrecognized class file version");
|
throw_class_format_error ("unrecognized class file version");
|
is_15 = (major_version >= MAJOR_1_5);
|
is_15 = (major_version >= MAJOR_1_5);
|
|
|
pool_count = read2u ();
|
pool_count = read2u ();
|
|
|
read_constpool ();
|
read_constpool ();
|
|
|
int access_flags = read2u ();
|
int access_flags = read2u ();
|
int this_class = read2u ();
|
int this_class = read2u ();
|
int super_class = read2u ();
|
int super_class = read2u ();
|
|
|
check_tag (this_class, JV_CONSTANT_Class);
|
check_tag (this_class, JV_CONSTANT_Class);
|
if (super_class != 0)
|
if (super_class != 0)
|
check_tag (super_class, JV_CONSTANT_Class);
|
check_tag (super_class, JV_CONSTANT_Class);
|
|
|
handleClassBegin (access_flags, this_class, super_class);
|
handleClassBegin (access_flags, this_class, super_class);
|
|
|
// Allocate our aux_info here, after the name is set, to fulfill our
|
// Allocate our aux_info here, after the name is set, to fulfill our
|
// contract with the collector interface.
|
// contract with the collector interface.
|
def->aux_info = (void *) _Jv_AllocRawObj (sizeof (_Jv_InterpClass));
|
def->aux_info = (void *) _Jv_AllocRawObj (sizeof (_Jv_InterpClass));
|
def_interp = (_Jv_InterpClass *) def->aux_info;
|
def_interp = (_Jv_InterpClass *) def->aux_info;
|
|
|
int interfaces_count = read2u ();
|
int interfaces_count = read2u ();
|
|
|
handleInterfacesBegin (interfaces_count);
|
handleInterfacesBegin (interfaces_count);
|
|
|
for (int i = 0; i < interfaces_count; i++)
|
for (int i = 0; i < interfaces_count; i++)
|
{
|
{
|
int iface = read2u ();
|
int iface = read2u ();
|
check_tag (iface, JV_CONSTANT_Class);
|
check_tag (iface, JV_CONSTANT_Class);
|
handleInterface (i, iface);
|
handleInterface (i, iface);
|
}
|
}
|
|
|
read_fields ();
|
read_fields ();
|
read_methods ();
|
read_methods ();
|
|
|
int attributes_count = read2u ();
|
int attributes_count = read2u ();
|
|
|
for (int i = 0; i < attributes_count; i++)
|
for (int i = 0; i < attributes_count; i++)
|
{
|
{
|
read_one_class_attribute ();
|
read_one_class_attribute ();
|
}
|
}
|
|
|
if (pos != len)
|
if (pos != len)
|
throw_class_format_error ("unused data before end of file");
|
throw_class_format_error ("unused data before end of file");
|
|
|
finish_reflection_data ();
|
finish_reflection_data ();
|
|
|
// Tell everyone we're done.
|
// Tell everyone we're done.
|
def->state = JV_STATE_READ;
|
def->state = JV_STATE_READ;
|
if (gcj::verbose_class_flag)
|
if (gcj::verbose_class_flag)
|
_Jv_Linker::print_class_loaded (def);
|
_Jv_Linker::print_class_loaded (def);
|
++gcj::loadedClasses;
|
++gcj::loadedClasses;
|
def->notifyAll ();
|
def->notifyAll ();
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::finish_reflection_data ()
|
_Jv_ClassReader::finish_reflection_data ()
|
{
|
{
|
if (data_stream == NULL)
|
if (data_stream == NULL)
|
return;
|
return;
|
data_stream->writeByte(JV_DONE_ATTR);
|
data_stream->writeByte(JV_DONE_ATTR);
|
data_stream->flush();
|
data_stream->flush();
|
int nbytes = reflection_data->count;
|
int nbytes = reflection_data->count;
|
unsigned char *new_bytes = (unsigned char *) _Jv_AllocBytes (nbytes);
|
unsigned char *new_bytes = (unsigned char *) _Jv_AllocBytes (nbytes);
|
memcpy (new_bytes, elements (reflection_data->buf), nbytes);
|
memcpy (new_bytes, elements (reflection_data->buf), nbytes);
|
def->reflection_data = new_bytes;
|
def->reflection_data = new_bytes;
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleEnclosingMethod (int len)
|
_Jv_ClassReader::handleEnclosingMethod (int len)
|
{
|
{
|
if (len != 4)
|
if (len != 4)
|
throw_class_format_error ("invalid EnclosingMethod attribute");
|
throw_class_format_error ("invalid EnclosingMethod attribute");
|
// FIXME: only allow one...
|
// FIXME: only allow one...
|
|
|
int class_index = read2u();
|
int class_index = read2u();
|
check_tag (class_index, JV_CONSTANT_Class);
|
check_tag (class_index, JV_CONSTANT_Class);
|
prepare_pool_entry (class_index, JV_CONSTANT_Class);
|
prepare_pool_entry (class_index, JV_CONSTANT_Class);
|
|
|
int method_index = read2u();
|
int method_index = read2u();
|
// Zero is ok and means no enclosing method.
|
// Zero is ok and means no enclosing method.
|
if (method_index != 0)
|
if (method_index != 0)
|
{
|
{
|
check_tag (method_index, JV_CONSTANT_NameAndType);
|
check_tag (method_index, JV_CONSTANT_NameAndType);
|
prepare_pool_entry (method_index, JV_CONSTANT_NameAndType);
|
prepare_pool_entry (method_index, JV_CONSTANT_NameAndType);
|
}
|
}
|
|
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
stream->writeByte(JV_CLASS_ATTR);
|
stream->writeByte(JV_CLASS_ATTR);
|
stream->writeInt(5);
|
stream->writeInt(5);
|
stream->writeByte(JV_ENCLOSING_METHOD_KIND);
|
stream->writeByte(JV_ENCLOSING_METHOD_KIND);
|
stream->writeShort(class_index);
|
stream->writeShort(class_index);
|
stream->writeShort(method_index);
|
stream->writeShort(method_index);
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleGenericSignature (jv_attr_type type,
|
_Jv_ClassReader::handleGenericSignature (jv_attr_type type,
|
unsigned short index,
|
unsigned short index,
|
int len)
|
int len)
|
{
|
{
|
if (len != 2)
|
if (len != 2)
|
throw_class_format_error ("invalid Signature attribute");
|
throw_class_format_error ("invalid Signature attribute");
|
|
|
int cpool_idx = read2u();
|
int cpool_idx = read2u();
|
check_tag (cpool_idx, JV_CONSTANT_Utf8);
|
check_tag (cpool_idx, JV_CONSTANT_Utf8);
|
prepare_pool_entry (cpool_idx, JV_CONSTANT_Utf8, false);
|
prepare_pool_entry (cpool_idx, JV_CONSTANT_Utf8, false);
|
|
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
stream->writeByte(type);
|
stream->writeByte(type);
|
int attrlen = 3;
|
int attrlen = 3;
|
if (type != JV_CLASS_ATTR)
|
if (type != JV_CLASS_ATTR)
|
attrlen += 2;
|
attrlen += 2;
|
stream->writeInt(attrlen);
|
stream->writeInt(attrlen);
|
if (type != JV_CLASS_ATTR)
|
if (type != JV_CLASS_ATTR)
|
stream->writeShort(index);
|
stream->writeShort(index);
|
stream->writeByte(JV_SIGNATURE_KIND);
|
stream->writeByte(JV_SIGNATURE_KIND);
|
stream->writeShort(cpool_idx);
|
stream->writeShort(cpool_idx);
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleAnnotationElement()
|
_Jv_ClassReader::handleAnnotationElement()
|
{
|
{
|
int tag = read1u();
|
int tag = read1u();
|
switch (tag)
|
switch (tag)
|
{
|
{
|
case 'B':
|
case 'B':
|
case 'C':
|
case 'C':
|
case 'S':
|
case 'S':
|
case 'Z':
|
case 'Z':
|
case 'I':
|
case 'I':
|
{
|
{
|
int index = read2u();
|
int index = read2u();
|
check_tag (index, JV_CONSTANT_Integer);
|
check_tag (index, JV_CONSTANT_Integer);
|
prepare_pool_entry (index, JV_CONSTANT_Integer);
|
prepare_pool_entry (index, JV_CONSTANT_Integer);
|
}
|
}
|
break;
|
break;
|
case 'D':
|
case 'D':
|
{
|
{
|
int index = read2u();
|
int index = read2u();
|
check_tag (index, JV_CONSTANT_Double);
|
check_tag (index, JV_CONSTANT_Double);
|
prepare_pool_entry (index, JV_CONSTANT_Double);
|
prepare_pool_entry (index, JV_CONSTANT_Double);
|
}
|
}
|
break;
|
break;
|
case 'F':
|
case 'F':
|
{
|
{
|
int index = read2u();
|
int index = read2u();
|
check_tag (index, JV_CONSTANT_Float);
|
check_tag (index, JV_CONSTANT_Float);
|
prepare_pool_entry (index, JV_CONSTANT_Float);
|
prepare_pool_entry (index, JV_CONSTANT_Float);
|
}
|
}
|
break;
|
break;
|
case 'J':
|
case 'J':
|
{
|
{
|
int index = read2u();
|
int index = read2u();
|
check_tag (index, JV_CONSTANT_Long);
|
check_tag (index, JV_CONSTANT_Long);
|
prepare_pool_entry (index, JV_CONSTANT_Long);
|
prepare_pool_entry (index, JV_CONSTANT_Long);
|
}
|
}
|
break;
|
break;
|
case 's':
|
case 's':
|
{
|
{
|
int index = read2u();
|
int index = read2u();
|
// Despite what the JVM spec says, compilers generate a Utf8
|
// Despite what the JVM spec says, compilers generate a Utf8
|
// constant here, not a String.
|
// constant here, not a String.
|
check_tag (index, JV_CONSTANT_Utf8);
|
check_tag (index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (index, JV_CONSTANT_Utf8, false);
|
prepare_pool_entry (index, JV_CONSTANT_Utf8, false);
|
}
|
}
|
break;
|
break;
|
|
|
case 'e':
|
case 'e':
|
{
|
{
|
int type_name_index = read2u();
|
int type_name_index = read2u();
|
int const_name_index = read2u ();
|
int const_name_index = read2u ();
|
check_tag (type_name_index, JV_CONSTANT_Utf8);
|
check_tag (type_name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (type_name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (type_name_index, JV_CONSTANT_Utf8);
|
check_tag (const_name_index, JV_CONSTANT_Utf8);
|
check_tag (const_name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (const_name_index, JV_CONSTANT_Utf8, false);
|
prepare_pool_entry (const_name_index, JV_CONSTANT_Utf8, false);
|
}
|
}
|
break;
|
break;
|
case 'c':
|
case 'c':
|
{
|
{
|
int index = read2u();
|
int index = read2u();
|
check_tag (index, JV_CONSTANT_Utf8);
|
check_tag (index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (index, JV_CONSTANT_Utf8);
|
}
|
}
|
break;
|
break;
|
case '@':
|
case '@':
|
handleAnnotation();
|
handleAnnotation();
|
break;
|
break;
|
case '[':
|
case '[':
|
{
|
{
|
int n_array_elts = read2u ();
|
int n_array_elts = read2u ();
|
for (int i = 0; i < n_array_elts; ++i)
|
for (int i = 0; i < n_array_elts; ++i)
|
handleAnnotationElement();
|
handleAnnotationElement();
|
}
|
}
|
break;
|
break;
|
default:
|
default:
|
throw_class_format_error ("invalid annotation element");
|
throw_class_format_error ("invalid annotation element");
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleAnnotation()
|
_Jv_ClassReader::handleAnnotation()
|
{
|
{
|
int type_index = read2u();
|
int type_index = read2u();
|
check_tag (type_index, JV_CONSTANT_Utf8);
|
check_tag (type_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
|
|
|
int npairs = read2u();
|
int npairs = read2u();
|
for (int i = 0; i < npairs; ++i)
|
for (int i = 0; i < npairs; ++i)
|
{
|
{
|
int name_index = read2u();
|
int name_index = read2u();
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
|
handleAnnotationElement();
|
handleAnnotationElement();
|
}
|
}
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleAnnotations()
|
_Jv_ClassReader::handleAnnotations()
|
{
|
{
|
int num = read2u();
|
int num = read2u();
|
while (num--)
|
while (num--)
|
handleAnnotation();
|
handleAnnotation();
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleMemberAnnotations(jv_attr_type member_type,
|
_Jv_ClassReader::handleMemberAnnotations(jv_attr_type member_type,
|
int member_index,
|
int member_index,
|
int len)
|
int len)
|
{
|
{
|
// We're going to copy the bytes in verbatim. But first we want to
|
// We're going to copy the bytes in verbatim. But first we want to
|
// make sure the attribute is well-formed, and we want to prepare
|
// make sure the attribute is well-formed, and we want to prepare
|
// the constant pool. So, we save our starting point.
|
// the constant pool. So, we save our starting point.
|
int orig_pos = pos;
|
int orig_pos = pos;
|
|
|
handleAnnotations();
|
handleAnnotations();
|
// FIXME: check that we read all LEN bytes?
|
// FIXME: check that we read all LEN bytes?
|
|
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
stream->writeByte(member_type);
|
stream->writeByte(member_type);
|
int newLen = len + 1;
|
int newLen = len + 1;
|
if (member_type != JV_CLASS_ATTR)
|
if (member_type != JV_CLASS_ATTR)
|
newLen += 2;
|
newLen += 2;
|
stream->writeInt(newLen);
|
stream->writeInt(newLen);
|
stream->writeByte(JV_ANNOTATIONS_KIND);
|
stream->writeByte(JV_ANNOTATIONS_KIND);
|
if (member_type != JV_CLASS_ATTR)
|
if (member_type != JV_CLASS_ATTR)
|
stream->writeShort(member_index);
|
stream->writeShort(member_index);
|
// Write the data as-is.
|
// Write the data as-is.
|
stream->write(input_data, input_offset + orig_pos, len);
|
stream->write(input_data, input_offset + orig_pos, len);
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleAnnotationDefault(int member_index, int len)
|
_Jv_ClassReader::handleAnnotationDefault(int member_index, int len)
|
{
|
{
|
int orig_pos = pos;
|
int orig_pos = pos;
|
handleAnnotationElement();
|
handleAnnotationElement();
|
|
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
stream->writeByte(JV_METHOD_ATTR);
|
stream->writeByte(JV_METHOD_ATTR);
|
stream->writeInt(len + 3);
|
stream->writeInt(len + 3);
|
stream->writeByte(JV_ANNOTATION_DEFAULT_KIND);
|
stream->writeByte(JV_ANNOTATION_DEFAULT_KIND);
|
stream->writeShort(member_index);
|
stream->writeShort(member_index);
|
stream->write(input_data, input_offset + orig_pos, len);
|
stream->write(input_data, input_offset + orig_pos, len);
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleParameterAnnotations(int member_index, int len)
|
_Jv_ClassReader::handleParameterAnnotations(int member_index, int len)
|
{
|
{
|
int orig_pos = pos;
|
int orig_pos = pos;
|
|
|
int n_params = read1u();
|
int n_params = read1u();
|
for (int i = 0; i < n_params; ++i)
|
for (int i = 0; i < n_params; ++i)
|
handleAnnotations();
|
handleAnnotations();
|
|
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
stream->writeByte(JV_METHOD_ATTR);
|
stream->writeByte(JV_METHOD_ATTR);
|
stream->writeInt(len + 3);
|
stream->writeInt(len + 3);
|
stream->writeByte(JV_PARAMETER_ANNOTATIONS_KIND);
|
stream->writeByte(JV_PARAMETER_ANNOTATIONS_KIND);
|
stream->writeShort(member_index);
|
stream->writeShort(member_index);
|
stream->write(input_data, input_offset + orig_pos, len);
|
stream->write(input_data, input_offset + orig_pos, len);
|
}
|
}
|
|
|
void _Jv_ClassReader::read_constpool ()
|
void _Jv_ClassReader::read_constpool ()
|
{
|
{
|
tags = (unsigned char*) _Jv_AllocBytes (pool_count);
|
tags = (unsigned char*) _Jv_AllocBytes (pool_count);
|
offsets = (unsigned int *) _Jv_AllocBytes (sizeof (int) * pool_count) ;
|
offsets = (unsigned int *) _Jv_AllocBytes (sizeof (int) * pool_count) ;
|
|
|
/** first, we scan the constant pool, collecting tags and offsets */
|
/** first, we scan the constant pool, collecting tags and offsets */
|
tags[0] = JV_CONSTANT_Undefined;
|
tags[0] = JV_CONSTANT_Undefined;
|
offsets[0] = pos;
|
offsets[0] = pos;
|
for (int c = 1; c < pool_count; c++)
|
for (int c = 1; c < pool_count; c++)
|
{
|
{
|
tags[c] = read1u ();
|
tags[c] = read1u ();
|
offsets[c] = pos;
|
offsets[c] = pos;
|
|
|
switch (tags[c])
|
switch (tags[c])
|
{
|
{
|
case JV_CONSTANT_String:
|
case JV_CONSTANT_String:
|
case JV_CONSTANT_Class:
|
case JV_CONSTANT_Class:
|
skip (2);
|
skip (2);
|
break;
|
break;
|
|
|
case JV_CONSTANT_Fieldref:
|
case JV_CONSTANT_Fieldref:
|
case JV_CONSTANT_Methodref:
|
case JV_CONSTANT_Methodref:
|
case JV_CONSTANT_InterfaceMethodref:
|
case JV_CONSTANT_InterfaceMethodref:
|
case JV_CONSTANT_NameAndType:
|
case JV_CONSTANT_NameAndType:
|
case JV_CONSTANT_Integer:
|
case JV_CONSTANT_Integer:
|
case JV_CONSTANT_Float:
|
case JV_CONSTANT_Float:
|
skip (4);
|
skip (4);
|
break;
|
break;
|
|
|
case JV_CONSTANT_Double:
|
case JV_CONSTANT_Double:
|
case JV_CONSTANT_Long:
|
case JV_CONSTANT_Long:
|
skip (8);
|
skip (8);
|
tags[++c] = JV_CONSTANT_Undefined;
|
tags[++c] = JV_CONSTANT_Undefined;
|
break;
|
break;
|
|
|
case JV_CONSTANT_Utf8:
|
case JV_CONSTANT_Utf8:
|
{
|
{
|
int len = read2u ();
|
int len = read2u ();
|
skip (len);
|
skip (len);
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_Unicode:
|
case JV_CONSTANT_Unicode:
|
throw_class_format_error ("unicode not supported");
|
throw_class_format_error ("unicode not supported");
|
break;
|
break;
|
|
|
default:
|
default:
|
throw_class_format_error ("erroneous constant pool tag");
|
throw_class_format_error ("erroneous constant pool tag");
|
}
|
}
|
}
|
}
|
|
|
handleConstantPool ();
|
handleConstantPool ();
|
}
|
}
|
|
|
|
|
void _Jv_ClassReader::read_fields ()
|
void _Jv_ClassReader::read_fields ()
|
{
|
{
|
int fields_count = read2u ();
|
int fields_count = read2u ();
|
handleFieldsBegin (fields_count);
|
handleFieldsBegin (fields_count);
|
|
|
// We want to sort the fields so that static fields come first,
|
// We want to sort the fields so that static fields come first,
|
// followed by instance fields. We do this before parsing the
|
// followed by instance fields. We do this before parsing the
|
// fields so that we can have the new indices available when
|
// fields so that we can have the new indices available when
|
// creating the annotation data structures.
|
// creating the annotation data structures.
|
|
|
// Allocate this on the heap in case there are a large number of
|
// Allocate this on the heap in case there are a large number of
|
// fields.
|
// fields.
|
int *fieldmap = (int *) _Jv_AllocBytes (fields_count * sizeof (int));
|
int *fieldmap = (int *) _Jv_AllocBytes (fields_count * sizeof (int));
|
int save_pos = pos;
|
int save_pos = pos;
|
int static_count = 0, instance_count = -1;
|
int static_count = 0, instance_count = -1;
|
for (int i = 0; i < fields_count; ++i)
|
for (int i = 0; i < fields_count; ++i)
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
int access_flags = read2u ();
|
int access_flags = read2u ();
|
skip (4);
|
skip (4);
|
int attributes_count = read2u ();
|
int attributes_count = read2u ();
|
|
|
if ((access_flags & Modifier::STATIC) != 0)
|
if ((access_flags & Modifier::STATIC) != 0)
|
fieldmap[i] = static_count++;
|
fieldmap[i] = static_count++;
|
else
|
else
|
fieldmap[i] = instance_count--;
|
fieldmap[i] = instance_count--;
|
|
|
for (int j = 0; j < attributes_count; ++j)
|
for (int j = 0; j < attributes_count; ++j)
|
{
|
{
|
skip (2);
|
skip (2);
|
int length = read4 ();
|
int length = read4 ();
|
skip (length);
|
skip (length);
|
}
|
}
|
}
|
}
|
pos = save_pos;
|
pos = save_pos;
|
|
|
// In the loop above, instance fields are represented by negative
|
// In the loop above, instance fields are represented by negative
|
// numbers. Here we rewrite these to be proper offsets.
|
// numbers. Here we rewrite these to be proper offsets.
|
for (int i = 0; i < fields_count; ++i)
|
for (int i = 0; i < fields_count; ++i)
|
{
|
{
|
if (fieldmap[i] < 0)
|
if (fieldmap[i] < 0)
|
fieldmap[i] = static_count - 1 - fieldmap[i];
|
fieldmap[i] = static_count - 1 - fieldmap[i];
|
}
|
}
|
def->static_field_count = static_count;
|
def->static_field_count = static_count;
|
|
|
for (int i = 0; i < fields_count; i++)
|
for (int i = 0; i < fields_count; i++)
|
{
|
{
|
int access_flags = read2u ();
|
int access_flags = read2u ();
|
int name_index = read2u ();
|
int name_index = read2u ();
|
int descriptor_index = read2u ();
|
int descriptor_index = read2u ();
|
int attributes_count = read2u ();
|
int attributes_count = read2u ();
|
|
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
|
|
|
check_tag (descriptor_index, JV_CONSTANT_Utf8);
|
check_tag (descriptor_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
|
|
|
handleField (i, access_flags, name_index, descriptor_index, fieldmap);
|
handleField (i, access_flags, name_index, descriptor_index, fieldmap);
|
|
|
bool found_value = false;
|
bool found_value = false;
|
for (int j = 0; j < attributes_count; j++)
|
for (int j = 0; j < attributes_count; j++)
|
{
|
{
|
read_one_field_attribute (fieldmap[i], &found_value);
|
read_one_field_attribute (fieldmap[i], &found_value);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
bool
|
bool
|
_Jv_ClassReader::is_attribute_name (int index, const char *name)
|
_Jv_ClassReader::is_attribute_name (int index, const char *name)
|
{
|
{
|
check_tag (index, JV_CONSTANT_Utf8);
|
check_tag (index, JV_CONSTANT_Utf8);
|
int len = get2u (bytes+offsets[index]);
|
int len = get2u (bytes+offsets[index]);
|
if (len != (int) strlen (name))
|
if (len != (int) strlen (name))
|
return false;
|
return false;
|
else
|
else
|
return !memcmp (bytes+offsets[index]+2, name, len);
|
return !memcmp (bytes+offsets[index]+2, name, len);
|
}
|
}
|
|
|
// Get a UTF8 value from the constant pool and turn it into a garbage
|
// Get a UTF8 value from the constant pool and turn it into a garbage
|
// collected char array.
|
// collected char array.
|
int _Jv_ClassReader::pool_Utf8_to_char_arr (int index, char** entry)
|
int _Jv_ClassReader::pool_Utf8_to_char_arr (int index, char** entry)
|
{
|
{
|
check_tag (index, JV_CONSTANT_Utf8);
|
check_tag (index, JV_CONSTANT_Utf8);
|
int len = get2u (bytes + offsets[index]);
|
int len = get2u (bytes + offsets[index]);
|
*entry = reinterpret_cast<char *> (_Jv_AllocBytes (len + 1));
|
*entry = reinterpret_cast<char *> (_Jv_AllocBytes (len + 1));
|
(*entry)[len] = '\0';
|
(*entry)[len] = '\0';
|
memcpy (*entry, bytes + offsets[index] + 2, len);
|
memcpy (*entry, bytes + offsets[index] + 2, len);
|
return len + 1;
|
return len + 1;
|
}
|
}
|
|
|
void _Jv_ClassReader::read_one_field_attribute (int field_index,
|
void _Jv_ClassReader::read_one_field_attribute (int field_index,
|
bool *found_value)
|
bool *found_value)
|
{
|
{
|
int name = read2u ();
|
int name = read2u ();
|
int length = read4 ();
|
int length = read4 ();
|
|
|
if (is_attribute_name (name, "ConstantValue"))
|
if (is_attribute_name (name, "ConstantValue"))
|
{
|
{
|
int cv = read2u ();
|
int cv = read2u ();
|
|
|
if (cv < pool_count
|
if (cv < pool_count
|
&& cv > 0
|
&& cv > 0
|
&& (tags[cv] == JV_CONSTANT_Integer
|
&& (tags[cv] == JV_CONSTANT_Integer
|
|| tags[cv] == JV_CONSTANT_Float
|
|| tags[cv] == JV_CONSTANT_Float
|
|| tags[cv] == JV_CONSTANT_Long
|
|| tags[cv] == JV_CONSTANT_Long
|
|| tags[cv] == JV_CONSTANT_Double
|
|| tags[cv] == JV_CONSTANT_Double
|
|| tags[cv] == JV_CONSTANT_String))
|
|| tags[cv] == JV_CONSTANT_String))
|
{
|
{
|
handleConstantValueAttribute (field_index, cv, found_value);
|
handleConstantValueAttribute (field_index, cv, found_value);
|
}
|
}
|
else
|
else
|
{
|
{
|
throw_class_format_error ("erroneous ConstantValue attribute");
|
throw_class_format_error ("erroneous ConstantValue attribute");
|
}
|
}
|
|
|
if (length != 2)
|
if (length != 2)
|
throw_class_format_error ("erroneous ConstantValue attribute");
|
throw_class_format_error ("erroneous ConstantValue attribute");
|
}
|
}
|
else if (is_attribute_name (name, "Signature"))
|
else if (is_attribute_name (name, "Signature"))
|
handleGenericSignature(JV_FIELD_ATTR, field_index, length);
|
handleGenericSignature(JV_FIELD_ATTR, field_index, length);
|
else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
|
else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
|
handleMemberAnnotations(JV_FIELD_ATTR, field_index, length);
|
handleMemberAnnotations(JV_FIELD_ATTR, field_index, length);
|
else
|
else
|
skip (length);
|
skip (length);
|
}
|
}
|
|
|
void _Jv_ClassReader::read_methods ()
|
void _Jv_ClassReader::read_methods ()
|
{
|
{
|
int methods_count = read2u ();
|
int methods_count = read2u ();
|
|
|
handleMethodsBegin (methods_count);
|
handleMethodsBegin (methods_count);
|
|
|
for (int i = 0; i < methods_count; i++)
|
for (int i = 0; i < methods_count; i++)
|
{
|
{
|
int access_flags = read2u ();
|
int access_flags = read2u ();
|
int name_index = read2u ();
|
int name_index = read2u ();
|
int descriptor_index = read2u ();
|
int descriptor_index = read2u ();
|
int attributes_count = read2u ();
|
int attributes_count = read2u ();
|
|
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8);
|
|
|
check_tag (descriptor_index, JV_CONSTANT_Utf8);
|
check_tag (descriptor_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (descriptor_index, JV_CONSTANT_Utf8);
|
|
|
handleMethod (i, access_flags, name_index,
|
handleMethod (i, access_flags, name_index,
|
descriptor_index);
|
descriptor_index);
|
|
|
for (int j = 0; j < attributes_count; j++)
|
for (int j = 0; j < attributes_count; j++)
|
{
|
{
|
read_one_method_attribute (i);
|
read_one_method_attribute (i);
|
}
|
}
|
}
|
}
|
|
|
handleMethodsEnd ();
|
handleMethodsEnd ();
|
}
|
}
|
|
|
void _Jv_ClassReader::read_one_method_attribute (int method_index)
|
void _Jv_ClassReader::read_one_method_attribute (int method_index)
|
{
|
{
|
int name = read2u ();
|
int name = read2u ();
|
int length = read4 ();
|
int length = read4 ();
|
|
|
if (is_attribute_name (name, "Exceptions"))
|
if (is_attribute_name (name, "Exceptions"))
|
{
|
{
|
_Jv_Method *method = reinterpret_cast<_Jv_Method *>
|
_Jv_Method *method = reinterpret_cast<_Jv_Method *>
|
(&def->methods[method_index]);
|
(&def->methods[method_index]);
|
if (method->throws != NULL)
|
if (method->throws != NULL)
|
throw_class_format_error ("only one Exceptions attribute allowed per method");
|
throw_class_format_error ("only one Exceptions attribute allowed per method");
|
|
|
int num_exceptions = read2u ();
|
int num_exceptions = read2u ();
|
_Jv_Utf8Const **exceptions =
|
_Jv_Utf8Const **exceptions =
|
(_Jv_Utf8Const **) _Jv_AllocBytes ((num_exceptions + 1)
|
(_Jv_Utf8Const **) _Jv_AllocBytes ((num_exceptions + 1)
|
* sizeof (_Jv_Utf8Const *));
|
* sizeof (_Jv_Utf8Const *));
|
|
|
int out = 0;
|
int out = 0;
|
_Jv_word *pool_data = def->constants.data;
|
_Jv_word *pool_data = def->constants.data;
|
for (int i = 0; i < num_exceptions; ++i)
|
for (int i = 0; i < num_exceptions; ++i)
|
{
|
{
|
int ndx = read2u ();
|
int ndx = read2u ();
|
// JLS 2nd Ed. 4.7.5 requires that the tag not be 0.
|
// JLS 2nd Ed. 4.7.5 requires that the tag not be 0.
|
if (ndx != 0)
|
if (ndx != 0)
|
{
|
{
|
check_tag (ndx, JV_CONSTANT_Class);
|
check_tag (ndx, JV_CONSTANT_Class);
|
exceptions[out++] = pool_data[ndx].utf8;
|
exceptions[out++] = pool_data[ndx].utf8;
|
}
|
}
|
}
|
}
|
exceptions[out] = NULL;
|
exceptions[out] = NULL;
|
method->throws = exceptions;
|
method->throws = exceptions;
|
}
|
}
|
|
|
else if (is_attribute_name (name, "Code"))
|
else if (is_attribute_name (name, "Code"))
|
{
|
{
|
int start_off = pos;
|
int start_off = pos;
|
int max_stack = read2u ();
|
int max_stack = read2u ();
|
int max_locals = read2u ();
|
int max_locals = read2u ();
|
int code_length = read4 ();
|
int code_length = read4 ();
|
|
|
int code_start = pos;
|
int code_start = pos;
|
skip (code_length);
|
skip (code_length);
|
int exception_table_length = read2u ();
|
int exception_table_length = read2u ();
|
|
|
handleCodeAttribute (method_index,
|
handleCodeAttribute (method_index,
|
max_stack, max_locals,
|
max_stack, max_locals,
|
code_start, code_length,
|
code_start, code_length,
|
exception_table_length);
|
exception_table_length);
|
|
|
|
|
for (int i = 0; i < exception_table_length; i++)
|
for (int i = 0; i < exception_table_length; i++)
|
{
|
{
|
int start_pc = read2u ();
|
int start_pc = read2u ();
|
int end_pc = read2u ();
|
int end_pc = read2u ();
|
int handler_pc = read2u ();
|
int handler_pc = read2u ();
|
int catch_type = read2u ();
|
int catch_type = read2u ();
|
|
|
if (start_pc > end_pc
|
if (start_pc > end_pc
|
|| start_pc < 0
|
|| start_pc < 0
|
// END_PC can be equal to CODE_LENGTH.
|
// END_PC can be equal to CODE_LENGTH.
|
// See JVM Spec 4.7.4.
|
// See JVM Spec 4.7.4.
|
|| end_pc > code_length
|
|| end_pc > code_length
|
|| handler_pc >= code_length)
|
|| handler_pc >= code_length)
|
throw_class_format_error ("erroneous exception handler info");
|
throw_class_format_error ("erroneous exception handler info");
|
|
|
if (! (tags[catch_type] == JV_CONSTANT_Class
|
if (! (tags[catch_type] == JV_CONSTANT_Class
|
|| tags[catch_type] == 0))
|
|| tags[catch_type] == 0))
|
{
|
{
|
throw_class_format_error ("erroneous exception handler info");
|
throw_class_format_error ("erroneous exception handler info");
|
}
|
}
|
|
|
handleExceptionTableEntry (method_index,
|
handleExceptionTableEntry (method_index,
|
i,
|
i,
|
start_pc,
|
start_pc,
|
end_pc,
|
end_pc,
|
handler_pc,
|
handler_pc,
|
catch_type);
|
catch_type);
|
|
|
}
|
}
|
|
|
int attributes_count = read2u ();
|
int attributes_count = read2u ();
|
|
|
for (int i = 0; i < attributes_count; i++)
|
for (int i = 0; i < attributes_count; i++)
|
{
|
{
|
read_one_code_attribute (method_index);
|
read_one_code_attribute (method_index);
|
}
|
}
|
|
|
if ((pos - start_off) != length)
|
if ((pos - start_off) != length)
|
throw_class_format_error ("code attribute too short");
|
throw_class_format_error ("code attribute too short");
|
}
|
}
|
else if (is_attribute_name (name, "Signature"))
|
else if (is_attribute_name (name, "Signature"))
|
handleGenericSignature(JV_METHOD_ATTR, method_index, length);
|
handleGenericSignature(JV_METHOD_ATTR, method_index, length);
|
else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
|
else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
|
handleMemberAnnotations(JV_METHOD_ATTR, method_index, length);
|
handleMemberAnnotations(JV_METHOD_ATTR, method_index, length);
|
else if (is_attribute_name (name, "RuntimeVisibleParameterAnnotations"))
|
else if (is_attribute_name (name, "RuntimeVisibleParameterAnnotations"))
|
handleParameterAnnotations(method_index, length);
|
handleParameterAnnotations(method_index, length);
|
else if (is_attribute_name (name, "AnnotationDefault"))
|
else if (is_attribute_name (name, "AnnotationDefault"))
|
handleAnnotationDefault(method_index, length);
|
handleAnnotationDefault(method_index, length);
|
else
|
else
|
{
|
{
|
/* ignore unknown attributes */
|
/* ignore unknown attributes */
|
skip (length);
|
skip (length);
|
}
|
}
|
}
|
}
|
|
|
void _Jv_ClassReader::read_one_code_attribute (int method_index)
|
void _Jv_ClassReader::read_one_code_attribute (int method_index)
|
{
|
{
|
int name = read2u ();
|
int name = read2u ();
|
int length = read4 ();
|
int length = read4 ();
|
if (is_attribute_name (name, "LineNumberTable"))
|
if (is_attribute_name (name, "LineNumberTable"))
|
{
|
{
|
_Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
|
_Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
|
(def_interp->interpreted_methods[method_index]);
|
(def_interp->interpreted_methods[method_index]);
|
if (method->line_table != NULL)
|
if (method->line_table != NULL)
|
throw_class_format_error ("Method already has LineNumberTable");
|
throw_class_format_error ("Method already has LineNumberTable");
|
|
|
int table_len = read2u ();
|
int table_len = read2u ();
|
_Jv_LineTableEntry* table
|
_Jv_LineTableEntry* table
|
= (_Jv_LineTableEntry *) _Jv_AllocBytes (table_len
|
= (_Jv_LineTableEntry *) _Jv_AllocBytes (table_len
|
* sizeof (_Jv_LineTableEntry));
|
* sizeof (_Jv_LineTableEntry));
|
for (int i = 0; i < table_len; i++)
|
for (int i = 0; i < table_len; i++)
|
{
|
{
|
table[i].bytecode_pc = read2u ();
|
table[i].bytecode_pc = read2u ();
|
table[i].line = read2u ();
|
table[i].line = read2u ();
|
}
|
}
|
method->line_table_len = table_len;
|
method->line_table_len = table_len;
|
method->line_table = table;
|
method->line_table = table;
|
}
|
}
|
else if (is_attribute_name (name, "LocalVariableTable"))
|
else if (is_attribute_name (name, "LocalVariableTable"))
|
{
|
{
|
_Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
|
_Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
|
(def_interp->interpreted_methods[method_index]);
|
(def_interp->interpreted_methods[method_index]);
|
if (method->local_var_table != NULL)
|
if (method->local_var_table != NULL)
|
throw_class_format_error ("Method already has LocalVariableTable");
|
throw_class_format_error ("Method already has LocalVariableTable");
|
|
|
int table_len = read2u ();
|
int table_len = read2u ();
|
_Jv_LocalVarTableEntry *table
|
_Jv_LocalVarTableEntry *table
|
= reinterpret_cast<_Jv_LocalVarTableEntry *>
|
= reinterpret_cast<_Jv_LocalVarTableEntry *>
|
(_Jv_AllocRawObj (table_len * sizeof (_Jv_LocalVarTableEntry)));
|
(_Jv_AllocRawObj (table_len * sizeof (_Jv_LocalVarTableEntry)));
|
|
|
for (int i = 0; i < table_len; i++)
|
for (int i = 0; i < table_len; i++)
|
{
|
{
|
table[i].bytecode_pc = read2u ();
|
table[i].bytecode_pc = read2u ();
|
table[i].length = read2u ();
|
table[i].length = read2u ();
|
pool_Utf8_to_char_arr (read2u (), &table[i].name);
|
pool_Utf8_to_char_arr (read2u (), &table[i].name);
|
pool_Utf8_to_char_arr (read2u (), &table[i].descriptor);
|
pool_Utf8_to_char_arr (read2u (), &table[i].descriptor);
|
table[i].slot = read2u ();
|
table[i].slot = read2u ();
|
|
|
if (table[i].slot > method->max_locals || table[i].slot < 0)
|
if (table[i].slot > method->max_locals || table[i].slot < 0)
|
throw_class_format_error ("Malformed Local Variable Table: Invalid Slot");
|
throw_class_format_error ("Malformed Local Variable Table: Invalid Slot");
|
}
|
}
|
|
|
method->local_var_table_len = table_len;
|
method->local_var_table_len = table_len;
|
method->local_var_table = table;
|
method->local_var_table = table;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* ignore unknown code attributes */
|
/* ignore unknown code attributes */
|
skip (length);
|
skip (length);
|
}
|
}
|
}
|
}
|
|
|
void _Jv_ClassReader::read_one_class_attribute ()
|
void _Jv_ClassReader::read_one_class_attribute ()
|
{
|
{
|
int name = read2u ();
|
int name = read2u ();
|
int length = read4 ();
|
int length = read4 ();
|
if (is_attribute_name (name, "SourceFile"))
|
if (is_attribute_name (name, "SourceFile"))
|
{
|
{
|
int source_index = read2u ();
|
int source_index = read2u ();
|
check_tag (source_index, JV_CONSTANT_Utf8);
|
check_tag (source_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (source_index, JV_CONSTANT_Utf8, false);
|
prepare_pool_entry (source_index, JV_CONSTANT_Utf8, false);
|
def_interp->source_file_name = _Jv_NewStringUtf8Const
|
def_interp->source_file_name = _Jv_NewStringUtf8Const
|
(def->constants.data[source_index].utf8);
|
(def->constants.data[source_index].utf8);
|
}
|
}
|
else if (is_attribute_name (name, "Signature"))
|
else if (is_attribute_name (name, "Signature"))
|
handleGenericSignature(JV_CLASS_ATTR, 0, length);
|
handleGenericSignature(JV_CLASS_ATTR, 0, length);
|
else if (is_attribute_name (name, "EnclosingMethod"))
|
else if (is_attribute_name (name, "EnclosingMethod"))
|
handleEnclosingMethod(length);
|
handleEnclosingMethod(length);
|
else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
|
else if (is_attribute_name (name, "RuntimeVisibleAnnotations"))
|
handleMemberAnnotations(JV_CLASS_ATTR, 0, length);
|
handleMemberAnnotations(JV_CLASS_ATTR, 0, length);
|
else if (is_attribute_name (name, "InnerClasses"))
|
else if (is_attribute_name (name, "InnerClasses"))
|
{
|
{
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
::java::io::DataOutputStream *stream = get_reflection_stream ();
|
stream->writeByte(JV_CLASS_ATTR);
|
stream->writeByte(JV_CLASS_ATTR);
|
stream->writeInt(length + 1);
|
stream->writeInt(length + 1);
|
stream->writeByte(JV_INNER_CLASSES_KIND);
|
stream->writeByte(JV_INNER_CLASSES_KIND);
|
stream->write(input_data, input_offset + pos, length);
|
stream->write(input_data, input_offset + pos, length);
|
skip (length);
|
skip (length);
|
}
|
}
|
else
|
else
|
{
|
{
|
/* Currently, we ignore most class attributes. */
|
/* Currently, we ignore most class attributes. */
|
skip (length);
|
skip (length);
|
}
|
}
|
}
|
}
|
|
|
|
|
|
|
|
|
/* this section defines the semantic actions of the parser */
|
/* this section defines the semantic actions of the parser */
|
|
|
void _Jv_ClassReader::handleConstantPool ()
|
void _Jv_ClassReader::handleConstantPool ()
|
{
|
{
|
/** now, we actually define the class' constant pool */
|
/** now, we actually define the class' constant pool */
|
|
|
jbyte *pool_tags = (jbyte*) _Jv_AllocBytes (pool_count);
|
jbyte *pool_tags = (jbyte*) _Jv_AllocBytes (pool_count);
|
_Jv_word *pool_data
|
_Jv_word *pool_data
|
= (_Jv_word*) _Jv_AllocRawObj (pool_count * sizeof (_Jv_word));
|
= (_Jv_word*) _Jv_AllocRawObj (pool_count * sizeof (_Jv_word));
|
|
|
def->constants.tags = pool_tags;
|
def->constants.tags = pool_tags;
|
def->constants.data = pool_data;
|
def->constants.data = pool_data;
|
def->constants.size = pool_count;
|
def->constants.size = pool_count;
|
|
|
// Here we make a pass to collect the strings! We do this, because
|
// Here we make a pass to collect the strings! We do this, because
|
// internally in the GCJ runtime, classes are encoded with .'s not /'s.
|
// internally in the GCJ runtime, classes are encoded with .'s not /'s.
|
// Therefore, we first collect the strings, and then translate the rest
|
// Therefore, we first collect the strings, and then translate the rest
|
// of the utf8-entries (thus not representing strings) from /-notation
|
// of the utf8-entries (thus not representing strings) from /-notation
|
// to .-notation.
|
// to .-notation.
|
for (int i = 1; i < pool_count; i++)
|
for (int i = 1; i < pool_count; i++)
|
{
|
{
|
if (tags[i] == JV_CONSTANT_String)
|
if (tags[i] == JV_CONSTANT_String)
|
{
|
{
|
unsigned char* str_data = bytes + offsets [i];
|
unsigned char* str_data = bytes + offsets [i];
|
int utf_index = get2u (str_data);
|
int utf_index = get2u (str_data);
|
check_tag (utf_index, JV_CONSTANT_Utf8);
|
check_tag (utf_index, JV_CONSTANT_Utf8);
|
unsigned char *utf_data = bytes + offsets[utf_index];
|
unsigned char *utf_data = bytes + offsets[utf_index];
|
int len = get2u (utf_data);
|
int len = get2u (utf_data);
|
pool_data[i].utf8 = _Jv_makeUtf8Const ((char*)(utf_data+2), len);
|
pool_data[i].utf8 = _Jv_makeUtf8Const ((char*)(utf_data+2), len);
|
pool_tags[i] = JV_CONSTANT_String;
|
pool_tags[i] = JV_CONSTANT_String;
|
}
|
}
|
else
|
else
|
{
|
{
|
pool_tags[i] = JV_CONSTANT_Undefined;
|
pool_tags[i] = JV_CONSTANT_Undefined;
|
}
|
}
|
}
|
}
|
|
|
// and now, we scan everything else but strings & utf8-entries. This
|
// and now, we scan everything else but strings & utf8-entries. This
|
// leaves out those utf8-entries which are not used; which will be left
|
// leaves out those utf8-entries which are not used; which will be left
|
// with a tag of JV_CONSTANT_Undefined in the class definition.
|
// with a tag of JV_CONSTANT_Undefined in the class definition.
|
for (int index = 1; index < pool_count; index++)
|
for (int index = 1; index < pool_count; index++)
|
{
|
{
|
switch (tags[index])
|
switch (tags[index])
|
{
|
{
|
case JV_CONSTANT_Undefined:
|
case JV_CONSTANT_Undefined:
|
case JV_CONSTANT_String:
|
case JV_CONSTANT_String:
|
case JV_CONSTANT_Utf8:
|
case JV_CONSTANT_Utf8:
|
continue;
|
continue;
|
|
|
default:
|
default:
|
prepare_pool_entry (index, tags[index]);
|
prepare_pool_entry (index, tags[index]);
|
}
|
}
|
}
|
}
|
|
|
}
|
}
|
|
|
/* this is a recursive procedure, which will prepare pool entries as needed.
|
/* this is a recursive procedure, which will prepare pool entries as needed.
|
Which is how we avoid initializing those entries which go unused.
|
Which is how we avoid initializing those entries which go unused.
|
|
|
REWRITE is true iff this pool entry is the Utf8 representation of a
|
REWRITE is true iff this pool entry is the Utf8 representation of a
|
class name or a signature.
|
class name or a signature.
|
*/
|
*/
|
|
|
void
|
void
|
_Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag,
|
_Jv_ClassReader::prepare_pool_entry (int index, unsigned char this_tag,
|
bool rewrite)
|
bool rewrite)
|
{
|
{
|
/* these two, pool_data and pool_tags, point into the class
|
/* these two, pool_data and pool_tags, point into the class
|
structure we are currently defining */
|
structure we are currently defining */
|
|
|
unsigned char *pool_tags = (unsigned char*) def->constants.tags;
|
unsigned char *pool_tags = (unsigned char*) def->constants.tags;
|
_Jv_word *pool_data = def->constants.data;
|
_Jv_word *pool_data = def->constants.data;
|
|
|
/* this entry was already prepared */
|
/* this entry was already prepared */
|
if (pool_tags[index] == this_tag)
|
if (pool_tags[index] == this_tag)
|
return;
|
return;
|
|
|
/* this_data points to the constant-pool information for the current
|
/* this_data points to the constant-pool information for the current
|
constant-pool entry */
|
constant-pool entry */
|
|
|
unsigned char *this_data = bytes + offsets[index];
|
unsigned char *this_data = bytes + offsets[index];
|
|
|
switch (this_tag)
|
switch (this_tag)
|
{
|
{
|
case JV_CONSTANT_Utf8:
|
case JV_CONSTANT_Utf8:
|
{
|
{
|
int len = get2u (this_data);
|
int len = get2u (this_data);
|
char *s = ((char*) this_data)+2;
|
char *s = ((char*) this_data)+2;
|
pool_tags[index] = JV_CONSTANT_Utf8;
|
pool_tags[index] = JV_CONSTANT_Utf8;
|
|
|
if (! rewrite)
|
if (! rewrite)
|
{
|
{
|
pool_data[index].utf8 = _Jv_makeUtf8Const (s, len);
|
pool_data[index].utf8 = _Jv_makeUtf8Const (s, len);
|
break;
|
break;
|
}
|
}
|
|
|
// If REWRITE is set, it is because some other tag needs this
|
// If REWRITE is set, it is because some other tag needs this
|
// utf8-entry for type information: it is a class or a
|
// utf8-entry for type information: it is a class or a
|
// signature. Thus, we translate /'s to .'s in order to
|
// signature. Thus, we translate /'s to .'s in order to
|
// accomondate gcj's internal representation.
|
// accomondate gcj's internal representation.
|
char *buffer = (char*) __builtin_alloca (len);
|
char *buffer = (char*) __builtin_alloca (len);
|
for (int i = 0; i < len; i++)
|
for (int i = 0; i < len; i++)
|
{
|
{
|
if (s[i] == '/')
|
if (s[i] == '/')
|
buffer[i] = '.';
|
buffer[i] = '.';
|
else
|
else
|
buffer[i] = s[i];
|
buffer[i] = s[i];
|
}
|
}
|
pool_data[index].utf8 = _Jv_makeUtf8Const (buffer, len);
|
pool_data[index].utf8 = _Jv_makeUtf8Const (buffer, len);
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_Class:
|
case JV_CONSTANT_Class:
|
{
|
{
|
int utf_index = get2u (this_data);
|
int utf_index = get2u (this_data);
|
check_tag (utf_index, JV_CONSTANT_Utf8);
|
check_tag (utf_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (utf_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (utf_index, JV_CONSTANT_Utf8);
|
|
|
if (verify)
|
if (verify)
|
verify_classname (pool_data[utf_index].utf8);
|
verify_classname (pool_data[utf_index].utf8);
|
|
|
pool_data[index].utf8 = pool_data[utf_index].utf8;
|
pool_data[index].utf8 = pool_data[utf_index].utf8;
|
pool_tags[index] = JV_CONSTANT_Class;
|
pool_tags[index] = JV_CONSTANT_Class;
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_String:
|
case JV_CONSTANT_String:
|
// already handled before...
|
// already handled before...
|
break;
|
break;
|
|
|
case JV_CONSTANT_Fieldref:
|
case JV_CONSTANT_Fieldref:
|
case JV_CONSTANT_Methodref:
|
case JV_CONSTANT_Methodref:
|
case JV_CONSTANT_InterfaceMethodref:
|
case JV_CONSTANT_InterfaceMethodref:
|
{
|
{
|
int class_index = get2u (this_data);
|
int class_index = get2u (this_data);
|
int nat_index = get2u (this_data+2);
|
int nat_index = get2u (this_data+2);
|
|
|
check_tag (class_index, JV_CONSTANT_Class);
|
check_tag (class_index, JV_CONSTANT_Class);
|
prepare_pool_entry (class_index, JV_CONSTANT_Class);
|
prepare_pool_entry (class_index, JV_CONSTANT_Class);
|
|
|
check_tag (nat_index, JV_CONSTANT_NameAndType);
|
check_tag (nat_index, JV_CONSTANT_NameAndType);
|
prepare_pool_entry (nat_index, JV_CONSTANT_NameAndType);
|
prepare_pool_entry (nat_index, JV_CONSTANT_NameAndType);
|
|
|
// here, verify the signature and identifier name
|
// here, verify the signature and identifier name
|
if (verify)
|
if (verify)
|
{
|
{
|
_Jv_ushort name_index, type_index;
|
_Jv_ushort name_index, type_index;
|
_Jv_loadIndexes (&pool_data[nat_index],
|
_Jv_loadIndexes (&pool_data[nat_index],
|
name_index, type_index);
|
name_index, type_index);
|
|
|
if (this_tag == JV_CONSTANT_Fieldref)
|
if (this_tag == JV_CONSTANT_Fieldref)
|
verify_field_signature (pool_data[type_index].utf8);
|
verify_field_signature (pool_data[type_index].utf8);
|
else
|
else
|
verify_method_signature (pool_data[type_index].utf8);
|
verify_method_signature (pool_data[type_index].utf8);
|
|
|
_Jv_Utf8Const* name = pool_data[name_index].utf8;
|
_Jv_Utf8Const* name = pool_data[name_index].utf8;
|
|
|
if (this_tag != JV_CONSTANT_Fieldref
|
if (this_tag != JV_CONSTANT_Fieldref
|
&& ( _Jv_equalUtf8Consts (name, clinit_name)
|
&& ( _Jv_equalUtf8Consts (name, clinit_name)
|
|| _Jv_equalUtf8Consts (name, init_name)))
|
|| _Jv_equalUtf8Consts (name, init_name)))
|
/* ignore */;
|
/* ignore */;
|
else
|
else
|
verify_identifier (pool_data[name_index].utf8);
|
verify_identifier (pool_data[name_index].utf8);
|
}
|
}
|
|
|
_Jv_storeIndexes (&pool_data[index], class_index, nat_index);
|
_Jv_storeIndexes (&pool_data[index], class_index, nat_index);
|
pool_tags[index] = this_tag;
|
pool_tags[index] = this_tag;
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_NameAndType:
|
case JV_CONSTANT_NameAndType:
|
{
|
{
|
_Jv_ushort name_index = get2u (this_data);
|
_Jv_ushort name_index = get2u (this_data);
|
_Jv_ushort type_index = get2u (this_data+2);
|
_Jv_ushort type_index = get2u (this_data+2);
|
|
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
check_tag (name_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
|
prepare_pool_entry (name_index, JV_CONSTANT_Utf8, false);
|
check_tag (type_index, JV_CONSTANT_Utf8);
|
check_tag (type_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
|
prepare_pool_entry (type_index, JV_CONSTANT_Utf8);
|
|
|
_Jv_storeIndexes (&pool_data[index], name_index, type_index);
|
_Jv_storeIndexes (&pool_data[index], name_index, type_index);
|
pool_tags[index] = JV_CONSTANT_NameAndType;
|
pool_tags[index] = JV_CONSTANT_NameAndType;
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_Float:
|
case JV_CONSTANT_Float:
|
{
|
{
|
jfloat f = java::lang::Float::intBitsToFloat ((jint) get4 (this_data));
|
jfloat f = java::lang::Float::intBitsToFloat ((jint) get4 (this_data));
|
_Jv_storeFloat (&pool_data[index], f);
|
_Jv_storeFloat (&pool_data[index], f);
|
pool_tags[index] = JV_CONSTANT_Float;
|
pool_tags[index] = JV_CONSTANT_Float;
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_Integer:
|
case JV_CONSTANT_Integer:
|
{
|
{
|
int i = get4 (this_data);
|
int i = get4 (this_data);
|
_Jv_storeInt (&pool_data[index], i);
|
_Jv_storeInt (&pool_data[index], i);
|
pool_tags[index] = JV_CONSTANT_Integer;
|
pool_tags[index] = JV_CONSTANT_Integer;
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_Double:
|
case JV_CONSTANT_Double:
|
{
|
{
|
jdouble d
|
jdouble d
|
= java::lang::Double::longBitsToDouble ((jlong) get8 (this_data));
|
= java::lang::Double::longBitsToDouble ((jlong) get8 (this_data));
|
_Jv_storeDouble (&pool_data[index], d);
|
_Jv_storeDouble (&pool_data[index], d);
|
pool_tags[index] = JV_CONSTANT_Double;
|
pool_tags[index] = JV_CONSTANT_Double;
|
}
|
}
|
break;
|
break;
|
|
|
case JV_CONSTANT_Long:
|
case JV_CONSTANT_Long:
|
{
|
{
|
jlong i = get8 (this_data);
|
jlong i = get8 (this_data);
|
_Jv_storeLong (&pool_data[index], i);
|
_Jv_storeLong (&pool_data[index], i);
|
pool_tags[index] = JV_CONSTANT_Long;
|
pool_tags[index] = JV_CONSTANT_Long;
|
}
|
}
|
break;
|
break;
|
|
|
default:
|
default:
|
throw_class_format_error ("erroneous constant pool tag");
|
throw_class_format_error ("erroneous constant pool tag");
|
}
|
}
|
}
|
}
|
|
|
|
|
void
|
void
|
_Jv_ClassReader::handleClassBegin (int access_flags, int this_class, int super_class)
|
_Jv_ClassReader::handleClassBegin (int access_flags, int this_class, int super_class)
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
unsigned char *pool_tags = (unsigned char*) def->constants.tags;
|
unsigned char *pool_tags = (unsigned char*) def->constants.tags;
|
_Jv_word *pool_data = def->constants.data;
|
_Jv_word *pool_data = def->constants.data;
|
|
|
check_tag (this_class, JV_CONSTANT_Class);
|
check_tag (this_class, JV_CONSTANT_Class);
|
_Jv_Utf8Const *loadedName = pool_data[this_class].utf8;
|
_Jv_Utf8Const *loadedName = pool_data[this_class].utf8;
|
|
|
// was ClassLoader.defineClass called with an expected class name?
|
// was ClassLoader.defineClass called with an expected class name?
|
if (def->name == 0)
|
if (def->name == 0)
|
{
|
{
|
jclass orig = def->loader->findLoadedClass(loadedName->toString());
|
jclass orig = def->loader->findLoadedClass(loadedName->toString());
|
|
|
if (orig == 0)
|
if (orig == 0)
|
{
|
{
|
def->name = loadedName;
|
def->name = loadedName;
|
}
|
}
|
else
|
else
|
{
|
{
|
jstring msg = JvNewStringUTF ("anonymous "
|
jstring msg = JvNewStringUTF ("anonymous "
|
"class data denotes "
|
"class data denotes "
|
"existing class ");
|
"existing class ");
|
msg = msg->concat (orig->getName ());
|
msg = msg->concat (orig->getName ());
|
|
|
throw_no_class_def_found_error (msg);
|
throw_no_class_def_found_error (msg);
|
}
|
}
|
}
|
}
|
|
|
// assert that the loaded class has the expected name, 5.3.5
|
// assert that the loaded class has the expected name, 5.3.5
|
else if (! _Jv_equalUtf8Consts (loadedName, def->name))
|
else if (! _Jv_equalUtf8Consts (loadedName, def->name))
|
{
|
{
|
jstring msg = JvNewStringUTF ("loaded class ");
|
jstring msg = JvNewStringUTF ("loaded class ");
|
msg = msg->concat (def->getName ());
|
msg = msg->concat (def->getName ());
|
msg = msg->concat (_Jv_NewStringUTF (" was in fact named "));
|
msg = msg->concat (_Jv_NewStringUTF (" was in fact named "));
|
jstring klass_name = loadedName->toString();
|
jstring klass_name = loadedName->toString();
|
msg = msg->concat (klass_name);
|
msg = msg->concat (klass_name);
|
|
|
throw_no_class_def_found_error (msg);
|
throw_no_class_def_found_error (msg);
|
}
|
}
|
|
|
def->accflags = access_flags | java::lang::reflect::Modifier::INTERPRETED;
|
def->accflags = access_flags | java::lang::reflect::Modifier::INTERPRETED;
|
pool_data[this_class].clazz = def;
|
pool_data[this_class].clazz = def;
|
pool_tags[this_class] = JV_CONSTANT_ResolvedClass;
|
pool_tags[this_class] = JV_CONSTANT_ResolvedClass;
|
|
|
if (super_class == 0)
|
if (super_class == 0)
|
{
|
{
|
// Note that this is ok if we are defining java.lang.Object.
|
// Note that this is ok if we are defining java.lang.Object.
|
// But there is no way to have this class be interpreted.
|
// But there is no way to have this class be interpreted.
|
throw_class_format_error ("no superclass reference");
|
throw_class_format_error ("no superclass reference");
|
}
|
}
|
|
|
def->state = JV_STATE_PRELOADING;
|
def->state = JV_STATE_PRELOADING;
|
|
|
// Register this class with its defining loader as well (despite the
|
// Register this class with its defining loader as well (despite the
|
// name of the function we're calling), so that super class lookups
|
// name of the function we're calling), so that super class lookups
|
// work properly. If there is an error, our caller will unregister
|
// work properly. If there is an error, our caller will unregister
|
// this class from the class loader. Also, we don't need to hold a
|
// this class from the class loader. Also, we don't need to hold a
|
// lock here, as our caller has acquired it.
|
// lock here, as our caller has acquired it.
|
_Jv_RegisterInitiatingLoader (def, def->loader);
|
_Jv_RegisterInitiatingLoader (def, def->loader);
|
|
|
// Note that we found a name so that unregistration can happen if
|
// Note that we found a name so that unregistration can happen if
|
// needed.
|
// needed.
|
*found_name = def->name;
|
*found_name = def->name;
|
|
|
if (super_class != 0)
|
if (super_class != 0)
|
{
|
{
|
// Load the superclass.
|
// Load the superclass.
|
check_tag (super_class, JV_CONSTANT_Class);
|
check_tag (super_class, JV_CONSTANT_Class);
|
_Jv_Utf8Const* super_name = pool_data[super_class].utf8;
|
_Jv_Utf8Const* super_name = pool_data[super_class].utf8;
|
|
|
// Load the superclass using our defining loader.
|
// Load the superclass using our defining loader.
|
jclass the_super = _Jv_FindClass (super_name, def->loader);
|
jclass the_super = _Jv_FindClass (super_name, def->loader);
|
|
|
// This will establish that we are allowed to be a subclass,
|
// 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);
|
checkExtends (def, the_super);
|
|
|
// Note: for an interface we will find Object as the
|
// Note: for an interface we will find Object as the
|
// superclass. We still check it above to ensure class file
|
// superclass. We still check it above to ensure class file
|
// validity, but we simply assign `null' to the actual field in
|
// validity, but we simply assign `null' to the actual field in
|
// this case.
|
// this case.
|
def->superclass = (((access_flags & Modifier::INTERFACE))
|
def->superclass = (((access_flags & Modifier::INTERFACE))
|
? NULL : the_super);
|
? NULL : the_super);
|
pool_data[super_class].clazz = the_super;
|
pool_data[super_class].clazz = the_super;
|
pool_tags[super_class] = JV_CONSTANT_ResolvedClass;
|
pool_tags[super_class] = JV_CONSTANT_ResolvedClass;
|
}
|
}
|
|
|
// Now we've come past the circularity problem, we can
|
// Now we've come past the circularity problem, we can
|
// now say that we're loading.
|
// now say that we're loading.
|
|
|
def->state = JV_STATE_LOADING;
|
def->state = JV_STATE_LOADING;
|
def->notifyAll ();
|
def->notifyAll ();
|
}
|
}
|
|
|
///// Implements the checks described in sect. 5.3.5.3
|
///// Implements the checks described in sect. 5.3.5.3
|
void
|
void
|
_Jv_ClassReader::checkExtends (jclass sub, jclass super)
|
_Jv_ClassReader::checkExtends (jclass sub, jclass super)
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
_Jv_Linker::wait_for_state (super, JV_STATE_LOADING);
|
_Jv_Linker::wait_for_state (super, JV_STATE_LOADING);
|
|
|
// Having an interface or a final class as a superclass is no good.
|
// Having an interface or a final class as a superclass is no good.
|
if ((super->accflags & (Modifier::INTERFACE | Modifier::FINAL)) != 0)
|
if ((super->accflags & (Modifier::INTERFACE | Modifier::FINAL)) != 0)
|
{
|
{
|
throw_incompatible_class_change_error (sub->getName ());
|
throw_incompatible_class_change_error (sub->getName ());
|
}
|
}
|
|
|
// If the super class is not public, we need to check some more.
|
// If the super class is not public, we need to check some more.
|
if ((super->accflags & Modifier::PUBLIC) == 0)
|
if ((super->accflags & Modifier::PUBLIC) == 0)
|
{
|
{
|
// With package scope, the classes must have the same class
|
// With package scope, the classes must have the same class
|
// loader.
|
// loader.
|
if ( sub->loader != super->loader
|
if ( sub->loader != super->loader
|
|| !_Jv_ClassNameSamePackage (sub->name, super->name))
|
|| !_Jv_ClassNameSamePackage (sub->name, super->name))
|
{
|
{
|
throw_incompatible_class_change_error (sub->getName ());
|
throw_incompatible_class_change_error (sub->getName ());
|
}
|
}
|
}
|
}
|
|
|
for (; super != 0; super = super->getSuperclass ())
|
for (; super != 0; super = super->getSuperclass ())
|
{
|
{
|
if (super == sub)
|
if (super == sub)
|
throw_class_circularity_error (sub->getName ());
|
throw_class_circularity_error (sub->getName ());
|
}
|
}
|
}
|
}
|
|
|
|
|
|
|
void _Jv_ClassReader::handleInterfacesBegin (int count)
|
void _Jv_ClassReader::handleInterfacesBegin (int count)
|
{
|
{
|
def->interfaces = (jclass*) _Jv_AllocRawObj (count*sizeof (jclass));
|
def->interfaces = (jclass*) _Jv_AllocRawObj (count*sizeof (jclass));
|
def->interface_count = count;
|
def->interface_count = count;
|
}
|
}
|
|
|
void _Jv_ClassReader::handleInterface (int if_number, int offset)
|
void _Jv_ClassReader::handleInterface (int if_number, int offset)
|
{
|
{
|
_Jv_word * pool_data = def->constants.data;
|
_Jv_word * pool_data = def->constants.data;
|
unsigned char * pool_tags = (unsigned char*) def->constants.tags;
|
unsigned char * pool_tags = (unsigned char*) def->constants.tags;
|
|
|
jclass the_interface;
|
jclass the_interface;
|
|
|
if (pool_tags[offset] == JV_CONSTANT_Class)
|
if (pool_tags[offset] == JV_CONSTANT_Class)
|
{
|
{
|
_Jv_Utf8Const* name = pool_data[offset].utf8;
|
_Jv_Utf8Const* name = pool_data[offset].utf8;
|
the_interface = _Jv_FindClass (name, def->loader);
|
the_interface = _Jv_FindClass (name, def->loader);
|
}
|
}
|
else if (pool_tags[offset] == JV_CONSTANT_ResolvedClass)
|
else if (pool_tags[offset] == JV_CONSTANT_ResolvedClass)
|
{
|
{
|
the_interface = pool_data[offset].clazz;
|
the_interface = pool_data[offset].clazz;
|
}
|
}
|
else
|
else
|
{
|
{
|
throw_no_class_def_found_error ("erroneous constant pool tag");
|
throw_no_class_def_found_error ("erroneous constant pool tag");
|
}
|
}
|
|
|
// checks the validity of the_interface, and that we are in fact
|
// checks the validity of the_interface, and that we are in fact
|
// allowed to implement that interface.
|
// allowed to implement that interface.
|
checkImplements (def, the_interface);
|
checkImplements (def, the_interface);
|
|
|
pool_data[offset].clazz = the_interface;
|
pool_data[offset].clazz = the_interface;
|
pool_tags[offset] = JV_CONSTANT_ResolvedClass;
|
pool_tags[offset] = JV_CONSTANT_ResolvedClass;
|
|
|
def->interfaces[if_number] = the_interface;
|
def->interfaces[if_number] = the_interface;
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::checkImplements (jclass sub, jclass super)
|
_Jv_ClassReader::checkImplements (jclass sub, jclass super)
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
// well, it *must* be an interface
|
// well, it *must* be an interface
|
if ((super->accflags & Modifier::INTERFACE) == 0)
|
if ((super->accflags & Modifier::INTERFACE) == 0)
|
{
|
{
|
throw_incompatible_class_change_error (sub->getName ());
|
throw_incompatible_class_change_error (sub->getName ());
|
}
|
}
|
|
|
// if it has package scope, it must also be defined by the
|
// if it has package scope, it must also be defined by the
|
// same loader.
|
// same loader.
|
if ((super->accflags & Modifier::PUBLIC) == 0)
|
if ((super->accflags & Modifier::PUBLIC) == 0)
|
{
|
{
|
if ( sub->loader != super->loader
|
if ( sub->loader != super->loader
|
|| !_Jv_ClassNameSamePackage (sub->name, super->name))
|
|| !_Jv_ClassNameSamePackage (sub->name, super->name))
|
{
|
{
|
throw_incompatible_class_change_error (sub->getName ());
|
throw_incompatible_class_change_error (sub->getName ());
|
}
|
}
|
}
|
}
|
|
|
// FIXME: add interface circularity check here
|
// FIXME: add interface circularity check here
|
if (sub == super)
|
if (sub == super)
|
{
|
{
|
throw_class_circularity_error (sub->getName ());
|
throw_class_circularity_error (sub->getName ());
|
}
|
}
|
}
|
}
|
|
|
void _Jv_ClassReader::handleFieldsBegin (int count)
|
void _Jv_ClassReader::handleFieldsBegin (int count)
|
{
|
{
|
def->fields = (_Jv_Field*) _Jv_AllocRawObj (count * sizeof (_Jv_Field));
|
def->fields = (_Jv_Field*) _Jv_AllocRawObj (count * sizeof (_Jv_Field));
|
def->field_count = count;
|
def->field_count = count;
|
def_interp->field_initializers
|
def_interp->field_initializers
|
= (_Jv_ushort*) _Jv_AllocRawObj (count * sizeof (_Jv_ushort));
|
= (_Jv_ushort*) _Jv_AllocRawObj (count * sizeof (_Jv_ushort));
|
for (int i = 0; i < count; i++)
|
for (int i = 0; i < count; i++)
|
def_interp->field_initializers[i] = (_Jv_ushort) 0;
|
def_interp->field_initializers[i] = (_Jv_ushort) 0;
|
}
|
}
|
|
|
void _Jv_ClassReader::handleField (int field_no,
|
void _Jv_ClassReader::handleField (int field_no,
|
int flags,
|
int flags,
|
int name,
|
int name,
|
int desc,
|
int desc,
|
int *fieldmap)
|
int *fieldmap)
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
_Jv_word *pool_data = def->constants.data;
|
_Jv_word *pool_data = def->constants.data;
|
|
|
_Jv_Field *field = &def->fields[fieldmap[field_no]];
|
_Jv_Field *field = &def->fields[fieldmap[field_no]];
|
_Jv_Utf8Const *field_name = pool_data[name].utf8;
|
_Jv_Utf8Const *field_name = pool_data[name].utf8;
|
|
|
field->name = field_name;
|
field->name = field_name;
|
|
|
// Ignore flags we don't know about.
|
// Ignore flags we don't know about.
|
field->flags = flags & (Field::FIELD_MODIFIERS
|
field->flags = flags & (Field::FIELD_MODIFIERS
|
| Modifier::SYNTHETIC
|
| Modifier::SYNTHETIC
|
| Modifier::ENUM);
|
| Modifier::ENUM);
|
|
|
_Jv_Utf8Const* sig = pool_data[desc].utf8;
|
_Jv_Utf8Const* sig = pool_data[desc].utf8;
|
|
|
if (verify)
|
if (verify)
|
{
|
{
|
verify_identifier (field_name);
|
verify_identifier (field_name);
|
|
|
for (int i = 0; i < field_no; ++i)
|
for (int i = 0; i < field_no; ++i)
|
{
|
{
|
if (_Jv_equalUtf8Consts (field_name, def->fields[fieldmap[i]].name)
|
if (_Jv_equalUtf8Consts (field_name, def->fields[fieldmap[i]].name)
|
&& _Jv_equalUtf8Consts (sig,
|
&& _Jv_equalUtf8Consts (sig,
|
// We know the other fields are
|
// We know the other fields are
|
// unresolved.
|
// unresolved.
|
(_Jv_Utf8Const *) def->fields[i].type))
|
(_Jv_Utf8Const *) def->fields[i].type))
|
throw_class_format_error ("duplicate field name");
|
throw_class_format_error ("duplicate field name");
|
}
|
}
|
|
|
// At most one of PUBLIC, PRIVATE, or PROTECTED is allowed.
|
// At most one of PUBLIC, PRIVATE, or PROTECTED is allowed.
|
if (1 < ( ((field->flags & Modifier::PUBLIC) ? 1 : 0)
|
if (1 < ( ((field->flags & Modifier::PUBLIC) ? 1 : 0)
|
+((field->flags & Modifier::PRIVATE) ? 1 : 0)
|
+((field->flags & Modifier::PRIVATE) ? 1 : 0)
|
+((field->flags & Modifier::PROTECTED) ? 1 : 0)))
|
+((field->flags & Modifier::PROTECTED) ? 1 : 0)))
|
throw_class_format_error ("erroneous field access flags");
|
throw_class_format_error ("erroneous field access flags");
|
|
|
// FIXME: JVM spec S4.5: Verify ACC_FINAL and ACC_VOLATILE are not
|
// FIXME: JVM spec S4.5: Verify ACC_FINAL and ACC_VOLATILE are not
|
// both set. Verify modifiers for interface fields.
|
// both set. Verify modifiers for interface fields.
|
|
|
}
|
}
|
|
|
if (verify)
|
if (verify)
|
verify_field_signature (sig);
|
verify_field_signature (sig);
|
|
|
// field->type is really a jclass, but while it is still
|
// field->type is really a jclass, but while it is still
|
// unresolved we keep an _Jv_Utf8Const* instead.
|
// unresolved we keep an _Jv_Utf8Const* instead.
|
field->type = (jclass) sig;
|
field->type = (jclass) sig;
|
field->flags |= _Jv_FIELD_UNRESOLVED_FLAG;
|
field->flags |= _Jv_FIELD_UNRESOLVED_FLAG;
|
field->u.boffset = 0;
|
field->u.boffset = 0;
|
}
|
}
|
|
|
|
|
void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
|
void _Jv_ClassReader::handleConstantValueAttribute (int field_index,
|
int value,
|
int value,
|
bool *found_value)
|
bool *found_value)
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
_Jv_Field *field = &def->fields[field_index];
|
_Jv_Field *field = &def->fields[field_index];
|
|
|
if ((field->flags & (Modifier::STATIC
|
if ((field->flags & (Modifier::STATIC
|
| Modifier::FINAL
|
| Modifier::FINAL
|
| Modifier::PRIVATE)) == 0)
|
| Modifier::PRIVATE)) == 0)
|
{
|
{
|
// Ignore, as per vmspec #4.7.2
|
// Ignore, as per vmspec #4.7.2
|
return;
|
return;
|
}
|
}
|
|
|
// do not allow multiple constant fields!
|
// do not allow multiple constant fields!
|
if (*found_value)
|
if (*found_value)
|
throw_class_format_error ("field has multiple ConstantValue attributes");
|
throw_class_format_error ("field has multiple ConstantValue attributes");
|
|
|
*found_value = true;
|
*found_value = true;
|
def_interp->field_initializers[field_index] = value;
|
def_interp->field_initializers[field_index] = value;
|
|
|
/* type check the initializer */
|
/* type check the initializer */
|
|
|
if (value <= 0 || value >= pool_count)
|
if (value <= 0 || value >= pool_count)
|
throw_class_format_error ("erroneous ConstantValue attribute");
|
throw_class_format_error ("erroneous ConstantValue attribute");
|
|
|
/* FIXME: do the rest */
|
/* FIXME: do the rest */
|
}
|
}
|
|
|
void
|
void
|
_Jv_ClassReader::handleMethodsBegin (int count)
|
_Jv_ClassReader::handleMethodsBegin (int count)
|
{
|
{
|
def->methods = (_Jv_Method *) _Jv_AllocRawObj (sizeof (_Jv_Method) * count);
|
def->methods = (_Jv_Method *) _Jv_AllocRawObj (sizeof (_Jv_Method) * count);
|
|
|
def_interp->interpreted_methods
|
def_interp->interpreted_methods
|
= (_Jv_MethodBase **) _Jv_AllocRawObj (sizeof (_Jv_MethodBase *)
|
= (_Jv_MethodBase **) _Jv_AllocRawObj (sizeof (_Jv_MethodBase *)
|
* count);
|
* count);
|
|
|
for (int i = 0; i < count; i++)
|
for (int i = 0; i < count; i++)
|
{
|
{
|
def_interp->interpreted_methods[i] = 0;
|
def_interp->interpreted_methods[i] = 0;
|
def->methods[i].index = (_Jv_ushort) -1;
|
def->methods[i].index = (_Jv_ushort) -1;
|
}
|
}
|
|
|
def->method_count = count;
|
def->method_count = count;
|
}
|
}
|
|
|
|
|
void _Jv_ClassReader::handleMethod
|
void _Jv_ClassReader::handleMethod
|
(int mth_index, int accflags, int name, int desc)
|
(int mth_index, int accflags, int name, int desc)
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
_Jv_word *pool_data = def->constants.data;
|
_Jv_word *pool_data = def->constants.data;
|
_Jv_Method *method = &def->methods[mth_index];
|
_Jv_Method *method = &def->methods[mth_index];
|
|
|
check_tag (name, JV_CONSTANT_Utf8);
|
check_tag (name, JV_CONSTANT_Utf8);
|
prepare_pool_entry (name, JV_CONSTANT_Utf8, false);
|
prepare_pool_entry (name, JV_CONSTANT_Utf8, false);
|
method->name = pool_data[name].utf8;
|
method->name = pool_data[name].utf8;
|
|
|
check_tag (desc, JV_CONSTANT_Utf8);
|
check_tag (desc, JV_CONSTANT_Utf8);
|
prepare_pool_entry (desc, JV_CONSTANT_Utf8);
|
prepare_pool_entry (desc, JV_CONSTANT_Utf8);
|
method->signature = pool_data[desc].utf8;
|
method->signature = pool_data[desc].utf8;
|
|
|
// ignore unknown flags
|
// ignore unknown flags
|
method->accflags = accflags & (Method::METHOD_MODIFIERS
|
method->accflags = accflags & (Method::METHOD_MODIFIERS
|
| Modifier::BRIDGE
|
| Modifier::BRIDGE
|
| Modifier::SYNTHETIC
|
| Modifier::SYNTHETIC
|
| Modifier::VARARGS);
|
| Modifier::VARARGS);
|
|
|
// Initialize...
|
// Initialize...
|
method->ncode = 0;
|
method->ncode = 0;
|
method->throws = NULL;
|
method->throws = NULL;
|
|
|
if (verify)
|
if (verify)
|
{
|
{
|
if (_Jv_equalUtf8Consts (method->name, clinit_name)
|
if (_Jv_equalUtf8Consts (method->name, clinit_name)
|
|| _Jv_equalUtf8Consts (method->name, init_name))
|
|| _Jv_equalUtf8Consts (method->name, init_name))
|
/* ignore */;
|
/* ignore */;
|
else
|
else
|
verify_identifier (method->name);
|
verify_identifier (method->name);
|
|
|
verify_method_signature (method->signature);
|
verify_method_signature (method->signature);
|
|
|
for (int i = 0; i < mth_index; ++i)
|
for (int i = 0; i < mth_index; ++i)
|
{
|
{
|
if (_Jv_equalUtf8Consts (method->name, def->methods[i].name)
|
if (_Jv_equalUtf8Consts (method->name, def->methods[i].name)
|
&& _Jv_equalUtf8Consts (method->signature,
|
&& _Jv_equalUtf8Consts (method->signature,
|
def->methods[i].signature))
|
def->methods[i].signature))
|
throw_class_format_error ("duplicate method");
|
throw_class_format_error ("duplicate method");
|
}
|
}
|
|
|
// At most one of PUBLIC, PRIVATE, or PROTECTED is allowed.
|
// At most one of PUBLIC, PRIVATE, or PROTECTED is allowed.
|
if (1 < ( ((method->accflags & Modifier::PUBLIC) ? 1 : 0)
|
if (1 < ( ((method->accflags & Modifier::PUBLIC) ? 1 : 0)
|
+((method->accflags & Modifier::PRIVATE) ? 1 : 0)
|
+((method->accflags & Modifier::PRIVATE) ? 1 : 0)
|
+((method->accflags & Modifier::PROTECTED) ? 1 : 0)))
|
+((method->accflags & Modifier::PROTECTED) ? 1 : 0)))
|
throw_class_format_error ("erroneous method access flags");
|
throw_class_format_error ("erroneous method access flags");
|
|
|
// FIXME: JVM spec S4.6: if ABSTRACT modifier is set, verify other
|
// FIXME: JVM spec S4.6: if ABSTRACT modifier is set, verify other
|
// flags are not set. Verify flags for interface methods. Verify
|
// flags are not set. Verify flags for interface methods. Verify
|
// modifiers for initializers.
|
// modifiers for initializers.
|
}
|
}
|
}
|
}
|
|
|
void _Jv_ClassReader::handleCodeAttribute
|
void _Jv_ClassReader::handleCodeAttribute
|
(int method_index, int max_stack, int max_locals,
|
(int method_index, int max_stack, int max_locals,
|
int code_start, int code_length, int exc_table_length)
|
int code_start, int code_length, int exc_table_length)
|
{
|
{
|
int size = _Jv_InterpMethod::size (exc_table_length, code_length);
|
int size = _Jv_InterpMethod::size (exc_table_length, code_length);
|
_Jv_InterpMethod *method =
|
_Jv_InterpMethod *method =
|
(_Jv_InterpMethod*) (_Jv_AllocRawObj (size));
|
(_Jv_InterpMethod*) (_Jv_AllocRawObj (size));
|
|
|
method->max_stack = max_stack;
|
method->max_stack = max_stack;
|
method->max_locals = max_locals;
|
method->max_locals = max_locals;
|
method->code_length = code_length;
|
method->code_length = code_length;
|
method->exc_count = exc_table_length;
|
method->exc_count = exc_table_length;
|
method->is_15 = is_15;
|
method->is_15 = is_15;
|
method->defining_class = def;
|
method->defining_class = def;
|
method->self = &def->methods[method_index];
|
method->self = &def->methods[method_index];
|
method->prepared = NULL;
|
method->prepared = NULL;
|
method->line_table_len = 0;
|
method->line_table_len = 0;
|
method->line_table = NULL;
|
method->line_table = NULL;
|
#ifdef DIRECT_THREADED
|
#ifdef DIRECT_THREADED
|
method->thread_count = 0;
|
method->thread_count = 0;
|
#endif
|
#endif
|
|
|
// grab the byte code!
|
// grab the byte code!
|
memcpy ((void*) method->bytecode (),
|
memcpy ((void*) method->bytecode (),
|
(void*) (bytes+code_start),
|
(void*) (bytes+code_start),
|
code_length);
|
code_length);
|
|
|
def_interp->interpreted_methods[method_index] = method;
|
def_interp->interpreted_methods[method_index] = method;
|
|
|
if ((method->self->accflags & java::lang::reflect::Modifier::STATIC))
|
if ((method->self->accflags & java::lang::reflect::Modifier::STATIC))
|
{
|
{
|
// Precompute the ncode field for a static method. This lets us
|
// Precompute the ncode field for a static method. This lets us
|
// call a static method of an interpreted class from precompiled
|
// call a static method of an interpreted class from precompiled
|
// code without first resolving the class (that will happen
|
// code without first resolving the class (that will happen
|
// during class initialization instead).
|
// during class initialization instead).
|
method->self->ncode = method->ncode (def);
|
method->self->ncode = method->ncode (def);
|
}
|
}
|
}
|
}
|
|
|
void _Jv_ClassReader::handleExceptionTableEntry
|
void _Jv_ClassReader::handleExceptionTableEntry
|
(int method_index, int exc_index,
|
(int method_index, int exc_index,
|
int start_pc, int end_pc, int handler_pc, int catch_type)
|
int start_pc, int end_pc, int handler_pc, int catch_type)
|
{
|
{
|
_Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
|
_Jv_InterpMethod *method = reinterpret_cast<_Jv_InterpMethod *>
|
(def_interp->interpreted_methods[method_index]);
|
(def_interp->interpreted_methods[method_index]);
|
_Jv_InterpException *exc = method->exceptions ();
|
_Jv_InterpException *exc = method->exceptions ();
|
|
|
exc[exc_index].start_pc.i = start_pc;
|
exc[exc_index].start_pc.i = start_pc;
|
exc[exc_index].end_pc.i = end_pc;
|
exc[exc_index].end_pc.i = end_pc;
|
exc[exc_index].handler_pc.i = handler_pc;
|
exc[exc_index].handler_pc.i = handler_pc;
|
exc[exc_index].handler_type.i = catch_type;
|
exc[exc_index].handler_type.i = catch_type;
|
}
|
}
|
|
|
void _Jv_ClassReader::handleMethodsEnd ()
|
void _Jv_ClassReader::handleMethodsEnd ()
|
{
|
{
|
using namespace java::lang::reflect;
|
using namespace java::lang::reflect;
|
|
|
for (int i = 0; i < def->method_count; i++)
|
for (int i = 0; i < def->method_count; i++)
|
{
|
{
|
_Jv_Method *method = &def->methods[i];
|
_Jv_Method *method = &def->methods[i];
|
if ((method->accflags & Modifier::NATIVE) != 0)
|
if ((method->accflags & Modifier::NATIVE) != 0)
|
{
|
{
|
if (def_interp->interpreted_methods[i] != 0)
|
if (def_interp->interpreted_methods[i] != 0)
|
throw_class_format_error ("code provided for native method");
|
throw_class_format_error ("code provided for native method");
|
else
|
else
|
{
|
{
|
_Jv_JNIMethod *m = (_Jv_JNIMethod *)
|
_Jv_JNIMethod *m = (_Jv_JNIMethod *)
|
_Jv_AllocRawObj (sizeof (_Jv_JNIMethod));
|
_Jv_AllocRawObj (sizeof (_Jv_JNIMethod));
|
m->defining_class = def;
|
m->defining_class = def;
|
m->self = method;
|
m->self = method;
|
m->function = NULL;
|
m->function = NULL;
|
def_interp->interpreted_methods[i] = m;
|
def_interp->interpreted_methods[i] = m;
|
|
|
if ((method->accflags & Modifier::STATIC))
|
if ((method->accflags & Modifier::STATIC))
|
{
|
{
|
// Precompute the ncode field for a static method.
|
// Precompute the ncode field for a static method.
|
// This lets us call a static method of an
|
// This lets us call a static method of an
|
// interpreted class from precompiled code without
|
// interpreted class from precompiled code without
|
// first resolving the class (that will happen
|
// first resolving the class (that will happen
|
// during class initialization instead).
|
// during class initialization instead).
|
method->ncode = m->ncode (def);
|
method->ncode = m->ncode (def);
|
}
|
}
|
}
|
}
|
}
|
}
|
else if ((method->accflags & Modifier::ABSTRACT) != 0)
|
else if ((method->accflags & Modifier::ABSTRACT) != 0)
|
{
|
{
|
if (def_interp->interpreted_methods[i] != 0)
|
if (def_interp->interpreted_methods[i] != 0)
|
throw_class_format_error ("code provided for abstract method");
|
throw_class_format_error ("code provided for abstract method");
|
method->ncode = (void *) &_Jv_ThrowAbstractMethodError;
|
method->ncode = (void *) &_Jv_ThrowAbstractMethodError;
|
}
|
}
|
else
|
else
|
{
|
{
|
if (def_interp->interpreted_methods[i] == 0)
|
if (def_interp->interpreted_methods[i] == 0)
|
throw_class_format_error ("method with no code");
|
throw_class_format_error ("method with no code");
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
void _Jv_ClassReader::throw_class_format_error (const char *msg)
|
void _Jv_ClassReader::throw_class_format_error (const char *msg)
|
{
|
{
|
jstring str;
|
jstring str;
|
if (def->name != NULL)
|
if (def->name != NULL)
|
{
|
{
|
jsize mlen = strlen (msg);
|
jsize mlen = strlen (msg);
|
unsigned char* data = (unsigned char*) def->name->chars();
|
unsigned char* data = (unsigned char*) def->name->chars();
|
int ulen = def->name->len();
|
int ulen = def->name->len();
|
unsigned char* limit = data + ulen;
|
unsigned char* limit = data + ulen;
|
jsize nlen = _Jv_strLengthUtf8 ((char *) data, ulen);
|
jsize nlen = _Jv_strLengthUtf8 ((char *) data, ulen);
|
jsize len = nlen + mlen + 3;
|
jsize len = nlen + mlen + 3;
|
str = JvAllocString(len);
|
str = JvAllocString(len);
|
jchar *chrs = JvGetStringChars(str);
|
jchar *chrs = JvGetStringChars(str);
|
while (data < limit)
|
while (data < limit)
|
*chrs++ = UTF8_GET(data, limit);
|
*chrs++ = UTF8_GET(data, limit);
|
*chrs++ = ' ';
|
*chrs++ = ' ';
|
*chrs++ = '(';
|
*chrs++ = '(';
|
for (;;)
|
for (;;)
|
{
|
{
|
char c = *msg++;
|
char c = *msg++;
|
if (c == 0)
|
if (c == 0)
|
break;
|
break;
|
*chrs++ = c & 0xFFFF;
|
*chrs++ = c & 0xFFFF;
|
}
|
}
|
*chrs++ = ')';
|
*chrs++ = ')';
|
}
|
}
|
else
|
else
|
str = JvNewStringLatin1 (msg);
|
str = JvNewStringLatin1 (msg);
|
::throw_class_format_error (str);
|
::throw_class_format_error (str);
|
}
|
}
|
|
|
/** Here we define the exceptions that can be thrown */
|
/** Here we define the exceptions that can be thrown */
|
|
|
static void
|
static void
|
throw_no_class_def_found_error (jstring msg)
|
throw_no_class_def_found_error (jstring msg)
|
{
|
{
|
throw (msg
|
throw (msg
|
? new java::lang::NoClassDefFoundError (msg)
|
? new java::lang::NoClassDefFoundError (msg)
|
: new java::lang::NoClassDefFoundError);
|
: new java::lang::NoClassDefFoundError);
|
}
|
}
|
|
|
static void
|
static void
|
throw_no_class_def_found_error (const char *msg)
|
throw_no_class_def_found_error (const char *msg)
|
{
|
{
|
throw_no_class_def_found_error (JvNewStringLatin1 (msg));
|
throw_no_class_def_found_error (JvNewStringLatin1 (msg));
|
}
|
}
|
|
|
static void
|
static void
|
throw_class_format_error (jstring msg)
|
throw_class_format_error (jstring msg)
|
{
|
{
|
throw (msg
|
throw (msg
|
? new java::lang::ClassFormatError (msg)
|
? new java::lang::ClassFormatError (msg)
|
: new java::lang::ClassFormatError);
|
: new java::lang::ClassFormatError);
|
}
|
}
|
|
|
static void
|
static void
|
throw_internal_error (const char *msg)
|
throw_internal_error (const char *msg)
|
{
|
{
|
throw new java::lang::InternalError (JvNewStringLatin1 (msg));
|
throw new java::lang::InternalError (JvNewStringLatin1 (msg));
|
}
|
}
|
|
|
static void
|
static void
|
throw_incompatible_class_change_error (jstring msg)
|
throw_incompatible_class_change_error (jstring msg)
|
{
|
{
|
throw new java::lang::IncompatibleClassChangeError (msg);
|
throw new java::lang::IncompatibleClassChangeError (msg);
|
}
|
}
|
|
|
static void
|
static void
|
throw_class_circularity_error (jstring msg)
|
throw_class_circularity_error (jstring msg)
|
{
|
{
|
throw new java::lang::ClassCircularityError (msg);
|
throw new java::lang::ClassCircularityError (msg);
|
}
|
}
|
|
|
#endif /* INTERPRETER */
|
#endif /* INTERPRETER */
|
|
|
|
|
|
|
/** This section takes care of verifying integrity of identifiers,
|
/** This section takes care of verifying integrity of identifiers,
|
signatures, field ddescriptors, and class names */
|
signatures, field ddescriptors, and class names */
|
|
|
#define UTF8_PEEK(PTR, LIMIT) \
|
#define UTF8_PEEK(PTR, LIMIT) \
|
({ unsigned char* xxkeep = (PTR); \
|
({ unsigned char* xxkeep = (PTR); \
|
int xxch = UTF8_GET(PTR,LIMIT); \
|
int xxch = UTF8_GET(PTR,LIMIT); \
|
PTR = xxkeep; xxch; })
|
PTR = xxkeep; xxch; })
|
|
|
/* Verify one element of a type descriptor or signature. */
|
/* Verify one element of a type descriptor or signature. */
|
static unsigned char*
|
static unsigned char*
|
_Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok)
|
_Jv_VerifyOne (unsigned char* ptr, unsigned char* limit, bool void_ok)
|
{
|
{
|
if (ptr >= limit)
|
if (ptr >= limit)
|
return 0;
|
return 0;
|
|
|
int ch = UTF8_GET (ptr, limit);
|
int ch = UTF8_GET (ptr, limit);
|
|
|
switch (ch)
|
switch (ch)
|
{
|
{
|
case 'V':
|
case 'V':
|
if (! void_ok)
|
if (! void_ok)
|
return 0;
|
return 0;
|
|
|
case 'S': case 'B': case 'I': case 'J':
|
case 'S': case 'B': case 'I': case 'J':
|
case 'Z': case 'C': case 'F': case 'D':
|
case 'Z': case 'C': case 'F': case 'D':
|
break;
|
break;
|
|
|
case 'L':
|
case 'L':
|
{
|
{
|
unsigned char *start = ptr, *end;
|
unsigned char *start = ptr, *end;
|
do
|
do
|
{
|
{
|
if (ptr > limit)
|
if (ptr > limit)
|
return 0;
|
return 0;
|
|
|
end = ptr;
|
end = ptr;
|
|
|
if ((ch = UTF8_GET (ptr, limit)) == -1)
|
if ((ch = UTF8_GET (ptr, limit)) == -1)
|
return 0;
|
return 0;
|
|
|
}
|
}
|
while (ch != ';');
|
while (ch != ';');
|
if (! _Jv_VerifyClassName (start, (unsigned short) (end-start)))
|
if (! _Jv_VerifyClassName (start, (unsigned short) (end-start)))
|
return 0;
|
return 0;
|
}
|
}
|
break;
|
break;
|
|
|
case '[':
|
case '[':
|
return _Jv_VerifyOne (ptr, limit, false);
|
return _Jv_VerifyOne (ptr, limit, false);
|
break;
|
break;
|
|
|
default:
|
default:
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return ptr;
|
return ptr;
|
}
|
}
|
|
|
/* Verification and loading procedures. */
|
/* Verification and loading procedures. */
|
bool
|
bool
|
_Jv_VerifyFieldSignature (_Jv_Utf8Const*sig)
|
_Jv_VerifyFieldSignature (_Jv_Utf8Const*sig)
|
{
|
{
|
unsigned char* ptr = (unsigned char*) sig->chars();
|
unsigned char* ptr = (unsigned char*) sig->chars();
|
unsigned char* limit = ptr + sig->len();
|
unsigned char* limit = ptr + sig->len();
|
|
|
ptr = _Jv_VerifyOne (ptr, limit, false);
|
ptr = _Jv_VerifyOne (ptr, limit, false);
|
|
|
return ptr == limit;
|
return ptr == limit;
|
}
|
}
|
|
|
bool
|
bool
|
_Jv_VerifyMethodSignature (_Jv_Utf8Const*sig)
|
_Jv_VerifyMethodSignature (_Jv_Utf8Const*sig)
|
{
|
{
|
unsigned char* ptr = (unsigned char*) sig->chars();
|
unsigned char* ptr = (unsigned char*) sig->chars();
|
unsigned char* limit = ptr + sig->len();
|
unsigned char* limit = ptr + sig->len();
|
|
|
if (ptr == limit || UTF8_GET(ptr,limit) != '(')
|
if (ptr == limit || UTF8_GET(ptr,limit) != '(')
|
return false;
|
return false;
|
|
|
while (ptr && UTF8_PEEK (ptr, limit) != ')')
|
while (ptr && UTF8_PEEK (ptr, limit) != ')')
|
ptr = _Jv_VerifyOne (ptr, limit, false);
|
ptr = _Jv_VerifyOne (ptr, limit, false);
|
|
|
if (! ptr || UTF8_GET (ptr, limit) != ')')
|
if (! ptr || UTF8_GET (ptr, limit) != ')')
|
return false;
|
return false;
|
|
|
// get the return type
|
// get the return type
|
ptr = _Jv_VerifyOne (ptr, limit, true);
|
ptr = _Jv_VerifyOne (ptr, limit, true);
|
|
|
return ptr == limit;
|
return ptr == limit;
|
}
|
}
|
|
|
/* We try to avoid calling the Character methods all the time, in
|
/* We try to avoid calling the Character methods all the time, in
|
fact, they will only be called for non-standard things. */
|
fact, they will only be called for non-standard things. */
|
static __inline__ int
|
static __inline__ int
|
is_identifier_start (int c)
|
is_identifier_start (int c)
|
{
|
{
|
unsigned int ch = (unsigned)c;
|
unsigned int ch = (unsigned)c;
|
|
|
if ((ch - 0x41U) < 29U) /* A ... Z */
|
if ((ch - 0x41U) < 29U) /* A ... Z */
|
return 1;
|
return 1;
|
if ((ch - 0x61U) < 29U) /* a ... z */
|
if ((ch - 0x61U) < 29U) /* a ... z */
|
return 1;
|
return 1;
|
if (ch == 0x5FU) /* _ */
|
if (ch == 0x5FU) /* _ */
|
return 1;
|
return 1;
|
|
|
return java::lang::Character::isJavaIdentifierStart ((jchar) ch);
|
return java::lang::Character::isJavaIdentifierStart ((jchar) ch);
|
}
|
}
|
|
|
static __inline__ int
|
static __inline__ int
|
is_identifier_part (int c)
|
is_identifier_part (int c)
|
{
|
{
|
unsigned int ch = (unsigned)c;
|
unsigned int ch = (unsigned)c;
|
|
|
if ((ch - 0x41U) < 29U) /* A ... Z */
|
if ((ch - 0x41U) < 29U) /* A ... Z */
|
return 1;
|
return 1;
|
if ((ch - 0x61U) < 29U) /* a ... z */
|
if ((ch - 0x61U) < 29U) /* a ... z */
|
return 1;
|
return 1;
|
if ((ch - 0x30) < 10U) /* 0 .. 9 */
|
if ((ch - 0x30) < 10U) /* 0 .. 9 */
|
return 1;
|
return 1;
|
if (ch == 0x5FU || ch == 0x24U) /* _ $ */
|
if (ch == 0x5FU || ch == 0x24U) /* _ $ */
|
return 1;
|
return 1;
|
|
|
return java::lang::Character::isJavaIdentifierStart ((jchar) ch);
|
return java::lang::Character::isJavaIdentifierStart ((jchar) ch);
|
}
|
}
|
|
|
bool
|
bool
|
_Jv_VerifyIdentifier (_Jv_Utf8Const* name)
|
_Jv_VerifyIdentifier (_Jv_Utf8Const* name)
|
{
|
{
|
unsigned char *ptr = (unsigned char*) name->chars();
|
unsigned char *ptr = (unsigned char*) name->chars();
|
unsigned char *limit = (unsigned char*) name->limit();
|
unsigned char *limit = (unsigned char*) name->limit();
|
int ch;
|
int ch;
|
|
|
if ((ch = UTF8_GET (ptr, limit))==-1
|
if ((ch = UTF8_GET (ptr, limit))==-1
|
|| ! is_identifier_start (ch))
|
|| ! is_identifier_start (ch))
|
return false;
|
return false;
|
|
|
while (ptr != limit)
|
while (ptr != limit)
|
{
|
{
|
if ((ch = UTF8_GET (ptr, limit))==-1
|
if ((ch = UTF8_GET (ptr, limit))==-1
|
|| ! is_identifier_part (ch))
|
|| ! is_identifier_part (ch))
|
return false;
|
return false;
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
|
|
bool
|
bool
|
_Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length)
|
_Jv_VerifyClassName (unsigned char* ptr, _Jv_ushort length)
|
{
|
{
|
unsigned char *limit = ptr+length;
|
unsigned char *limit = ptr+length;
|
int ch;
|
int ch;
|
|
|
if ('[' == UTF8_PEEK (ptr, limit))
|
if ('[' == UTF8_PEEK (ptr, limit))
|
{
|
{
|
unsigned char *end = _Jv_VerifyOne (++ptr, limit, false);
|
unsigned char *end = _Jv_VerifyOne (++ptr, limit, false);
|
// _Jv_VerifyOne must leave us looking at the terminating nul
|
// _Jv_VerifyOne must leave us looking at the terminating nul
|
// byte.
|
// byte.
|
if (! end || *end)
|
if (! end || *end)
|
return false;
|
return false;
|
else
|
else
|
return true;
|
return true;
|
}
|
}
|
|
|
next_level:
|
next_level:
|
for (;;) {
|
for (;;) {
|
if ((ch = UTF8_GET (ptr, limit))==-1)
|
if ((ch = UTF8_GET (ptr, limit))==-1)
|
return false;
|
return false;
|
if (! is_identifier_start (ch))
|
if (! is_identifier_start (ch))
|
return false;
|
return false;
|
for (;;) {
|
for (;;) {
|
if (ptr == limit)
|
if (ptr == limit)
|
return true;
|
return true;
|
else if ((ch = UTF8_GET (ptr, limit))==-1)
|
else if ((ch = UTF8_GET (ptr, limit))==-1)
|
return false;
|
return false;
|
else if (ch == '.')
|
else if (ch == '.')
|
goto next_level;
|
goto next_level;
|
else if (! is_identifier_part (ch))
|
else if (! is_identifier_part (ch))
|
return false;
|
return false;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
bool
|
bool
|
_Jv_VerifyClassName (_Jv_Utf8Const *name)
|
_Jv_VerifyClassName (_Jv_Utf8Const *name)
|
{
|
{
|
return _Jv_VerifyClassName ((unsigned char*)name->chars(), name->len());
|
return _Jv_VerifyClassName ((unsigned char*)name->chars(), name->len());
|
}
|
}
|
|
|
/* Returns true, if NAME1 and NAME2 represent classes in the same
|
/* Returns true, if NAME1 and NAME2 represent classes in the same
|
package. Neither NAME2 nor NAME2 may name an array type. */
|
package. Neither NAME2 nor NAME2 may name an array type. */
|
bool
|
bool
|
_Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2)
|
_Jv_ClassNameSamePackage (_Jv_Utf8Const *name1, _Jv_Utf8Const *name2)
|
{
|
{
|
unsigned char* ptr1 = (unsigned char*) name1->chars();
|
unsigned char* ptr1 = (unsigned char*) name1->chars();
|
unsigned char* limit1 = (unsigned char*) name1->limit();
|
unsigned char* limit1 = (unsigned char*) name1->limit();
|
|
|
unsigned char* last1 = ptr1;
|
unsigned char* last1 = ptr1;
|
|
|
// scan name1, and find the last occurrence of '.'
|
// scan name1, and find the last occurrence of '.'
|
while (ptr1 < limit1) {
|
while (ptr1 < limit1) {
|
int ch1 = UTF8_GET (ptr1, limit1);
|
int ch1 = UTF8_GET (ptr1, limit1);
|
|
|
if (ch1 == '.')
|
if (ch1 == '.')
|
last1 = ptr1;
|
last1 = ptr1;
|
|
|
else if (ch1 == -1)
|
else if (ch1 == -1)
|
return false;
|
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->chars();
|
int len = last1 - (unsigned char*) name1->chars();
|
|
|
// If this is longer than NAME2, then we're off.
|
// If this is longer than NAME2, then we're off.
|
if (len > name2->len())
|
if (len > name2->len())
|
return false;
|
return false;
|
|
|
// Then compare the first len bytes for equality.
|
// Then compare the first len bytes for equality.
|
if (memcmp ((void*) name1->chars(), (void*) name2->chars(), len) == 0)
|
if (memcmp ((void*) name1->chars(), (void*) name2->chars(), 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->chars() + len;
|
unsigned char* ptr2 = (unsigned char*) name2->chars() + len;
|
unsigned char* limit2 = (unsigned char*) name2->limit();
|
unsigned char* limit2 = (unsigned char*) name2->limit();
|
|
|
while (ptr2 < limit2)
|
while (ptr2 < limit2)
|
{
|
{
|
int ch2 = UTF8_GET (ptr2, limit2);
|
int ch2 = UTF8_GET (ptr2, limit2);
|
if (ch2 == -1 || ch2 == '.')
|
if (ch2 == -1 || ch2 == '.')
|
return false;
|
return false;
|
}
|
}
|
return true;
|
return true;
|
}
|
}
|
return false;
|
return false;
|
}
|
}
|
|
|
