oobj.h

《移动Agent技术》一书的所有章节源代码。

/*
 * @(#)oobj.h   1.78 98/01/12
 *
 * Copyright (c) 1995, 1996 Sun Microsystems, Inc. All Rights Reserved.
 *
 * This software is the confidential and proprietary information of Sun
 * Microsystems, Inc. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with Sun.
 *
 * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
 * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
 * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
 * THIS SOFTWARE OR ITS DERIVATIVES.
 *
 * CopyrightVersion 1.1_beta
 *
 */
/*
 * Java object header format
 */

#ifndef _OOBJ_H_
#define _OOBJ_H_

#ifndef JAVA_CLASSFILE_MAGIC

#include <stddef.h>

#ifdef MON_FLAT                                                         /*ibm.3740*/
#include "atomic_md.h"
#endif                                                                  /*ibm.3740*/

#include "typedefs.h"
#include "debug.h"
#include "bool.h"
#include "oobj_md.h"
#include "signature.h"

#define JAVA_CLASSFILE_MAGIC              0xCafeBabe

#define JAVASRCEXT "java"
#define JAVASRCEXTLEN 4
#define JAVAOBJEXT "class"
#define JAVAOBJEXTLEN 5

#define JAVA_VERSION     45
#define JAVA_MINOR_VERSION 3
#define ARRAYHEADER     long alloclen

#ifdef JMS_TRL                                                          /*ibm*/
/*
 * [TRL] HandleTo for TRL Java Memory System
 * The unhand macro definition has also been moved from interpreter.h.
 */
#ifdef MON_FLAT                                                         /*ibm.3740*/
#define HandleTo(T) typedef struct H##T { struct methodtable *methods; atomic_t locknflags; Class##T obj; } H##T
#else                                                                   /*ibm.3740*/
#define HandleTo(T) typedef struct H##T { struct methodtable *methods; unsigned long hash; Class##T obj; } H##T
#endif                                                                  /*ibm.3740*/

#define unhand(o) (&(o)->obj)
#define HANDLE_SIZE  offsetof(HObject, obj)
#define rehand(obj)  ((JHandle*)(((char*)(obj))-HANDLE_SIZE))
#else                                                                   /*ibm*/
#define HandleTo(T) typedef struct H##T { Class##T *obj; struct methodtable *methods;} H##T
#endif                                                                  /*ibm*/

typedef long OBJECT;
typedef OBJECT Classjava_lang_Object;
typedef OBJECT ClassObject;
HandleTo(java_lang_Object);
typedef Hjava_lang_Object JHandle;
typedef Hjava_lang_Object HObject;

typedef unsigned short unicode;

extern unicode  *str2unicode(char *, unicode *, long);
extern char     *int642CString(int64_t number, char *buf, int buflen);

#if defined (IBM_AIX)                                           /*ibm.7650*/
    #undef ALIGN
#endif                                                          /*ibm.7650*/
#define ALIGN(n) (((n)+3)&~3)
#define UCALIGN(n) ((unsigned char *)ALIGN((int)(n)))

struct Hjava_lang_Class;        /* forward reference for some compilers */
struct Classjava_lang_Class;    /* forward reference for some compilers */

typedef struct Classjava_lang_Class Classjava_lang_Class;

#ifndef JMS_TRL                                                         /*ibm*/
HandleTo(java_lang_Class);        /* Sun's original declaration point        */
#endif                                                                  /*ibm*/
typedef struct Hjava_lang_Class ClassClass;


struct fieldblock {
    ClassClass *clazz;
    char *signature;
    char *name;
    unsigned long ID;
    unsigned short access;
    union {
        unsigned long offset;   /* info of data */
        OBJECT static_value;
        void *static_address;
    } u;
};

#define fieldname(fb)    ((fb)->name)
#define fieldsig(fb)     ((fb)->signature)
#define fieldIsArray(fb) (fieldsig(fb)[0] == SIGNATURE_ARRAY)
#define fieldIsClass(fb) (fieldsig(fb)[0] == SIGNATURE_CLASS)
#define fieldclass(fb)   ((fb)->clazz)

struct execenv;

struct methodblock {
    struct fieldblock fb;
    unsigned char       *code;  /* the code */
    struct CatchFrame   *exception_table;
    struct lineno       *line_number_table;
    struct localvar     *localvar_table;

    unsigned long        code_length;
    unsigned long        exception_table_length;
    unsigned long        line_number_table_length;
    unsigned long        localvar_table_length;

