class.h

java 1.1 gemini 08_16

    cell offset;
    cell length;
    struct internedStringInstanceStruct *next;
};

struct throwableInstanceStruct { 
    COMMON_OBJECT_INFO(INSTANCE_CLASS)

    STRING_INSTANCE message;
    ARRAY   backtrace;
};

typedef union cellOrPointer {
    cell cell;
    cell *cellp;
    cell **cellpp;              /* For global roots */

    /* Occasionally needed by GC */
    char *charp;
    char **charpp;
} cellOrPointer;

/* ARRAY */
struct arrayStruct {
    COMMON_OBJECT_INFO(ARRAY_CLASS)

    cell  length;               /* Number of elements */
    cellOrPointer data[1];  
};

/* POINTERLIST */
struct pointerListStruct {
    long  length;
    cellOrPointer data[1];  
};

/* WEAKPOINTERLIST */
struct weakPointerListStruct { 
    long length;
    struct weakPointerListStruct* gcReserved;
    void (*finalizer)(INSTANCE_HANDLE);
    cellOrPointer data[1];  
};

#ifdef CLDC11
/* WEAKREFERENCE (Added for CLDC 1.1 support) */
struct weakReferenceStruct {
    COMMON_OBJECT_INFO(INSTANCE_CLASS)
    cell* referent;
    struct weakReferenceStruct* gcReserved;
};
#endif /* CLDC11 */

/* BYTEARRAY */
struct byteArrayStruct {
    COMMON_OBJECT_INFO(ARRAY_CLASS)

    cell  length;               /* The size of the array (slot count) */
    signed char bdata[1];       /* First (zeroeth) data slot of the array */
};

/* SHORTARRAY */
struct shortArrayStruct {
    COMMON_OBJECT_INFO(ARRAY_CLASS)

    cell  length;               /* The size of the array (slot count) */
    short sdata[1];             /* First (zeroeth) data slot of the array */
};

/*=========================================================================
 * Sizes for the above structures
 *=======================================================================*/

#define SIZEOF_CLASS              StructSizeInCells(classStruct)
#define SIZEOF_INSTANCE(n)        (StructSizeInCells(instanceStruct)+((n)-1))
#define SIZEOF_ARRAY(n)           (StructSizeInCells(arrayStruct)+((n)-1))

#define SIZEOF_INSTANCE_CLASS     StructSizeInCells(instanceClassStruct)
#define SIZEOF_ARRAY_CLASS        StructSizeInCells(arrayClassStruct)

#define SIZEOF_POINTERLIST(n)     (StructSizeInCells(pointerListStruct)+((n)-1))
#define SIZEOF_WEAKPOINTERLIST(n) (StructSizeInCells(weakPointerListStruct)+((n)-1))

#define SIZEOF_STRING_INSTANCE           SIZEOF_INSTANCE(3)
#define SIZEOF_INTERNED_STRING_INSTANCE  SIZEOF_INSTANCE(4)

/*=========================================================================
 * Definitions that manipulate the monitorOrHashCode (mhc) field
 *=======================================================================*/

/** 
 * See thread.h for more information on monitorOrHashCode operations.
 */

#define OBJECT_HAS_MONITOR(obj)      (OBJECT_MHC_TAG(obj) != MHC_UNLOCKED)
#define OBJECT_HAS_REAL_MONITOR(obj) (OBJECT_MHC_TAG(obj) == MHC_MONITOR)

#define SET_OBJECT_HASHCODE(obj, hc) \
        SET_OBJECT_MHC_LONG(obj, (long)(hc) + MHC_UNLOCKED)

#define SET_OBJECT_MONITOR(obj, mon) \
        SET_OBJECT_MHC_ADDRESS(obj, (char *)(mon) + MHC_MONITOR)

#define SET_OBJECT_SIMPLE_LOCK(obj, thr) \
        SET_OBJECT_MHC_ADDRESS(obj, (char *)(thr) + MHC_SIMPLE_LOCK)

#define SET_OBJECT_EXTENDED_LOCK(obj, thr) \
        SET_OBJECT_MHC_ADDRESS(obj, (char *)(thr) + MHC_EXTENDED_LOCK)

#if !RELOCATABLE_ROM

#define SET_OBJECT_MHC_LONG(obj, value) (obj)->mhc.hashCode = (value)
#define SET_OBJECT_MHC_ADDRESS(obj, value) (obj)->mhc.address = (value)

#else
void setObjectMhcInternal(OBJECT, long);
#define SET_OBJECT_MHC_LONG(obj, value)    SET_OBJECT_MHC_FIELD(obj,(value))
#define SET_OBJECT_MHC_ADDRESS(obj, value) SET_OBJECT_MHC_FIELD(obj,(long)(value))

#define SET_OBJECT_MHC_FIELD(obj, value)              \
       if (!RELOCATABLE_ROM || inAnyHeap(obj)) {      \
           (obj)->mhc.hashCode = value;               \
       } else {                                       \
            setObjectMhcInternal((OBJECT)obj, value); \
       }                                              \

#endif /* !RELOCATABLE_ROM */

/*=========================================================================
 * Global variables
 *=======================================================================*/

/*=========================================================================
 * These global variables hold references to various Java-specific
 * runtime structures needed for executing certain low-level operations.
 *
 * NOTE: To minimize the footprint of the VM, the internal structures these
 *       variables represent are loaded lazily (as opposed to standard JDK
 *       behaviour where these core classes are loaded upon VM
 *       initialization). This means that care must be taken when using
 *       them to ensure that they are not null references.
 *=======================================================================*/

