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                          Philipp Tomsich         EMAIL: cacao@complang.tuwien.ac.at
  13
  14         Last Change: $Id: lang.c 115 1999-01-20 01:52:45Z phil $
  15
  16 *******************************************************************************/
  17
  18 #include <math.h>
  19 #include <string.h>
  20 #include <assert.h>
  21 #include <sys/time.h>
  22
  23 #include "../threads/thread.h"                       /* schani */
  24 #include "../threads/locks.h"
  25
  26 static void use_class_as_object (classinfo *c)
  27 {
  28         c->header.vftbl = class_java_lang_Class -> vftbl;
  29 }
  30
  31
  32 /************************************** java.lang.Object ***********************************/
  33
  34 struct java_lang_Class* java_lang_Object_getClass (struct java_lang_Object* this)
  35 {
  36         classinfo *c = this->header.vftbl -> class;
  37         use_class_as_object (c);
  38         return (java_lang_Class*) c;
  39 }
  40
  41 s4 java_lang_Object_hashCode (struct java_lang_Object* this)
  42 {
  43         return ((char*) this) - ((char*) 0);
  44 }
  45
  46
  47 struct java_lang_Object* java_lang_Object_clone (struct java_lang_Object* this)
  48 {
  49         classinfo *c;
  50         java_lang_Object *new;
  51
  52         if (((java_objectheader*)this)->vftbl->class == class_array)
  53           {
  54             static u4 multiplicator[10];
  55             static int is_initialized = 0;
  56
  57             java_arrayheader *array = (java_arrayheader*)this;
  58             u4 size;
  59
  60             if (!is_initialized)
  61               {
  62                 multiplicator[ARRAYTYPE_INT] = sizeof(s4);
  63                 multiplicator[ARRAYTYPE_LONG] = sizeof(s8);
  64                 multiplicator[ARRAYTYPE_FLOAT] = sizeof(float);
  65                 multiplicator[ARRAYTYPE_DOUBLE] = sizeof(double);
  66                 multiplicator[ARRAYTYPE_BYTE] = sizeof(s1);
  67                 multiplicator[ARRAYTYPE_CHAR] = sizeof(u2);
  68                 multiplicator[ARRAYTYPE_SHORT] = sizeof(s2);
  69                 multiplicator[ARRAYTYPE_BOOLEAN] = sizeof(u1);
  70                 multiplicator[ARRAYTYPE_OBJECT] = sizeof(void*);
  71                 multiplicator[ARRAYTYPE_ARRAY] = sizeof(void*);
  72                 is_initialized = 1;
  73               }
  74
  75             size = sizeof(java_arrayheader)
  76               + array->size * multiplicator[array->arraytype];
  77
  78             new = (java_lang_Object*)heap_allocate(size, false, NULL);
  79             memcpy(new, this, size);
  80
  81             return new;
  82           }
  83         else
  84           {
  85             if (! builtin_instanceof ((java_objectheader*) this, class_java_lang_Cloneable) ) {
  86                 exceptionptr = native_new_and_init (class_java_lang_CloneNotSupportedException);
  87                 return NULL;
  88                 }
  89
  90         c = this -> header.vftbl -> class;
  91         new = (java_lang_Object*) builtin_new (c);
  92         if (!new) {
  93                 exceptionptr = proto_java_lang_OutOfMemoryError;
  94                 return NULL;
  95                 }
  96
  97             memcpy (new, this, c->instancesize);
  98             return new;
  99           }
 100 }
 101
 102 void java_lang_Object_notify (struct java_lang_Object* this)
 103 {
 104         if (runverbose)
 105                 log_text ("java_lang_Object_notify called");
 106
 107 #ifdef USE_THREADS
 108     signal_cond_for_object(&this->header);
 109 #endif
 110 }
 111
 112 void java_lang_Object_notifyAll (struct java_lang_Object* this)
 113 {
 114         if (runverbose)
 115                 log_text ("java_lang_Object_notifyAll called");
 116
 117 #ifdef USE_THREADS
 118         broadcast_cond_for_object(&this->header);
 119 #endif
 120 }
 121
 122 void java_lang_Object_wait (struct java_lang_Object* this, s8 time)
 123 {
 124         if (runverbose)
 125                 log_text ("java_lang_Object_wait called");
 126
 127 #ifdef USE_THREADS
 128         wait_cond_for_object(&this->header, time);
 129 #endif
 130 }
 131
 132
 133 /********************************** java.lang.Class **************************************/
 134
 135
 136 struct java_lang_Class* java_lang_Class_forName (struct java_lang_String* s)
 137 {
 138         java_chararray *a,*b;
 139         u4 i;
 140         unicode *u;
 141         classinfo *c;
 142
 143         if (!s) return NULL;
 144         if (!(a = s->value) ) return NULL;
 145         b = builtin_newarray_char (s->count);
 146         if (!b) return NULL;
 147         for (i=0; i<s->count; i++) {
 148                 if (a->data[s->offset+i]=='.') b->data[i] = '/';
 149             else                           b->data[i] = a->data[s->offset+i];
 150             }
 151         u = unicode_new_u2 (b->data, b->header.size);
 152         c = u->class;
 153         if (!c) {
 154                 c = loader_load (u);
 155                 loader_initclasses ();
 156
 157                 if (!c) {
 158                         exceptionptr =
 159                         native_new_and_init (class_java_lang_ClassNotFoundException);
 160
 161                         return NULL;
 162                         }
 163
 164                 }
 165
 166         use_class_as_object (c);
 167         return (java_lang_Class*) c;
 168 }
 169
 170 struct java_lang_Object* java_lang_Class_newInstance (struct java_lang_Class* this)
 171 {
 172         java_objectheader *o = native_new_and_init ((classinfo*) this);
 173         if (!o) {
 174                 exceptionptr =
 175                         native_new_and_init (class_java_lang_InstantiationException);
 176                 }
 177         return (java_lang_Object*) o;
 178 }
 179
 180 struct java_lang_String* java_lang_Class_getName (struct java_lang_Class* this)
 181 {
 182         u4 i;
 183         classinfo *c = (classinfo*) this;
 184         java_lang_String *s = (java_lang_String*) javastring_new(c->name);
 185
 186         if (!s) return NULL;
 187
 188         for (i=0; i<s->value->header.size; i++) {
 189                 if (s->value->data[i] == '/') s->value->data[i] = '.';
 190                 }
 191
 192         return s;
 193 }
 194
 195 struct java_lang_Class* java_lang_Class_getSuperclass (struct java_lang_Class* this)
 196 {
 197         classinfo *c = ((classinfo*) this) -> super;
 198         if (!c) return NULL;
 199
 200         use_class_as_object (c);
 201         return (java_lang_Class*) c;
 202 }
 203
 204 java_objectarray* java_lang_Class_getInterfaces (struct java_lang_Class* this)
 205 {
 206         classinfo *c = (classinfo*) this;
 207         u4 i;
 208         java_objectarray *a = builtin_anewarray (c->interfacescount, class_java_lang_Class);
 209         if (!a) return NULL;
 210         for (i=0; i<c->interfacescount; i++) {
 211                 use_class_as_object (c->interfaces[i]);
 212
 213                 a->data[i] = (java_objectheader*) c->interfaces[i];
 214                 }
 215         return a;
 216 }
 217
 218 struct java_lang_ClassLoader* java_lang_Class_getClassLoader (struct java_lang_Class* this)
 219 {
 220         log_text ("java_lang_Class_getClassLoader called");
 221         return NULL;
 222 }
 223
 224 s4 java_lang_Class_isInterface (struct java_lang_Class* this)
 225 {
 226         classinfo *c = (classinfo*) this;
 227         if (c->flags & ACC_INTERFACE) return 1;
 228         return 0;
 229 }
 230
 231 /************************************ java.lang.ClassLoader *******************************/
 232
 233
 234 struct java_lang_Class* java_lang_ClassLoader_defineClass (struct java_lang_ClassLoader* this, java_bytearray* par1, s4 par2, s4 par3)
 235 {
 236         log_text ("java_lang_ClassLoader_defineClass called");
 237         return NULL;
 238 }
 239 void java_lang_ClassLoader_resolveClass (struct java_lang_ClassLoader* this, struct java_lang_Class* par1)
 240 {
 241         log_text ("java_lang_ClassLoader_resolveClass called");
 242 }
 243 struct java_lang_Class* java_lang_ClassLoader_findSystemClass (struct java_lang_ClassLoader* this, struct java_lang_String* par1)
 244 {
 245         log_text ("java_lang_ClassLoader_findSystemClass called");
 246         return NULL;
 247 }
 248 void java_lang_ClassLoader_init (struct java_lang_ClassLoader* this)
 249 {
 250         log_text ("java_lang_ClassLoader_init called");
 251 }
 252 struct java_lang_Class* java_lang_ClassLoader_findSystemClass0 (struct java_lang_ClassLoader* this, struct java_lang_String* par1)
 253 {
 254         log_text ("java_lang_ClassLoader_findSystemClass0 called");
 255         return NULL;
 256 }
 257
 258 struct java_lang_Class* java_lang_ClassLoader_defineClass0 (struct java_lang_ClassLoader* this, java_bytearray* par1, s4 par2, s4 par3)
 259 {
 260         log_text ("java_lang_ClassLoader_defineClass0 called");
 261         return NULL;
 262 }
 263 void java_lang_ClassLoader_resolveClass0 (struct java_lang_ClassLoader* this, struct java_lang_Class* par1)
 264 {
 265         log_text ("java_lang_ClassLoader_resolveClass0 called");
 266         return;
 267 }
 268
 269 /************************************** java.lang.Compiler  *******************************/
 270
 271 void java_lang_Compiler_initialize ()
 272 {
 273         log_text ("java_lang_Compiler_initialize called");
 274 }
 275 s4 java_lang_Compiler_compileClass (struct java_lang_Class* par1)
 276 {
 277         log_text ("java_lang_Compiler_compileClass called");
 278         return 0;
 279 }
 280 s4 java_lang_Compiler_compileClasses (struct java_lang_String* par1)
 281 {
 282         log_text ("java_lang_Compiler_compileClasses called");
 283         return 0;
 284 }
 285 struct java_lang_Object* java_lang_Compiler_command (struct java_lang_Object* par1)
 286 {
 287         log_text ("java_lang_Compiler_command called");
 288         return NULL;
 289 }
 290 void java_lang_Compiler_enable ()
 291 {
 292         log_text ("java_lang_Compiler_enable called");
 293 }
 294 void java_lang_Compiler_disable ()
 295 {
 296         log_text ("java_lang_Compiler_disable called");
 297 }
 298
 299
 300 /******************************** java.lang.Double **************************************/
 301
 302 struct java_lang_String* java_lang_Double_toString (double par1)
 303 {
 304         char b[400];
 305         sprintf (b, "%-.6g", par1);
 306         return (java_lang_String*) javastring_new_char (b);
 307 }
 308 struct java_lang_Double* java_lang_Double_valueOf (struct java_lang_String* par1)
 309 {
 310         float val;
 311         java_lang_Double *d = (java_lang_Double*) builtin_new (class_java_lang_Double);
 312         if (d) {
 313                 sscanf (javastring_tochar((java_objectheader*) par1), "%f", &val);
 314                 d->value = val;
 315                 return d;
 316         }
 317         return NULL;
 318 }
 319 s8 java_lang_Double_doubleToLongBits (double par1)
 320 {
 321         s8 l;
 322         double d = par1;
 323         memcpy ((u1*) &l, (u1*) &d, 8);
 324         return l;
 325 }
 326 double java_lang_Double_longBitsToDouble (s8 par1)
 327 {
 328         s8 l = par1;
 329         double d;
 330         memcpy ((u1*) &d, (u1*) &l, 8);
 331         return d;
 332 }
 333
 334 /******************************** java.lang.Float ***************************************/
 335
 336 struct java_lang_String* java_lang_Float_toString (float par1)
 337 {
 338         char b[50];
 339         sprintf (b, "%-.6g", (double) par1);
 340         return (java_lang_String*) javastring_new_char (b);
 341 }
 342 struct java_lang_Float* java_lang_Float_valueOf (struct java_lang_String* par1)
 343 {
 344         float val;
 345         java_lang_Float *d = (java_lang_Float*) builtin_new (class_java_lang_Float);
 346         if (d) {
 347                 sscanf (javastring_tochar((java_objectheader*) par1), "%f", &val);
 348                 d->value = val;
 349                 return d;
 350         }
 351         return NULL;
 352 }
 353 s4 java_lang_Float_floatToIntBits (float par1)
 354 {
 355         s4 i;
 356         float f = par1;
 357         memcpy ((u1*) &i, (u1*) &f, 4);
 358         return i;
 359 }
 360 float java_lang_Float_intBitsToFloat (s4 par1)
 361 {
 362         s4 i = par1;
 363         float f;
 364         memcpy ((u1*) &f, (u1*) &i, 4);
 365         return f;
 366 }
 367
 368
 369 /******************************** java.lang.Math ****************************************/
 370
 371 double java_lang_Math_sin (double par1)
 372 {
 373         return sin(par1);
 374 }
 375
 376 double java_lang_Math_cos (double par1)
 377 {
 378         return cos(par1);
 379 }
 380
 381 double java_lang_Math_tan (double par1)
 382 {
 383         return tan(par1);
 384 }
 385
 386 double java_lang_Math_asin (double par1)
 387 {
 388         return asin(par1);
 389 }
 390
 391 double java_lang_Math_acos (double par1)
 392 {
 393         return acos(par1);
 394 }
 395
 396 double java_lang_Math_atan (double par1)
 397 {
 398         return atan(par1);
 399 }
 400
 401 double java_lang_Math_exp (double par1)
 402 {
 403         return exp(par1);
 404 }
 405
 406 double java_lang_Math_log (double par1)
 407 {
 408         if (par1<0.0) {
 409                 exceptionptr = proto_java_lang_ArithmeticException;
 410                 return 0.0;
 411                 }
 412         return log(par1);
 413 }
 414
 415 double java_lang_Math_sqrt (double par1)
 416 {
 417         if (par1<0.0) {
 418                 exceptionptr = proto_java_lang_ArithmeticException;
 419                 return 0.0;
 420                 }
 421         return sqrt(par1);
 422 }
 423
 424 static u8 dbl_nan    = 0xffffffffffffffffL ;
 425
 426 #define DBL_NAN    (*((double*) (&dbl_nan)))
 427
 428 double java_lang_Math_IEEEremainder (double a, double b)
 429 {
 430         double d;
 431         if (finite(a) && finite(b)) {
 432                 d = a / b;
 433                 if (finite(d))
 434                         return a - floor(d) * b;
 435                 return DBL_NAN;
 436                 }
 437         if (isnan(b))
 438                 return DBL_NAN;
 439         if (finite(a))
 440                 return a;
 441         return DBL_NAN;
 442 }
 443
 444 double java_lang_Math_ceil (double par1)
 445 {
 446         return ceil(par1);
 447 }
 448
 449 double java_lang_Math_floor (double par1)
 450 {
 451         return floor(par1);
 452 }
 453
 454 double java_lang_Math_rint (double par1)
 455 {
 456         return rint(par1); /* phil, 1998/12/12 */
 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