jni.c

   1 /********************************** jni.c *****************************************
   2
   3         implementation of the Java Native Interface functions
   4         which are used in the JNI function table
   5
   6 ***********************************************************************************/
   7
   8
   9 #define JNI_VERSION       0x00010002
  10
  11
  12 /********************* accessing instance-fields **********************************/
  13
  14 #define setField(obj,typ,var,val) *((typ*) ((long int) obj + (long int) var->offset))=val;
  15 #define getField(obj,typ,var)     *((typ*) ((long int) obj + (long int) var->offset))
  16 #define setfield_critical(clazz,obj,name,sig,jdatatype,val) setField(obj,jdatatype,getFieldID_critical(env,clazz,name,sig),val);
  17
  18 /*************************** function: jclass_findfield ****************************
  19
  20         searches for field with specified name and type in a 'classinfo'-structur
  21         if no such field is found NULL is returned
  22
  23 ************************************************************************************/
  24
  25 fieldinfo *jclass_findfield (classinfo *c, utf *name, utf *desc)
  26 {
  27         s4 i;
  28         for (i = 0; i < c->fieldscount; i++) {
  29                 if ((c->fields[i].name == name) && (c->fields[i].descriptor == desc))
  30                         return &(c->fields[i]);
  31                 }
  32
  33         return NULL;
  34 }
  35
  36 /********************* returns version of native method interface *****************/
  37
  38 jint GetVersion (JNIEnv* env)
  39 {
  40         return JNI_VERSION;
  41 }
  42
  43 /****************** loads a class from a buffer of raw class data *****************/
  44
  45 jclass DefineClass(JNIEnv* env, const char *name, jobject loader, const jbyte *buf, jsize len)
  46 {
  47         jclass clazz;
  48
  49         /* change suck-mode, so subsequent class_load will read from memory-buffer */
  50         classload_buffer( (u1*) buf,len);
  51
  52         clazz = loader_load(utf_new_char ((char *) name));
  53
  54         /* restore old suck-mode */
  55         classload_buffer(NULL,0);
  56
  57         return clazz;
  58 }
  59
  60
  61 /*************** loads locally defined class with the specified name **************/
  62
  63 jclass FindClass (JNIEnv* env, const char *name)
  64 {
  65         classinfo *c;
  66
  67         c = loader_load(utf_new_char ((char *) name));
  68
  69         if (!c) exceptionptr = native_new_and_init(class_java_lang_ClassFormatError);
  70
  71         return c;
  72 }
  73
  74
  75 /***********************************************************************************
  76
  77         converts java.lang.reflect.Method or
  78         java.lang.reflect.Constructor object to a method ID
  79
  80  **********************************************************************************/
  81
  82 jmethodID FromReflectedMethod (JNIEnv* env, jobject method)
  83 {
  84         log_text("JNI-Call: FromReflectedMethod");
  85 }
  86
  87
  88 /*************** return superclass of the class represented by sub ****************/
  89
  90 jclass GetSuperclass (JNIEnv* env, jclass sub)
  91 {
  92         classinfo *c;
  93
  94         c = ((classinfo*) sub) -> super;
  95
  96         if (!c) return NULL;
  97         use_class_as_object (c);
  98         return c;
  99 }
 100
 101
 102 /*********************** check whether sub can be cast to sup  ********************/
 103
 104 jboolean IsAssignableForm (JNIEnv* env, jclass sub, jclass sup)
 105 {
 106         return builtin_isanysubclass(sub,sup);
 107 }
 108
 109
 110 /***** converts a field ID derived from cls to a java.lang.reflect.Field object ***/
 111
 112 jobject ToReflectedField (JNIEnv* env, jclass cls, jfieldID fieldID, jboolean isStatic)
 113 {
 114         log_text("JNI-Call: ToReflectedField");
 115 }
 116
 117
 118 /***************** throw java.lang.Throwable object  ******************************/
 119
 120 jint Throw (JNIEnv* env, jthrowable obj)
 121 {
 122         exceptionptr = (java_objectheader*) obj;
 123         return 0;
 124 }
 125
 126
 127 /***********************************************************************************
 128
 129         create exception object from the class clazz with the
 130         specified message and cause it to be thrown
 131
 132  **********************************************************************************/
 133
 134
 135 jint ThrowNew (JNIEnv* env, jclass clazz, const char *msg)
 136 {
 137         java_lang_Throwable *o;
 138
 139         /* instantiate exception object */
 140         o = (java_lang_Throwable *) native_new_and_init ((classinfo*) clazz);
 141
 142         if (!o) return (-1);
 143
 144         o->detailMessage = (java_lang_String*) javastring_new_char((char *) msg);
 145
 146         exceptionptr = (java_objectheader*) o;
 147         return 0;
 148 }
 149
 150 /************************* check if exception occured *****************************/
 151
 152 jthrowable ExceptionOccurred (JNIEnv* env)
 153 {
 154         return (jthrowable) exceptionptr;
 155 }
 156
 157 /********** print exception and a backtrace of the stack (for debugging) **********/
 158
 159 void ExceptionDescribe (JNIEnv* env)
 160 {
 161         utf_display(exceptionptr->vftbl->class->name);
 162         printf ("\n");
 163         fflush (stdout);
 164 }
 165
 166
 167 /******************* clear any exception currently being thrown *******************/
 168
 169 void ExceptionClear (JNIEnv* env)
 170 {
 171         exceptionptr = NULL;
 172 }
 173
 174
 175 /********** raises a fatal error and does not expect the VM to recover ************/
 176
 177 void FatalError (JNIEnv* env, const char *msg)
 178 {
 179         panic((char *) msg);
 180 }
 181
 182 /******************* creates a new local reference frame **************************/
 183
 184 jint PushLocalFrame (JNIEnv* env, jint capacity)
 185 {
 186         /* empty */
 187 }
 188
 189 /**************** Pops off the current local reference frame **********************/
 190
 191 jobject PopLocalFrame (JNIEnv* env, jobject result)
 192 {
 193         /* empty */
 194 }
 195
 196
 197 /** Creates a new global reference to the object referred to by the obj argument **/
 198
 199 jobject NewGlobalRef (JNIEnv* env, jobject lobj)
 200 {
 201         heap_addreference ( (void**) &lobj);
 202         return lobj;
 203 }
 204
 205 /*************  Deletes the global reference pointed to by globalRef **************/
 206
 207 void DeleteGlobalRef (JNIEnv* env, jobject gref)
 208 {
 209         /* empty */
 210 }
 211
 212
 213 /*************** Deletes the local reference pointed to by localRef ***************/
 214
 215 void DeleteLocalRef (JNIEnv* env, jobject localRef)
 216 {
 217         /* empty */
 218 }
 219
 220 /********** Tests whether two references refer to the same Java object ************/
 221
 222 jboolean IsSameObject (JNIEnv* env, jobject obj1, jobject obj2)
 223 {
 224         return (obj1==obj2);
 225 }
 226
 227 /***** Creates a new local reference that refers to the same object as ref  *******/
 228
 229 jobject NewLocalRef (JNIEnv* env, jobject ref)
 230 {
 231         return ref;
 232 }
 233
 234 /***********************************************************************************
 235
 236         Ensures that at least a given number of local references can
 237         be created in the current thread
 238
 239  **********************************************************************************/
 240
 241 jint EnsureLocalCapacity (JNIEnv* env, jint capacity)
 242 {
 243         return 0; /* return 0 on success */
 244 }
 245
 246
 247 /********* Allocates a new Java object without invoking a constructor *************/
 248
 249 jobject AllocObject (JNIEnv* env, jclass clazz)
 250 {
 251         java_objectheader *o = builtin_new(clazz);
 252         return o;
 253 }
 254
 255
 256 /***********************************************************************************
 257
 258         Constructs a new Java object
 259         arguments that are to be passed to the constructor are placed after methodID
 260
 261 ***********************************************************************************/
 262
 263 jobject NewObject (JNIEnv* env, jclass clazz, jmethodID methodID, ...)
 264 {
 265         log_text("JNI-Call: NewObject");
 266 }
 267
 268 /***********************************************************************************
 269
 270        Constructs a new Java object
 271        arguments that are to be passed to the constructor are placed in va_list args
 272
 273 ***********************************************************************************/
 274
 275 jobject NewObjectV (JNIEnv* env, jclass clazz, jmethodID methodID, va_list args)
 276 {
 277         log_text("JNI-Call: NewObjectV");
 278 }
 279
 280 /***********************************************************************************
 281
 282         Constructs a new Java object
 283         arguments that are to be passed to the constructor are placed in
 284         args array of jvalues
 285
 286 ***********************************************************************************/
 287
 288 jobject NewObjectA (JNIEnv* env, jclass clazz, jmethodID methodID, jvalue *args)
 289 {
 290         log_text("JNI-Call: NewObjectA");
 291 }
 292
 293
 294 /************************ returns the class of an object **************************/
 295
 296 jclass GetObjectClass (JNIEnv* env, jobject obj)
 297 {
 298         classinfo *c = obj->vftbl -> class;
 299         use_class_as_object (c);
 300         return c;
 301 }
 302
 303 /************* tests whether an object is an instance of a class ******************/
 304
 305 jboolean IsInstanceOf (JNIEnv* env, jobject obj, jclass clazz)
 306 {
 307         return builtin_instanceof(obj,clazz);
 308 }
 309
 310
 311 /***************** converts a java.lang.reflect.Field to a field ID ***************/
 312
 313 jfieldID FromReflectedField (JNIEnv* env, jobject field)
 314 {
 315         log_text("JNI-Call: FromReflectedField");
 316 }
 317
 318 /**********************************************************************************
 319
 320         converts a method ID to a java.lang.reflect.Method or
 321         java.lang.reflect.Constructor object
 322
 323 **********************************************************************************/
 324
 325 jobject ToReflectedMethod (JNIEnv* env, jclass cls, jmethodID methodID, jboolean isStatic)
 326 {
 327         log_text("JNI-Call: ToReflectedMethod");
 328 }
 329
 330 /**************** returns the method ID for an instance method ********************/
 331
 332 jmethodID GetMethodID (JNIEnv* env, jclass clazz, const char *name, const char *sig)
 333 {
 334         jmethodID m;
 335
 336         m = class_resolvemethod (
 337                 clazz,
 338                 utf_new_char ((char*) name),
 339                 utf_new_char ((char*) sig)
 340         );
 341
 342         if (!m) exceptionptr = native_new_and_init(class_java_lang_NoSuchMethodError);
 343
 344         return m;
 345 }
 346
 347 /******************** JNI-functions for calling instance methods ******************/
 348
 349 jobject CallObjectMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 350 {
 351         log_text("JNI-Call: CallObjectMethod");
 352
 353         return NULL;
 354 }
 355
 356
 357 jobject CallObjectMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 358 {
 359         log_text("JNI-Call: CallObjectMethodV");
 360
 361         return NULL;
 362 }
 363
 364
 365 jobject CallObjectMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 366 {
 367         log_text("JNI-Call: CallObjectMethodA");
 368
 369         return NULL;
 370 }
 371
 372
 373 jboolean CallBooleanMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 374 {
 375         log_text("JNI-Call: CallBooleanMethod");
 376
 377         return 0;
 378 }
 379
 380 jboolean CallBooleanMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 381 {
 382         log_text("JNI-Call: CallBooleanMethodV");
 383
 384         return 0;
 385 }
 386
 387 jboolean CallBooleanMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 388 {
 389         log_text("JNI-Call: CallBooleanMethodA");
 390
 391         return 0;
 392 }
 393
 394 jbyte CallByteMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 395 {
 396         log_text("JNI-Call: CallByteMethod");
 397
 398         return 0;
 399 }
 400
 401 jbyte CallByteMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 402 {
 403         log_text("JNI-Call: CallByteMethodV");
 404
 405         return 0;
 406 }
 407
 408
 409 jbyte CallByteMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 410 {
 411         log_text("JNI-Call: CallByteMethodA");
 412
 413         return 0;
 414 }
 415
 416
 417 jchar CallCharMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 418 {
 419         log_text("JNI-Call: CallCharMethod");
 420
 421         return 0;
 422 }
 423
 424 jchar CallCharMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 425 {
 426         log_text("JNI-Call: CallCharMethodV");
 427
 428         return 0;
 429 }
 430
 431
 432 jchar CallCharMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 433 {
 434         log_text("JNI-Call: CallCharMethodA");
 435
 436         return 0;
 437 }
 438
 439
 440 jshort CallShortMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 441 {
 442         log_text("JNI-Call: CallShortMethod");
 443
 444         return 0;
 445 }
 446
 447
 448 jshort CallShortMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 449 {
 450         log_text("JNI-Call: CallShortMethodV");
 451
 452         return 0;
 453 }
 454
 455
 456 jshort CallShortMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 457 {
 458         log_text("JNI-Call: CallShortMethodA");
 459
 460         return 0;
 461 }
 462
 463
 464
 465 jint CallIntMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 466 {
 467         log_text("JNI-Call: CallIntMethod");
 468
 469         return 0;
 470 }
 471
 472
 473 jint CallIntMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 474 {
 475         log_text("JNI-Call: CallIntMethodV");
 476
 477         return 0;
 478 }
 479
 480
 481 jint CallIntMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 482 {
 483         log_text("JNI-Call: CallIntMethodA");
 484
 485         return 0;
 486 }
 487
 488
 489
 490 jlong CallLongMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 491 {
 492         log_text("JNI-Call: CallLongMethod");
 493
 494         return 0;
 495 }
 496
 497
 498 jlong CallLongMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 499 {
 500         log_text("JNI-Call: CallLongMethodV");
 501
 502         return 0;
 503 }
 504
 505
 506 jlong CallLongMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 507 {
 508         log_text("JNI-Call: CallLongMethodA");
 509
 510         return 0;
 511 }
 512
 513
 514
 515 jfloat CallFloatMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 516 {
 517         log_text("JNI-Call: CallFloatMethod");
 518
 519         return 0;
 520 }
 521
 522
 523 jfloat CallFloatMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 524 {
 525         log_text("JNI-Call: CallFloatMethodV");
 526
 527         return 0;
 528 }
 529
 530
 531 jfloat CallFloatMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 532 {
 533         log_text("JNI-Call: CallFloatMethodA");
 534
 535         return 0;
 536 }
 537
 538
 539
 540 jdouble CallDoubleMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 541 {
 542         log_text("JNI-Call: CallDoubleMethod");
 543
 544         return 0;
 545 }
 546
 547
 548 jdouble CallDoubleMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 549 {
 550         log_text("JNI-Call: CallDoubleMethodV");
 551
 552         return 0;
 553 }
 554
 555
 556 jdouble CallDoubleMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args)
 557 {
 558         log_text("JNI-Call: CallDoubleMethodA");
 559
 560         return 0;
 561 }
 562
 563
 564
 565 void CallVoidMethod (JNIEnv *env, jobject obj, jmethodID methodID, ...)
 566 {
 567         log_text("JNI-Call: CallVoidMethod");
 568
 569 }
 570
 571
 572 void CallVoidMethodV (JNIEnv *env, jobject obj, jmethodID methodID, va_list args)
 573 {
 574         log_text("JNI-Call: CallVoidMethodV");
 575
 576 }
 577
 578
 579 void CallVoidMethodA (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args)
 580 {
 581         log_text("JNI-Call: CallVoidMethodA");
 582
 583 }
 584
 585
 586
 587 jobject CallNonvirtualObjectMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 588 {
 589         log_text("JNI-Call: CallNonvirtualObjectMethod");
 590
 591         return NULL;
 592 }
 593
 594
 595 jobject CallNonvirtualObjectMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 596 {
 597         log_text("JNI-Call: CallNonvirtualObjectMethodV");
 598
 599         return NULL;
 600 }
 601
 602
 603 jobject CallNonvirtualObjectMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 604 {
 605         log_text("JNI-Call: CallNonvirtualObjectMethodA");
 606
 607         return NULL;
 608 }
 609
 610
 611
 612 jboolean CallNonvirtualBooleanMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 613 {
 614         log_text("JNI-Call: CallNonvirtualBooleanMethod");
 615
 616         return 0;
 617 }
 618
 619
 620 jboolean CallNonvirtualBooleanMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 621 {
 622         log_text("JNI-Call: CallNonvirtualBooleanMethodV");
 623
 624         return 0;
 625 }
 626
 627
 628 jboolean CallNonvirtualBooleanMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 629 {
 630         log_text("JNI-Call: CallNonvirtualBooleanMethodA");
 631
 632         return 0;
 633 }
 634
 635
 636
 637 jbyte CallNonvirtualByteMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 638 {
 639         log_text("JNI-Call: CallNonvirtualByteMethod");
 640
 641         return 0;
 642 }
 643
 644
 645 jbyte CallNonvirtualByteMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 646 {
 647         log_text("JNI-Call: CallNonvirtualByteMethodV");
 648
 649         return 0;
 650 }
 651
 652
 653 jbyte CallNonvirtualByteMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 654 {
 655         log_text("JNI-Call: CallNonvirtualByteMethodA");
 656
 657         return 0;
 658 }
 659
 660
 661
 662 jchar CallNonvirtualCharMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 663 {
 664         log_text("JNI-Call: CallNonvirtualCharMethod");
 665
 666         return 0;
 667 }
 668
 669
 670 jchar CallNonvirtualCharMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 671 {
 672         log_text("JNI-Call: CallNonvirtualCharMethodV");
 673
 674         return 0;
 675 }
 676
 677
 678 jchar CallNonvirtualCharMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 679 {
 680         log_text("JNI-Call: CallNonvirtualCharMethodA");
 681
 682         return 0;
 683 }
 684
 685
 686
 687 jshort CallNonvirtualShortMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 688 {
 689         log_text("JNI-Call: CallNonvirtualShortMethod");
 690
 691         return 0;
 692 }
 693
 694
 695 jshort CallNonvirtualShortMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 696 {
 697         log_text("JNI-Call: CallNonvirtualShortMethodV");
 698
 699         return 0;
 700 }
 701
 702
 703 jshort CallNonvirtualShortMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 704 {
 705         log_text("JNI-Call: CallNonvirtualShortMethodA");
 706
 707         return 0;
 708 }
 709
 710
 711
 712 jint CallNonvirtualIntMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 713 {
 714         log_text("JNI-Call: CallNonvirtualIntMethod");
 715
 716         return 0;
 717 }
 718
 719
 720 jint CallNonvirtualIntMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 721 {
 722         log_text("JNI-Call: CallNonvirtualIntMethodV");
 723
 724         return 0;
 725 }
 726
 727
 728 jint CallNonvirtualIntMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 729 {
 730         log_text("JNI-Call: CallNonvirtualIntMethodA");
 731
 732         return 0;
 733 }
 734
 735
 736
 737 jlong CallNonvirtualLongMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 738 {
 739         log_text("JNI-Call: CallNonvirtualLongMethod");
 740
 741         return 0;
 742 }
 743
 744
 745 jlong CallNonvirtualLongMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 746 {
 747         log_text("JNI-Call: CallNonvirtualLongMethodV");
 748
 749         return 0;
 750 }
 751
 752
 753 jlong CallNonvirtualLongMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 754 {
 755         log_text("JNI-Call: CallNonvirtualLongMethodA");
 756
 757         return 0;
 758 }
 759
 760
 761
 762 jfloat CallNonvirtualFloatMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 763 {
 764         log_text("JNI-Call: CallNonvirtualFloatMethod");
 765
 766         return 0;
 767 }
 768
 769
 770 jfloat CallNonvirtualFloatMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 771 {
 772         log_text("JNI-Call: CallNonvirtualFloatMethodV");
 773
 774         return 0;
 775 }
 776
 777
 778 jfloat CallNonvirtualFloatMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 779 {
 780         log_text("JNI-Call: CallNonvirtualFloatMethodA");
 781
 782         return 0;
 783 }
 784
 785
 786
 787 jdouble CallNonvirtualDoubleMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 788 {
 789         log_text("JNI-Call: CallNonvirtualDoubleMethod");
 790
 791         return 0;
 792 }
 793
 794
 795 jdouble CallNonvirtualDoubleMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 796 {
 797         log_text("JNI-Call: CallNonvirtualDoubleMethodV");
 798
 799         return 0;
 800 }
 801
 802
 803 jdouble CallNonvirtualDoubleMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue *args)
 804 {
 805         log_text("JNI-Call: CallNonvirtualDoubleMethodA");
 806
 807         return 0;
 808 }
 809
 810
 811
 812 void CallNonvirtualVoidMethod (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...)
 813 {
 814         log_text("JNI-Call: CallNonvirtualVoidMethod");
 815 }
 816
 817
 818 void CallNonvirtualVoidMethodV (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, va_list args)
 819 {
 820         log_text("JNI-Call: CallNonvirtualVoidMethodV");
 821 }
 822
 823
 824 void CallNonvirtualVoidMethodA (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, jvalue * args)
 825 {
 826         log_text("JNI-Call: CallNonvirtualVoidMethodA");
 827 }
 828
 829 /************************* JNI-functions for accessing fields ************************/
 830
 831 jfieldID GetFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
 832 {
 833         jfieldID f;
 834
 835         f = jclass_findfield(clazz,
 836                             utf_new_char ((char*) name),
 837                             utf_new_char ((char*) sig)
 838                             );
 839
 840         if (!f) exceptionptr =  native_new_and_init(class_java_lang_NoSuchFieldError);
 841
 842         return f;
 843 }
 844
 845 /*************************** retrieve fieldid, abort on error ************************/
 846
 847 jfieldID getFieldID_critical(JNIEnv *env,jclass clazz,const char *name,const char *sig)
 848 {
 849     jfieldID id = env->GetFieldID(env,clazz,name,sig);
 850     if (!id) panic("setfield_critical failed");
 851     return id;
 852 }
 853
 854 jobject GetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID)
 855 {
 856         return getField(obj,jobject,fieldID);
 857 }
 858
 859 jboolean GetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID)
 860 {
 861         return getField(obj,jboolean,fieldID);
 862 }
 863
 864
 865 jbyte GetByteField (JNIEnv *env, jobject obj, jfieldID fieldID)
 866 {
 867         return getField(obj,jbyte,fieldID);
 868 }
 869
 870
 871 jchar GetCharField (JNIEnv *env, jobject obj, jfieldID fieldID)
 872 {
 873         return getField(obj,jchar,fieldID);
 874 }
 875
 876
 877 jshort GetShortField (JNIEnv *env, jobject obj, jfieldID fieldID)
 878 {
 879         return getField(obj,jshort,fieldID);
 880 }
 881
 882
 883 jint GetIntField (JNIEnv *env, jobject obj, jfieldID fieldID)
 884 {
 885         return getField(obj,jint,fieldID);
 886 }
 887
 888
 889 jlong GetLongField (JNIEnv *env, jobject obj, jfieldID fieldID)
 890 {
 891         return getField(obj,jlong,fieldID);
 892 }
 893
 894
 895 jfloat GetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID)
 896 {
 897         return getField(obj,jfloat,fieldID);
 898 }
 899
 900
 901 jdouble GetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID)
 902 {
 903         return getField(obj,jdouble,fieldID);
 904 }
 905
 906 void SetObjectField (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val)
 907 {
 908         setField(obj,jobject,fieldID,val);
 909 }
 910
 911
 912 void SetBooleanField (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val)
 913 {
 914         setField(obj,jboolean,fieldID,val);
 915 }
 916
 917
 918 void SetByteField (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val)
 919 {
 920         setField(obj,jbyte,fieldID,val);
 921 }
 922
 923
 924 void SetCharField (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val)
 925 {
 926         setField(obj,jchar,fieldID,val);
 927 }
 928
 929
 930 void SetShortField (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val)
 931 {
 932         setField(obj,jshort,fieldID,val);
 933 }
 934
 935
 936 void SetIntField (JNIEnv *env, jobject obj, jfieldID fieldID, jint val)
 937 {
 938         setField(obj,jint,fieldID,val);
 939 }
 940
 941
 942 void SetLongField (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val)
 943 {
 944         setField(obj,jlong,fieldID,val);
 945 }
 946
 947
 948 void SetFloatField (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val)
 949 {
 950         setField(obj,jfloat,fieldID,val);
 951 }
 952
 953
 954 void SetDoubleField (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val)
 955 {
 956         setField(obj,jdouble,fieldID,val);
 957 }
 958
 959 /**************** JNI-functions for calling static methods **********************/
 960
 961 jmethodID GetStaticMethodID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
 962 {
 963         jmethodID m;
 964
 965         m = class_resolvemethod (
 966                 clazz,
 967                 utf_new_char ((char*) name),
 968                 utf_new_char ((char*) sig)
 969         );
 970
 971         if (!m) exceptionptr =  native_new_and_init(class_java_lang_NoSuchMethodError);
 972
 973         return m;
 974 }
 975
 976 jobject CallStaticObjectMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
 977 {
 978         log_text("JNI-Call: CallStaticObjectMethod");
 979
 980         return NULL;
 981 }
 982
 983
 984 jobject CallStaticObjectMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
 985 {
 986         log_text("JNI-Call: CallStaticObjectMethodV");
 987
 988         return NULL;
 989 }
 990
 991
 992 jobject CallStaticObjectMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
 993 {
 994         log_text("JNI-Call: CallStaticObjectMethodA");
 995
 996         return NULL;
 997 }
 998
 999