/* Pointers to the most important Java classes needed by the VM */
extern INSTANCE_CLASS JavaLangObject;    /* Pointer to java.lang.Object */
extern INSTANCE_CLASS JavaLangClass;     /* Pointer to java.lang.Class */
extern INSTANCE_CLASS JavaLangString;    /* Pointer to java.lang.String */
extern INSTANCE_CLASS JavaLangSystem;    /* Pointer to java.lang.System */
extern INSTANCE_CLASS JavaLangThread;    /* Pointer to java.lang.Thread */
extern INSTANCE_CLASS JavaLangThrowable; /* Pointer to java.lang.Throwable */
extern INSTANCE_CLASS JavaLangError;     /* Pointer to java.lang.Error */
extern INSTANCE_CLASS JavaLangOutOfMemoryError; /* java.lang.OutOfMemoryError */
extern ARRAY_CLASS    JavaLangCharArray; /* Array of characters */

extern NameTypeKey initNameAndType;
extern NameTypeKey clinitNameAndType;
extern NameTypeKey runNameAndType;
extern NameTypeKey mainNameAndType;

extern METHOD RunCustomCodeMethod;
extern THROWABLE_INSTANCE OutOfMemoryObject;
extern THROWABLE_INSTANCE StackOverflowObject;

#define RunCustomCodeMethod_MAX_STACK_SIZE 4

/*=========================================================================
 * Constructors
 *=======================================================================*/

void initializeClass(INSTANCE_CLASS);

/*=========================================================================
 * System-level constructors
 *=======================================================================*/

void  InitializeJavaSystemClasses(void);
void  FinalizeJavaSystemClasses(void);

/*=========================================================================
 * Operations on classes
 *=======================================================================*/

CLASS getRawClass(const char *name);
CLASS getRawClassX(CONST_CHAR_HANDLE nameH, int offset, int length);

CLASS getClass(const char *name);
CLASS getClassX(CONST_CHAR_HANDLE nameH, int offset, int length);

ARRAY_CLASS getArrayClass(int depth, INSTANCE_CLASS baseClass, char signCode);

extern ARRAY_CLASS PrimitiveArrayClasses[];
ARRAY_CLASS getObjectArrayClass(CLASS elementType);

/* Returns the result.  Note, the return value of the second one is
 * the closing '\0' */
char *getClassName(CLASS clazz);
char *getClassName_inBuffer(CLASS clazz, char *result);

#ifdef CLDC11
/*
 * This is required if an error occurs during class loading. That is, if an
 * error occurs before a class reaches the class initialization step, it is
 * reverted to a raw class. This complies with the JVM specification.
 */
INSTANCE_CLASS revertToRawClass(INSTANCE_CLASS clazz);
#endif /* CLDC11 */

/*=========================================================================
 * Type conversion helper functions
 *=======================================================================*/

char typeCodeToSignature(char typeCode);

/*=========================================================================
 * Operations on (regular, non-array) instances
 *=======================================================================*/

INSTANCE instantiate(INSTANCE_CLASS);
long     objectHashCode(OBJECT object);
bool_t   implementsInterface(INSTANCE_CLASS, INSTANCE_CLASS);
bool_t   isAssignableTo(CLASS, CLASS);

/* guaranteed not to GC.  Returns TRUE or "don't know" */
bool_t   isAssignableToFast(CLASS, CLASS);

/*=========================================================================
 * Operations on array instances
 *=======================================================================*/

ARRAY    instantiateArray(ARRAY_CLASS arrayClass, long length);
ARRAY    instantiateMultiArray(ARRAY_CLASS arrayClass, long*, int dimensions);
long     arrayItemSize(int arrayType);

/*=========================================================================
 * Operations on string instances
 *=======================================================================*/

STRING_INSTANCE instantiateString(const char* string, int length);
INTERNED_STRING_INSTANCE instantiateInternedString(const char* string, int length);
#ifdef CLDC11
SHORTARRAY createCharArray(const char* utf8stringArg, int utf8length,
                           int* unicodelengthP, bool_t isPermanent);
#endif /* CLDC11 */

char*    getStringContents(STRING_INSTANCE string);
char*    getStringContentsSafely(STRING_INSTANCE string, char *buf, int lth);

/*=========================================================================
 * Debugging operations
 *=======================================================================*/

#if INCLUDEDEBUGCODE
void printInstance(INSTANCE);
void printArray(ARRAY);
void printClassName(CLASS);
#ifdef CLDC11
void printString(INSTANCE);
#endif /* CLDC11 */
#else
#  define printInstance(instance)
#  define printArray(ARRAY)
#endif

/*=========================================================================
 * Iterator macros
 *=======================================================================*/

#define FOR_ALL_CLASSES(__clazz__)                                   \
    {                                                                \
     HASHTABLE __table__ = ClassTable;                               \
     int __count__ = __table__->bucketCount;                         \
     while (-- __count__ >= 0) {                                     \
         CLASS __bucket__ = (CLASS)__table__->bucket[__count__];     \
         for ( ; __bucket__ != NULL; __bucket__ = __bucket__->next) { \
              CLASS __clazz__ = __bucket__ ; 

#define END_FOR_ALL_CLASSES   \
                        }     \
                }             \
        }