    bool_t  (*invoker)
      (JHandle *o, struct methodblock *mb, int args_size, struct execenv *ee);
    unsigned short       args_size;     /* total size of all arguments */
    unsigned short       maxstack;      /* maximum stack usage */
    unsigned short       nlocals;       /* maximum number of locals */
    /* 2 spare bytes here */
    void                *CompiledCode; /* it's type is machine dependent */
    void                *CompiledCodeInfo; /* it's type is machine dependent */
    long                 CompiledCodeFlags; /* machine dependent bits */
#if defined(IBM_MIXED_MODE)                                         /*ibm.6205*/
    unsigned short      return_type;
    unsigned short      before_compile;
#endif /* +IBM_MIXED_MODE */                                        /*ibm.6205*/
    unsigned long        inlining;      /* possible inlining of code */
    unsigned short       nexceptions;   /* number of checked exceptions */
    unsigned short      *exceptions;    /* constant pool indices */
#ifdef JCOV
    struct covtable      *coverage_table;
    unsigned long        coverage_table_length;
#endif
};

struct HIOstream;

struct methodtable {
    ClassClass *classdescriptor;
    struct methodblock *methods[1];
};

struct imethodtable {
    int icount;                 /* number of interfaces to follow */
    struct {
        ClassClass *classdescriptor;
        unsigned long *offsets; /* info of data */
    } itable[1];
};

typedef struct {
    char body[1];
} ArrayOfByte;
typedef ArrayOfByte ClassArrayOfByte;
HandleTo(ArrayOfByte);

typedef struct {
    unicode body[1];
} ArrayOfChar;
typedef ArrayOfChar ClassArrayOfChar;
HandleTo(ArrayOfChar);

typedef struct {
    signed short body[1];
} ArrayOfShort;
typedef ArrayOfShort ClassArrayOfShort;
HandleTo(ArrayOfShort);

typedef struct {
    long        body[1];
} ArrayOfInt;
typedef ArrayOfInt ClassArrayOfInt;
HandleTo(ArrayOfInt);

typedef struct {
    int64_t        body[1];
} ArrayOfLong;
typedef ArrayOfLong ClassArrayOfLong;
HandleTo(ArrayOfLong);

typedef struct {
    float_t     body[1];                                        /*ibm.1229*/
} ArrayOfFloat;
typedef ArrayOfFloat ClassArrayOfFloat;
HandleTo(ArrayOfFloat);

typedef struct {
    double_t     body[1];                                       /*ibm.1229*/
} ArrayOfDouble;
typedef ArrayOfDouble ClassArrayOfDouble;
HandleTo(ArrayOfDouble);

typedef struct {
    JHandle *(body[1]);
} ArrayOfArray;
typedef ArrayOfArray ClassArrayOfArray;
HandleTo(ArrayOfArray);

typedef struct {
    HObject *(body[1]);
} ArrayOfObject;
typedef ArrayOfObject ClassArrayOfObject;
HandleTo(ArrayOfObject);

typedef struct Hjava_lang_String HString;

typedef struct {
    HString  *(body[1]);
} ArrayOfString;
typedef ArrayOfString ClassArrayOfString;
HandleTo(ArrayOfString);

#ifdef JIT_WAY                                                          /*ibm*/
struct Hjava_lang_Thread;
#endif                                                                  /*ibm*/

#if defined(JMS_TRL) && ! defined(IBM_HAIFA_GC)                /* ibm.f.6076 */
typedef unsigned short markoffset_t;
#endif /* JMS_TRL etc. */

/* Note: any handles in this structure must also have explicit
   code in the ScanClasses() routine of the garbage collector
   to mark the handle. */
struct Classjava_lang_Class {
    /* Things following here are saved in the .class file */
    unsigned short           major_version;
    unsigned short           minor_version;
    char                    *name;
    char                    *super_name;
    char                    *source_name;
    ClassClass              *superclass;
    ClassClass              *HandleToSelf;
    struct Hjava_lang_ClassLoader *loader;
    struct methodblock      *finalizer;

    union cp_item_type      *constantpool;
    struct methodblock      *methods;
    struct fieldblock       *fields;
#ifdef IBM_HAIFA_GC                                                     /*ibm.4760*/
    unsigned long           nonstatic_references;
    unsigned long           *references_offsets;
#endif /* IBM_HAIFA_GC */                                               /*ibm.4760*/
    short                   *implements;

    struct methodtable      *methodtable;
    struct methodtable      *methodtable_mem;
    struct fieldblock      **slottable;

    HString                 *classname;

    union {
        struct {
            unsigned long       thishash;         /* unused */
            unsigned long       totalhash;        /* unused */
        } cbhash;
        struct {
            unsigned char       typecode;         /* VM typecode */
            char                typesig;          /* signature constant */
            unsigned char       slotsize;         /* (bytes) in slot */
            unsigned char       elementsize;      /* (bytes) in array */
            unsigned long       xxspare;
        } cbtypeinfo;
    } hashinfo;

    unsigned short           constantpool_count;  /* number of items in pool */
    unsigned short           methods_count;       /* number of methods */
    unsigned short           fields_count;        /* number of fields */
    unsigned short           implements_count;    /* number of protocols */