nat/System.c

   1 /* class: java/lang/System */
   2
   3 /*
   4  * Class:     java/lang/System
   5  * Method:    currentTimeMillis
   6  * Signature: ()J
   7  */
   8 JNIEXPORT s8 JNICALL Java_java_lang_System_currentTimeMillis ( JNIEnv *env )
   9 {
  10         struct timeval tv;
  11
  12         (void) gettimeofday(&tv, NULL);
  13         return ((s8) tv.tv_sec) * 1000 + tv.tv_usec / 1000;
  14 }
  15
  16 /*
  17  * Class:     java/lang/System
  18  * Method:    arraycopy
  19  * Signature: (Ljava/lang/Object;ILjava/lang/Object;II)V
  20  */
  21 JNIEXPORT void JNICALL Java_java_lang_System_arraycopy (JNIEnv *env, struct java_lang_Object* source, s4 sp, struct java_lang_Object* dest, s4 dp, s4 len)
  22 {
  23         s4 i;
  24         java_arrayheader *s = (java_arrayheader*) source;
  25         java_arrayheader *d = (java_arrayheader*) dest;
  26
  27         if (((s == NULL) | (d == NULL)) != 0) {
  28                 exceptionptr = proto_java_lang_NullPointerException;
  29                 return;
  30                 }
  31
  32         if (s->objheader.vftbl->class != class_array) {
  33                 exceptionptr = proto_java_lang_ArrayStoreException;
  34                 return;
  35                 }
  36
  37         if (((sp<0) | (sp+len > s->size) | (dp<0) | (dp+len > d->size)) != 0) {
  38                 exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
  39                 return;
  40                 }
  41
  42 /*          if (s->arraytype != d->arraytype) { */
  43 /*            exceptionptr = proto_java_lang_ArrayStoreException;  */
  44 /*            return;  */
  45 /*          } */
  46
  47         switch (s->arraytype) {
  48         case ARRAYTYPE_BYTE:
  49                 if (s->objheader.vftbl != d->objheader.vftbl) {
  50                         exceptionptr = proto_java_lang_ArrayStoreException;
  51                         return;
  52                         }
  53                 memmove(((java_bytearray*) d)->data + dp,
  54                         ((java_bytearray*) s)->data + sp,
  55                         (size_t) len);
  56                 return;
  57         case ARRAYTYPE_BOOLEAN:
  58                 if (s->objheader.vftbl != d->objheader.vftbl) {
  59                         exceptionptr = proto_java_lang_ArrayStoreException;
  60                         return;
  61                         }
  62                 memmove(((java_booleanarray*) d)->data + dp,
  63                         ((java_booleanarray*) s)->data + sp,
  64                         (size_t) len);
  65                 return;
  66         case ARRAYTYPE_CHAR:
  67                 if (s->objheader.vftbl != d->objheader.vftbl) {
  68                         exceptionptr = proto_java_lang_ArrayStoreException;
  69                         return;
  70                         }
  71                 memmove(((java_chararray*) d)->data + dp,
  72                         ((java_chararray*) s)->data + sp,
  73                         (size_t) len * sizeof(u2));
  74                 return;
  75         case ARRAYTYPE_SHORT:
  76                 if (s->objheader.vftbl != d->objheader.vftbl) {
  77                         exceptionptr = proto_java_lang_ArrayStoreException;
  78                         return;
  79                         }
  80                 memmove(((java_shortarray*) d)->data + dp,
  81                         ((java_shortarray*) s)->data + sp,
  82                         (size_t) len * sizeof(s2));
  83                 return;
  84         case ARRAYTYPE_INT:
  85                 if (s->objheader.vftbl != d->objheader.vftbl) {
  86                         exceptionptr = proto_java_lang_ArrayStoreException;
  87                         return;
  88                         }
  89                 memmove(((java_intarray*) d)->data + dp,
  90                         ((java_intarray*) s)->data + sp,
  91                         (size_t) len * sizeof(s4));
  92                 return;
  93         case ARRAYTYPE_LONG:
  94                 if (s->objheader.vftbl != d->objheader.vftbl) {
  95                         exceptionptr = proto_java_lang_ArrayStoreException;
  96                         return;
  97                         }
  98                 memmove(((java_longarray*) d)->data + dp,
  99                         ((java_longarray*) s)->data + sp,
 100                         (size_t) len * sizeof(s8));
 101                 return;
 102         case ARRAYTYPE_FLOAT:
 103                 if (s->objheader.vftbl != d->objheader.vftbl) {
 104                         exceptionptr = proto_java_lang_ArrayStoreException;
 105                         return;
 106                         }
 107                 memmove(((java_floatarray*) d)->data + dp,
 108                         ((java_floatarray*) s)->data + sp,
 109                         (size_t) len * sizeof(float));
 110                 return;
 111         case ARRAYTYPE_DOUBLE:
 112                 if (s->objheader.vftbl != d->objheader.vftbl) {
 113                         exceptionptr = proto_java_lang_ArrayStoreException;
 114                         return;
 115                         }
 116                 memmove(((java_doublearray*) d)->data + dp,
 117                         ((java_doublearray*) s)->data + sp,
 118                         (size_t) len * sizeof(double));
 119                 return;
 120         case ARRAYTYPE_OBJECT:
 121                 {
 122                 java_objectarray *oas = (java_objectarray*) s;
 123                 java_objectarray *oad = (java_objectarray*) d;
 124
 125                 if (d->objheader.vftbl->class != class_array) {
 126                         exceptionptr = proto_java_lang_ArrayStoreException;
 127                         return;
 128                         }
 129                 if (s->arraytype != d->arraytype) {
 130                         exceptionptr = proto_java_lang_ArrayStoreException;
 131                         return;
 132                         }
 133
 134                 if (dp<=sp)
 135                         for (i=0; i<len; i++) {
 136                                 java_objectheader *o = oas->data[sp+i];
 137                                 if (!builtin_canstore(oad, o)) {
 138                                         exceptionptr = proto_java_lang_ArrayStoreException;
 139                                         return;
 140                                         }
 141                                 oad->data[dp+i] = o;
 142                                 }
 143                 else
 144                         for (i=len-1; i>=0; i--) {
 145                                 java_objectheader *o = oas->data[sp+i];
 146                                 if (!builtin_canstore(oad, o)) {
 147                                         exceptionptr = proto_java_lang_ArrayStoreException;
 148                                         return;
 149                                         }
 150                                 oad->data[dp+i] = o;
 151                                 }
 152
 153                 }
 154                 break;
 155         case ARRAYTYPE_ARRAY:
 156                 {
 157                 java_arrayarray *aas = (java_arrayarray*) s;
 158                 java_arrayarray *aad = (java_arrayarray*) d;
 159
 160                 if (d->objheader.vftbl->class != class_array) {
 161                         exceptionptr = proto_java_lang_ArrayStoreException;
 162                         return;
 163                         }
 164                 if (s->arraytype != d->arraytype) {
 165                         exceptionptr = proto_java_lang_ArrayStoreException;
 166                         return;
 167                         }
 168
 169                 if (dp<=sp)
 170                         for (i=0; i<len; i++) {
 171                                 java_arrayheader *o = aas->data[sp+i];
 172                                 if (!builtin_canstore( (java_objectarray*)aad,
 173                                         (java_objectheader*)o )) {
 174                                         exceptionptr = proto_java_lang_ArrayStoreException;
 175                                         return;
 176                                         }
 177                                 aad->data[dp+i] = o;
 178                                 }
 179                 else
 180                         for (i=len-1; i>=0; i--) {
 181                                 java_arrayheader *o = aas->data[sp+i];
 182                                 if (!builtin_canstore( (java_objectarray*)aad,
 183                                         (java_objectheader*)o )) {
 184                                         exceptionptr = proto_java_lang_ArrayStoreException;
 185                                         return;
 186                                         }
 187                                 aad->data[dp+i] = o;
 188                                 }
 189
 190                 }
 191                 break;
 192
 193         default:
 194                 panic ("Unknown data type for arraycopy");
 195         }
 196 }
 197
 198 #define MAXPROPS 100
 199 static int activeprops = 15;
 200
 201 static char *proplist[MAXPROPS][2] = {
 202         { "java.class.path", NULL },
 203         { "java.home", NULL },
 204         { "user.home", NULL },
 205         { "user.name", NULL },
 206         { "user.dir",  NULL },
 207
 208         { "os.arch", NULL },
 209         { "os.name", NULL },
 210         { "os.version", NULL },
 211
 212         { "java.class.version", "45.3" },
 213         { "java.version", PACKAGE":"VERSION },
 214         { "java.vendor", "CACAO Team" },
 215         { "java.vendor.url", "http://www.complang.tuwien.ac.at/java/cacao/" },
 216         { "path.separator", ":" },
 217         { "file.separator", "/" },
 218         { "line.separator", "\n" }
 219 };
 220
 221 void attach_property (char *name, char *value)
 222 {
 223         if (activeprops >= MAXPROPS) panic ("Too many properties defined");
 224         proplist[activeprops][0] = name;
 225         proplist[activeprops][1] = value;
 226         activeprops++;
 227 }
 228
 229 /*
 230  * Class:     java/lang/System
 231  * Method:    initProperties
 232  * Signature: (Ljava/util/Properties;)Ljava/util/Properties;
 233  */
 234 JNIEXPORT struct java_util_Properties* JNICALL Java_java_lang_System_initProperties (JNIEnv *env,struct java_util_Properties* p)
 235 {
 236         #define BUFFERSIZE 200
 237         u4 i;
 238         methodinfo *m;
 239         char buffer[BUFFERSIZE];
 240         java_objectheader *o;
 241         struct utsname utsnamebuf;
 242
 243         proplist[0][1] = classpath;
 244         proplist[1][1] = getenv("JAVA_HOME");
 245         proplist[2][1] = getenv("HOME");
 246         proplist[3][1] = getenv("USER");
 247         proplist[4][1] = getcwd(buffer,BUFFERSIZE);
 248
 249         /* get properties from system */
 250         uname(&utsnamebuf);
 251         proplist[5][1] = utsnamebuf.machine;
 252         proplist[6][1] = utsnamebuf.sysname;
 253         proplist[7][1] = utsnamebuf.release;
 254
 255         if (!p) panic ("initProperties called with NULL-Argument");
 256
 257         /* search for method to add properties */
 258         m = class_resolvemethod (
 259                 p->header.vftbl->class,
 260                 utf_new_char ("put"),
 261                 utf_new_char ("(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;")
 262         );
 263
 264         if (!m) panic ("Can not find method 'put' for class Properties");
 265
 266         /* add the properties */
 267         for (i=0; i<activeprops; i++) {
 268
 269             if (proplist[i][1]==NULL) proplist[i][1]="";
 270
 271             asm_calljavamethod(m,  p,
 272                                 javastring_new_char(proplist[i][0]),
 273                                 javastring_new_char(proplist[i][1]),
 274                                         NULL
 275                                 );
 276         }
 277
 278         return p;
 279
 280 }
 281
 282
 283 JNIEXPORT void JNICALL Java_java_lang_System_registerNatives (JNIEnv *env )
 284 {
 285     /* empty */
 286 }
 287
 288 /*
 289  * Class:     java/lang/System
 290  * Method:    setErr0
 291  * Signature: (Ljava/io/PrintStream;)V
 292  */
 293 JNIEXPORT void JNICALL Java_java_lang_System_setErr0 (JNIEnv *env , struct java_io_PrintStream* stream)
 294 {
 295     /* set static field 'err' of class java.lang.System */
 296
 297     jfieldID fid =
 298         env->GetStaticFieldID(env,class_java_lang_System,"err","Ljava/io/PrintStream;");
 299
 300     if (!fid) panic("unable to access static field of class System");
 301
 302     env->SetStaticObjectField(env,class_java_lang_System,fid,(jobject) stream);
 303 }
 304
 305 /*
 306  * Class:     java/lang/System
 307  * Method:    setIn0
 308  * Signature: (Ljava/io/InputStream;)V
 309  */
 310 JNIEXPORT void JNICALL Java_java_lang_System_setIn0 (JNIEnv *env , struct java_io_InputStream* stream)
 311 {
 312     /* set static field 'in' of class java.lang.System */
 313
 314     jfieldID fid =
 315         env->GetStaticFieldID(env,class_java_lang_System,"in","Ljava/io/InputStream;");
 316
 317     if (!fid) panic("unable to access static field of class System");
 318
 319     env->SetStaticObjectField(env,class_java_lang_System,fid,(jobject) stream);
 320 }
 321
 322 /*
 323  * Class:     java/lang/System
 324  * Method:    setOut0
 325  * Signature: (Ljava/io/PrintStream;)V
 326  */
 327 JNIEXPORT void JNICALL Java_java_lang_System_setOut0 (JNIEnv *env , struct java_io_PrintStream* stream)
 328 {
 329     /* set static field 'out' of class java.lang.System */
 330
 331     jfieldID fid =
 332         env->GetStaticFieldID(env,class_java_lang_System,"out","Ljava/io/PrintStream;");
 333
 334     if (!fid) panic("unable to access static field of class System");
 335
 336     env->SetStaticObjectField(env,class_java_lang_System,fid,(jobject) stream);
 337 }
 338
 339 /*
 340  * Class:     java/lang/System
 341  * Method:    mapLibraryName
 342  * Signature: (Ljava/lang/String;)Ljava/lang/String;
 343  */
 344 JNIEXPORT struct java_lang_String* JNICALL Java_java_lang_System_mapLibraryName (JNIEnv *env , struct java_lang_String* s)
 345 {
 346   char somefile[MAXSTRINGSIZE];
 347   char *java_home;
 348
 349   /* return name of any file that exists (relative to root),
 350      so ClassLoader believes we dynamically load the native library */
 351
 352   if (strlen(classpath)+24>MAXSTRINGSIZE)
 353     panic("filename too long");
 354
 355   java_home = getenv("JAVA_HOME");
 356   if (java_home == 0)
 357       java_home = "/tmp";
 358   strcpy(somefile,java_home);
 359   strcat(somefile,"/dummy");
 360
 361   return (java_lang_String* ) javastring_new_char(&somefile[1]);
 362 }
 363
 364
 365
 366 /*
 367  * Class:     java/lang/System
 368  * Method:    getCallerClass
 369  * Signature: ()Ljava/lang/Class;
 370  */
 371 JNIEXPORT struct java_lang_Class* JNICALL Java_java_lang_System_getCallerClass (JNIEnv *env )
 372 {
 373   /* determine the callerclass by getting the method which called getCallerClass */
 374   classinfo *c;
 375   methodinfo *m = asm_getcallingmethod();
 376
 377   if (m && (c = m->class)) {
 378           use_class_as_object (c);
 379           return (java_lang_Class*) c;
 380   }
 381
 382   /* caller class could not be determined */
 383   return NULL;
 384 }
 385
 386 /*
 387  * Class:     java/lang/System
 388  * Method:    identityHashCode
 389  * Signature: (Ljava/lang/Object;)I
 390  */
 391 JNIEXPORT s4 JNICALL Java_java_lang_System_identityHashCode (JNIEnv *env , struct java_lang_Object* par1)
 392 {
 393         return ((char*) par1) - ((char*) 0);
 394 }
 395
 396
 397
 398