src/native/vm/VMObject.c

   1 /* class: java/lang/Object */
   2
   3 /*
   4  * Class:     java/lang/Object
   5  * Method:    clone
   6  * Signature: ()Ljava/lang/Object;
   7  */
   8 /* XXX delete */
   9 #if 0
  10 JNIEXPORT struct java_lang_Object* JNICALL Java_java_lang_VMObject_clone ( JNIEnv *env ,  jclass clazz, struct java_lang_Cloneable* this)
  11 {
  12 /*      log_text("Java_java_lang_VMObject_clone called");
  13         utf_display(((java_objectheader*)this)->vftbl->class->name);
  14         log_text("starting cloning");     */
  15         classinfo *c;
  16         java_lang_Object *new;
  17
  18         if (((java_objectheader*)this)->vftbl->class == class_array)
  19           {
  20             static u4 multiplicator[10];
  21             static int is_initialized = 0;
  22
  23             java_arrayheader *array = (java_arrayheader*)this;
  24             u4 size;
  25
  26             if (!is_initialized)
  27               {
  28                 multiplicator[ARRAYTYPE_INT] = sizeof(s4);
  29                 multiplicator[ARRAYTYPE_LONG] = sizeof(s8);
  30                 multiplicator[ARRAYTYPE_FLOAT] = sizeof(float);
  31                 multiplicator[ARRAYTYPE_DOUBLE] = sizeof(double);
  32                 multiplicator[ARRAYTYPE_BYTE] = sizeof(s1);
  33                 multiplicator[ARRAYTYPE_CHAR] = sizeof(u2);
  34                 multiplicator[ARRAYTYPE_SHORT] = sizeof(s2);
  35                 multiplicator[ARRAYTYPE_BOOLEAN] = sizeof(u1);
  36                 multiplicator[ARRAYTYPE_OBJECT] = sizeof(void*);
  37                 multiplicator[ARRAYTYPE_ARRAY] = sizeof(void*);
  38                 is_initialized = 1;
  39               }
  40
  41             size = sizeof(java_arrayheader)
  42               + array->size * multiplicator[array->arraytype];
  43             if (array->arraytype == ARRAYTYPE_OBJECT /* elementtype */
  44                 || array->arraytype == ARRAYTYPE_ARRAY) /* elementdescriptor */
  45                 size += sizeof(void*);
  46
  47             if (array->arraytype==ARRAYTYPE_OBJECT || array->arraytype==ARRAYTYPE_OBJECT)
  48                 size+=sizeof(void*);
  49
  50             new = (java_lang_Object*)heap_allocate(size, false, NULL);
  51             memcpy(new, this, size);
  52
  53             return new;
  54           }
  55         else
  56           {
  57             if (!class_java_lang_Cloneable)
  58                   class_java_lang_Cloneable =
  59                         class_new ( utf_new_char ("java/lang/Cloneable") );
  60             if (! builtin_instanceof ((java_objectheader*) this, class_java_lang_Cloneable) ) {
  61                 exceptionptr = native_new_and_init (class_java_lang_CloneNotSupportedException);
  62                 return NULL;
  63                 }
  64
  65         c = this -> header.vftbl -> class;
  66         new = (java_lang_Object*) builtin_new (c);
  67         if (!new) {
  68                 exceptionptr = proto_java_lang_OutOfMemoryError;
  69                 return NULL;
  70                 }
  71
  72             memcpy (new, this, c->instancesize);
  73             return new;
  74           }
  75         return 0;
  76 }
  77 #endif
  78 JNIEXPORT struct java_lang_Object* JNICALL Java_java_lang_VMObject_clone ( JNIEnv *env ,  jclass clazz, struct java_lang_Cloneable* this)
  79 {
  80 /*      log_text("Java_java_lang_VMObject_clone called");
  81         utf_display(((java_objectheader*)this)->vftbl->class->name);
  82         log_text("starting cloning");     */
  83     classinfo *c;
  84     java_lang_Object *new;
  85     arraydescriptor *desc;
  86
  87     if ((desc = this->header.vftbl->arraydesc) != NULL) {
  88         /* We are cloning an array */
  89
  90         u4 size = desc->dataoffset + desc->componentsize * ((java_arrayheader*)this)->size;
  91
  92         new = (java_lang_Object*)heap_allocate(size, (desc->arraytype == ARRAYTYPE_OBJECT), NULL);
  93         memcpy(new, this, size);
  94
  95         return new;
  96     }
  97
  98     /* We are cloning a non-array */
  99     if (! builtin_instanceof ((java_objectheader*) this, class_java_lang_Cloneable) ) {
 100         exceptionptr = native_new_and_init (class_java_lang_CloneNotSupportedException);
 101         return NULL;
 102     }
 103
 104     /* XXX should use vftbl */
 105     c = this -> header.vftbl -> class;
 106     new = (java_lang_Object*) builtin_new (c);
 107     if (!new) {
 108         exceptionptr = proto_java_lang_OutOfMemoryError;
 109         return NULL;
 110     }
 111     memcpy (new, this, c->instancesize);
 112     return new;
 113 }
 114
 115
 116 /*
 117  * Class:     java/lang/Object
 118  * Method:    notify
 119  * Signature: ()V
 120  */
 121 JNIEXPORT void JNICALL Java_java_lang_VMObject_notify ( JNIEnv *env ,  jclass clazz, struct java_lang_Object* this)
 122 {
 123         if (runverbose)
 124                 log_text ("java_lang_Object_notify called");
 125
 126         #ifdef USE_THREADS
 127                 signal_cond_for_object(&this->header);
 128         #endif
 129 }
 130
 131 /*
 132  * Class:     java/lang/Object
 133  * Method:    notifyAll
 134  * Signature: ()V
 135  */
 136 JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll ( JNIEnv *env ,  jclass clazz, struct java_lang_Object* this)
 137 {
 138         if (runverbose)
 139                 log_text ("java_lang_Object_notifyAll called");
 140
 141         #ifdef USE_THREADS
 142                 broadcast_cond_for_object(&this->header);
 143         #endif
 144 }
 145
 146
 147 /*
 148  * Class:     java/lang/Object
 149  * Method:    wait
 150  * Signature: (J)V
 151  */
 152 JNIEXPORT void JNICALL Java_java_lang_VMObject_wait ( JNIEnv *env , jclass clazz, struct java_lang_Object* this, s8 time,s4 par3)
 153 {
 154         if (runverbose)
 155                 log_text ("java_lang_Object_wait called");
 156
 157         #ifdef USE_THREADS
 158                 wait_cond_for_object(&this->header, time);
 159         #endif
 160 }
 161
 162