nat/lang.c

   1 /* -*- mode: c; tab-width: 4; c-basic-offset: 4 -*- */
   2 /****************************** nat/lang.c *************************************
   3
   4         Copyright (c) 1997 A. Krall, R. Grafl, M. Gschwind, M. Probst
   5
   6         See file COPYRIGHT for information on usage and disclaimer of warranties
   7
   8         Contains the native functions for class java.lang.
   9
  10         Authors: Reinhard Grafl      EMAIL: cacao@complang.tuwien.ac.at
  11                  Mark Probst         EMAIL: cacao@complang.tuwien.ac.at
  12
  13         Last Change: 1997/06/10
  14
  15 *******************************************************************************/
  16
  17 #include <math.h>
  18 #include <string.h>
  19 #include <assert.h>
  20 #include <sys/time.h>
  21
  22 #include "../threads/thread.h"                       /* schani */
  23 #include "../threads/locks.h"
  24
  25 static void use_class_as_object (classinfo *c)
  26 {
  27         c->header.vftbl = class_java_lang_Class -> vftbl;
  28 }
  29
  30
  31 /************************************** java.lang.Object ***********************************/
  32
  33 struct java_lang_Class* java_lang_Object_getClass (struct java_lang_Object* this)
  34 {
  35         classinfo *c = this->header.vftbl -> class;
  36         use_class_as_object (c);
  37         return (java_lang_Class*) c;
  38 }
  39
  40 s4 java_lang_Object_hashCode (struct java_lang_Object* this)
  41 {
  42         return ((char*) this) - ((char*) 0);
  43 }
  44
  45
  46 struct java_lang_Object* java_lang_Object_clone (struct java_lang_Object* this)
  47 {
  48         classinfo *c;
  49         java_lang_Object *new;
  50
  51         if (((java_objectheader*)this)->vftbl->class == class_array)
  52           {
  53             static u4 multiplicator[10];
  54             static int is_initialized = 0;
  55
  56             java_arrayheader *array = (java_arrayheader*)this;
  57             u4 size;
  58
  59             if (!is_initialized)
  60               {
  61                 multiplicator[ARRAYTYPE_INT] = sizeof(s4);
  62                 multiplicator[ARRAYTYPE_LONG] = sizeof(s8);
  63                 multiplicator[ARRAYTYPE_FLOAT] = sizeof(float);
  64                 multiplicator[ARRAYTYPE_DOUBLE] = sizeof(double);
  65                 multiplicator[ARRAYTYPE_BYTE] = sizeof(s1);
  66                 multiplicator[ARRAYTYPE_CHAR] = sizeof(u2);
  67                 multiplicator[ARRAYTYPE_SHORT] = sizeof(s2);
  68                 multiplicator[ARRAYTYPE_BOOLEAN] = sizeof(u1);
  69                 multiplicator[ARRAYTYPE_OBJECT] = sizeof(void*);
  70                 multiplicator[ARRAYTYPE_ARRAY] = sizeof(void*);
  71                 is_initialized = 1;
  72               }
  73
  74             size = sizeof(java_arrayheader)
  75               + array->size * multiplicator[array->arraytype];
  76
  77             new = (java_lang_Object*)heap_allocate(size, false, NULL);
  78             memcpy(new, this, size);
  79
  80             return new;
  81           }
  82         else
  83           {
  84             if (! builtin_instanceof ((java_objectheader*) this, class_java_lang_Cloneable) ) {
  85                 exceptionptr = native_new_and_init (class_java_lang_CloneNotSupportedException);
  86                 return NULL;
  87                 }
  88
  89         c = this -> header.vftbl -> class;
  90         new = (java_lang_Object*) builtin_new (c);
  91         if (!new) {
  92                 exceptionptr = proto_java_lang_OutOfMemoryError;
  93                 return NULL;
  94                 }
  95
  96             memcpy (new, this, c->instancesize);
  97             return new;
  98           }
  99 }
 100
 101 void java_lang_Object_notify (struct java_lang_Object* this)
 102 {
 103         if (runverbose)
 104                 log_text ("java_lang_Object_notify called");
 105
 106 #ifdef USE_THREADS
 107     signal_cond_for_object(&this->header);
 108 #endif
 109 }
 110
 111 void java_lang_Object_notifyAll (struct java_lang_Object* this)
 112 {
 113         if (runverbose)
 114                 log_text ("java_lang_Object_notifyAll called");
 115
 116 #ifdef USE_THREADS
 117         broadcast_cond_for_object(&this->header);
 118 #endif
 119 }
 120
 121 void java_lang_Object_wait (struct java_lang_Object* this, s8 time)
 122 {
 123         if (runverbose)
 124                 log_text ("java_lang_Object_wait called");
 125
 126 #ifdef USE_THREADS
 127         wait_cond_for_object(&this->header, time);
 128 #endif
 129 }
 130
 131
 132 /********************************** java.lang.Class **************************************/
 133
 134
 135 struct java_lang_Class* java_lang_Class_forName (struct java_lang_String* s)
 136 {
 137         java_chararray *a,*b;
 138         u4 i;
 139         unicode *u;
 140         classinfo *c;
 141
 142         if (!s) return NULL;
 143         if (!(a = s->value) ) return NULL;
 144         b = builtin_newarray_char (s->count);
 145         if (!b) return NULL;
 146         for (i=0; i<s->count; i++) {
 147                 if (a->data[s->offset+i]=='.') b->data[i] = '/';
 148             else                           b->data[i] = a->data[s->offset+i];
 149             }
 150         u = unicode_new_u2 (b->data, b->header.size);
 151         c = u->class;
 152         if (!c) {
 153                 c = loader_load (u);
 154                 loader_initclasses ();
 155
 156                 if (!c) {
 157                         exceptionptr =
 158                         native_new_and_init (class_java_lang_ClassNotFoundException);
 159
 160                         return NULL;
 161                         }
 162
 163                 }
 164
 165         use_class_as_object (c);
 166         return (java_lang_Class*) c;
 167 }
 168
 169 struct java_lang_Object* java_lang_Class_newInstance (struct java_lang_Class* this)
 170 {
 171         java_objectheader *o = native_new_and_init ((classinfo*) this);
 172         if (!o) {
 173                 exceptionptr =
 174                         native_new_and_init (class_java_lang_InstantiationException);
 175                 }
 176         return (java_lang_Object*) o;
 177 }
 178
 179 struct java_lang_String* java_lang_Class_getName (struct java_lang_Class* this)
 180 {
 181         u4 i;
 182         classinfo *c = (classinfo*) this;
 183         java_lang_String *s = (java_lang_String*) javastring_new(c->name);
 184
 185         if (!s) return NULL;
 186
 187         for (i=0; i<s->value->header.size; i++) {
 188                 if (s->value->data[i] == '/') s->value->data[i] = '.';
 189                 }
 190
 191         return s;
 192 }
 193
 194 struct java_lang_Class* java_lang_Class_getSuperclass (struct java_lang_Class* this)
 195 {
 196         classinfo *c = ((classinfo*) this) -> super;
 197         if (!c) return NULL;
 198
 199         use_class_as_object (c);
 200         return (java_lang_Class*) c;
 201 }
 202
 203 java_objectarray* java_lang_Class_getInterfaces (struct java_lang_Class* this)
 204 {
 205         classinfo *c = (classinfo*) this;
 206         u4 i;
 207         java_objectarray *a = builtin_anewarray (c->interfacescount, class_java_lang_Class);
 208         if (!a) return NULL;
 209         for (i=0; i<c->interfacescount; i++) {
 210                 use_class_as_object (c->interfaces[i]);
 211
 212                 a->data[i] = (java_objectheader*) c->interfaces[i];
 213                 }
 214         return a;
 215 }
 216
 217 struct java_lang_ClassLoader* java_lang_Class_getClassLoader (struct java_lang_Class* this)
 218 {
 219         log_text ("java_lang_Class_getClassLoader called");
 220         return NULL;
 221 }
 222
 223 s4 java_lang_Class_isInterface (struct java_lang_Class* this)
 224 {
 225         classinfo *c = (classinfo*) this;
 226         if (c->flags & ACC_INTERFACE) return 1;
 227         return 0;
 228 }
 229
 230 /************************************ java.lang.ClassLoader *******************************/
 231
 232
 233 struct java_lang_Class* java_lang_ClassLoader_defineClass (struct java_lang_ClassLoader* this, java_bytearray* par1, s4 par2, s4 par3)
 234 {
 235         log_text ("java_lang_ClassLoader_defineClass called");
 236         return NULL;
 237 }
 238 void java_lang_ClassLoader_resolveClass (struct java_lang_ClassLoader* this, struct java_lang_Class* par1)
 239 {
 240         log_text ("java_lang_ClassLoader_resolveClass called");
 241 }
 242 struct java_lang_Class* java_lang_ClassLoader_findSystemClass (struct java_lang_ClassLoader* this, struct java_lang_String* par1)
 243 {
 244         log_text ("java_lang_ClassLoader_findSystemClass called");
 245         return NULL;
 246 }
 247 void java_lang_ClassLoader_init (struct java_lang_ClassLoader* this)
 248 {
 249         log_text ("java_lang_ClassLoader_init called");
 250 }
 251 struct java_lang_Class* java_lang_ClassLoader_findSystemClass0 (struct java_lang_ClassLoader* this, struct java_lang_String* par1)
 252 {
 253         log_text ("java_lang_ClassLoader_findSystemClass0 called");
 254         return NULL;
 255 }
 256
 257 struct java_lang_Class* java_lang_ClassLoader_defineClass0 (struct java_lang_ClassLoader* this, java_bytearray* par1, s4 par2, s4 par3)
 258 {
 259         log_text ("java_lang_ClassLoader_defineClass0 called");
 260         return NULL;
 261 }
 262 void java_lang_ClassLoader_resolveClass0 (struct java_lang_ClassLoader* this, struct java_lang_Class* par1)
 263 {
 264         log_text ("java_lang_ClassLoader_resolveClass0 called");
 265         return;
 266 }
 267
 268 /************************************** java.lang.Compiler  *******************************/
 269
 270 void java_lang_Compiler_initialize ()
 271 {
 272         log_text ("java_lang_Compiler_initialize called");
 273 }
 274 s4 java_lang_Compiler_compileClass (struct java_lang_Class* par1)
 275 {
 276         log_text ("java_lang_Compiler_compileClass called");
 277         return 0;
 278 }
 279 s4 java_lang_Compiler_compileClasses (struct java_lang_String* par1)
 280 {
 281         log_text ("java_lang_Compiler_compileClasses called");
 282         return 0;
 283 }
 284 struct java_lang_Object* java_lang_Compiler_command (struct java_lang_Object* par1)
 285 {
 286         log_text ("java_lang_Compiler_command called");
 287         return NULL;
 288 }
 289 void java_lang_Compiler_enable ()
 290 {
 291         log_text ("java_lang_Compiler_enable called");
 292 }
 293 void java_lang_Compiler_disable ()
 294 {
 295         log_text ("java_lang_Compiler_disable called");
 296 }
 297
 298
 299 /******************************** java.lang.Double **************************************/
 300
 301 struct java_lang_String* java_lang_Double_toString (double par1)
 302 {
 303         char b[400];
 304         sprintf (b, "%-.6g", par1);
 305         return (java_lang_String*) javastring_new_char (b);
 306 }
 307 struct java_lang_Double* java_lang_Double_valueOf (struct java_lang_String* par1)
 308 {
 309         float val;
 310         java_lang_Double *d = (java_lang_Double*) builtin_new (class_java_lang_Double);
 311         if (d) {
 312                 sscanf (javastring_tochar((java_objectheader*) par1), "%f", &val);
 313                 d->value = val;
 314                 return d;
 315         }
 316         return NULL;
 317 }
 318 s8 java_lang_Double_doubleToLongBits (double par1)
 319 {
 320         s8 l;
 321         double d = par1;
 322         memcpy ((u1*) &l, (u1*) &d, 8);
 323         return l;
 324 }
 325 double java_lang_Double_longBitsToDouble (s8 par1)
 326 {
 327         s8 l = par1;
 328         double d;
 329         memcpy ((u1*) &d, (u1*) &l, 8);
 330         return d;
 331 }
 332
 333 /******************************** java.lang.Float ***************************************/
 334
 335 struct java_lang_String* java_lang_Float_toString (float par1)
 336 {
 337         char b[50];
 338         sprintf (b, "%-.6g", (double) par1);
 339         return (java_lang_String*) javastring_new_char (b);
 340 }
 341 struct java_lang_Float* java_lang_Float_valueOf (struct java_lang_String* par1)
 342 {
 343         float val;
 344         java_lang_Float *d = (java_lang_Float*) builtin_new (class_java_lang_Float);
 345         if (d) {
 346                 sscanf (javastring_tochar((java_objectheader*) par1), "%f", &val);
 347                 d->value = val;
 348                 return d;
 349         }
 350         return NULL;
 351 }
 352 s4 java_lang_Float_floatToIntBits (float par1)
 353 {
 354         s4 i;
 355         float f = par1;
 356         memcpy ((u1*) &i, (u1*) &f, 4);
 357         return i;
 358 }
 359 float java_lang_Float_intBitsToFloat (s4 par1)
 360 {
 361         s4 i = par1;
 362         float f;
 363         memcpy ((u1*) &f, (u1*) &i, 4);
 364         return f;
 365 }
 366
 367
 368 /******************************** java.lang.Math ****************************************/
 369
 370 double java_lang_Math_sin (double par1)
 371 {
 372         return sin(par1);
 373 }
 374
 375 double java_lang_Math_cos (double par1)
 376 {
 377         return cos(par1);
 378 }
 379
 380 double java_lang_Math_tan (double par1)
 381 {
 382         return tan(par1);
 383 }
 384
 385 double java_lang_Math_asin (double par1)
 386 {
 387         return asin(par1);
 388 }
 389
 390 double java_lang_Math_acos (double par1)
 391 {
 392         return acos(par1);
 393 }
 394
 395 double java_lang_Math_atan (double par1)
 396 {
 397         return atan(par1);
 398 }
 399
 400 double java_lang_Math_exp (double par1)
 401 {
 402         return exp(par1);
 403 }
 404
 405 double java_lang_Math_log (double par1)
 406 {
 407         if (par1<0.0) {
 408                 exceptionptr = proto_java_lang_ArithmeticException;
 409                 return 0.0;
 410                 }
 411         return log(par1);
 412 }
 413
 414 double java_lang_Math_sqrt (double par1)
 415 {
 416         if (par1<0.0) {
 417                 exceptionptr = proto_java_lang_ArithmeticException;
 418                 return 0.0;
 419                 }
 420         return sqrt(par1);
 421 }
 422
 423 static u8 dbl_nan    = 0xffffffffffffffffL ;
 424
 425 #define DBL_NAN    (*((double*) (&dbl_nan)))
 426
 427 double java_lang_Math_IEEEremainder (double a, double b)
 428 {
 429         double d;
 430         if (finite(a) && finite(b)) {
 431                 d = a / b;
 432                 if (finite(d))
 433                         return a - floor(d) * b;
 434                 return DBL_NAN;
 435                 }
 436         if (isnan(b))
 437                 return DBL_NAN;
 438         if (finite(a))
 439                 return a;
 440         return DBL_NAN;
 441 }
 442
 443 double java_lang_Math_ceil (double par1)
 444 {
 445         return ceil(par1);
 446 }
 447
 448 double java_lang_Math_floor (double par1)
 449 {
 450         return floor(par1);
 451 }
 452
 453 double java_lang_Math_rint (double par1)
 454 {
 455         panic ("native Methode java_lang_rint not implemented yet");
 456         return 0.0;
 457 }
 458
 459 double java_lang_Math_atan2 (double par1, double par2)
 460 {
 461         return atan2(par1,par2);
 462 }
 463
 464 double java_lang_Math_pow (double par1, double par2)
 465 {
 466         return pow(par1,par2);
 467 }
 468
 469
 470 /******************************* java.lang.Runtime **************************************/
 471
 472 void java_lang_Runtime_exitInternal (struct java_lang_Runtime* this, s4 par1)
 473 {
 474         cacao_shutdown (par1);
 475 }
 476 struct java_lang_Process* java_lang_Runtime_execInternal (struct java_lang_Runtime* this, java_objectarray* par1, java_objectarray* par2)
 477 {
 478         log_text ("java_lang_Runtime_execInternal called");
 479         return NULL;
 480 }
 481 s8 java_lang_Runtime_freeMemory (struct java_lang_Runtime* this)
 482 {
 483         log_text ("java_lang_Runtime_freeMemory called");
 484         return builtin_i2l (0);
 485 }
 486 s8 java_lang_Runtime_totalMemory (struct java_lang_Runtime* this)
 487 {
 488         log_text ("java_lang_Runtime_totalMemory called");
 489         return builtin_i2l (0);
 490 }
 491 void java_lang_Runtime_gc (struct java_lang_Runtime* this)
 492 {
 493         gc_call();
 494 }
 495 void java_lang_Runtime_runFinalization (struct java_lang_Runtime* this)
 496 {
 497         log_text ("java_lang_Runtime_runFinalization called");
 498 }
 499 void java_lang_Runtime_traceInstructions (struct java_lang_Runtime* this, s4 par1)
 500 {
 501         log_text ("java_lang_Runtime_traceInstructions called");
 502 }
 503 void java_lang_Runtime_traceMethodCalls (struct java_lang_Runtime* this, s4 par1)
 504 {
 505         log_text ("java_lang_Runtime_traceMethodCalls called");
 506 }
 507 struct java_lang_String* java_lang_Runtime_initializeLinkerInternal (struct java_lang_Runtime* this)
 508 {
 509         log_text ("java_lang_Runtime_initializeLinkerInternal called");
 510         return (java_lang_String*)javastring_new_char(".");
 511 }
 512 struct java_lang_String* java_lang_Runtime_buildLibName (struct java_lang_Runtime* this, struct java_lang_String* par1, struct java_lang_String* par2)
 513 {
 514         log_text ("java_lang_Runtime_buildLibName called");
 515         return NULL;
 516 }
 517 s4 java_lang_Runtime_loadFileInternal (struct java_lang_Runtime* this, struct java_lang_String* par1)
 518 {
 519         log_text ("java_lang_Runtime_loadFileInternal called");
 520         return 1;
 521 }
 522
 523
 524 /**************************************** java.lang.SecurityManager ***********************/
 525
 526 java_objectarray* java_lang_SecurityManager_getClassContext (struct java_lang_SecurityManager* this)
 527 {
 528         log_text ("called: java_lang_SecurityManager_getClassContext");
 529         return NULL;
 530 }
 531 struct java_lang_ClassLoader* java_lang_SecurityManager_currentClassLoader (struct java_lang_SecurityManager* this)
 532 {
 533         log_text ("called: java_lang_SecurityManager_currentClassLoader");
 534         return NULL;
 535 }
 536 s4 java_lang_SecurityManager_classDepth (struct java_lang_SecurityManager* this, struct java_lang_String* par1)
 537 {
 538         log_text ("called: java_lang_SecurityManager_classDepth");
 539         return 0;
 540 }
 541 s4 java_lang_SecurityManager_classLoaderDepth (struct java_lang_SecurityManager* this)
 542 {
 543         log_text ("called: java_lang_SecurityManager_classLoaderDepth");
 544         return 0;
 545 }
 546
 547
 548
 549 /*********************************** java.lang.System ************************************/
 550
 551 s8 java_lang_System_currentTimeMillis ()
 552 {
 553         struct timeval tv;
 554
 555         (void) gettimeofday(&tv, NULL);
 556         return ((s8) tv.tv_sec) * 1000 + tv.tv_usec / 1000;
 557 }
 558
 559
 560 void java_lang_System_arraycopy (struct java_lang_Object* source, s4 sp,
 561                                  struct java_lang_Object* dest, s4 dp, s4 len)
 562 {
 563         s4 i;
 564         java_arrayheader *s = (java_arrayheader*) source;
 565         java_arrayheader *d = (java_arrayheader*) dest;
 566
 567         if (((s == NULL) | (d == NULL)) != 0) {
 568                 exceptionptr = proto_java_lang_NullPointerException;
 569                 return;
 570                 }
 571
 572         if (s->objheader.vftbl->class != class_array) {
 573                 exceptionptr = proto_java_lang_ArrayStoreException;
 574                 return;
 575                 }
 576
 577         if (((sp<0) | (sp+len > s->size) | (dp<0) | (dp+len > d->size)) != 0) {
 578                 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
 579                 return;
 580                 }
 581
 582         switch (s->arraytype) {
 583         case ARRAYTYPE_BYTE:
 584                 if (s->objheader.vftbl != d->objheader.vftbl) {
 585                         exceptionptr = proto_java_lang_ArrayStoreException;
 586                         return;
 587                         }
 588                 memmove(((java_bytearray*) d)->data + dp,
 589                         ((java_bytearray*) s)->data + sp,
 590                         (size_t) len);
 591                 return;
 592         case ARRAYTYPE_BOOLEAN:
 593                 if (s->objheader.vftbl != d->objheader.vftbl) {
 594                         exceptionptr = proto_java_lang_ArrayStoreException;
 595                         return;
 596                         }
 597                 memmove(((java_booleanarray*) d)->data + dp,
 598                         ((java_booleanarray*) s)->data + sp,
 599                         (size_t) len);
 600                 return;
 601         case ARRAYTYPE_CHAR:
 602                 if (s->objheader.vftbl != d->objheader.vftbl) {
 603                         exceptionptr = proto_java_lang_ArrayStoreException;
 604                         return;
 605                         }
 606                 memmove(((java_chararray*) d)->data + dp,
 607                         ((java_chararray*) s)->data + sp,
 608                         (size_t) len * sizeof(u2));
 609                 return;
 610         case ARRAYTYPE_SHORT:
 611                 if (s->objheader.vftbl != d->objheader.vftbl) {
 612                         exceptionptr = proto_java_lang_ArrayStoreException;
 613                         return;
 614                         }
 615                 memmove(((java_shortarray*) d)->data + dp,
 616                         ((java_shortarray*) s)->data + sp,
 617                         (size_t) len * sizeof(s2));
 618                 return;
 619         case ARRAYTYPE_INT:
 620                 if (s->objheader.vftbl != d->objheader.vftbl) {
 621                         exceptionptr = proto_java_lang_ArrayStoreException;
 622                         return;
 623                         }
 624                 memmove(((java_intarray*) d)->data + dp,
 625                         ((java_intarray*) s)->data + sp,
 626                         (size_t) len * sizeof(s4));
 627                 return;
 628         case ARRAYTYPE_LONG:
 629                 if (s->objheader.vftbl != d->objheader.vftbl) {
 630                         exceptionptr = proto_java_lang_ArrayStoreException;
 631                         return;
 632                         }
 633                 memmove(((java_longarray*) d)->data + dp,
 634                         ((java_longarray*) s)->data + sp,
 635                         (size_t) len * sizeof(s8));
 636                 return;
 637         case ARRAYTYPE_FLOAT:
 638                 if (s->objheader.vftbl != d->objheader.vftbl) {
 639                         exceptionptr = proto_java_lang_ArrayStoreException;
 640                         return;
 641                         }
 642                 memmove(((java_floatarray*) d)->data + dp,
 643                         ((java_floatarray*) s)->data + sp,
 644                         (size_t) len * sizeof(float));
 645                 return;
 646         case ARRAYTYPE_DOUBLE:
 647                 if (s->objheader.vftbl != d->objheader.vftbl) {
 648                         exceptionptr = proto_java_lang_ArrayStoreException;
 649                         return;
 650                         }
 651                 memmove(((java_doublearray*) d)->data + dp,
 652                         ((java_doublearray*) s)->data + sp,
 653                         (size_t) len * sizeof(double));
 654                 return;
 655         case ARRAYTYPE_OBJECT:
 656                 {
 657                 java_objectarray *oas = (java_objectarray*) s;
 658                 java_objectarray *oad = (java_objectarray*) d;
 659
 660                 if (d->objheader.vftbl->class != class_array) {
 661                         exceptionptr = proto_java_lang_ArrayStoreException;
 662                         return;
 663                         }
 664                 if (s->arraytype != d->arraytype) {
 665                         exceptionptr = proto_java_lang_ArrayStoreException;
 666                         return;
 667                         }
 668
 669                 if (dp<=sp)
 670                         for (i=0; i<len; i++) {
 671                                 java_objectheader *o = oas->data[sp+i];
 672                                 if (!builtin_canstore(oad, o)) {
 673                                         exceptionptr = proto_java_lang_ArrayStoreException;
 674                                         return;
 675                                         }
 676                                 oad->data[dp+i] = o;
 677                                 }
 678                 else
 679                         for (i=len-1; i>=0; i--) {
 680                                 java_objectheader *o = oas->data[sp+i];
 681                                 if (!builtin_canstore(oad, o)) {
 682                                         exceptionptr = proto_java_lang_ArrayStoreException;
 683                                         return;
 684                                         }
 685                                 oad->data[dp+i] = o;
 686                                 }
 687
 688                 }
 689                 break;
 690         case ARRAYTYPE_ARRAY:
 691                 {
 692                 java_arrayarray *aas = (java_arrayarray*) s;
 693                 java_arrayarray *aad = (java_arrayarray*) d;
 694
 695                 if (d->objheader.vftbl->class != class_array) {
 696                         exceptionptr = proto_java_lang_ArrayStoreException;
 697                         return;
 698                         }
 699                 if (s->arraytype != d->arraytype) {
 700                         exceptionptr = proto_java_lang_ArrayStoreException;
 701                         return;
 702                         }
 703
 704                 if (dp<=sp)
 705                         for (i=0; i<len; i++) {
 706                                 java_arrayheader *o = aas->data[sp+i];
 707                                 if (!builtin_canstore( (java_objectarray*)aad,
 708                                         (java_objectheader*)o )) {
 709                                         exceptionptr = proto_java_lang_ArrayStoreException;
 710                                         return;
 711                                         }
 712                                 aad->data[dp+i] = o;
 713                                 }
 714                 else
 715                         for (i=len-1; i>=0; i--) {
 716                                 java_arrayheader *o = aas->data[sp+i];
 717                                 if (!builtin_canstore( (java_objectarray*)aad,
 718                                         (java_objectheader*)o )) {
 719                                         exceptionptr = proto_java_lang_ArrayStoreException;
 720                                         return;
 721                                         }
 722                                 aad->data[dp+i] = o;
 723                                 }
 724
 725                 }
 726                 break;
 727
 728         default:
 729                 panic ("Unknown data type for arraycopy");
 730         }
 731
 732 }
 733
 734
 735 #define MAXPROPS 100
 736 static int activeprops = 15;
 737
 738 static char *proplist[MAXPROPS][2] = {
 739         { "java.class.path", NULL },
 740         { "java.home", NULL },
 741         { "user.home", NULL },
 742         { "user.name", NULL },
 743         { "user.dir",  NULL },
 744
 745         { "java.class.version", "45.3" },
 746         { "java.version", "cacao:0.3" },
 747         { "java.vendor", "CACAO Team" },
 748         { "java.vendor.url", "http://www.complang.tuwien.ac.at/java/cacao/" },
 749         { "os.arch", "Alpha" },
 750         { "os.name", "Linux/Digital Unix" },
 751         { "os.version", "4.0/3.2C/V4.0" },
 752         { "path.separator", ":" },
 753         { "file.separator", "/" },
 754         { "line.separator", "\n" }
 755 };
 756
 757 void attach_property (char *name, char *value)
 758 {
 759         if (activeprops >= MAXPROPS) panic ("Too many properties defined");
 760         proplist[activeprops][0] = name;
 761         proplist[activeprops][1] = value;
 762         activeprops++;
 763 }
 764
 765
 766 struct java_util_Properties* java_lang_System_initProperties (struct java_util_Properties* p)
 767 {
 768         u4 i;
 769         methodinfo *m;
 770 #define BUFFERSIZE 200
 771         char buffer[BUFFERSIZE];
 772
 773         proplist[0][1] = classpath;
 774         proplist[1][1] = getenv("JAVA_HOME");
 775         proplist[2][1] = getenv("HOME");
 776         proplist[3][1] = getenv("USER");
 777         proplist[4][1] = getcwd(buffer,BUFFERSIZE);
 778
 779         if (!p) panic ("initProperties called with NULL-Argument");
 780
 781         m = class_resolvemethod (
 782                 p->header.vftbl->class,
 783                 unicode_new_char ("put"),
 784                 unicode_new_char ("(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;")
 785         );
 786     if (!m) panic ("Can not find method 'put' for class Properties");
 787
 788     for (i=0; i<activeprops; i++) {
 789         if (proplist[i][1]==NULL) proplist[i][1]="";
 790
 791         asm_calljavamethod (m,  p,
 792                                 javastring_new_char(proplist[i][0]),
 793                                 javastring_new_char(proplist[i][1]),
 794                                         NULL
 795                            );
 796         }
 797
 798         return p;
 799 }
 800
 801
 802
 803
 804 /*********************************** java.lang.Thread ***********************************/
 805
 806 struct java_lang_Thread* java_lang_Thread_currentThread ()
 807 {
 808   if (runverbose)
 809     log_text ("java_lang_Thread_currentThread called");
 810 #ifdef USE_THREADS
 811         return (struct java_lang_Thread*)currentThread;
 812 #else
 813         return 0;
 814 #endif
 815 }
 816
 817 void java_lang_Thread_yield ()
 818 {
 819   if (runverbose)
 820     log_text ("java_lang_Thread_yield called");
 821 #ifdef USE_THREADS
 822         yieldThread();
 823 #endif
 824 }
 825
 826 void java_lang_Thread_sleep (s8 par1)
 827 {
 828   if (runverbose)
 829     log_text ("java_lang_Thread_sleep called");
 830 #ifdef USE_THREADS
 831         yieldThread();
 832 #endif
 833         /* not yet implemented */
 834 }
 835
 836 void java_lang_Thread_start (struct java_lang_Thread* this)
 837 {
 838   if (runverbose)
 839     log_text ("java_lang_Thread_start called");
 840 #ifdef USE_THREADS
 841         startThread((thread*)this);
 842 #endif
 843 }
 844
 845 s4 java_lang_Thread_isAlive (struct java_lang_Thread* this)
 846 {
 847   if (runverbose)
 848     log_text ("java_lang_Thread_isAlive called");
 849 #ifdef USE_THREADS
 850         return aliveThread((thread*)this);
 851 #else
 852         return 0;
 853 #endif
 854 }
 855
 856 s4 java_lang_Thread_countStackFrames (struct java_lang_Thread* this)
 857 {
 858   log_text ("java_lang_Thread_countStackFrames called");
 859   return 0;         /* not yet implemented */
 860 }
 861
 862 void java_lang_Thread_setPriority0 (struct java_lang_Thread* this, s4 par1)
 863 {
 864   if (runverbose)
 865     log_text ("java_lang_Thread_setPriority0 called");
 866 #ifdef USE_THREADS
 867   setPriorityThread((thread*)this, par1);
 868 #endif
 869 }
 870
 871 void java_lang_Thread_stop0 (struct java_lang_Thread* this, struct java_lang_Object* par1)
 872 {
 873   if (runverbose)
 874     log_text ("java_lang_Thread_stop0 called");
 875 #ifdef USE_THREADS
 876         if (currentThread == (thread*)this)
 877         {
 878             log_text("killing");
 879             killThread(0);
 880             /*
 881                 exceptionptr = proto_java_lang_ThreadDeath;
 882                 return;
 883             */
 884         }
 885         else
 886         {
 887                 CONTEXT((thread*)this).flags |= THREAD_FLAGS_KILLED;
 888                 resumeThread((thread*)this);
 889         }
 890 #endif
 891 }
 892
 893 void java_lang_Thread_suspend0 (struct java_lang_Thread* this)
 894 {
 895   if (runverbose)
 896     log_text ("java_lang_Thread_suspend0 called");
 897 #ifdef USE_THREADS
 898         suspendThread((thread*)this);
 899 #endif
 900 }
 901
 902 void java_lang_Thread_resume0 (struct java_lang_Thread* this)
 903 {
 904   if (runverbose)
 905     log_text ("java_lang_Thread_resume0 called");
 906 #ifdef USE_THREADS
 907         resumeThread((thread*)this);
 908 #endif
 909 }
 910
 911
 912
 913 /************************************ java.lang.Throwable *********************************/
 914
 915 void java_lang_Throwable_printStackTrace0 (struct java_lang_Throwable* this, struct java_io_PrintStream* par1)
 916 {
 917         log_text ("java_lang_Throwable_printStackTrace0 called");
 918         return;
 919 }
 920
 921 struct java_lang_Throwable* java_lang_Throwable_fillInStackTrace (struct java_lang_Throwable *this)
 922 {
 923         this -> detailMessage =
 924           (java_lang_String*) (javastring_new_char ("no backtrace info!") );
 925         return this;
 926 }
 927