jni.c

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