oobj.h

已经移植好的java虚拟机

    char                    **new_class_entries;
    int                     n_new_utf8_entries;
    char                    **new_utf8_entries;
    int             has_stack_maps;

    int                     inner_classes_count;
    struct innerClasses    *inner_classes;

    unsigned deprecated:1;
    unsigned synthetic:1;
    unsigned hasTimeStamp:1;
};

struct innerClasses {
    int inner_class;
    int outer_class;
    char *inner_name;
    int access;
};

extern void FreeClass(ClassClass *cb);
extern void MakeClassSticky(ClassClass *cb);

#define cbAccess(cb)          ((unhand(cb))->access)
#define cbClassname(cb)       ((unhand(cb))->classname)
#define cbConstantPool(cb)    ((unhand(cb))->constantpool)
#define cbConstantPoolCount(cb) ((unhand(cb))->constantpool_count)
#define cbFields(cb)          ((unhand(cb))->fields)
#define cbFieldsCount(cb)     ((unhand(cb))->fields_count)
#define cbFinalizer(cb)       ((unhand(cb))->finalizer)
#define cbFlags(cb)           ((unhand(cb))->flags)
#define cbHandle(cb)          (cb)
#define cbImplements(cb)      ((unhand(cb))->implements)
#define cbImplementsCount(cb) ((unhand(cb))->implements_count)
#define cbInstanceSize(cb)    ((unhand(cb))->instance_size)
#define cbIntfMethodTable(cb) ((unhand(cb))->imethodtable)
#define cbLastSubclassOf(cb)  ((unhand(cb))->last_subclass_of)
#define cbLoader(cb)          ((unhand(cb))->loader)
#define cbMajorVersion(cb)    ((unhand(cb))->major_version)
#define cbMethods(cb)         ((unhand(cb))->methods)
#define cbMethodsCount(cb)    ((unhand(cb))->methods_count)
#define cbMethodTable(cb)     ((unhand(cb))->methodtable)
#define cbMethodTableMem(cb)  ((unhand(cb))->methodtable_mem)
#define cbMethodTableSize(cb) ((unhand(cb))->methodtable_size)
#define cbMinorVersion(cb)    ((unhand(cb))->minor_version)
#define cbName(cb)            ((unhand(cb))->name)
#define cbSigners(cb)         ((unhand(cb))->signers)
#define cbSlotTable(cb)       ((unhand(cb))->slottable)
#define cbSlotTableSize(cb)   ((unhand(cb))->slottbl_size)
#define cbSourceName(cb)      ((unhand(cb))->source_name)
#define cbSuperclass(cb)      ((unhand(cb))->superclass)
#define cbSuperName(cb)       ((unhand(cb))->super_name)
#define cbThisHash(cb)        ((unhand(cb))->hashinfo.cbhash.thishash)
#define cbTotalHash(cb)       ((unhand(cb))->hashinfo.cbhash.totalhash)
#define cbInitThread(cb)      ((unhand(cb))->init_thread)
#define cbInnerClasses(cb)     ((unhand(cb))->inner_classes)
#define cbInnerClassesCount(cb)((unhand(cb))->inner_classes_count)



#define cbAbsoluteSourceName(cb) ((unhand(cb))->absolute_source_name)
#define cbTimestamp(cb)       ((unhand(cb))->timestamp)

#define cbIsInterface(cb)       ((cbAccess(cb) & ACC_INTERFACE) != 0)
#define cbIsAbstract(cb)        ((cbAccess(cb) & ACC_ABSTRACT) != 0)
#define cbAccessNotAbstract(cb) ((unhand(cb))->access & ~ACC_ABSTRACT)

/* These are currently only valid for primitive types */
#define cbIsPrimitive(cb)      (CCIs(cb, Primitive))
#define cbTypeCode(cb)         ((unhand(cb))->hashinfo.cbtypeinfo.typecode)
#define cbTypeSig(cb)          ((unhand(cb))->hashinfo.cbtypeinfo.typesig)
#define cbSlotSize(cb)         ((unhand(cb))->hashinfo.cbtypeinfo.slotsize)
#define cbElementSize(cb)      ((unhand(cb))->hashinfo.cbtypeinfo.elementsize)

extern char *classname2string(char *str, char *dst, int size);

#define twoword_static_address(fb) ((fb)->u.static_address)
#define normal_static_address(fb)  (&(fb)->u.static_value)

/* ClassClass flags */
#define CCF_IsSysLock     0x01  /* any instance treated as a "system" lock */
#define CCF_IsResolved    0x02  /* has <clinit> been run? */
#define CCF_IsError   0x04  /* Resolution caused an error */
#define CCF_IsSoftRef     0x08  /* whether this is class Ref or subclass */
#define CCF_IsInitialized 0x10  /* whether this is class has been inited */
#define CCF_IsLinked      0x20  /* Has symbolic entries been linked */
#define CCF_IsVerified    0x40  /* has the verifier been run */

#define CCF_IsPrimitive   0x100 /* if pseudo-class for a primitive type */
#define CCF_IsReferenced  0x200 /* Class is in use */
#define CCF_IsSticky      0x400 /* Don't unload this class */