1000 jboolean CallStaticBooleanMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1001 {
1002         log_text("JNI-Call: CallStaticBooleanMethod");
1003
1004         return 0;
1005 }
1006
1007
1008 jboolean CallStaticBooleanMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1009 {
1010         log_text("JNI-Call: CallStaticBooleanMethodV");
1011
1012         return 0;
1013 }
1014
1015
1016 jboolean CallStaticBooleanMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1017 {
1018         log_text("JNI-Call: CallStaticBooleanMethodA");
1019
1020         return 0;
1021 }
1022
1023
1024 jbyte CallStaticByteMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1025 {
1026         log_text("JNI-Call: CallStaticByteMethod");
1027
1028         return 0;
1029 }
1030
1031
1032 jbyte CallStaticByteMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1033 {
1034         log_text("JNI-Call: CallStaticByteMethodV");
1035
1036         return 0;
1037 }
1038
1039
1040 jbyte CallStaticByteMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1041 {
1042         log_text("JNI-Call: CallStaticByteMethodA");
1043
1044         return 0;
1045 }
1046
1047 jchar CallStaticCharMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1048 {
1049         log_text("JNI-Call: CallStaticCharMethod");
1050
1051         return 0;
1052 }
1053
1054
1055 jchar CallStaticCharMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1056 {
1057         log_text("JNI-Call: CallStaticCharMethodV");
1058
1059         return 0;
1060 }
1061
1062
1063 jchar CallStaticCharMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1064 {
1065         log_text("JNI-Call: CallStaticCharMethodA");
1066
1067         return 0;
1068 }
1069
1070
1071
1072 jshort CallStaticShortMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1073 {
1074         log_text("JNI-Call: CallStaticShortMethod");
1075
1076         return 0;
1077 }
1078
1079
1080 jshort CallStaticShortMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1081 {
1082         log_text("JNI-Call: CallStaticShortMethodV");
1083
1084         return 0;
1085 }
1086
1087
1088 jshort CallStaticShortMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1089 {
1090         log_text("JNI-Call: CallStaticShortMethodA");
1091
1092         return 0;
1093 }
1094
1095
1096
1097 jint CallStaticIntMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1098 {
1099         log_text("JNI-Call: CallStaticIntMethod");
1100
1101         return 0;
1102 }
1103
1104
1105 jint CallStaticIntMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1106 {
1107         log_text("JNI-Call: CallStaticIntMethodV");
1108
1109         return 0;
1110 }
1111
1112
1113 jint CallStaticIntMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1114 {
1115         log_text("JNI-Call: CallStaticIntMethodA");
1116
1117         return 0;
1118 }
1119
1120
1121
1122 jlong CallStaticLongMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1123 {
1124         log_text("JNI-Call: CallStaticLongMethod");
1125
1126         return 0;
1127 }
1128
1129
1130 jlong CallStaticLongMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1131 {
1132         log_text("JNI-Call: CallStaticLongMethodV");
1133
1134         return 0;
1135 }
1136
1137
1138 jlong CallStaticLongMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1139 {
1140         log_text("JNI-Call: CallStaticLongMethodA");
1141
1142         return 0;
1143 }
1144
1145
1146
1147 jfloat CallStaticFloatMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1148 {
1149         log_text("JNI-Call: CallStaticFloatMethod");
1150
1151         return 0;
1152 }
1153
1154
1155 jfloat CallStaticFloatMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1156 {
1157         log_text("JNI-Call: CallStaticFloatMethodV");
1158
1159         return 0;
1160 }
1161
1162
1163 jfloat CallStaticFloatMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1164 {
1165         log_text("JNI-Call: CallStaticFloatMethodA");
1166
1167         return 0;
1168 }
1169
1170
1171
1172 jdouble CallStaticDoubleMethod (JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1173 {
1174         log_text("JNI-Call: CallStaticDoubleMethod");
1175
1176         return 0;
1177 }
1178
1179
1180 jdouble CallStaticDoubleMethodV (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args)
1181 {
1182         log_text("JNI-Call: CallStaticDoubleMethodV");
1183
1184         return 0;
1185 }
1186
1187
1188 jdouble CallStaticDoubleMethodA (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args)
1189 {
1190         log_text("JNI-Call: CallStaticDoubleMethodA");
1191
1192         return 0;
1193 }
1194
1195
1196
1197 void CallStaticVoidMethod (JNIEnv *env, jclass cls, jmethodID methodID, ...)
1198 {
1199         log_text("JNI-Call: CallStaticVoidMethod");
1200
1201 }
1202
1203
1204 void CallStaticVoidMethodV (JNIEnv *env, jclass cls, jmethodID methodID, va_list args)
1205 {
1206         log_text("JNI-Call: CallStaticVoidMethodV");
1207
1208 }
1209
1210
1211 void CallStaticVoidMethodA (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args)
1212 {
1213         log_text("JNI-Call: CallStaticVoidMethodA");
1214
1215 }
1216
1217 /****************** JNI-functions for accessing static fields ********************/
1218
1219 jfieldID GetStaticFieldID (JNIEnv *env, jclass clazz, const char *name, const char *sig)
1220 {
1221         jfieldID f;
1222
1223         f = jclass_findfield(clazz,
1224                             utf_new_char ((char*) name),
1225                             utf_new_char ((char*) sig)
1226                             );
1227
1228         if (!f) exceptionptr =  native_new_and_init(class_java_lang_NoSuchFieldError);
1229
1230         return f;
1231 }
1232
1233
1234 jobject GetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1235 {
1236         return fieldID->value.a;
1237 }
1238
1239
1240 jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1241 {
1242         return fieldID->value.i;
1243 }
1244
1245
1246 jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1247 {
1248         return fieldID->value.i;
1249 }
1250
1251
1252 jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1253 {
1254         return fieldID->value.i;
1255 }
1256
1257
1258 jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1259 {
1260         return fieldID->value.i;
1261 }
1262
1263
1264 jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1265 {
1266         return fieldID->value.i;
1267 }
1268
1269
1270 jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1271 {
1272         return fieldID->value.l;
1273 }
1274
1275
1276 jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1277 {
1278         return fieldID->value.f;
1279 }
1280
1281
1282 jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1283 {
1284         return fieldID->value.d;
1285 }
1286
1287
1288
1289 void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
1290 {
1291         fieldID->value.a = value;
1292 }
1293
1294
1295 void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
1296 {
1297         fieldID->value.i = value;
1298 }
1299
1300
1301 void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
1302 {
1303         fieldID->value.i = value;
1304 }
1305
1306
1307 void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
1308 {
1309         fieldID->value.i = value;
1310 }
1311
1312
1313 void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
1314 {
1315         fieldID->value.i = value;
1316 }
1317
1318
1319 void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
1320 {
1321         fieldID->value.i = value;
1322 }
1323
1324
1325 void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
1326 {
1327         fieldID->value.l = value;
1328 }
1329
1330
1331 void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
1332 {
1333         fieldID->value.f = value;
1334 }
1335
1336
1337 void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
1338 {
1339         fieldID->value.d = value;
1340 }
1341
1342
1343 /*****  create new java.lang.String object from an array of Unicode characters ****/
1344
1345 jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
1346 {
1347         u4 i;
1348         java_lang_String *s;
1349         java_chararray *a;
1350
1351         s = (java_lang_String*) builtin_new (class_java_lang_String);
1352         a = builtin_newarray_char (len);
1353
1354         /* javastring or characterarray could not be created */
1355         if ( (!a) || (!s) ) return NULL;
1356
1357         /* copy text */
1358         for (i=0; i<len; i++) a->data[i] = buf[i];
1359         s -> value = a;
1360         s -> offset = 0;
1361         s -> count = len;
1362
1363         return (jstring) s;
1364 }
1365
1366 /******************* returns the length of a Java string ***************************/
1367
1368 jsize GetStringLength (JNIEnv *env, jstring str)
1369 {
1370         return ((java_lang_String*) str)->count;
1371 }
1372
1373
1374 /********************  convertes javastring to u2-array ****************************/
1375
1376 u2 *javastring_tou2 (jstring so)
1377 {
1378         java_lang_String *s = (java_lang_String*) so;
1379         java_chararray *a;
1380         u4 i;
1381         u2 *stringbuffer;
1382
1383         if (!s) return NULL;
1384
1385         a = s->value;
1386         if (!a) return NULL;
1387
1388         /* allocate memory */
1389         stringbuffer = MNEW( u2 , s->count + 1 );
1390
1391         /* copy text */
1392         for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
1393
1394         /* terminate string */
1395         stringbuffer[i] = '\0';
1396
1397         return stringbuffer;
1398 }
1399
1400 /********* returns a pointer to an array of Unicode characters of the string *******/
1401
1402 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
1403 {
1404         return javastring_tou2(str);
1405 }
1406
1407 /**************** native code no longer needs access to chars **********************/
1408
1409 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
1410 {
1411         MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count);
1412 }
1413
1414 /************ create new java.lang.String object from utf8-characterarray **********/
1415
1416 jstring NewStringUTF (JNIEnv *env, const char *utf)
1417 {
1418     log_text("NewStringUTF called");
1419 }
1420
1421 /****************** returns the utf8 length in bytes of a string *******************/
1422
1423 jsize GetStringUTFLength (JNIEnv *env, jstring string)
1424 {
1425     java_lang_String *s = (java_lang_String*) string;
1426
1427     return (jsize) u2_utflength(s->value->data, s->count);
1428 }
1429
1430 /************ converts a Javastring to an array of UTF-8 characters ****************/
1431
1432 const char* GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy)
1433 {
1434     return javastring_toutf((java_lang_String*) string,false)->text;
1435 }
1436
1437 /***************** native code no longer needs access to utf ***********************/
1438
1439 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
1440 {
1441     log_text("JNI-Call: ReleaseStringUTFChars");
1442 }
1443
1444 /************************** array operations ***************************************/
1445
1446 jsize GetArrayLength (JNIEnv *env, jarray array)
1447 {
1448     return array->size;
1449 }
1450
1451 jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
1452 {
1453     java_objectarray *j = builtin_anewarray (len, clazz);
1454     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1455     return j;
1456 }
1457
1458 jobject GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
1459 {
1460     jobject j = NULL;
1461
1462     if (index<array->header.size)
1463         j = array->data[index];
1464     else
1465         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1466
1467     return j;
1468 }
1469
1470 void SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index, jobject val)
1471 {
1472     if (index>=array->header.size)
1473         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1474     else {
1475
1476         /* check if the class of value is a subclass of the element class of the array */
1477
1478         if (!builtin_instanceof(val, array->elementtype))
1479             exceptionptr = proto_java_lang_ArrayStoreException;
1480         else
1481             array->data[index] = val;
1482     }
1483 }
1484
1485
1486
1487 jbooleanArray NewBooleanArray (JNIEnv *env, jsize len)
1488 {
1489     java_booleanarray *j = builtin_newarray_boolean(len);
1490     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1491     return j;
1492 }
1493
1494
1495 jbyteArray NewByteArray (JNIEnv *env, jsize len)
1496 {
1497     java_bytearray *j = builtin_newarray_byte(len);
1498     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1499     return j;
1500 }
1501
1502
1503 jcharArray NewCharArray (JNIEnv *env, jsize len)
1504 {
1505     java_chararray *j = builtin_newarray_char(len);
1506     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1507     return j;
1508 }
1509
1510
1511 jshortArray NewShortArray (JNIEnv *env, jsize len)
1512 {
1513     java_shortarray *j = builtin_newarray_short(len);
1514     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1515     return j;
1516 }
1517
1518
1519 jintArray NewIntArray (JNIEnv *env, jsize len)
1520 {
1521     java_intarray *j = builtin_newarray_int(len);
1522     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1523     return j;
1524 }
1525
1526
1527 jlongArray NewLongArray (JNIEnv *env, jsize len)
1528 {
1529     java_longarray *j = builtin_newarray_long(len);
1530     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1531     return j;
1532 }
1533
1534
1535 jfloatArray NewFloatArray (JNIEnv *env, jsize len)
1536 {
1537     java_floatarray *j = builtin_newarray_float(len);
1538     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1539     return j;
1540 }
1541
1542
1543 jdoubleArray NewDoubleArray (JNIEnv *env, jsize len)
1544 {
1545     java_doublearray *j = builtin_newarray_double(len);
1546     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1547     return j;
1548 }
1549
1550
1551 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
1552 {
1553     if (isCopy) *isCopy = JNI_FALSE;
1554     return array->data;
1555 }
1556
1557
1558 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
1559 {
1560     if (isCopy) *isCopy = JNI_FALSE;
1561     return array->data;
1562 }
1563
1564
1565 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
1566 {
1567     if (isCopy) *isCopy = JNI_FALSE;
1568     return array->data;
1569 }
1570
1571
1572 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
1573 {
1574     if (isCopy) *isCopy = JNI_FALSE;
1575     return array->data;
1576 }
1577
1578
1579 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
1580 {
1581     if (isCopy) *isCopy = JNI_FALSE;
1582     return array->data;
1583 }
1584
1585
1586 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
1587 {
1588     if (isCopy) *isCopy = JNI_FALSE;
1589     return array->data;
1590 }
1591
1592
1593 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
1594 {
1595     if (isCopy) *isCopy = JNI_FALSE;
1596     return array->data;
1597 }
1598
1599
1600 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
1601 {
1602     if (isCopy) *isCopy = JNI_FALSE;
1603     return array->data;
1604 }
1605
1606
1607
1608 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
1609 {
1610     /* empty */
1611 }
1612
1613
1614 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
1615 {
1616     /* empty */
1617 }
1618
1619
1620 void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
1621 {
1622     /* empty */
1623 }
1624
1625
1626 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
1627 {
1628     /* empty */
1629 }
1630
1631
1632 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
1633 {
1634     /* empty */
1635 }
1636
1637
1638 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
1639 {
1640     /* empty */
1641 }
1642
1643
1644 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
1645 {
1646     /* empty */
1647 }
1648
1649
1650 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
1651 {
1652     /* empty */
1653 }
1654
1655 void GetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
1656 {
1657     if (start<0 || len<0 || start+len>array->header.size)
1658         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1659     else
1660         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1661 }
1662
1663
1664 void GetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
1665 {
1666     if (start<0 || len<0 || start+len>array->header.size)
1667         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1668     else
1669         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1670 }
1671
1672
1673 void GetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
1674 {
1675     if (start<0 || len<0 || start+len>array->header.size)
1676         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1677     else
1678         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1679 }
1680
1681
1682 void GetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
1683 {
1684     if (start<0 || len<0 || start+len>array->header.size)
1685         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1686     else
1687         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1688 }
1689
1690
1691 void GetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
1692 {
1693     if (start<0 || len<0 || start+len>array->header.size)
1694         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1695     else
1696         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1697 }
1698
1699
1700 void GetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
1701 {
1702     if (start<0 || len<0 || start+len>array->header.size)
1703         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1704     else
1705         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1706 }
1707
1708
1709 void GetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
1710 {
1711     if (start<0 || len<0 || start+len>array->header.size)
1712         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1713     else
1714         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1715 }
1716
1717
1718 void GetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
1719 {
1720     if (start<0 || len<0 || start+len>array->header.size)
1721         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1722     else
1723         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1724 }
1725
1726
1727 void SetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *buf)
1728 {
1729     if (start<0 || len<0 || start+len>array->header.size)
1730         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1731     else
1732         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1733 }
1734
1735
1736 void SetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
1737 {
1738     if (start<0 || len<0 || start+len>array->header.size)
1739         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1740     else
1741         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1742 }
1743
1744
1745 void SetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
1746 {
1747     if (start<0 || len<0 || start+len>array->header.size)
1748         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1749     else
1750         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1751
1752 }
1753
1754
1755 void SetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *buf)
1756 {
1757     if (start<0 || len<0 || start+len>array->header.size)
1758         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1759     else
1760         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1761 }
1762
1763
1764 void SetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *buf)
1765 {
1766     if (start<0 || len<0 || start+len>array->header.size)
1767         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1768     else
1769         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1770
1771 }
1772
1773 void SetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *buf)
1774 {
1775     if (start<0 || len<0 || start+len>array->header.size)
1776         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1777     else
1778         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1779
1780 }
1781
1782 void SetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
1783 {
1784     if (start<0 || len<0 || start+len>array->header.size)
1785         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1786     else
1787         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1788
1789 }
1790
1791 void SetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
1792 {
1793     if (start<0 || len<0 || start+len>array->header.size)
1794         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1795     else
1796         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1797 }
1798
1799 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
1800 {
1801     log_text("JNI-Call: RegisterNatives");
1802     return 0;
1803 }
1804
1805
1806 jint UnregisterNatives (JNIEnv* env, jclass clazz)
1807 {
1808     log_text("JNI-Call: UnregisterNatives");
1809     return 0;
1810 }
1811
1812 /******************************* monitor operations ********************************/
1813
1814 jint MonitorEnter (JNIEnv* env, jobject obj)
1815 {
1816     builtin_monitorenter(obj);
1817     return 0;
1818 }
1819
1820
1821 jint MonitorExit (JNIEnv* env, jobject obj)
1822 {
1823     builtin_monitorexit(obj);
1824     return 0;
1825 }
1826
1827
1828 /************************************* JavaVM interface ****************************/
1829
1830 jint GetJavaVM (JNIEnv* env, JavaVM **vm)
1831 {
1832     log_text("JNI-Call: GetJavaVM");
1833     return 0;
1834 }
1835
1836 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
1837 {
1838     log_text("JNI-Call: GetStringRegion");
1839
1840 }
1841
1842 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
1843 {
1844     log_text("JNI-Call: GetStringUTFRegion");
1845
1846 }
1847
1848 /****************** obtain direct pointer to array elements ***********************/
1849
1850 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
1851 {
1852         java_arrayheader *s = (java_arrayheader*) array;
1853
1854         switch (s->arraytype) {
1855                 case ARRAYTYPE_BYTE:    return (((java_bytearray*)    array)->data);
1856                 case ARRAYTYPE_BOOLEAN: return (((java_booleanarray*) array)->data);
1857                 case ARRAYTYPE_CHAR:    return (((java_chararray*)    array)->data);
1858                 case ARRAYTYPE_SHORT:   return (((java_shortarray*)   array)->data);
1859                 case ARRAYTYPE_INT:     return (((java_intarray*)     array)->data);
1860                 case ARRAYTYPE_LONG:    return (((java_longarray*)    array)->data);
1861                 case ARRAYTYPE_FLOAT:   return (((java_floatarray*)   array)->data);
1862                 case ARRAYTYPE_DOUBLE:  return (((java_doublearray*)  array)->data);
1863                 case ARRAYTYPE_OBJECT:  return (((java_objectarray*)  array)->data);
1864                 case ARRAYTYPE_ARRAY:   return (((java_arrayarray*)   array)->data);
1865         }
1866
1867         return NULL;
1868 }
1869
1870
1871 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
1872 {
1873         log_text("JNI-Call: ReleasePrimitiveArrayCritical");
1874
1875         /* empty */
1876 }
1877
1878 /********* returns a pointer to an array of Unicode characters of the string *******/
1879
1880 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
1881 {
1882         log_text("JNI-Call: GetStringCritical");
1883
1884         return GetStringChars(env,string,isCopy);
1885 }
1886
1887 /**************** native code no longer needs access to chars **********************/
1888
1889 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
1890 {
1891         log_text("JNI-Call: ReleaseStringCritical");
1892
1893         ReleaseStringChars(env,string,cstring);
1894 }
1895
1896
1897 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
1898 {
1899         log_text("JNI-Call: NewWeakGlobalRef");
1900
1901         return obj;
1902 }
1903
1904
1905 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
1906 {
1907         log_text("JNI-Call: DeleteWeakGlobalRef");
1908
1909         /* empty */
1910 }
1911
1912
1913 /******************************* check for pending exception ***********************/
1914
1915
1916 jboolean ExceptionCheck (JNIEnv* env)
1917 {
1918         log_text("JNI-Call: ExceptionCheck");
1919
1920         return exceptionptr ? JNI_TRUE : JNI_FALSE;
1921 }
1922
1923 /********************************* JNI function table ******************************/
1924
1925 JNIEnv env =
1926    {
1927     NULL,
1928     NULL,
1929     NULL,
1930     NULL,
1931     &GetVersion,
1932     &DefineClass,
1933     &FindClass,
1934     &FromReflectedMethod,
1935     &FromReflectedField,
1936     &ToReflectedMethod,
1937     &GetSuperclass,
1938     &IsAssignableForm,
1939     &ToReflectedField,
1940     &Throw,
1941     &ThrowNew,
1942     &ExceptionOccurred,
1943     &ExceptionDescribe,
1944     &ExceptionClear,
1945     &FatalError,
1946     &PushLocalFrame,
1947     &PopLocalFrame,
1948     &NewGlobalRef,
1949     &DeleteGlobalRef,
1950     &DeleteLocalRef,
1951     &IsSameObject,
1952     &NewLocalRef,
1953     &EnsureLocalCapacity,
1954     &AllocObject,
1955     &NewObject,
1956     &NewObjectV,
1957     &NewObjectA,
1958     &GetObjectClass,
1959     &IsInstanceOf,
1960     &GetMethodID,
1961     &CallObjectMethod,
1962     &CallObjectMethodV,
1963     &CallObjectMethodA,
1964     &CallBooleanMethod,
1965     &CallBooleanMethodV,
1966     &CallBooleanMethodA,
1967     &CallByteMethod,
1968     &CallByteMethodV,
1969     &CallByteMethodA,
1970     &CallCharMethod,
1971     &CallCharMethodV,
1972     &CallCharMethodA,
1973     &CallShortMethod,
1974     &CallShortMethodV,
1975     &CallShortMethodA,
1976     &CallIntMethod,
1977     &CallIntMethodV,
1978     &CallIntMethodA,
1979     &CallLongMethod,
1980     &CallLongMethodV,
1981     &CallLongMethodA,
1982     &CallFloatMethod,
1983     &CallFloatMethodV,
1984     &CallFloatMethodA,
1985     &CallDoubleMethod,
1986     &CallDoubleMethodV,
1987     &CallDoubleMethodA,
1988     &CallVoidMethod,
1989     &CallVoidMethodV,
1990     &CallVoidMethodA,
1991     &CallNonvirtualObjectMethod,
1992     &CallNonvirtualObjectMethodV,
1993     &CallNonvirtualObjectMethodA,
1994     &CallNonvirtualBooleanMethod,
1995     &CallNonvirtualBooleanMethodV,
1996     &CallNonvirtualBooleanMethodA,
1997     &CallNonvirtualByteMethod,
1998     &CallNonvirtualByteMethodV,
1999     &CallNonvirtualByteMethodA,
2000     &CallNonvirtualCharMethod,
2001     &CallNonvirtualCharMethodV,
2002     &CallNonvirtualCharMethodA,
2003     &CallNonvirtualShortMethod,
2004     &CallNonvirtualShortMethodV,
2005     &CallNonvirtualShortMethodA,
2006     &CallNonvirtualIntMethod,
2007     &CallNonvirtualIntMethodV,
2008     &CallNonvirtualIntMethodA,
2009     &CallNonvirtualLongMethod,
2010     &CallNonvirtualLongMethodV,
2011     &CallNonvirtualLongMethodA,
2012     &CallNonvirtualFloatMethod,
2013     &CallNonvirtualFloatMethodV,
2014     &CallNonvirtualFloatMethodA,
2015     &CallNonvirtualDoubleMethod,
2016     &CallNonvirtualDoubleMethodV,
2017     &CallNonvirtualDoubleMethodA,
2018     &CallNonvirtualVoidMethod,
2019     &CallNonvirtualVoidMethodV,
2020     &CallNonvirtualVoidMethodA,
2021     &GetFieldID,
2022     &GetObjectField,
2023     &GetBooleanField,
2024     &GetByteField,
2025     &GetCharField,
2026     &GetShortField,
2027     &GetIntField,
2028     &GetLongField,
2029     &GetFloatField,
2030     &GetDoubleField,
2031     &SetObjectField,
2032     &SetBooleanField,
2033     &SetByteField,
2034     &SetCharField,
2035     &SetShortField,
2036     &SetIntField,
2037     &SetLongField,
2038     &SetFloatField,
2039     &SetDoubleField,
2040     &GetStaticMethodID,
2041     &CallStaticObjectMethod,
2042     &CallStaticObjectMethodV,
2043     &CallStaticObjectMethodA,
2044     &CallStaticBooleanMethod,
2045     &CallStaticBooleanMethodV,
2046     &CallStaticBooleanMethodA,
2047     &CallStaticByteMethod,
2048     &CallStaticByteMethodV,
2049     &CallStaticByteMethodA,
2050     &CallStaticCharMethod,
2051     &CallStaticCharMethodV,
2052     &CallStaticCharMethodA,
2053     &CallStaticShortMethod,
2054     &CallStaticShortMethodV,
2055     &CallStaticShortMethodA,
2056     &CallStaticIntMethod,
2057     &CallStaticIntMethodV,
2058     &CallStaticIntMethodA,
2059     &CallStaticLongMethod,
2060     &CallStaticLongMethodV,
2061     &CallStaticLongMethodA,
2062     &CallStaticFloatMethod,
2063     &CallStaticFloatMethodV,
2064     &CallStaticFloatMethodA,
2065     &CallStaticDoubleMethod,
2066     &CallStaticDoubleMethodV,
2067     &CallStaticDoubleMethodA,
2068     &CallStaticVoidMethod,
2069     &CallStaticVoidMethodV,
2070     &CallStaticVoidMethodA,
2071     &GetStaticFieldID,
2072     &GetStaticObjectField,
2073     &GetStaticBooleanField,
2074     &GetStaticByteField,
2075     &GetStaticCharField,
2076     &GetStaticShortField,
2077     &GetStaticIntField,
2078     &GetStaticLongField,
2079     &GetStaticFloatField,
2080     &GetStaticDoubleField,
2081     &SetStaticObjectField,
2082     &SetStaticBooleanField,
2083     &SetStaticByteField,
2084     &SetStaticCharField,
2085     &SetStaticShortField,
2086     &SetStaticIntField,
2087     &SetStaticLongField,
2088     &SetStaticFloatField,
2089     &SetStaticDoubleField,
2090     &NewString,
2091     &GetStringLength,
2092     &GetStringChars,
2093     &ReleaseStringChars,
2094     &NewStringUTF,
2095     &GetStringUTFLength,
2096     &GetStringUTFChars,
2097     &ReleaseStringUTFChars,
2098     &GetArrayLength,
2099     &NewObjectArray,
2100     &GetObjectArrayElement,
2101     &SetObjectArrayElement,
2102     &NewBooleanArray,
2103     &NewByteArray,
2104     &NewCharArray,
2105     &NewShortArray,
2106     &NewIntArray,
2107     &NewLongArray,
2108     &NewFloatArray,
2109     &NewDoubleArray,
2110     &GetBooleanArrayElements,
2111     &GetByteArrayElements,
2112     &GetCharArrayElements,
2113     &GetShortArrayElements,
2114     &GetIntArrayElements,
2115     &GetLongArrayElements,
2116     &GetFloatArrayElements,
2117     &GetDoubleArrayElements,
2118     &ReleaseBooleanArrayElements,
2119     &ReleaseByteArrayElements,
2120     &ReleaseCharArrayElements,
2121     &ReleaseShortArrayElements,
2122     &ReleaseIntArrayElements,
2123     &ReleaseLongArrayElements,
2124     &ReleaseFloatArrayElements,
2125     &ReleaseDoubleArrayElements,
2126     &GetBooleanArrayRegion,
2127     &GetByteArrayRegion,
2128     &GetCharArrayRegion,
2129     &GetShortArrayRegion,
2130     &GetIntArrayRegion,
2131     &GetLongArrayRegion,
2132     &GetFloatArrayRegion,
2133     &GetDoubleArrayRegion,
2134     &SetBooleanArrayRegion,
2135     &SetByteArrayRegion,
2136     &SetCharArrayRegion,
2137     &SetShortArrayRegion,
2138     &SetIntArrayRegion,
2139     &SetLongArrayRegion,
2140     &SetFloatArrayRegion,
2141     &SetDoubleArrayRegion,
2142     &RegisterNatives,
2143     &UnregisterNatives,
2144     &MonitorEnter,
2145     &MonitorExit,
2146     &GetJavaVM,
2147     &GetStringRegion,
2148     &GetStringUTFRegion,
2149     &GetPrimitiveArrayCritical,
2150     &ReleasePrimitiveArrayCritical,
2151     &GetStringCritical,
2152     &ReleaseStringCritical,
2153     &NewWeakGlobalRef,
2154     &DeleteWeakGlobalRef,
2155     &ExceptionCheck
2156     };