src/native/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         class_init(clazz);
1237         return fieldID->value.a;
1238 }
1239
1240
1241 jboolean GetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1242 {
1243         class_init(clazz);
1244         return fieldID->value.i;
1245 }
1246
1247
1248 jbyte GetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1249 {
1250         class_init(clazz);
1251         return fieldID->value.i;
1252 }
1253
1254
1255 jchar GetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1256 {
1257         class_init(clazz);
1258         return fieldID->value.i;
1259 }
1260
1261
1262 jshort GetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1263 {
1264         class_init(clazz);
1265         return fieldID->value.i;
1266 }
1267
1268
1269 jint GetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1270 {
1271         class_init(clazz);
1272         return fieldID->value.i;
1273 }
1274
1275
1276 jlong GetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1277 {
1278         class_init(clazz);
1279         return fieldID->value.l;
1280 }
1281
1282
1283 jfloat GetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1284 {
1285         class_init(clazz);
1286         return fieldID->value.f;
1287 }
1288
1289
1290 jdouble GetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID)
1291 {
1292         class_init(clazz);
1293         return fieldID->value.d;
1294 }
1295
1296
1297
1298 void SetStaticObjectField (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value)
1299 {
1300         class_init(clazz);
1301         fieldID->value.a = value;
1302 }
1303
1304
1305 void SetStaticBooleanField (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value)
1306 {
1307         class_init(clazz);
1308         fieldID->value.i = value;
1309 }
1310
1311
1312 void SetStaticByteField (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value)
1313 {
1314         class_init(clazz);
1315         fieldID->value.i = value;
1316 }
1317
1318
1319 void SetStaticCharField (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value)
1320 {
1321         class_init(clazz);
1322         fieldID->value.i = value;
1323 }
1324
1325
1326 void SetStaticShortField (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value)
1327 {
1328         class_init(clazz);
1329         fieldID->value.i = value;
1330 }
1331
1332
1333 void SetStaticIntField (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value)
1334 {
1335         class_init(clazz);
1336         fieldID->value.i = value;
1337 }
1338
1339
1340 void SetStaticLongField (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value)
1341 {
1342         class_init(clazz);
1343         fieldID->value.l = value;
1344 }
1345
1346
1347 void SetStaticFloatField (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value)
1348 {
1349         class_init(clazz);
1350         fieldID->value.f = value;
1351 }
1352
1353
1354 void SetStaticDoubleField (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value)
1355 {
1356         class_init(clazz);
1357         fieldID->value.d = value;
1358 }
1359
1360
1361 /*****  create new java.lang.String object from an array of Unicode characters ****/
1362
1363 jstring NewString (JNIEnv *env, const jchar *buf, jsize len)
1364 {
1365         u4 i;
1366         java_lang_String *s;
1367         java_chararray *a;
1368
1369         s = (java_lang_String*) builtin_new (class_java_lang_String);
1370         a = builtin_newarray_char (len);
1371
1372         /* javastring or characterarray could not be created */
1373         if ( (!a) || (!s) ) return NULL;
1374
1375         /* copy text */
1376         for (i=0; i<len; i++) a->data[i] = buf[i];
1377         s -> value = a;
1378         s -> offset = 0;
1379         s -> count = len;
1380
1381         return (jstring) s;
1382 }
1383
1384 /******************* returns the length of a Java string ***************************/
1385
1386 jsize GetStringLength (JNIEnv *env, jstring str)
1387 {
1388         return ((java_lang_String*) str)->count;
1389 }
1390
1391
1392 /********************  convertes javastring to u2-array ****************************/
1393
1394 u2 *javastring_tou2 (jstring so)
1395 {
1396         java_lang_String *s = (java_lang_String*) so;
1397         java_chararray *a;
1398         u4 i;
1399         u2 *stringbuffer;
1400
1401         if (!s) return NULL;
1402
1403         a = s->value;
1404         if (!a) return NULL;
1405
1406         /* allocate memory */
1407         stringbuffer = MNEW( u2 , s->count + 1 );
1408
1409         /* copy text */
1410         for (i=0; i<s->count; i++) stringbuffer[i] = a->data[s->offset+i];
1411
1412         /* terminate string */
1413         stringbuffer[i] = '\0';
1414
1415         return stringbuffer;
1416 }
1417
1418 /********* returns a pointer to an array of Unicode characters of the string *******/
1419
1420 const jchar *GetStringChars (JNIEnv *env, jstring str, jboolean *isCopy)
1421 {
1422         return javastring_tou2(str);
1423 }
1424
1425 /**************** native code no longer needs access to chars **********************/
1426
1427 void ReleaseStringChars (JNIEnv *env, jstring str, const jchar *chars)
1428 {
1429         MFREE(((jchar*) chars),jchar,((java_lang_String*) str)->count);
1430 }
1431
1432 /************ create new java.lang.String object from utf8-characterarray **********/
1433
1434 jstring NewStringUTF (JNIEnv *env, const char *utf)
1435 {
1436     log_text("NewStringUTF called");
1437 }
1438
1439 /****************** returns the utf8 length in bytes of a string *******************/
1440
1441 jsize GetStringUTFLength (JNIEnv *env, jstring string)
1442 {
1443     java_lang_String *s = (java_lang_String*) string;
1444
1445     return (jsize) u2_utflength(s->value->data, s->count);
1446 }
1447
1448 /************ converts a Javastring to an array of UTF-8 characters ****************/
1449
1450 const char* GetStringUTFChars (JNIEnv *env, jstring string, jboolean *isCopy)
1451 {
1452     return javastring_toutf((java_lang_String*) string,false)->text;
1453 }
1454
1455 /***************** native code no longer needs access to utf ***********************/
1456
1457 void ReleaseStringUTFChars (JNIEnv *env, jstring str, const char* chars)
1458 {
1459     log_text("JNI-Call: ReleaseStringUTFChars");
1460 }
1461
1462 /************************** array operations ***************************************/
1463
1464 jsize GetArrayLength (JNIEnv *env, jarray array)
1465 {
1466     return array->size;
1467 }
1468
1469 jobjectArray NewObjectArray (JNIEnv *env, jsize len, jclass clazz, jobject init)
1470 {
1471     java_objectarray *j = builtin_anewarray (len, clazz);
1472     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1473     return j;
1474 }
1475
1476 jobject GetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index)
1477 {
1478     jobject j = NULL;
1479
1480     if (index<array->header.size)
1481         j = array->data[index];
1482     else
1483         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1484
1485     return j;
1486 }
1487
1488 void SetObjectArrayElement (JNIEnv *env, jobjectArray array, jsize index, jobject val)
1489 {
1490     if (index>=array->header.size)
1491         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1492     else {
1493
1494         /* check if the class of value is a subclass of the element class of the array */
1495
1496         if (!builtin_instanceof(val, array->elementtype))
1497             exceptionptr = proto_java_lang_ArrayStoreException;
1498         else
1499             array->data[index] = val;
1500     }
1501 }
1502
1503
1504
1505 jbooleanArray NewBooleanArray (JNIEnv *env, jsize len)
1506 {
1507     java_booleanarray *j = builtin_newarray_boolean(len);
1508     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1509     return j;
1510 }
1511
1512
1513 jbyteArray NewByteArray (JNIEnv *env, jsize len)
1514 {
1515     java_bytearray *j = builtin_newarray_byte(len);
1516     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1517     return j;
1518 }
1519
1520
1521 jcharArray NewCharArray (JNIEnv *env, jsize len)
1522 {
1523     java_chararray *j = builtin_newarray_char(len);
1524     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1525     return j;
1526 }
1527
1528
1529 jshortArray NewShortArray (JNIEnv *env, jsize len)
1530 {
1531     java_shortarray *j = builtin_newarray_short(len);
1532     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1533     return j;
1534 }
1535
1536
1537 jintArray NewIntArray (JNIEnv *env, jsize len)
1538 {
1539     java_intarray *j = builtin_newarray_int(len);
1540     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1541     return j;
1542 }
1543
1544
1545 jlongArray NewLongArray (JNIEnv *env, jsize len)
1546 {
1547     java_longarray *j = builtin_newarray_long(len);
1548     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1549     return j;
1550 }
1551
1552
1553 jfloatArray NewFloatArray (JNIEnv *env, jsize len)
1554 {
1555     java_floatarray *j = builtin_newarray_float(len);
1556     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1557     return j;
1558 }
1559
1560
1561 jdoubleArray NewDoubleArray (JNIEnv *env, jsize len)
1562 {
1563     java_doublearray *j = builtin_newarray_double(len);
1564     if (!j) exceptionptr = proto_java_lang_OutOfMemoryError;
1565     return j;
1566 }
1567
1568
1569 jboolean * GetBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *isCopy)
1570 {
1571     if (isCopy) *isCopy = JNI_FALSE;
1572     return array->data;
1573 }
1574
1575
1576 jbyte * GetByteArrayElements (JNIEnv *env, jbyteArray array, jboolean *isCopy)
1577 {
1578     if (isCopy) *isCopy = JNI_FALSE;
1579     return array->data;
1580 }
1581
1582
1583 jchar * GetCharArrayElements (JNIEnv *env, jcharArray array, jboolean *isCopy)
1584 {
1585     if (isCopy) *isCopy = JNI_FALSE;
1586     return array->data;
1587 }
1588
1589
1590 jshort * GetShortArrayElements (JNIEnv *env, jshortArray array, jboolean *isCopy)
1591 {
1592     if (isCopy) *isCopy = JNI_FALSE;
1593     return array->data;
1594 }
1595
1596
1597 jint * GetIntArrayElements (JNIEnv *env, jintArray array, jboolean *isCopy)
1598 {
1599     if (isCopy) *isCopy = JNI_FALSE;
1600     return array->data;
1601 }
1602
1603
1604 jlong * GetLongArrayElements (JNIEnv *env, jlongArray array, jboolean *isCopy)
1605 {
1606     if (isCopy) *isCopy = JNI_FALSE;
1607     return array->data;
1608 }
1609
1610
1611 jfloat * GetFloatArrayElements (JNIEnv *env, jfloatArray array, jboolean *isCopy)
1612 {
1613     if (isCopy) *isCopy = JNI_FALSE;
1614     return array->data;
1615 }
1616
1617
1618 jdouble * GetDoubleArrayElements (JNIEnv *env, jdoubleArray array, jboolean *isCopy)
1619 {
1620     if (isCopy) *isCopy = JNI_FALSE;
1621     return array->data;
1622 }
1623
1624
1625
1626 void ReleaseBooleanArrayElements (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode)
1627 {
1628     /* empty */
1629 }
1630
1631
1632 void ReleaseByteArrayElements (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode)
1633 {
1634     /* empty */
1635 }
1636
1637
1638 void ReleaseCharArrayElements (JNIEnv *env, jcharArray array, jchar *elems, jint mode)
1639 {
1640     /* empty */
1641 }
1642
1643
1644 void ReleaseShortArrayElements (JNIEnv *env, jshortArray array, jshort *elems, jint mode)
1645 {
1646     /* empty */
1647 }
1648
1649
1650 void ReleaseIntArrayElements (JNIEnv *env, jintArray array, jint *elems, jint mode)
1651 {
1652     /* empty */
1653 }
1654
1655
1656 void ReleaseLongArrayElements (JNIEnv *env, jlongArray array, jlong *elems, jint mode)
1657 {
1658     /* empty */
1659 }
1660
1661
1662 void ReleaseFloatArrayElements (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode)
1663 {
1664     /* empty */
1665 }
1666
1667
1668 void ReleaseDoubleArrayElements (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode)
1669 {
1670     /* empty */
1671 }
1672
1673 void GetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *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 GetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *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 GetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *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 GetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *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 GetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *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 GetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *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 GetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
1728 {
1729     if (start<0 || len<0 || start+len>array->header.size)
1730         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1731     else
1732         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1733 }
1734
1735
1736 void GetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
1737 {
1738     if (start<0 || len<0 || start+len>array->header.size)
1739         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1740     else
1741         memcpy(buf,&array->data[start],len*sizeof(array->data[0]));
1742 }
1743
1744
1745 void SetBooleanArrayRegion (JNIEnv* env, jbooleanArray array, jsize start, jsize len, jboolean *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 void SetByteArrayRegion (JNIEnv* env, jbyteArray array, jsize start, jsize len, jbyte *buf)
1755 {
1756     if (start<0 || len<0 || start+len>array->header.size)
1757         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1758     else
1759         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1760 }
1761
1762
1763 void SetCharArrayRegion (JNIEnv* env, jcharArray array, jsize start, jsize len, jchar *buf)
1764 {
1765     if (start<0 || len<0 || start+len>array->header.size)
1766         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1767     else
1768         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1769
1770 }
1771
1772
1773 void SetShortArrayRegion (JNIEnv* env, jshortArray array, jsize start, jsize len, jshort *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 SetIntArrayRegion (JNIEnv* env, jintArray array, jsize start, jsize len, jint *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 SetLongArrayRegion (JNIEnv* env, jlongArray array, jsize start, jsize len, jlong *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
1800 void SetFloatArrayRegion (JNIEnv* env, jfloatArray array, jsize start, jsize len, jfloat *buf)
1801 {
1802     if (start<0 || len<0 || start+len>array->header.size)
1803         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1804     else
1805         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1806
1807 }
1808
1809 void SetDoubleArrayRegion (JNIEnv* env, jdoubleArray array, jsize start, jsize len, jdouble *buf)
1810 {
1811     if (start<0 || len<0 || start+len>array->header.size)
1812         exceptionptr = proto_java_lang_ArrayIndexOutOfBoundsException;
1813     else
1814         memcpy(&array->data[start],buf,len*sizeof(array->data[0]));
1815 }
1816
1817 jint RegisterNatives (JNIEnv* env, jclass clazz, const JNINativeMethod *methods, jint nMethods)
1818 {
1819     log_text("JNI-Call: RegisterNatives");
1820     return 0;
1821 }
1822
1823
1824 jint UnregisterNatives (JNIEnv* env, jclass clazz)
1825 {
1826     log_text("JNI-Call: UnregisterNatives");
1827     return 0;
1828 }
1829
1830 /******************************* monitor operations ********************************/
1831
1832 jint MonitorEnter (JNIEnv* env, jobject obj)
1833 {
1834     builtin_monitorenter(obj);
1835     return 0;
1836 }
1837
1838
1839 jint MonitorExit (JNIEnv* env, jobject obj)
1840 {
1841     builtin_monitorexit(obj);
1842     return 0;
1843 }
1844
1845
1846 /************************************* JavaVM interface ****************************/
1847
1848 jint GetJavaVM (JNIEnv* env, JavaVM **vm)
1849 {
1850     log_text("JNI-Call: GetJavaVM");
1851     return 0;
1852 }
1853
1854 void GetStringRegion (JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
1855 {
1856     log_text("JNI-Call: GetStringRegion");
1857
1858 }
1859
1860 void GetStringUTFRegion (JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
1861 {
1862     log_text("JNI-Call: GetStringUTFRegion");
1863
1864 }
1865
1866 /****************** obtain direct pointer to array elements ***********************/
1867
1868 void * GetPrimitiveArrayCritical (JNIEnv* env, jarray array, jboolean *isCopy)
1869 {
1870         java_arrayheader *s = (java_arrayheader*) array;
1871
1872         switch (s->arraytype) {
1873                 case ARRAYTYPE_BYTE:    return (((java_bytearray*)    array)->data);
1874                 case ARRAYTYPE_BOOLEAN: return (((java_booleanarray*) array)->data);
1875                 case ARRAYTYPE_CHAR:    return (((java_chararray*)    array)->data);
1876                 case ARRAYTYPE_SHORT:   return (((java_shortarray*)   array)->data);
1877                 case ARRAYTYPE_INT:     return (((java_intarray*)     array)->data);
1878                 case ARRAYTYPE_LONG:    return (((java_longarray*)    array)->data);
1879                 case ARRAYTYPE_FLOAT:   return (((java_floatarray*)   array)->data);
1880                 case ARRAYTYPE_DOUBLE:  return (((java_doublearray*)  array)->data);
1881                 case ARRAYTYPE_OBJECT:  return (((java_objectarray*)  array)->data);
1882                 case ARRAYTYPE_ARRAY:   return (((java_arrayarray*)   array)->data);
1883         }
1884
1885         return NULL;
1886 }
1887
1888
1889 void ReleasePrimitiveArrayCritical (JNIEnv* env, jarray array, void *carray, jint mode)
1890 {
1891         log_text("JNI-Call: ReleasePrimitiveArrayCritical");
1892
1893         /* empty */
1894 }
1895
1896 /********* returns a pointer to an array of Unicode characters of the string *******/
1897
1898 const jchar * GetStringCritical (JNIEnv* env, jstring string, jboolean *isCopy)
1899 {
1900         log_text("JNI-Call: GetStringCritical");
1901
1902         return GetStringChars(env,string,isCopy);
1903 }
1904
1905 /**************** native code no longer needs access to chars **********************/
1906
1907 void ReleaseStringCritical (JNIEnv* env, jstring string, const jchar *cstring)
1908 {
1909         log_text("JNI-Call: ReleaseStringCritical");
1910
1911         ReleaseStringChars(env,string,cstring);
1912 }
1913
1914
1915 jweak NewWeakGlobalRef (JNIEnv* env, jobject obj)
1916 {
1917         log_text("JNI-Call: NewWeakGlobalRef");
1918
1919         return obj;
1920 }
1921
1922
1923 void DeleteWeakGlobalRef (JNIEnv* env, jweak ref)
1924 {
1925         log_text("JNI-Call: DeleteWeakGlobalRef");
1926
1927         /* empty */
1928 }
1929
1930
1931 /******************************* check for pending exception ***********************/
1932
1933
1934 jboolean ExceptionCheck (JNIEnv* env)
1935 {
1936         log_text("JNI-Call: ExceptionCheck");
1937
1938         return exceptionptr ? JNI_TRUE : JNI_FALSE;
1939 }
1940
1941 /********************************* JNI function table ******************************/
1942
1943 JNIEnv env =
1944    {
1945     NULL,
1946     NULL,
1947     NULL,
1948     NULL,
1949     &GetVersion,
1950     &DefineClass,
1951     &FindClass,
1952     &FromReflectedMethod,
1953     &FromReflectedField,
1954     &ToReflectedMethod,
1955     &GetSuperclass,
1956     &IsAssignableForm,
1957     &ToReflectedField,
1958     &Throw,
1959     &ThrowNew,
1960     &ExceptionOccurred,
1961     &ExceptionDescribe,
1962     &ExceptionClear,
1963     &FatalError,
1964     &PushLocalFrame,
1965     &PopLocalFrame,
1966     &NewGlobalRef,
1967     &DeleteGlobalRef,
1968     &DeleteLocalRef,
1969     &IsSameObject,
1970     &NewLocalRef,
1971     &EnsureLocalCapacity,
1972     &AllocObject,
1973     &NewObject,
1974     &NewObjectV,
1975     &NewObjectA,
1976     &GetObjectClass,
1977     &IsInstanceOf,
1978     &GetMethodID,
1979     &CallObjectMethod,
1980     &CallObjectMethodV,
1981     &CallObjectMethodA,
1982     &CallBooleanMethod,
1983     &CallBooleanMethodV,
1984     &CallBooleanMethodA,
1985     &CallByteMethod,
1986     &CallByteMethodV,
1987     &CallByteMethodA,
1988     &CallCharMethod,
1989     &CallCharMethodV,
1990     &CallCharMethodA,
1991     &CallShortMethod,
1992     &CallShortMethodV,
1993     &CallShortMethodA,
1994     &CallIntMethod,
1995     &CallIntMethodV,
1996     &CallIntMethodA,
1997     &CallLongMethod,
1998     &CallLongMethodV,
1999     &CallLongMethodA,
2000     &CallFloatMethod,
2001     &CallFloatMethodV,
2002     &CallFloatMethodA,
2003     &CallDoubleMethod,
2004     &CallDoubleMethodV,
2005     &CallDoubleMethodA,
2006     &CallVoidMethod,
2007     &CallVoidMethodV,
2008     &CallVoidMethodA,
2009     &CallNonvirtualObjectMethod,
2010     &CallNonvirtualObjectMethodV,
2011     &CallNonvirtualObjectMethodA,
2012     &CallNonvirtualBooleanMethod,
2013     &CallNonvirtualBooleanMethodV,
2014     &CallNonvirtualBooleanMethodA,
2015     &CallNonvirtualByteMethod,
2016     &CallNonvirtualByteMethodV,
2017     &CallNonvirtualByteMethodA,
2018     &CallNonvirtualCharMethod,
2019     &CallNonvirtualCharMethodV,
2020     &CallNonvirtualCharMethodA,
2021     &CallNonvirtualShortMethod,
2022     &CallNonvirtualShortMethodV,
2023     &CallNonvirtualShortMethodA,
2024     &CallNonvirtualIntMethod,
2025     &CallNonvirtualIntMethodV,
2026     &CallNonvirtualIntMethodA,
2027     &CallNonvirtualLongMethod,
2028     &CallNonvirtualLongMethodV,
2029     &CallNonvirtualLongMethodA,
2030     &CallNonvirtualFloatMethod,
2031     &CallNonvirtualFloatMethodV,
2032     &CallNonvirtualFloatMethodA,
2033     &CallNonvirtualDoubleMethod,
2034     &CallNonvirtualDoubleMethodV,
2035     &CallNonvirtualDoubleMethodA,
2036     &CallNonvirtualVoidMethod,
2037     &CallNonvirtualVoidMethodV,
2038     &CallNonvirtualVoidMethodA,
2039     &GetFieldID,
2040     &GetObjectField,
2041     &GetBooleanField,
2042     &GetByteField,
2043     &GetCharField,
2044     &GetShortField,
2045     &GetIntField,
2046     &GetLongField,
2047     &GetFloatField,
2048     &GetDoubleField,
2049     &SetObjectField,
2050     &SetBooleanField,
2051     &SetByteField,
2052     &SetCharField,
2053     &SetShortField,
2054     &SetIntField,
2055     &SetLongField,
2056     &SetFloatField,
2057     &SetDoubleField,
2058     &GetStaticMethodID,
2059     &CallStaticObjectMethod,
2060     &CallStaticObjectMethodV,
2061     &CallStaticObjectMethodA,
2062     &CallStaticBooleanMethod,
2063     &CallStaticBooleanMethodV,
2064     &CallStaticBooleanMethodA,
2065     &CallStaticByteMethod,
2066     &CallStaticByteMethodV,
2067     &CallStaticByteMethodA,
2068     &CallStaticCharMethod,
2069     &CallStaticCharMethodV,
2070     &CallStaticCharMethodA,
2071     &CallStaticShortMethod,
2072     &CallStaticShortMethodV,
2073     &CallStaticShortMethodA,
2074     &CallStaticIntMethod,
2075     &CallStaticIntMethodV,
2076     &CallStaticIntMethodA,
2077     &CallStaticLongMethod,
2078     &CallStaticLongMethodV,
2079     &CallStaticLongMethodA,
2080     &CallStaticFloatMethod,
2081     &CallStaticFloatMethodV,
2082     &CallStaticFloatMethodA,
2083     &CallStaticDoubleMethod,
2084     &CallStaticDoubleMethodV,
2085     &CallStaticDoubleMethodA,
2086     &CallStaticVoidMethod,
2087     &CallStaticVoidMethodV,
2088     &CallStaticVoidMethodA,
2089     &GetStaticFieldID,
2090     &GetStaticObjectField,
2091     &GetStaticBooleanField,
2092     &GetStaticByteField,
2093     &GetStaticCharField,
2094     &GetStaticShortField,
2095     &GetStaticIntField,
2096     &GetStaticLongField,
2097     &GetStaticFloatField,
2098     &GetStaticDoubleField,
2099     &SetStaticObjectField,
2100     &SetStaticBooleanField,
2101     &SetStaticByteField,
2102     &SetStaticCharField,
2103     &SetStaticShortField,
2104     &SetStaticIntField,
2105     &SetStaticLongField,
2106     &SetStaticFloatField,
2107     &SetStaticDoubleField,
2108     &NewString,
2109     &GetStringLength,
2110     &GetStringChars,
2111     &ReleaseStringChars,
2112     &NewStringUTF,
2113     &GetStringUTFLength,
2114     &GetStringUTFChars,
2115     &ReleaseStringUTFChars,
2116     &GetArrayLength,
2117     &NewObjectArray,
2118     &GetObjectArrayElement,
2119     &SetObjectArrayElement,
2120     &NewBooleanArray,
2121     &NewByteArray,
2122     &NewCharArray,
2123     &NewShortArray,
2124     &NewIntArray,
2125     &NewLongArray,
2126     &NewFloatArray,
2127     &NewDoubleArray,
2128     &GetBooleanArrayElements,
2129     &GetByteArrayElements,
2130     &GetCharArrayElements,
2131     &GetShortArrayElements,
2132     &GetIntArrayElements,
2133     &GetLongArrayElements,
2134     &GetFloatArrayElements,
2135     &GetDoubleArrayElements,
2136     &ReleaseBooleanArrayElements,
2137     &ReleaseByteArrayElements,
2138     &ReleaseCharArrayElements,
2139     &ReleaseShortArrayElements,
2140     &ReleaseIntArrayElements,
2141     &ReleaseLongArrayElements,
2142     &ReleaseFloatArrayElements,
2143     &ReleaseDoubleArrayElements,
2144     &GetBooleanArrayRegion,
2145     &GetByteArrayRegion,
2146     &GetCharArrayRegion,
2147     &GetShortArrayRegion,
2148     &GetIntArrayRegion,
2149     &GetLongArrayRegion,
2150     &GetFloatArrayRegion,
2151     &GetDoubleArrayRegion,
2152     &SetBooleanArrayRegion,
2153     &SetByteArrayRegion,
2154     &SetCharArrayRegion,
2155     &SetShortArrayRegion,
2156     &SetIntArrayRegion,
2157     &SetLongArrayRegion,
2158     &SetFloatArrayRegion,
2159     &SetDoubleArrayRegion,
2160     &RegisterNatives,
2161     &UnregisterNatives,
2162     &MonitorEnter,
2163     &MonitorExit,
2164     &GetJavaVM,
2165     &GetStringRegion,
2166     &GetStringUTFRegion,
2167     &GetPrimitiveArrayCritical,
2168     &ReleasePrimitiveArrayCritical,
2169     &GetStringCritical,
2170     &ReleaseStringCritical,
2171     &NewWeakGlobalRef,
2172     &DeleteWeakGlobalRef,
2173     &ExceptionCheck
2174     };
2175
2176 /*
2177  * These are local overrides for various environment variables in Emacs.
2178  * Please do not remove this and leave it at the end of the file, where
2179  * Emacs will automagically detect them.
2180  * ---------------------------------------------------------------------
2181  * Local variables:
2182  * mode: c
2183  * indent-tabs-mode: t
2184  * c-basic-offset: 4
2185  * tab-width: 4
2186  * End:
2187  */