#define CCIs(cb,flag) (((unhand(cb))->flags & CCF_Is##flag) != 0)
#define CCSet(cb,flag) ((unhand(cb))->flags |= CCF_Is##flag)
#define CCClear(cb,flag) ((unhand(cb))->flags &= ~CCF_Is##flag)

/* map from pc to line number */
struct lineno {
    unsigned long pc,
    line_number;
};

extern struct lineno *lntbl;
extern long lntsize, lntused;

/* Symbol table entry for local variables and parameters.
   pc0/length defines the range that the variable is valid, slot
   is the position in the local variable array in ExecEnv.
   nameoff and sigoff are offsets into the string table for the
   variable name and type signature.  A variable is defined with
   DefineVariable, and at that time, the node for that name is
   stored in the localvar entry.  When code generate is completed
   for a particular scope, a second pass it made to replace the
   src node entry with the correct length. */

struct localvar {
    long pc0;           /* starting pc for this variable */
    long length;        /* -1 initially, end pc - pc when we're done */
    char *name;                 /*  */
    char *signature;
    long slot;          /* local variable slot */
};

/* Try/catch is implemented as follows.  On a per class basis,
   there is a catch frame handler (below) for each catch frame
   that appears in the source.  It contains the pc range of the
   corresponding try body, a pc to jump to in the event that that
   handler is chosen, and a catchType which must match the object
   being thrown if that catch handler is to be taken.

   The list of catch frames are sorted by pc.  If one range is
   inside another, then outer most range (the one that encompasses
   the other) appears last in the list.  Therefore, it is possible
   to search forward, and the first one that matches is the
   innermost one.

   Methods with catch handlers will layout the code without the
   catch frames.  After all the code is generated, the catch
   clauses are generated and table entries are created.

   When the class is complete, the table entries are dumped along
   with the rest of the class. */

struct CatchFrame {
    long    start_pc, end_pc;   /* pc range of corresponding try block */
    long    handler_pc;         /* pc of catch handler */
    void*   compiled_CatchFrame; /* space to be used by machine code */
    short   catchType;          /* type of catch parameter */
};

#define MC_SUPER        (1<<5)
#define MC_NARGSMASK    (MC_SUPER-1)
#define MC_INT          (0<<6)
#define MC_FLOAT        (1<<6)
#define MC_VOID         (2<<6)
#define MC_OTHER        (3<<6)
#define MC_TYPEMASK     (3<<6)

enum {
    CONSTANT_Utf8 = 1,
    CONSTANT_Unicode,       /* unused */
    CONSTANT_Integer,
    CONSTANT_Float,
    CONSTANT_Long,
    CONSTANT_Double,
    CONSTANT_Class,
    CONSTANT_String,
    CONSTANT_Fieldref,
    CONSTANT_Methodref,
    CONSTANT_InterfaceMethodref,
    CONSTANT_NameAndType
};

union cp_item_type {
    int i;
    float f;
    char *cp;
    unsigned char *type;        /* for type table */
    ClassClass *clazz;
    struct methodblock *mb;
    struct fieldblock *fb;
    struct Hjava_lang_String *str;
    void *p;                    /* for very rare occasions */
};

typedef union cp_item_type cp_item_type;

#define CONSTANT_POOL_ENTRY_RESOLVED 0x80
#define CONSTANT_POOL_ENTRY_TYPEMASK 0x7F
#define CONSTANT_POOL_TYPE_TABLE_GET(cp,i) (((unsigned char *)(cp))[i])
#define CONSTANT_POOL_TYPE_TABLE_PUT(cp,i,v) (CONSTANT_POOL_TYPE_TABLE_GET(cp,i) = (v))
#define CONSTANT_POOL_TYPE_TABLE_SET_RESOLVED(cp,i) \
    (CONSTANT_POOL_TYPE_TABLE_GET(cp,i) |= CONSTANT_POOL_ENTRY_RESOLVED)
#define CONSTANT_POOL_TYPE_TABLE_IS_RESOLVED(cp,i) \
    ((CONSTANT_POOL_TYPE_TABLE_GET(cp,i) & CONSTANT_POOL_ENTRY_RESOLVED) != 0)
#define CONSTANT_POOL_TYPE_TABLE_GET_TYPE(cp,i) \
        (CONSTANT_POOL_TYPE_TABLE_GET(cp,i) & CONSTANT_POOL_ENTRY_TYPEMASK)

#define CONSTANT_POOL_TYPE_TABLE_INDEX 0
#define CONSTANT_POOL_UNUSED_INDEX 1

/* The following are used by the constant pool of "array" classes. */

#define CONSTANT_POOL_ARRAY_DEPTH_INDEX 1
#define CONSTANT_POOL_ARRAY_TYPE_INDEX 2
#define CONSTANT_POOL_ARRAY_CLASS_INDEX 3
#define CONSTANT_POOL_ARRAY_LENGTH 4

/*
 * Package shorthand: this isn't obviously the correct place.
 */
