src/native/vm/VMSystem.c

   1 /* class: java/lang/System */
   2
   3 #if 0
   4 /*
   5  * Class:     java/lang/System
   6  * Method:    currentTimeMillis
   7  * Signature: ()J
   8  */
   9 JNIEXPORT s8 JNICALL Java_java_lang_VMSystem_currentTimeMillis ( JNIEnv *env )
  10 {
  11         struct timeval tv;
  12
  13         (void) gettimeofday(&tv, NULL);
  14         return ((s8) tv.tv_sec) * 1000 + tv.tv_usec / 1000;
  15 }
  16 #endif
  17
  18 /*
  19  * Class:     java/lang/System
  20  * Method:    arraycopy
  21  * Signature: (Ljava/lang/Object;ILjava/lang/Object;II)V
  22  */
  23 /* XXX delete */
  24 #if 0
  25 JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy (JNIEnv *env, jclass clazz,struct java_lang_Object* source, s4 sp, struct java_lang_Object* dest, s4 dp, s4 len)
  26 {
  27         s4 i;
  28         java_arrayheader *s = (java_arrayheader*) source;
  29         java_arrayheader *d = (java_arrayheader*) dest;
  30
  31         printf("arraycopy: %p:%x->%p:%x||len=%d\n",source,sp,dest,dp,len);
  32         fflush(stdout);
  33
  34
  35         if (((s == NULL) || (d == NULL)) != 0) {
  36                 exceptionptr = proto_java_lang_NullPointerException;
  37                 return;
  38                 }
  39         log_text("Passed nullpointer check");
  40         if (s->objheader.vftbl->class != class_array) {
  41                 exceptionptr = proto_java_lang_ArrayStoreException;
  42                 return;
  43                 }
  44
  45         log_text("Passed array storeexception");
  46         if (((sp<0) | (sp+len > s->size) | (dp<0) | (dp+len > d->size)) != 0) {
  47                 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
  48                 return;
  49                 }
  50
  51         log_text("Passed array out of bounds exception");
  52         printf("ARRAY TYPE: %d\n",s->arraytype);
  53
  54         switch (s->arraytype) {
  55         case ARRAYTYPE_BYTE:
  56                 if (s->objheader.vftbl != d->objheader.vftbl) {
  57                         exceptionptr = proto_java_lang_ArrayStoreException;
  58                         return;
  59                         }
  60                 memmove(((java_bytearray*) d)->data + dp,
  61                         ((java_bytearray*) s)->data + sp,
  62                         (size_t) len);
  63                 return;
  64         case ARRAYTYPE_BOOLEAN:
  65                 if (s->objheader.vftbl != d->objheader.vftbl) {
  66                         exceptionptr = proto_java_lang_ArrayStoreException;
  67                         return;
  68                         }
  69                 memmove(((java_booleanarray*) d)->data + dp,
  70                         ((java_booleanarray*) s)->data + sp,
  71                         (size_t) len);
  72                 return;
  73         case ARRAYTYPE_CHAR:
  74                 if (s->objheader.vftbl != d->objheader.vftbl) {
  75                         exceptionptr = proto_java_lang_ArrayStoreException;
  76                         return;
  77                         }
  78         printf("CHARARRAY:");
  79         if (len>0) {
  80                 utf_display(utf_new_u2(((java_chararray*)d)->data+sp,len*sizeof(u2), 0));
  81         }
  82         printf("\n");
  83
  84                 memmove(((java_chararray*) d)->data + dp,
  85                         ((java_chararray*) s)->data + sp,
  86                         (size_t) len * sizeof(u2));
  87                 return;
  88         case ARRAYTYPE_SHORT:
  89                 if (s->objheader.vftbl != d->objheader.vftbl) {
  90                         exceptionptr = proto_java_lang_ArrayStoreException;
  91                         return;
  92                         }
  93                 memmove(((java_shortarray*) d)->data + dp,
  94                         ((java_shortarray*) s)->data + sp,
  95                         (size_t) len * sizeof(s2));
  96                 return;
  97         case ARRAYTYPE_INT:
  98                 if (s->objheader.vftbl != d->objheader.vftbl) {
  99                         exceptionptr = proto_java_lang_ArrayStoreException;
 100                         return;
 101                         }
 102                 memmove(((java_intarray*) d)->data + dp,
 103                         ((java_intarray*) s)->data + sp,
 104                         (size_t) len * sizeof(s4));
 105                 return;
 106         case ARRAYTYPE_LONG:
 107                 if (s->objheader.vftbl != d->objheader.vftbl) {
 108                         exceptionptr = proto_java_lang_ArrayStoreException;
 109                         return;
 110                         }
 111                 memmove(((java_longarray*) d)->data + dp,
 112                         ((java_longarray*) s)->data + sp,
 113                         (size_t) len * sizeof(s8));
 114                 return;
 115         case ARRAYTYPE_FLOAT:
 116                 if (s->objheader.vftbl != d->objheader.vftbl) {
 117                         exceptionptr = proto_java_lang_ArrayStoreException;
 118                         return;
 119                         }
 120                 memmove(((java_floatarray*) d)->data + dp,
 121                         ((java_floatarray*) s)->data + sp,
 122                         (size_t) len * sizeof(float));
 123                 return;
 124         case ARRAYTYPE_DOUBLE:
 125                 if (s->objheader.vftbl != d->objheader.vftbl) {
 126                         exceptionptr = proto_java_lang_ArrayStoreException;
 127                         return;
 128                         }
 129                 memmove(((java_doublearray*) d)->data + dp,
 130                         ((java_doublearray*) s)->data + sp,
 131                         (size_t) len * sizeof(double));
 132                 return;
 133         case ARRAYTYPE_OBJECT:
 134                 {
 135                 java_objectarray *oas = (java_objectarray*) s;
 136                 java_objectarray *oad = (java_objectarray*) d;
 137
 138                 if (d->objheader.vftbl->class != class_array) {
 139                         exceptionptr = proto_java_lang_ArrayStoreException;
 140                         return;
 141                         }
 142                 if (s->arraytype != d->arraytype) {
 143                         exceptionptr = proto_java_lang_ArrayStoreException;
 144                         return;
 145                         }
 146
 147                 if (dp<=sp)
 148                         for (i=0; i<len; i++) {
 149                                 java_objectheader *o = oas->data[sp+i];
 150                                 if (!builtin_canstore(oad, o)) {
 151                                         exceptionptr = proto_java_lang_ArrayStoreException;
 152                                         return;
 153                                         }
 154                                 oad->data[dp+i] = o;
 155                                 }
 156                 else
 157                         for (i=len-1; i>=0; i--) {
 158                                 java_objectheader *o = oas->data[sp+i];
 159                                 if (!builtin_canstore(oad, o)) {
 160                                         exceptionptr = proto_java_lang_ArrayStoreException;
 161                                         return;
 162                                         }
 163                                 oad->data[dp+i] = o;
 164                                 }
 165
 166                 }
 167                 break;
 168         case ARRAYTYPE_ARRAY:
 169                 {
 170                 java_arrayarray *aas = (java_arrayarray*) s;
 171                 java_arrayarray *aad = (java_arrayarray*) d;
 172
 173                 if (d->objheader.vftbl->class != class_array) {
 174                         exceptionptr = proto_java_lang_ArrayStoreException;
 175                         return;
 176                         }
 177                 if (s->arraytype != d->arraytype) {
 178                         exceptionptr = proto_java_lang_ArrayStoreException;
 179                         return;
 180                         }
 181
 182                 if (dp<=sp)
 183                         for (i=0; i<len; i++) {
 184                                 java_arrayheader *o = aas->data[sp+i];
 185                                 if (!builtin_canstore( (java_objectarray*)aad,
 186                                         (java_objectheader*)o )) {
 187                                         exceptionptr = proto_java_lang_ArrayStoreException;
 188                                         return;
 189                                         }
 190                                 aad->data[dp+i] = o;
 191                                 }
 192                 else
 193                         for (i=len-1; i>=0; i--) {
 194                                 java_arrayheader *o = aas->data[sp+i];
 195                                 if (!builtin_canstore( (java_objectarray*)aad,
 196                                         (java_objectheader*)o )) {
 197                                         exceptionptr = proto_java_lang_ArrayStoreException;
 198                                         return;
 199                                         }
 200                                 aad->data[dp+i] = o;
 201                                 }
 202
 203                 }
 204                 break;
 205
 206         default:
 207                 panic ("Unknown data type for arraycopy");
 208         }
 209 }
 210 #endif
 211 JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy (JNIEnv *env, jclass clazz,struct java_lang_Object* source, s4 sp, struct java_lang_Object* dest, s4 dp, s4 len)
 212 {
 213         s4 i;
 214         java_arrayheader *s = (java_arrayheader*) source;
 215         java_arrayheader *d = (java_arrayheader*) dest;
 216         arraydescriptor *sdesc;
 217         arraydescriptor *ddesc;
 218
 219 /*      printf("arraycopy: %p:%x->%p:%x\n",source,sp,dest,dp);
 220         fflush(stdout);*/
 221
 222         if (!s || !d) {
 223             exceptionptr = proto_java_lang_NullPointerException;
 224             return;
 225         }
 226
 227         sdesc = s->objheader.vftbl->arraydesc;
 228         ddesc = d->objheader.vftbl->arraydesc;
 229
 230         if (!sdesc || !ddesc || (sdesc->arraytype != ddesc->arraytype)) {
 231             exceptionptr = proto_java_lang_ArrayStoreException;
 232             return;
 233         }
 234
 235         if ((len<0) || (sp<0) || (sp+len > s->size) || (dp<0) || (dp+len > d->size)) {
 236             exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
 237             return;
 238         }
 239
 240         if (sdesc->componentvftbl == ddesc->componentvftbl) {
 241             /* We copy primitive values or references of exactly the same type */
 242             s4 dataoffset = sdesc->dataoffset;
 243             s4 componentsize = sdesc->componentsize;
 244             memmove(((u1*)d) + dataoffset + componentsize * dp,
 245                     ((u1*)s) + dataoffset + componentsize * sp,
 246                     (size_t) len * componentsize);
 247         }
 248         else {
 249             /* We copy references of different type */
 250             java_objectarray *oas = (java_objectarray*) s;
 251             java_objectarray *oad = (java_objectarray*) d;
 252
 253             if (dp<=sp)
 254                 for (i=0; i<len; i++) {
 255                     java_objectheader *o = oas->data[sp+i];
 256                     if (!builtin_canstore(oad, o)) {
 257                         exceptionptr = proto_java_lang_ArrayStoreException;
 258                         return;
 259                     }
 260                     oad->data[dp+i] = o;
 261                 }
 262             else
 263                 /* XXX this does not completely obey the specification!
 264                  * If an exception is thrown only the elements above
 265                  * the current index have been copied. The
 266                  * specification requires that only the elements
 267                  * *below* the current index have been copied before
 268                  * the throw.
 269                  */
 270                 for (i=len-1; i>=0; i--) {
 271                     java_objectheader *o = oas->data[sp+i];
 272                     if (!builtin_canstore(oad, o)) {
 273                         exceptionptr = proto_java_lang_ArrayStoreException;
 274                         return;
 275                     }
 276                     oad->data[dp+i] = o;
 277                 }
 278         }
 279 }
 280
 281 void attach_property (char *name, char *value)
 282 {
 283         log_text("attach_property not supported");
 284 #if 0
 285         if (activeprops >= MAXPROPS) panic ("Too many properties defined");
 286         proplist[activeprops][0] = name;
 287         proplist[activeprops][1] = value;
 288         activeprops++;
 289 #endif
 290 }
 291
 292 /*
 293  * Class:     java/lang/System
 294  * Method:    identityHashCode
 295  * Signature: (Ljava/lang/Object;)I
 296  */
 297 JNIEXPORT s4 JNICALL Java_java_lang_VMSystem_identityHashCode (JNIEnv *env , jclass clazz, struct java_lang_Object* par1)
 298 {
 299         return ((char*) par1) - ((char*) 0);
 300 }
 301
 302
 303
 304