#define JAVAPKG         "java/lang/"
#define JAVAIOPKG       "java/io/"
#define JAVANETPKG      "java/net/"

#define unhand(o) ((o)->obj)


extern ClassClass *classJavaLangClass;     /* class java/lang/Class */
extern ClassClass *classJavaLangObject;    /* class java/lang/Object */
extern ClassClass *classJavaLangString;    /* class java/lang/String */

extern ClassClass *classJavaLangThrowable;
extern ClassClass *classJavaLangException;
extern ClassClass *classJavaLangError;
extern ClassClass *classJavaLangRuntimeException;
extern ClassClass *classJavaLangThreadDeath;

extern ClassClass *interfaceJavaLangCloneable; /* class java/lang/Cloneable */
extern ClassClass *interfaceJavaIoSerializable; /* class java/io/Serializable */

enum { VERIFY_NONE, VERIFY_REMOTE, VERIFY_ALL };

extern int verifyclasses;
extern bool_t verbose;
extern char * const opnames[];

int jio_snprintf(char *str, size_t count, const char *fmt, ...);
int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args);

int jio_printf(const char *fmt, ...);
int jio_fprintf(FILE *, const char *fmt, ...);
int jio_vfprintf(FILE *, const char *fmt, va_list args);

struct StrIDhash;
unsigned short Str2ID(struct StrIDhash **, char *, void ***, int);
char *ID2Str(struct StrIDhash *, unsigned short, void ***);
void Str2IDFree(struct StrIDhash **);

unsigned NameAndTypeToHash(char *name, char *type);
bool_t IsSameClassPackage(ClassClass *class1, ClassClass *class2);
unsigned Signature2ArgsSize(char *method_signature);
char *GetClassConstantClassName(cp_item_type *constant_pool, int index);
ClassClass *FindClass(struct execenv *ee, char *name, bool_t resolve);
ClassClass *FindClassFromClass(struct execenv *ee, char *name,
                   bool_t resolve, ClassClass *from);

bool_t createInternalClass(unsigned char *bytes, unsigned char *limit,
                           ClassClass *cb, struct Hjava_lang_ClassLoader *,
                            char *utfname, char **detail);

bool_t VerifyClass(ClassClass *cb);
bool_t IsLegalClassname(char *name, bool_t allowArrayClass);
bool_t verify_class_codes(ClassClass *cb);

struct execenv {
    /* Detecting class circularities */
    struct seenclass {
    ClassClass    *cb;
    struct seenclass *next;
    } seenclasses;

    /* error message occurred during class loading */
    char *class_loading_msg;
};

typedef struct execenv ExecEnv;

extern ExecEnv * EE();

ClassClass *FindStickySystemClass(struct execenv *, char *, bool_t resolve);
bool_t VerifyClassAccess(ClassClass *, ClassClass *, bool_t);
void InitializeInvoker(ClassClass *cb);
bool_t RunStaticInitializers(ClassClass *cb);
ClassClass *ClassLoaderFindClass(ExecEnv *ee,
                 struct Hjava_lang_ClassLoader *loader,
                 char *name, bool_t resolve);
ClassClass *LoadClassLocally(char *name);
ClassClass *createFakeArrayClass(char *name, int base_type, int depth,
                 ClassClass *inner_cb,
                 struct Hjava_lang_ClassLoader *);
ClassClass *createPrimitiveClass(char *name, char sig, unsigned char typecode,
    unsigned char slotsize, unsigned char elementsize);

bool_t isJARfile(char *fn, int length);

#define BINCLASS_LOCK()
#define BINCLASS_UNLOCK()
#define LOADCLASS_LOCK()
#define LOADCLASS_UNLOCK()
#define NAMETYPEHASH_LOCK()
#define NAMETYPEHASH_UNLOCK()

#define FINALIZER_METHOD_NAME "finalize"
#define FINALIZER_METHOD_SIGNATURE "()V"

#define CLS_RESLV_INIT_CLASS    "java/lang/Class"
#define CLS_RESLV_INIT_OBJECT   "java/lang/Object"
#define CLS_RESLV_INIT_REF      "sun/misc/Ref"

#define METHOD_FLAG_BITS 5
#define FLAG_MASK       ((1<<METHOD_FLAG_BITS)-1)  /* valid flag bits */
#define METHOD_MASK     (~FLAG_MASK)  /* valid mtable ptr bits */
#define LENGTH_MASK     METHOD_MASK

#define mt_slot(methodtable, slot) (methodtable)->methods[slot]

#define monitorEnter(m)
#define monitorExit(m)

#define exceptionOccurred(ee) 0
void SignalError(struct execenv *, char *, char *);

void panic(const char *format, ...);

void printCurrentClassName(void);

void ensure_dir_exists(char *dir);
void ensure_dir_writable(char *dir);

extern bool_t no_native_methods;
extern bool_t no_floating_point;
extern bool_t no_finalizers;

extern int errorCode;         /* status error returned by program*/
                              /* Set to 1 if any errors encountered
                               * during class verification in VerifyFile()
                               */
#endif /* !_OOBJ_H_ */