src/native/jni.c

   1 /* src/native/jni.c - implementation of the Java Native Interface functions
   2
   3    Copyright (C) 1996-2005, 2006, 2007, 2008
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5
   6    This file is part of CACAO.
   7
   8    This program is free software; you can redistribute it and/or
   9    modify it under the terms of the GNU General Public License as
  10    published by the Free Software Foundation; either version 2, or (at
  11    your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23 */
  24
  25
  26 #include "config.h"
  27
  28 #include <assert.h>
  29 #include <stdint.h>
  30 #include <string.h>
  31
  32 #include "vm/types.h"
  33
  34 #include "mm/gc-common.h"
  35 #include "mm/memory.h"
  36
  37 #include "native/jni.h"
  38 #include "native/llni.h"
  39 #include "native/localref.h"
  40 #include "native/native.h"
  41
  42 #if defined(ENABLE_JAVASE)
  43 # if defined(WITH_CLASSPATH_GNU)
  44 #  include "native/include/gnu_classpath_Pointer.h"
  45
  46 #  if SIZEOF_VOID_P == 8
  47 #   include "native/include/gnu_classpath_Pointer64.h"
  48 #  else
  49 #   include "native/include/gnu_classpath_Pointer32.h"
  50 #  endif
  51 # endif
  52 #endif
  53
  54 #include "native/include/java_lang_Object.h"
  55 #include "native/include/java_lang_String.h"
  56 #include "native/include/java_lang_Throwable.h"
  57
  58 #if defined(ENABLE_JAVASE)
  59 # if defined(WITH_CLASSPATH_SUN)
  60 #  include "native/include/java_nio_ByteBuffer.h"       /* required by j.l.CL */
  61 # endif
  62
  63 /* java_lang_ClassLoader is used in java_lang_Class and vice versa, so
  64    we pre-define it here to prevent a compiler warning for Sun
  65    configurations. */
  66
  67 struct java_lang_ClassLoader;
  68
  69 # include "native/include/java_lang_Class.h"
  70 # include "native/include/java_lang_ClassLoader.h"
  71
  72 # include "native/include/java_lang_reflect_Constructor.h"
  73 # include "native/include/java_lang_reflect_Field.h"
  74 # include "native/include/java_lang_reflect_Method.h"
  75
  76 # include "native/include/java_nio_Buffer.h"
  77
  78 # if defined(WITH_CLASSPATH_GNU)
  79 #  include "native/include/java_nio_DirectByteBufferImpl.h"
  80 # endif
  81 #endif
  82
  83 #if defined(ENABLE_JVMTI)
  84 # include "native/jvmti/cacaodbg.h"
  85 #endif
  86
  87 #include "native/vm/java_lang_Class.h"
  88
  89 #if defined(ENABLE_JAVASE)
  90 # include "native/vm/reflect.h"
  91 #endif
  92
  93 #include "threads/lock-common.h"
  94 #include "threads/threads-common.h"
  95
  96 #include "toolbox/logging.h"
  97
  98 #include "vm/array.h"
  99 #include "vm/builtin.h"
 100 #include "vm/exceptions.h"
 101 #include "vm/global.h"
 102 #include "vm/initialize.h"
 103 #include "vm/primitive.h"
 104 #include "vm/resolve.h"
 105 #include "vm/stringlocal.h"
 106 #include "vm/vm.h"
 107
 108 #include "vm/jit/argument.h"
 109 #include "vm/jit/asmpart.h"
 110 #include "vm/jit/jit.h"
 111 #include "vm/jit/stacktrace.h"
 112
 113 #include "vmcore/loader.h"
 114 #include "vmcore/options.h"
 115 #include "vmcore/statistics.h"
 116
 117
 118 /* debug **********************************************************************/
 119
 120 #if !defined(NDEBUG)
 121 # define TRACEJNICALLS(text)                                    \
 122     do {                                                                                \
 123         if (opt_TraceJNICalls) {                                \
 124             log_println text;                                   \
 125         }                                                                               \
 126     } while (0)
 127 #else
 128 # define TRACEJNICALLS(text)
 129 #endif
 130
 131
 132 /* global variables ***********************************************************/
 133
 134 /* global reference table *****************************************************/
 135
 136 /* hashsize must be power of 2 */
 137
 138 #define HASHTABLE_GLOBAL_REF_SIZE    64 /* initial size of globalref-hash     */
 139
 140 static hashtable *hashtable_global_ref; /* hashtable for globalrefs           */
 141
 142
 143 /* direct buffer stuff ********************************************************/
 144
 145 #if defined(ENABLE_JAVASE)
 146 static classinfo *class_java_nio_Buffer;
 147
 148 # if defined(WITH_CLASSPATH_GNU)
 149
 150 static classinfo *class_java_nio_DirectByteBufferImpl;
 151 static classinfo *class_java_nio_DirectByteBufferImpl_ReadWrite;
 152
 153 #  if SIZEOF_VOID_P == 8
 154 static classinfo *class_gnu_classpath_Pointer64;
 155 #  else
 156 static classinfo *class_gnu_classpath_Pointer32;
 157 #  endif
 158
 159 static methodinfo *dbbirw_init;
 160
 161 # elif defined(WITH_CLASSPATH_SUN)
 162
 163 static classinfo *class_sun_nio_ch_DirectBuffer;
 164 static classinfo *class_java_nio_DirectByteBuffer;
 165
 166 static methodinfo *dbb_init;
 167
 168 # endif
 169 #endif
 170
 171
 172 /* some forward declarations **************************************************/
 173
 174 jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref);
 175
 176
 177 /* jni_init ********************************************************************
 178
 179    Initialize the JNI subsystem.
 180
 181 *******************************************************************************/
 182
 183 bool jni_init(void)
 184 {
 185         TRACESUBSYSTEMINITIALIZATION("jni_init");
 186
 187         /* create global ref hashtable */
 188
 189         hashtable_global_ref = NEW(hashtable);
 190
 191         hashtable_create(hashtable_global_ref, HASHTABLE_GLOBAL_REF_SIZE);
 192
 193
 194 #if defined(ENABLE_JAVASE)
 195         /* Direct buffer stuff. */
 196
 197         if (!(class_java_nio_Buffer =
 198                   load_class_bootstrap(utf_new_char("java/nio/Buffer"))) ||
 199                 !link_class(class_java_nio_Buffer))
 200                 return false;
 201
 202 # if defined(WITH_CLASSPATH_GNU)
 203
 204         if (!(class_java_nio_DirectByteBufferImpl =
 205                   load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl"))) ||
 206                 !link_class(class_java_nio_DirectByteBufferImpl))
 207                 return false;
 208
 209         if (!(class_java_nio_DirectByteBufferImpl_ReadWrite =
 210                   load_class_bootstrap(utf_new_char("java/nio/DirectByteBufferImpl$ReadWrite"))) ||
 211                 !link_class(class_java_nio_DirectByteBufferImpl_ReadWrite))
 212                 return false;
 213
 214         if (!(dbbirw_init =
 215                 class_resolvemethod(class_java_nio_DirectByteBufferImpl_ReadWrite,
 216                                                         utf_init,
 217                                                         utf_new_char("(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V"))))
 218                 return false;
 219
 220 #  if SIZEOF_VOID_P == 8
 221         if (!(class_gnu_classpath_Pointer64 =
 222                   load_class_bootstrap(utf_new_char("gnu/classpath/Pointer64"))) ||
 223                 !link_class(class_gnu_classpath_Pointer64))
 224                 return false;
 225 #  else
 226         if (!(class_gnu_classpath_Pointer32 =
 227                   load_class_bootstrap(utf_new_char("gnu/classpath/Pointer32"))) ||
 228                 !link_class(class_gnu_classpath_Pointer32))
 229                 return false;
 230 #  endif
 231
 232 # elif defined(WITH_CLASSPATH_SUN)
 233
 234         if (!(class_sun_nio_ch_DirectBuffer =
 235                   load_class_bootstrap(utf_new_char("sun/nio/ch/DirectBuffer"))))
 236                 vm_abort("jni_init: loading sun/nio/ch/DirectBuffer failed");
 237
 238         if (!link_class(class_sun_nio_ch_DirectBuffer))
 239                 vm_abort("jni_init: linking sun/nio/ch/DirectBuffer failed");
 240
 241         if (!(class_java_nio_DirectByteBuffer =
 242                   load_class_bootstrap(utf_new_char("java/nio/DirectByteBuffer"))))
 243                 vm_abort("jni_init: loading java/nio/DirectByteBuffer failed");
 244
 245         if (!link_class(class_java_nio_DirectByteBuffer))
 246                 vm_abort("jni_init: linking java/nio/DirectByteBuffer failed");
 247
 248         if (!(dbb_init =
 249                   class_resolvemethod(class_java_nio_DirectByteBuffer,
 250                                                           utf_init,
 251                                                           utf_new_char("(JI)V"))))
 252                 vm_abort("jni_init: resolving java/nio/DirectByteBuffer.init(JI)V failed");
 253
 254 # endif
 255
 256 #endif /* defined(ENABLE_JAVASE) */
 257
 258         return true;
 259 }
 260
 261
 262 /* jni_version_check ***********************************************************
 263
 264    Check if the given JNI version is supported.
 265
 266    IN:
 267        version....JNI version to check
 268
 269    RETURN VALUE:
 270        true.......supported
 271        false......not supported
 272
 273 *******************************************************************************/
 274
 275 bool jni_version_check(int version)
 276 {
 277         switch (version) {
 278         case JNI_VERSION_1_1:
 279         case JNI_VERSION_1_2:
 280         case JNI_VERSION_1_4:
 281         case JNI_VERSION_1_6:
 282                 return true;
 283         default:
 284                 return false;
 285         }
 286 }
 287
 288
 289 /* _Jv_jni_CallObjectMethod ****************************************************
 290
 291    Internal function to call Java Object methods.
 292
 293 *******************************************************************************/
 294
 295 static java_handle_t *_Jv_jni_CallObjectMethod(java_handle_t *o,
 296                                                                                            vftbl_t *vftbl,
 297                                                                                            methodinfo *m, va_list ap)
 298 {
 299         methodinfo    *resm;
 300         java_handle_t *ro;
 301
 302         STATISTICS(jniinvokation());
 303
 304         if (m == NULL) {
 305                 exceptions_throw_nullpointerexception();
 306                 return NULL;
 307         }
 308
 309         /* Class initialization is done by the JIT compiler.  This is ok
 310            since a static method always belongs to the declaring class. */
 311
 312         if (m->flags & ACC_STATIC) {
 313                 /* For static methods we reset the object. */
 314
 315                 if (o != NULL)
 316                         o = NULL;
 317
 318                 /* for convenience */
 319
 320                 resm = m;
 321
 322         } else {
 323                 /* For instance methods we make a virtual function table lookup. */
 324
 325                 resm = method_vftbl_lookup(vftbl, m);
 326         }
 327
 328         STATISTICS(jnicallXmethodnvokation());
 329
 330         ro = vm_call_method_valist(resm, o, ap);
 331
 332         return ro;
 333 }
 334
 335
 336 /* _Jv_jni_CallObjectMethodA ***************************************************
 337
 338    Internal function to call Java Object methods.
 339
 340 *******************************************************************************/
 341
 342 static java_handle_t *_Jv_jni_CallObjectMethodA(java_handle_t *o,
 343                                                                                                 vftbl_t *vftbl,
 344                                                                                                 methodinfo *m,
 345                                                                                                 const jvalue *args)
 346 {
 347         methodinfo    *resm;
 348         java_handle_t *ro;
 349
 350         STATISTICS(jniinvokation());
 351
 352         if (m == NULL) {
 353                 exceptions_throw_nullpointerexception();
 354                 return NULL;
 355         }
 356
 357         /* Class initialization is done by the JIT compiler.  This is ok
 358            since a static method always belongs to the declaring class. */
 359
 360         if (m->flags & ACC_STATIC) {
 361                 /* For static methods we reset the object. */
 362
 363                 if (o != NULL)
 364                         o = NULL;
 365
 366                 /* for convenience */
 367
 368                 resm = m;
 369
 370         } else {
 371                 /* For instance methods we make a virtual function table lookup. */
 372
 373                 resm = method_vftbl_lookup(vftbl, m);
 374         }
 375
 376         STATISTICS(jnicallXmethodnvokation());
 377
 378         ro = vm_call_method_jvalue(resm, o, args);
 379
 380         return ro;
 381 }
 382
 383
 384 /* _Jv_jni_CallIntMethod *******************************************************
 385
 386    Internal function to call Java integer class methods (boolean,
 387    byte, char, short, int).
 388
 389 *******************************************************************************/
 390
 391 static jint _Jv_jni_CallIntMethod(java_handle_t *o, vftbl_t *vftbl,
 392                                                                   methodinfo *m, va_list ap)
 393 {
 394         methodinfo *resm;
 395         jint        i;
 396
 397         STATISTICS(jniinvokation());
 398
 399         if (m == NULL) {
 400                 exceptions_throw_nullpointerexception();
 401                 return 0;
 402         }
 403
 404         /* Class initialization is done by the JIT compiler.  This is ok
 405            since a static method always belongs to the declaring class. */
 406
 407         if (m->flags & ACC_STATIC) {
 408                 /* For static methods we reset the object. */
 409
 410                 if (o != NULL)
 411                         o = NULL;
 412
 413                 /* for convenience */
 414
 415                 resm = m;
 416
 417         } else {
 418                 /* For instance methods we make a virtual function table lookup. */
 419
 420                 resm = method_vftbl_lookup(vftbl, m);
 421         }
 422
 423         STATISTICS(jnicallXmethodnvokation());
 424
 425         i = vm_call_method_int_valist(resm, o, ap);
 426
 427         return i;
 428 }
 429
 430
 431 /* _Jv_jni_CallIntMethodA ******************************************************
 432
 433    Internal function to call Java integer class methods (boolean,
 434    byte, char, short, int).
 435
 436 *******************************************************************************/
 437
 438 static jint _Jv_jni_CallIntMethodA(java_handle_t *o, vftbl_t *vftbl,
 439                                                                    methodinfo *m, const jvalue *args)
 440 {
 441         methodinfo *resm;
 442         jint        i;
 443
 444         STATISTICS(jniinvokation());
 445
 446         if (m == NULL) {
 447                 exceptions_throw_nullpointerexception();
 448                 return 0;
 449         }
 450
 451         /* Class initialization is done by the JIT compiler.  This is ok
 452            since a static method always belongs to the declaring class. */
 453
 454         if (m->flags & ACC_STATIC) {
 455                 /* For static methods we reset the object. */
 456
 457                 if (o != NULL)
 458                         o = NULL;
 459
 460                 /* for convenience */
 461
 462                 resm = m;
 463
 464         } else {
 465                 /* For instance methods we make a virtual function table lookup. */
 466
 467                 resm = method_vftbl_lookup(vftbl, m);
 468         }
 469
 470         STATISTICS(jnicallXmethodnvokation());
 471
 472         i = vm_call_method_int_jvalue(resm, o, args);
 473
 474         return i;
 475 }
 476
 477
 478 /* _Jv_jni_CallLongMethod ******************************************************
 479
 480    Internal function to call Java long methods.
 481
 482 *******************************************************************************/
 483
 484 static jlong _Jv_jni_CallLongMethod(java_handle_t *o, vftbl_t *vftbl,
 485                                                                         methodinfo *m, va_list ap)
 486 {
 487         methodinfo *resm;
 488         jlong       l;
 489
 490         STATISTICS(jniinvokation());
 491
 492         if (m == NULL) {
 493                 exceptions_throw_nullpointerexception();
 494                 return 0;
 495         }
 496
 497         /* Class initialization is done by the JIT compiler.  This is ok
 498            since a static method always belongs to the declaring class. */
 499
 500         if (m->flags & ACC_STATIC) {
 501                 /* For static methods we reset the object. */
 502
 503                 if (o != NULL)
 504                         o = NULL;
 505
 506                 /* for convenience */
 507
 508                 resm = m;
 509
 510         } else {
 511                 /* For instance methods we make a virtual function table lookup. */
 512
 513                 resm = method_vftbl_lookup(vftbl, m);
 514         }
 515
 516         STATISTICS(jnicallXmethodnvokation());
 517
 518         l = vm_call_method_long_valist(resm, o, ap);
 519
 520         return l;
 521 }
 522
 523
 524 /* _Jv_jni_CallLongMethodA *****************************************************
 525
 526    Internal function to call Java long methods.
 527
 528 *******************************************************************************/
 529
 530 static jlong _Jv_jni_CallLongMethodA(java_handle_t *o, vftbl_t *vftbl,
 531                                                                          methodinfo *m, const jvalue *args)
 532 {
 533         methodinfo *resm;
 534         jlong       l;
 535
 536         STATISTICS(jniinvokation());
 537
 538         if (m == NULL) {
 539                 exceptions_throw_nullpointerexception();
 540                 return 0;
 541         }
 542
 543         /* Class initialization is done by the JIT compiler.  This is ok
 544            since a static method always belongs to the declaring class. */
 545
 546         if (m->flags & ACC_STATIC) {
 547                 /* For static methods we reset the object. */
 548
 549                 if (o != NULL)
 550                         o = NULL;
 551
 552                 /* for convenience */
 553
 554                 resm = m;
 555         }
 556         else {
 557                 /* For instance methods we make a virtual function table lookup. */
 558
 559                 resm = method_vftbl_lookup(vftbl, m);
 560         }
 561
 562         STATISTICS(jnicallXmethodnvokation());
 563
 564         l = vm_call_method_long_jvalue(resm, o, args);
 565
 566         return l;
 567 }
 568
 569
 570 /* _Jv_jni_CallFloatMethod *****************************************************
 571
 572    Internal function to call Java float methods.
 573
 574 *******************************************************************************/
 575
 576 static jfloat _Jv_jni_CallFloatMethod(java_handle_t *o, vftbl_t *vftbl,
 577                                                                           methodinfo *m, va_list ap)
 578 {
 579         methodinfo *resm;
 580         jfloat      f;
 581
 582         /* Class initialization is done by the JIT compiler.  This is ok
 583            since a static method always belongs to the declaring class. */
 584
 585         if (m->flags & ACC_STATIC) {
 586                 /* For static methods we reset the object. */
 587
 588                 if (o != NULL)
 589                         o = NULL;
 590
 591                 /* for convenience */
 592
 593                 resm = m;
 594
 595         } else {
 596                 /* For instance methods we make a virtual function table lookup. */
 597
 598                 resm = method_vftbl_lookup(vftbl, m);
 599         }
 600
 601         STATISTICS(jnicallXmethodnvokation());
 602
 603         f = vm_call_method_float_valist(resm, o, ap);
 604
 605         return f;
 606 }
 607
 608
 609 /* _Jv_jni_CallFloatMethodA ****************************************************
 610
 611    Internal function to call Java float methods.
 612
 613 *******************************************************************************/
 614
 615 static jfloat _Jv_jni_CallFloatMethodA(java_handle_t *o, vftbl_t *vftbl,
 616                                                                            methodinfo *m, const jvalue *args)
 617 {
 618         methodinfo *resm;
 619         jfloat      f;
 620
 621         /* Class initialization is done by the JIT compiler.  This is ok
 622            since a static method always belongs to the declaring class. */
 623
 624         if (m->flags & ACC_STATIC) {
 625                 /* For static methods we reset the object. */
 626
 627                 if (o != NULL)
 628                         o = NULL;
 629
 630                 /* for convenience */
 631
 632                 resm = m;
 633         }
 634         else {
 635                 /* For instance methods we make a virtual function table lookup. */
 636
 637                 resm = method_vftbl_lookup(vftbl, m);
 638         }
 639
 640         STATISTICS(jnicallXmethodnvokation());
 641
 642         f = vm_call_method_float_jvalue(resm, o, args);
 643
 644         return f;
 645 }
 646
 647
 648 /* _Jv_jni_CallDoubleMethod ****************************************************
 649
 650    Internal function to call Java double methods.
 651
 652 *******************************************************************************/
 653
 654 static jdouble _Jv_jni_CallDoubleMethod(java_handle_t *o, vftbl_t *vftbl,
 655                                                                                 methodinfo *m, va_list ap)
 656 {
 657         methodinfo *resm;
 658         jdouble     d;
 659
 660         /* Class initialization is done by the JIT compiler.  This is ok
 661            since a static method always belongs to the declaring class. */
 662
 663         if (m->flags & ACC_STATIC) {
 664                 /* For static methods we reset the object. */
 665
 666                 if (o != NULL)
 667                         o = NULL;
 668
 669                 /* for convenience */
 670
 671                 resm = m;
 672
 673         } else {
 674                 /* For instance methods we make a virtual function table lookup. */
 675
 676                 resm = method_vftbl_lookup(vftbl, m);
 677         }
 678
 679         d = vm_call_method_double_valist(resm, o, ap);
 680
 681         return d;
 682 }
 683
 684
 685 /* _Jv_jni_CallDoubleMethodA ***************************************************
 686
 687    Internal function to call Java double methods.
 688
 689 *******************************************************************************/
 690
 691 static jdouble _Jv_jni_CallDoubleMethodA(java_handle_t *o, vftbl_t *vftbl,
 692                                                                                  methodinfo *m, const jvalue *args)
 693 {
 694         methodinfo *resm;
 695         jdouble     d;
 696
 697         /* Class initialization is done by the JIT compiler.  This is ok
 698            since a static method always belongs to the declaring class. */
 699
 700         if (m->flags & ACC_STATIC) {
 701                 /* For static methods we reset the object. */
 702
 703                 if (o != NULL)
 704                         o = NULL;
 705
 706                 /* for convenience */
 707
 708                 resm = m;
 709         }
 710         else {
 711                 /* For instance methods we make a virtual function table lookup. */
 712
 713                 resm = method_vftbl_lookup(vftbl, m);
 714         }
 715
 716         d = vm_call_method_double_jvalue(resm, o, args);
 717
 718         return d;
 719 }
 720
 721
 722 /* _Jv_jni_CallVoidMethod ******************************************************
 723
 724    Internal function to call Java void methods.
 725
 726 *******************************************************************************/
 727
 728 static void _Jv_jni_CallVoidMethod(java_handle_t *o, vftbl_t *vftbl,
 729                                                                    methodinfo *m, va_list ap)
 730 {
 731         methodinfo *resm;
 732
 733         if (m == NULL) {
 734                 exceptions_throw_nullpointerexception();
 735                 return;
 736         }
 737
 738         /* Class initialization is done by the JIT compiler.  This is ok
 739            since a static method always belongs to the declaring class. */
 740
 741         if (m->flags & ACC_STATIC) {
 742                 /* For static methods we reset the object. */
 743
 744                 if (o != NULL)
 745                         o = NULL;
 746
 747                 /* for convenience */
 748
 749                 resm = m;
 750
 751         } else {
 752                 /* For instance methods we make a virtual function table lookup. */
 753
 754                 resm = method_vftbl_lookup(vftbl, m);
 755         }
 756
 757         STATISTICS(jnicallXmethodnvokation());
 758
 759         (void) vm_call_method_valist(resm, o, ap);
 760 }
 761
 762
 763 /* _Jv_jni_CallVoidMethodA *****************************************************
 764
 765    Internal function to call Java void methods.
 766
 767 *******************************************************************************/
 768
 769 static void _Jv_jni_CallVoidMethodA(java_handle_t *o, vftbl_t *vftbl,
 770                                                                         methodinfo *m, const jvalue *args)
 771 {
 772         methodinfo *resm;
 773
 774         if (m == NULL) {
 775                 exceptions_throw_nullpointerexception();
 776                 return;
 777         }
 778
 779         /* Class initialization is done by the JIT compiler.  This is ok
 780            since a static method always belongs to the declaring class. */
 781
 782         if (m->flags & ACC_STATIC) {
 783                 /* For static methods we reset the object. */
 784
 785                 if (o != NULL)
 786                         o = NULL;
 787
 788                 /* for convenience */
 789
 790                 resm = m;
 791
 792         } else {
 793                 /* For instance methods we make a virtual function table lookup. */
 794
 795                 resm = method_vftbl_lookup(vftbl, m);
 796         }
 797
 798         STATISTICS(jnicallXmethodnvokation());
 799
 800         (void) vm_call_method_jvalue(resm, o, args);
 801 }
 802
 803
 804 /* _Jv_jni_invokeNative ********************************************************
 805
 806    Invoke a method on the given object with the given arguments.
 807
 808    For instance methods OBJ must be != NULL and the method is looked up
 809    in the vftbl of the object.
 810
 811    For static methods, OBJ is ignored.
 812
 813 *******************************************************************************/
 814
 815 java_handle_t *_Jv_jni_invokeNative(methodinfo *m, java_handle_t *o,
 816                                                                         java_handle_objectarray_t *params)
 817 {
 818         methodinfo    *resm;
 819         java_handle_t *ro;
 820         s4             argcount;
 821         s4             paramcount;
 822
 823         if (m == NULL) {
 824                 exceptions_throw_nullpointerexception();
 825                 return NULL;
 826         }
 827
 828         argcount = m->parseddesc->paramcount;
 829         paramcount = argcount;
 830
 831         /* if method is non-static, remove the `this' pointer */
 832
 833         if (!(m->flags & ACC_STATIC))
 834                 paramcount--;
 835
 836         /* For instance methods the object has to be an instance of the
 837            class the method belongs to. For static methods the obj
 838            parameter is ignored. */
 839
 840         if (!(m->flags & ACC_STATIC) && o && (!builtin_instanceof(o, m->class))) {
 841                 exceptions_throw_illegalargumentexception();
 842                 return NULL;
 843         }
 844
 845         /* check if we got the right number of arguments */
 846
 847         if (((params == NULL) && (paramcount != 0)) ||
 848                 (params && (LLNI_array_size(params) != paramcount)))
 849         {
 850                 exceptions_throw_illegalargumentexception();
 851                 return NULL;
 852         }
 853
 854         /* for instance methods we need an object */
 855
 856         if (!(m->flags & ACC_STATIC) && (o == NULL)) {
 857                 /* XXX not sure if that is the correct exception */
 858                 exceptions_throw_nullpointerexception();
 859                 return NULL;
 860         }
 861
 862         /* for static methods, zero object to make subsequent code simpler */
 863         if (m->flags & ACC_STATIC)
 864                 o = NULL;
 865
 866         if (o != NULL) {
 867                 /* for instance methods we must do a vftbl lookup */
 868                 resm = method_vftbl_lookup(LLNI_vftbl_direct(o), m);
 869         }
 870         else {
 871                 /* for static methods, just for convenience */
 872                 resm = m;
 873         }
 874
 875         ro = vm_call_method_objectarray(resm, o, params);
 876
 877         return ro;
 878 }
 879
 880
 881 /* GetVersion ******************************************************************
 882
 883    Returns the major version number in the higher 16 bits and the
 884    minor version number in the lower 16 bits.
 885
 886 *******************************************************************************/
 887
 888 jint _Jv_JNI_GetVersion(JNIEnv *env)
 889 {
 890         TRACEJNICALLS(("_Jv_JNI_GetVersion(env=%p)", env));
 891
 892         /* We support JNI 1.6. */
 893
 894         return JNI_VERSION_1_6;
 895 }
 896
 897
 898 /* Class Operations ***********************************************************/
 899
 900 /* DefineClass *****************************************************************
 901
 902    Loads a class from a buffer of raw class data. The buffer
 903    containing the raw class data is not referenced by the VM after the
 904    DefineClass call returns, and it may be discarded if desired.
 905
 906 *******************************************************************************/
 907
 908 jclass _Jv_JNI_DefineClass(JNIEnv *env, const char *name, jobject loader,
 909                                                    const jbyte *buf, jsize bufLen)
 910 {
 911 #if defined(ENABLE_JAVASE)
 912         utf             *u;
 913         classloader     *cl;
 914         classinfo       *c;
 915         java_lang_Class *co;
 916
 917         TRACEJNICALLS(("_Jv_JNI_DefineClass(env=%p, name=%s, loader=%p, buf=%p, bufLen=%d)", env, name, loader, buf, bufLen));
 918
 919         u  = utf_new_char(name);
 920         cl = loader_hashtable_classloader_add((java_handle_t *) loader);
 921
 922         c = class_define(u, cl, bufLen, (uint8_t *) buf, NULL);
 923
 924         co = LLNI_classinfo_wrap(c);
 925
 926         return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) co);
 927 #else
 928         vm_abort("_Jv_JNI_DefineClass: not implemented in this configuration");
 929
 930         /* keep compiler happy */
 931
 932         return 0;
 933 #endif
 934 }
 935
 936
 937 /* FindClass *******************************************************************
 938
 939    This function loads a locally-defined class. It searches the
 940    directories and zip files specified by the CLASSPATH environment
 941    variable for the class with the specified name.
 942
 943 *******************************************************************************/
 944
 945 jclass _Jv_JNI_FindClass(JNIEnv *env, const char *name)
 946 {
 947 #if defined(ENABLE_JAVASE)
 948
 949         utf             *u;
 950         classinfo       *cc;
 951         classinfo       *c;
 952         java_lang_Class *co;
 953
 954         TRACEJNICALLS(("_Jv_JNI_FindClass(env=%p, name=%s)", env, name));
 955
 956         u = utf_new_char_classname((char *) name);
 957
 958         /* Check stacktrace for classloader, if one found use it,
 959            otherwise use the system classloader. */
 960
 961         /* Quote from the JNI documentation:
 962
 963            In the Java 2 Platform, FindClass locates the class loader
 964            associated with the current native method.  If the native code
 965            belongs to a system class, no class loader will be
 966            involved. Otherwise, the proper class loader will be invoked to
 967            load and link the named class. When FindClass is called through
 968            the Invocation Interface, there is no current native method or
 969            its associated class loader. In that case, the result of
 970            ClassLoader.getBaseClassLoader is used." */
 971
 972         cc = stacktrace_get_current_class();
 973
 974         if (cc == NULL)
 975                 c = load_class_from_sysloader(u);
 976         else
 977                 c = load_class_from_classloader(u, cc->classloader);
 978
 979         if (c == NULL)
 980                 return NULL;
 981
 982         if (!link_class(c))
 983                 return NULL;
 984
 985         co = LLNI_classinfo_wrap(c);
 986
 987         return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) co);
 988
 989 #elif defined(ENABLE_JAVAME_CLDC1_1)
 990
 991         utf       *u;
 992         classinfo *c;
 993
 994         TRACEJNICALLS(("_Jv_JNI_FindClass(env=%p, name=%s)", env, name));
 995
 996         u = utf_new_char_classname((char *) name);
 997         c = load_class_bootstrap(u);
 998
 999         if (c == NULL)
1000                 return NULL;
1001
1002         if (!link_class(c))
1003                 return NULL;
1004
1005         return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) c);
1006
1007 #else
1008         vm_abort("_Jv_JNI_FindClass: not implemented in this configuration");
1009
1010         /* keep compiler happy */
1011
1012         return NULL;
1013 #endif
1014 }
1015
1016
1017 /* GetSuperclass ***************************************************************
1018
1019    If clazz represents any class other than the class Object, then
1020    this function returns the object that represents the superclass of
1021    the class specified by clazz.
1022
1023 *******************************************************************************/
1024
1025 jclass _Jv_JNI_GetSuperclass(JNIEnv *env, jclass sub)
1026 {
1027         classinfo       *c;
1028         classinfo       *super;
1029         java_lang_Class *co;
1030
1031         TRACEJNICALLS(("_Jv_JNI_GetSuperclass(env=%p, sub=%p)", env, sub));
1032
1033         c = LLNI_classinfo_unwrap(sub);
1034
1035         if (c == NULL)
1036                 return NULL;
1037
1038         super = class_get_superclass(c);
1039
1040         co = LLNI_classinfo_wrap(super);
1041
1042         return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) co);
1043 }
1044
1045
1046 /* IsAssignableFrom ************************************************************
1047
1048    Determines whether an object of sub can be safely cast to sup.
1049
1050 *******************************************************************************/
1051
1052 jboolean _Jv_JNI_IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup)
1053 {
1054         java_lang_Class *csup;
1055         java_lang_Class *csub;
1056
1057         csup = (java_lang_Class *) sup;
1058         csub = (java_lang_Class *) sub;
1059
1060         STATISTICS(jniinvokation());
1061
1062         return _Jv_java_lang_Class_isAssignableFrom(csup, csub);
1063 }
1064
1065
1066 /* Throw ***********************************************************************
1067
1068    Causes a java.lang.Throwable object to be thrown.
1069
1070 *******************************************************************************/
1071
1072 jint _Jv_JNI_Throw(JNIEnv *env, jthrowable obj)
1073 {
1074         java_handle_t *o;
1075
1076         STATISTICS(jniinvokation());
1077
1078         o = (java_handle_t *) obj;
1079
1080         exceptions_set_exception(o);
1081
1082         return JNI_OK;
1083 }
1084
1085
1086 /* ThrowNew ********************************************************************
1087
1088    Constructs an exception object from the specified class with the
1089    message specified by message and causes that exception to be
1090    thrown.
1091
1092 *******************************************************************************/
1093
1094 jint _Jv_JNI_ThrowNew(JNIEnv* env, jclass clazz, const char *msg)
1095 {
1096         classinfo     *c;
1097         java_handle_t *o;
1098         java_handle_t *s;
1099
1100         STATISTICS(jniinvokation());
1101
1102         c = LLNI_classinfo_unwrap(clazz);
1103         if (msg == NULL)
1104                 msg = "";
1105         s = javastring_new_from_utf_string(msg);
1106
1107         /* instantiate exception object */
1108
1109         o = native_new_and_init_string(c, s);
1110
1111         if (o == NULL)
1112                 return -1;
1113
1114         exceptions_set_exception(o);
1115
1116         return 0;
1117 }
1118
1119
1120 /* ExceptionOccurred ***********************************************************
1121
1122    Determines if an exception is being thrown. The exception stays
1123    being thrown until either the native code calls ExceptionClear(),
1124    or the Java code handles the exception.
1125
1126 *******************************************************************************/
1127
1128 jthrowable _Jv_JNI_ExceptionOccurred(JNIEnv *env)
1129 {
1130         java_handle_t *o;
1131
1132         TRACEJNICALLS(("_Jv_JNI_ExceptionOccurred(env=%p)", env));
1133
1134         o = exceptions_get_exception();
1135
1136         return _Jv_JNI_NewLocalRef(env, (jthrowable) o);
1137 }
1138
1139
1140 /* ExceptionDescribe ***********************************************************
1141
1142    Prints an exception and a backtrace of the stack to a system
1143    error-reporting channel, such as stderr. This is a convenience
1144    routine provided for debugging.
1145
1146 *******************************************************************************/
1147
1148 void _Jv_JNI_ExceptionDescribe(JNIEnv *env)
1149 {
1150         java_handle_t *o;
1151         classinfo     *c;
1152         methodinfo    *m;
1153
1154         TRACEJNICALLS(("_Jv_JNI_ExceptionDescribe(env=%p)", env));
1155
1156         /* Clear exception, because we are probably calling Java code
1157            again. */
1158
1159         o = exceptions_get_and_clear_exception();
1160
1161         if (o != NULL) {
1162                 /* get printStackTrace method from exception class */
1163
1164                 LLNI_class_get(o, c);
1165
1166                 m = class_resolveclassmethod(c,
1167                                                                          utf_printStackTrace,
1168                                                                          utf_void__void,
1169                                                                          NULL,
1170                                                                          true);
1171
1172                 if (m == NULL)
1173                         vm_abort("_Jv_JNI_ExceptionDescribe: could not find printStackTrace");
1174
1175                 /* Print the stacktrace. */
1176
1177                 (void) vm_call_method(m, o);
1178         }
1179 }
1180
1181
1182 /* ExceptionClear **************************************************************
1183
1184    Clears any exception that is currently being thrown. If no
1185    exception is currently being thrown, this routine has no effect.
1186
1187 *******************************************************************************/
1188
1189 void _Jv_JNI_ExceptionClear(JNIEnv *env)
1190 {
1191         STATISTICS(jniinvokation());
1192
1193         exceptions_clear_exception();
1194 }
1195
1196
1197 /* FatalError ******************************************************************
1198
1199    Raises a fatal error and does not expect the VM to recover. This
1200    function does not return.
1201
1202 *******************************************************************************/
1203
1204 void _Jv_JNI_FatalError(JNIEnv *env, const char *msg)
1205 {
1206         STATISTICS(jniinvokation());
1207
1208         /* this seems to be the best way */
1209
1210         vm_abort("JNI Fatal error: %s", msg);
1211 }
1212
1213
1214 /* PushLocalFrame **************************************************************
1215
1216    Creates a new local reference frame, in which at least a given
1217    number of local references can be created.
1218
1219 *******************************************************************************/
1220
1221 jint _Jv_JNI_PushLocalFrame(JNIEnv* env, jint capacity)
1222 {
1223         STATISTICS(jniinvokation());
1224
1225         if (capacity <= 0)
1226                 return -1;
1227
1228         /* add new local reference frame to current table */
1229
1230         if (!localref_frame_push(capacity))
1231                 return -1;
1232
1233         return 0;
1234 }
1235
1236
1237 /* PopLocalFrame ***************************************************************
1238
1239    Pops off the current local reference frame, frees all the local
1240    references, and returns a local reference in the previous local
1241    reference frame for the given result object.
1242
1243 *******************************************************************************/
1244
1245 jobject _Jv_JNI_PopLocalFrame(JNIEnv* env, jobject result)
1246 {
1247         STATISTICS(jniinvokation());
1248
1249         /* release all current local frames */
1250
1251         localref_frame_pop_all();
1252
1253         /* add local reference and return the value */
1254
1255         return _Jv_JNI_NewLocalRef(env, result);
1256 }
1257
1258
1259 /* DeleteLocalRef **************************************************************
1260
1261    Deletes the local reference pointed to by localRef.
1262
1263 *******************************************************************************/
1264
1265 void _Jv_JNI_DeleteLocalRef(JNIEnv *env, jobject localRef)
1266 {
1267         java_handle_t *o;
1268
1269         STATISTICS(jniinvokation());
1270
1271         o = (java_handle_t *) localRef;
1272
1273         if (o == NULL)
1274                 return;
1275
1276         /* delete the reference */
1277
1278         localref_del(o);
1279 }
1280
1281
1282 /* IsSameObject ****************************************************************
1283
1284    Tests whether two references refer to the same Java object.
1285
1286 *******************************************************************************/
1287
1288 jboolean _Jv_JNI_IsSameObject(JNIEnv *env, jobject ref1, jobject ref2)
1289 {
1290         java_handle_t *o1;
1291         java_handle_t *o2;
1292         jboolean       result;
1293
1294         STATISTICS(jniinvokation());
1295
1296         o1 = (java_handle_t *) ref1;
1297         o2 = (java_handle_t *) ref2;
1298
1299         LLNI_CRITICAL_START;
1300
1301         if (LLNI_UNWRAP(o1) == LLNI_UNWRAP(o2))
1302                 result = JNI_TRUE;
1303         else
1304                 result = JNI_FALSE;
1305
1306         LLNI_CRITICAL_END;
1307
1308         return result;
1309 }
1310
1311
1312 /* NewLocalRef *****************************************************************
1313
1314    Creates a new local reference that refers to the same object as ref.
1315
1316 *******************************************************************************/
1317
1318 jobject _Jv_JNI_NewLocalRef(JNIEnv *env, jobject ref)
1319 {
1320         java_handle_t *o;
1321         java_handle_t *localref;
1322
1323         STATISTICS(jniinvokation());
1324
1325         o = (java_handle_t *) ref;
1326
1327         if (o == NULL)
1328                 return NULL;
1329
1330         /* insert the reference */
1331
1332         localref = localref_add(LLNI_DIRECT(o));
1333
1334         return (jobject) localref;
1335 }
1336
1337
1338 /* EnsureLocalCapacity *********************************************************
1339
1340    Ensures that at least a given number of local references can be
1341    created in the current thread
1342
1343 *******************************************************************************/
1344
1345 jint _Jv_JNI_EnsureLocalCapacity(JNIEnv* env, jint capacity)
1346 {
1347         localref_table *lrt;
1348
1349         STATISTICS(jniinvokation());
1350
1351         /* get local reference table (thread specific) */
1352
1353         lrt = LOCALREFTABLE;
1354
1355         /* check if capacity elements are available in the local references table */
1356
1357         if ((lrt->used + capacity) > lrt->capacity)
1358                 return _Jv_JNI_PushLocalFrame(env, capacity);
1359
1360         return 0;
1361 }
1362
1363
1364 /* AllocObject *****************************************************************
1365
1366    Allocates a new Java object without invoking any of the
1367    constructors for the object. Returns a reference to the object.
1368
1369 *******************************************************************************/
1370
1371 jobject _Jv_JNI_AllocObject(JNIEnv *env, jclass clazz)
1372 {
1373         classinfo     *c;
1374         java_handle_t *o;
1375
1376         STATISTICS(jniinvokation());
1377
1378         c = LLNI_classinfo_unwrap(clazz);
1379
1380         if ((c->flags & ACC_INTERFACE) || (c->flags & ACC_ABSTRACT)) {
1381                 exceptions_throw_instantiationexception(c);
1382                 return NULL;
1383         }
1384
1385         o = builtin_new(c);
1386
1387         return _Jv_JNI_NewLocalRef(env, (jobject) o);
1388 }
1389
1390
1391 /* NewObject *******************************************************************
1392
1393    Programmers place all arguments that are to be passed to the
1394    constructor immediately following the methodID
1395    argument. NewObject() accepts these arguments and passes them to
1396    the Java method that the programmer wishes to invoke.
1397
1398 *******************************************************************************/
1399
1400 jobject _Jv_JNI_NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...)
1401 {
1402         java_handle_t *o;
1403         classinfo     *c;
1404         methodinfo    *m;
1405         va_list        ap;
1406
1407         STATISTICS(jniinvokation());
1408
1409         c = LLNI_classinfo_unwrap(clazz);
1410         m = (methodinfo *) methodID;
1411
1412         /* create object */
1413
1414         o = builtin_new(c);
1415
1416         if (o == NULL)
1417                 return NULL;
1418
1419         /* call constructor */
1420
1421         va_start(ap, methodID);
1422         _Jv_jni_CallVoidMethod(o, LLNI_vftbl_direct(o), m, ap);
1423         va_end(ap);
1424
1425         return _Jv_JNI_NewLocalRef(env, (jobject) o);
1426 }
1427
1428
1429 /* NewObjectV ******************************************************************
1430
1431    Programmers place all arguments that are to be passed to the
1432    constructor in an args argument of type va_list that immediately
1433    follows the methodID argument. NewObjectV() accepts these
1434    arguments, and, in turn, passes them to the Java method that the
1435    programmer wishes to invoke.
1436
1437 *******************************************************************************/
1438
1439 jobject _Jv_JNI_NewObjectV(JNIEnv* env, jclass clazz, jmethodID methodID,
1440                                                    va_list args)
1441 {
1442         java_handle_t *o;
1443         classinfo     *c;
1444         methodinfo    *m;
1445
1446         STATISTICS(jniinvokation());
1447
1448         c = LLNI_classinfo_unwrap(clazz);
1449         m = (methodinfo *) methodID;
1450
1451         /* create object */
1452
1453         o = builtin_new(c);
1454
1455         if (o == NULL)
1456                 return NULL;
1457
1458         /* call constructor */
1459
1460         _Jv_jni_CallVoidMethod(o, LLNI_vftbl_direct(o), m, args);
1461
1462         return _Jv_JNI_NewLocalRef(env, (jobject) o);
1463 }
1464
1465
1466 /* NewObjectA *****************************************************************
1467
1468    Programmers place all arguments that are to be passed to the
1469    constructor in an args array of jvalues that immediately follows
1470    the methodID argument. NewObjectA() accepts the arguments in this
1471    array, and, in turn, passes them to the Java method that the
1472    programmer wishes to invoke.
1473
1474 *******************************************************************************/
1475
1476 jobject _Jv_JNI_NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID,
1477                                                    const jvalue *args)
1478 {
1479         java_handle_t *o;
1480         classinfo     *c;
1481         methodinfo    *m;
1482
1483         STATISTICS(jniinvokation());
1484
1485         c = LLNI_classinfo_unwrap(clazz);
1486         m = (methodinfo *) methodID;
1487
1488         /* create object */
1489
1490         o = builtin_new(c);
1491
1492         if (o == NULL)
1493                 return NULL;
1494
1495         /* call constructor */
1496
1497         _Jv_jni_CallVoidMethodA(o, LLNI_vftbl_direct(o), m, args);
1498
1499         return _Jv_JNI_NewLocalRef(env, (jobject) o);
1500 }
1501
1502
1503 /* GetObjectClass **************************************************************
1504
1505  Returns the class of an object.
1506
1507 *******************************************************************************/
1508
1509 jclass _Jv_JNI_GetObjectClass(JNIEnv *env, jobject obj)
1510 {
1511         java_handle_t   *o;
1512         classinfo       *c;
1513         java_lang_Class *co;
1514
1515         STATISTICS(jniinvokation());
1516
1517         o = (java_handle_t *) obj;
1518
1519         if ((o == NULL) || (LLNI_vftbl_direct(o) == NULL))
1520                 return NULL;
1521
1522         LLNI_class_get(o, c);
1523
1524         co = LLNI_classinfo_wrap(c);
1525
1526         return (jclass) _Jv_JNI_NewLocalRef(env, (jobject) co);
1527 }
1528
1529
1530 /* IsInstanceOf ****************************************************************
1531
1532    Tests whether an object is an instance of a class.
1533
1534 *******************************************************************************/
1535
1536 jboolean _Jv_JNI_IsInstanceOf(JNIEnv *env, jobject obj, jclass clazz)
1537 {
1538         java_lang_Class  *c;
1539         java_lang_Object *o;
1540
1541         STATISTICS(jniinvokation());
1542
1543         c = (java_lang_Class *) clazz;
1544         o = (java_lang_Object *) obj;
1545
1546         return _Jv_java_lang_Class_isInstance(c, o);
1547 }
1548
1549
1550 /* Reflection Support *********************************************************/
1551
1552 /* FromReflectedMethod *********************************************************
1553
1554    Converts java.lang.reflect.Method or java.lang.reflect.Constructor
1555    object to a method ID.
1556
1557 *******************************************************************************/
1558
1559 jmethodID _Jv_JNI_FromReflectedMethod(JNIEnv *env, jobject method)
1560 {
1561 #if defined(ENABLE_JAVASE)
1562         java_handle_t *o;
1563         classinfo     *c;
1564         methodinfo    *m;
1565         s4             slot;
1566
1567         STATISTICS(jniinvokation());
1568
1569         o = (java_handle_t *) method;
1570
1571         if (o == NULL)
1572                 return NULL;
1573
1574         if (builtin_instanceof(o, class_java_lang_reflect_Method)) {
1575                 java_lang_reflect_Method *rm;
1576
1577                 rm   = (java_lang_reflect_Method *) method;
1578                 LLNI_field_get_cls(rm, clazz, c);
1579                 LLNI_field_get_val(rm, slot , slot);
1580         }
1581         else if (builtin_instanceof(o, class_java_lang_reflect_Constructor)) {
1582                 java_lang_reflect_Constructor *rc;
1583
1584                 rc   = (java_lang_reflect_Constructor *) method;
1585                 LLNI_field_get_cls(rc, clazz, c);
1586                 LLNI_field_get_val(rc, slot , slot);
1587         }
1588         else
1589                 return NULL;
1590
1591         m = &(c->methods[slot]);
1592
1593         return (jmethodID) m;
1594 #else
1595         vm_abort("_Jv_JNI_FromReflectedMethod: not implemented in this configuration");
1596
1597         /* keep compiler happy */
1598
1599         return NULL;
1600 #endif
1601 }
1602
1603
1604 /* FromReflectedField **********************************************************
1605
1606    Converts a java.lang.reflect.Field to a field ID.
1607
1608 *******************************************************************************/
1609
1610 jfieldID _Jv_JNI_FromReflectedField(JNIEnv* env, jobject field)
1611 {
1612 #if defined(ENABLE_JAVASE)
1613         java_lang_reflect_Field *rf;
1614         classinfo               *c;
1615         fieldinfo               *f;
1616         int32_t                  slot;
1617
1618         STATISTICS(jniinvokation());
1619
1620         rf = (java_lang_reflect_Field *) field;
1621
1622         if (rf == NULL)
1623                 return NULL;
1624
1625         LLNI_field_get_cls(rf, clazz, c);
1626         LLNI_field_get_val(rf, slot , slot);
1627         f = &(c->fields[slot]);
1628
1629         return (jfieldID) f;
1630 #else
1631         vm_abort("_Jv_JNI_FromReflectedField: not implemented in this configuration");
1632
1633         /* keep compiler happy */
1634
1635         return NULL;
1636 #endif
1637 }
1638
1639
1640 /* ToReflectedMethod ***********************************************************
1641
1642    Converts a method ID derived from cls to an instance of the
1643    java.lang.reflect.Method class or to an instance of the
1644    java.lang.reflect.Constructor class.
1645
1646 *******************************************************************************/
1647
1648 jobject _Jv_JNI_ToReflectedMethod(JNIEnv* env, jclass cls, jmethodID methodID,
1649                                                                   jboolean isStatic)
1650 {
1651 #if defined(ENABLE_JAVASE)
1652         methodinfo                    *m;
1653         java_lang_reflect_Constructor *rc;
1654         java_lang_reflect_Method      *rm;
1655
1656         TRACEJNICALLS(("_Jv_JNI_ToReflectedMethod(env=%p, cls=%p, methodID=%p, isStatic=%d)", env, cls, methodID, isStatic));
1657
1658         m = (methodinfo *) methodID;
1659
1660         /* HotSpot does the same assert. */
1661
1662         assert(((m->flags & ACC_STATIC) != 0) == (isStatic != 0));
1663
1664         if (m->name == utf_init) {
1665                 rc = reflect_constructor_new(m);
1666
1667                 return (jobject) rc;
1668         }
1669         else {
1670                 rm = reflect_method_new(m);
1671
1672                 return (jobject) rm;
1673         }
1674 #else
1675         vm_abort("_Jv_JNI_ToReflectedMethod: not implemented in this configuration");
1676
1677         /* keep compiler happy */
1678
1679         return NULL;
1680 #endif
1681 }
1682
1683
1684 /* ToReflectedField ************************************************************
1685
1686    Converts a field ID derived from cls to an instance of the
1687    java.lang.reflect.Field class.
1688
1689 *******************************************************************************/
1690
1691 jobject _Jv_JNI_ToReflectedField(JNIEnv* env, jclass cls, jfieldID fieldID,
1692                                                                  jboolean isStatic)
1693 {
1694         STATISTICS(jniinvokation());
1695
1696         log_text("JNI-Call: ToReflectedField: IMPLEMENT ME!");
1697
1698         return NULL;
1699 }
1700
1701
1702 /* Calling Instance Methods ***************************************************/
1703
1704 /* GetMethodID *****************************************************************
1705
1706    Returns the method ID for an instance (nonstatic) method of a class
1707    or interface. The method may be defined in one of the clazz's
1708    superclasses and inherited by clazz. The method is determined by
1709    its name and signature.
1710
1711    GetMethodID() causes an uninitialized class to be initialized.
1712
1713 *******************************************************************************/
1714
1715 jmethodID _Jv_JNI_GetMethodID(JNIEnv* env, jclass clazz, const char *name,
1716                                                           const char *sig)
1717 {
1718         classinfo  *c;
1719         utf        *uname;
1720         utf        *udesc;
1721         methodinfo *m;
1722
1723         STATISTICS(jniinvokation());
1724
1725         c = LLNI_classinfo_unwrap(clazz);
1726
1727         if (c == NULL)
1728                 return NULL;
1729
1730         if (!(c->state & CLASS_INITIALIZED))
1731                 if (!initialize_class(c))
1732                         return NULL;
1733
1734         /* try to get the method of the class or one of it's superclasses */
1735
1736         uname = utf_new_char((char *) name);
1737         udesc = utf_new_char((char *) sig);
1738
1739         m = class_resolvemethod(c, uname, udesc);
1740
1741         if ((m == NULL) || (m->flags & ACC_STATIC)) {
1742                 exceptions_throw_nosuchmethoderror(c, uname, udesc);
1743
1744                 return NULL;
1745         }
1746
1747         return (jmethodID) m;
1748 }
1749
1750
1751 /* JNI-functions for calling instance methods *********************************/
1752
1753 #define JNI_CALL_VIRTUAL_METHOD(name, type, intern)         \
1754 type _Jv_JNI_Call##name##Method(JNIEnv *env, jobject obj,   \
1755                                                                 jmethodID methodID, ...)    \
1756 {                                                           \
1757         java_handle_t *o;                                       \
1758         methodinfo    *m;                                       \
1759         va_list        ap;                                      \
1760         type           ret;                                     \
1761                                                             \
1762         o = (java_handle_t *) obj;                              \
1763         m = (methodinfo *) methodID;                            \
1764                                                             \
1765         va_start(ap, methodID);                                 \
1766         ret = _Jv_jni_Call##intern##Method(o, LLNI_vftbl_direct(o), m, ap); \
1767         va_end(ap);                                             \
1768                                                             \
1769         return ret;                                             \
1770 }
1771
1772 JNI_CALL_VIRTUAL_METHOD(Boolean, jboolean, Int)
1773 JNI_CALL_VIRTUAL_METHOD(Byte,    jbyte,    Int)
1774 JNI_CALL_VIRTUAL_METHOD(Char,    jchar,    Int)
1775 JNI_CALL_VIRTUAL_METHOD(Short,   jshort,   Int)
1776 JNI_CALL_VIRTUAL_METHOD(Int,     jint,     Int)
1777 JNI_CALL_VIRTUAL_METHOD(Long,    jlong,    Long)
1778 JNI_CALL_VIRTUAL_METHOD(Float,   jfloat,   Float)
1779 JNI_CALL_VIRTUAL_METHOD(Double,  jdouble,  Double)
1780
1781
1782 #define JNI_CALL_VIRTUAL_METHOD_V(name, type, intern)              \
1783 type _Jv_JNI_Call##name##MethodV(JNIEnv *env, jobject obj,         \
1784                                                                  jmethodID methodID, va_list args) \
1785 {                                                                  \
1786         java_handle_t *o;                                              \
1787         methodinfo    *m;                                              \
1788         type           ret;                                            \
1789                                                                    \
1790         o = (java_handle_t *) obj;                                     \
1791         m = (methodinfo *) methodID;                                   \
1792                                                                    \
1793         ret = _Jv_jni_Call##intern##Method(o, LLNI_vftbl_direct(o), m, args);      \
1794                                                                    \
1795         return ret;                                                    \
1796 }
1797
1798 JNI_CALL_VIRTUAL_METHOD_V(Boolean, jboolean, Int)
1799 JNI_CALL_VIRTUAL_METHOD_V(Byte,    jbyte,    Int)
1800 JNI_CALL_VIRTUAL_METHOD_V(Char,    jchar,    Int)
1801 JNI_CALL_VIRTUAL_METHOD_V(Short,   jshort,   Int)
1802 JNI_CALL_VIRTUAL_METHOD_V(Int,     jint,     Int)
1803 JNI_CALL_VIRTUAL_METHOD_V(Long,    jlong,    Long)
1804 JNI_CALL_VIRTUAL_METHOD_V(Float,   jfloat,   Float)
1805 JNI_CALL_VIRTUAL_METHOD_V(Double,  jdouble,  Double)
1806
1807
1808 #define JNI_CALL_VIRTUAL_METHOD_A(name, type, intern)          \
1809 type _Jv_JNI_Call##name##MethodA(JNIEnv *env, jobject obj,     \
1810                                                                  jmethodID methodID,           \
1811                                                                  const jvalue *args)           \
1812 {                                                              \
1813         java_handle_t *o;                                          \
1814         methodinfo    *m;                                          \
1815         type           ret;                                        \
1816                                                                \
1817         o = (java_handle_t *) obj;                                 \
1818         m = (methodinfo *) methodID;                               \
1819                                                                \
1820         ret = _Jv_jni_Call##intern##MethodA(o, LLNI_vftbl_direct(o), m, args); \
1821                                                                \
1822         return ret;                                                \
1823 }
1824
1825 JNI_CALL_VIRTUAL_METHOD_A(Boolean, jboolean, Int)
1826 JNI_CALL_VIRTUAL_METHOD_A(Byte,    jbyte,    Int)
1827 JNI_CALL_VIRTUAL_METHOD_A(Char,    jchar,    Int)
1828 JNI_CALL_VIRTUAL_METHOD_A(Short,   jshort,   Int)
1829 JNI_CALL_VIRTUAL_METHOD_A(Int,     jint,     Int)
1830 JNI_CALL_VIRTUAL_METHOD_A(Long,    jlong,    Long)
1831 JNI_CALL_VIRTUAL_METHOD_A(Float,   jfloat,   Float)
1832 JNI_CALL_VIRTUAL_METHOD_A(Double,  jdouble,  Double)
1833
1834
1835 jobject _Jv_JNI_CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID,
1836                                                                  ...)
1837 {
1838         java_handle_t *o;
1839         methodinfo    *m;
1840         java_handle_t *ret;
1841         va_list        ap;
1842
1843         o = (java_handle_t *) obj;
1844         m = (methodinfo *) methodID;
1845
1846         va_start(ap, methodID);
1847         ret = _Jv_jni_CallObjectMethod(o, LLNI_vftbl_direct(o), m, ap);
1848         va_end(ap);
1849
1850         return _Jv_JNI_NewLocalRef(env, (jobject) ret);
1851 }
1852
1853
1854 jobject _Jv_JNI_CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
1855                                                                   va_list args)
1856 {
1857         java_handle_t *o;
1858         methodinfo    *m;
1859         java_handle_t *ret;
1860
1861         o = (java_handle_t *) obj;
1862         m = (methodinfo *) methodID;
1863
1864         ret = _Jv_jni_CallObjectMethod(o, LLNI_vftbl_direct(o), m, args);
1865
1866         return _Jv_JNI_NewLocalRef(env, (jobject) ret);
1867 }
1868
1869
1870 jobject _Jv_JNI_CallObjectMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
1871                                                                   const jvalue *args)
1872 {
1873         java_handle_t *o;
1874         methodinfo    *m;
1875         java_handle_t *ret;
1876
1877         o = (java_handle_t *) obj;
1878         m = (methodinfo *) methodID;
1879
1880         ret = _Jv_jni_CallObjectMethodA(o, LLNI_vftbl_direct(o), m, args);
1881
1882         return _Jv_JNI_NewLocalRef(env, (jobject) ret);
1883 }
1884
1885
1886
1887 void _Jv_JNI_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...)
1888 {
1889         java_handle_t *o;
1890         methodinfo    *m;
1891         va_list        ap;
1892
1893         o = (java_handle_t *) obj;
1894         m = (methodinfo *) methodID;
1895
1896         va_start(ap, methodID);
1897         _Jv_jni_CallVoidMethod(o, LLNI_vftbl_direct(o), m, ap);
1898         va_end(ap);
1899 }
1900
1901
1902 void _Jv_JNI_CallVoidMethodV(JNIEnv *env, jobject obj, jmethodID methodID,
1903                                                          va_list args)
1904 {
1905         java_handle_t *o;
1906         methodinfo    *m;
1907
1908         o = (java_handle_t *) obj;
1909         m = (methodinfo *) methodID;
1910
1911         _Jv_jni_CallVoidMethod(o, LLNI_vftbl_direct(o), m, args);
1912 }
1913
1914
1915 void _Jv_JNI_CallVoidMethodA(JNIEnv *env, jobject obj, jmethodID methodID,
1916                                                          const jvalue *args)
1917 {
1918         java_handle_t *o;
1919         methodinfo    *m;
1920
1921         o = (java_handle_t *) obj;
1922         m = (methodinfo *) methodID;
1923
1924         _Jv_jni_CallVoidMethodA(o, LLNI_vftbl_direct(o), m, args);
1925 }
1926
1927
1928
1929 #define JNI_CALL_NONVIRTUAL_METHOD(name, type, intern)                      \
1930 type _Jv_JNI_CallNonvirtual##name##Method(JNIEnv *env, jobject obj,         \
1931                                                                                   jclass clazz, jmethodID methodID, \
1932                                                                                   ...)                              \
1933 {                                                                           \
1934         java_handle_t *o;                                                       \
1935         classinfo     *c;                                                       \
1936         methodinfo    *m;                                                       \
1937         va_list        ap;                                                      \
1938         type           ret;                                                     \
1939                                                                             \
1940         o = (java_handle_t *) obj;                                              \
1941         c = LLNI_classinfo_unwrap(clazz);                                       \
1942         m = (methodinfo *) methodID;                                            \
1943                                                                             \
1944         va_start(ap, methodID);                                                 \
1945         ret = _Jv_jni_Call##intern##Method(o, c->vftbl, m, ap);                 \
1946         va_end(ap);                                                             \
1947                                                                             \
1948         return ret;                                                             \
1949 }
1950
1951 JNI_CALL_NONVIRTUAL_METHOD(Boolean, jboolean, Int)
1952 JNI_CALL_NONVIRTUAL_METHOD(Byte,    jbyte,    Int)
1953 JNI_CALL_NONVIRTUAL_METHOD(Char,    jchar,    Int)
1954 JNI_CALL_NONVIRTUAL_METHOD(Short,   jshort,   Int)
1955 JNI_CALL_NONVIRTUAL_METHOD(Int,     jint,     Int)
1956 JNI_CALL_NONVIRTUAL_METHOD(Long,    jlong,    Long)
1957 JNI_CALL_NONVIRTUAL_METHOD(Float,   jfloat,   Float)
1958 JNI_CALL_NONVIRTUAL_METHOD(Double,  jdouble,  Double)
1959
1960
1961 #define JNI_CALL_NONVIRTUAL_METHOD_V(name, type, intern)                     \
1962 type _Jv_JNI_CallNonvirtual##name##MethodV(JNIEnv *env, jobject obj,         \
1963                                                                                    jclass clazz, jmethodID methodID, \
1964                                                                                    va_list args)                     \
1965 {                                                                            \
1966         java_handle_t *o;                                                        \
1967         classinfo     *c;                                                        \
1968         methodinfo    *m;                                                        \
1969         type           ret;                                                      \
1970                                                                              \
1971         o = (java_handle_t *) obj;                                               \
1972         c = LLNI_classinfo_unwrap(clazz);                                        \
1973         m = (methodinfo *) methodID;                                             \
1974                                                                              \
1975         ret = _Jv_jni_CallIntMethod(o, c->vftbl, m, args);                       \
1976                                                                              \
1977         return ret;                                                              \
1978 }
1979
1980 JNI_CALL_NONVIRTUAL_METHOD_V(Boolean, jboolean, Int)
1981 JNI_CALL_NONVIRTUAL_METHOD_V(Byte,    jbyte,    Int)
1982 JNI_CALL_NONVIRTUAL_METHOD_V(Char,    jchar,    Int)
1983 JNI_CALL_NONVIRTUAL_METHOD_V(Short,   jshort,   Int)
1984 JNI_CALL_NONVIRTUAL_METHOD_V(Int,     jint,     Int)
1985 JNI_CALL_NONVIRTUAL_METHOD_V(Long,    jlong,    Long)
1986 JNI_CALL_NONVIRTUAL_METHOD_V(Float,   jfloat,   Float)
1987 JNI_CALL_NONVIRTUAL_METHOD_V(Double,  jdouble,  Double)
1988
1989
1990 #define JNI_CALL_NONVIRTUAL_METHOD_A(name, type, intern)                     \
1991 type _Jv_JNI_CallNonvirtual##name##MethodA(JNIEnv *env, jobject obj,         \
1992                                                                                    jclass clazz, jmethodID methodID, \
1993                                                                                    const jvalue *args)               \
1994 {                                                                            \
1995         log_text("JNI-Call: CallNonvirtual##name##MethodA: IMPLEMENT ME!");      \
1996                                                                              \
1997         return 0;                                                                \
1998 }
1999
2000 JNI_CALL_NONVIRTUAL_METHOD_A(Boolean, jboolean, Int)
2001 JNI_CALL_NONVIRTUAL_METHOD_A(Byte,    jbyte,    Int)
2002 JNI_CALL_NONVIRTUAL_METHOD_A(Char,    jchar,    Int)
2003 JNI_CALL_NONVIRTUAL_METHOD_A(Short,   jshort,   Int)
2004 JNI_CALL_NONVIRTUAL_METHOD_A(Int,     jint,     Int)
2005 JNI_CALL_NONVIRTUAL_METHOD_A(Long,    jlong,    Long)
2006 JNI_CALL_NONVIRTUAL_METHOD_A(Float,   jfloat,   Float)
2007 JNI_CALL_NONVIRTUAL_METHOD_A(Double,  jdouble,  Double)
2008
2009 jobject _Jv_JNI_CallNonvirtualObjectMethod(JNIEnv *env, jobject obj,
2010                                                                                    jclass clazz, jmethodID methodID,
2011                                                                                    ...)
2012 {
2013         java_handle_t *o;
2014         classinfo     *c;
2015         methodinfo    *m;
2016         java_handle_t *r;
2017         va_list        ap;
2018
2019         o = (java_handle_t *) obj;
2020         c = LLNI_classinfo_unwrap(clazz);
2021         m = (methodinfo *) methodID;
2022
2023         va_start(ap, methodID);
2024         r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, ap);
2025         va_end(ap);
2026
2027         return _Jv_JNI_NewLocalRef(env, (jobject) r);
2028 }
2029
2030
2031 jobject _Jv_JNI_CallNonvirtualObjectMethodV(JNIEnv *env, jobject obj,
2032                                                                                         jclass clazz, jmethodID methodID,
2033                                                                                         va_list args)
2034 {
2035         java_handle_t *o;
2036         classinfo     *c;
2037         methodinfo    *m;
2038         java_handle_t *r;
2039
2040         o = (java_handle_t *) obj;
2041         c = LLNI_classinfo_unwrap(clazz);
2042         m = (methodinfo *) methodID;
2043
2044         r = _Jv_jni_CallObjectMethod(o, c->vftbl, m, args);
2045
2046         return _Jv_JNI_NewLocalRef(env, (jobject) r);
2047 }
2048
2049
2050 jobject _Jv_JNI_CallNonvirtualObjectMethodA(JNIEnv *env, jobject obj,
2051                                                                                         jclass clazz, jmethodID methodID,
2052                                                                                         const jvalue *args)
2053 {
2054         log_text("JNI-Call: CallNonvirtualObjectMethodA: IMPLEMENT ME!");
2055
2056         return _Jv_JNI_NewLocalRef(env, NULL);
2057 }
2058
2059
2060 void _Jv_JNI_CallNonvirtualVoidMethod(JNIEnv *env, jobject obj, jclass clazz,
2061                                                                           jmethodID methodID, ...)
2062 {
2063         java_handle_t *o;
2064         classinfo     *c;
2065         methodinfo    *m;
2066         va_list        ap;
2067
2068         o = (java_handle_t *) obj;
2069         c = LLNI_classinfo_unwrap(clazz);
2070         m = (methodinfo *) methodID;
2071
2072         va_start(ap, methodID);
2073         _Jv_jni_CallVoidMethod(o, c->vftbl, m, ap);
2074         va_end(ap);
2075 }
2076
2077
2078 void _Jv_JNI_CallNonvirtualVoidMethodV(JNIEnv *env, jobject obj, jclass clazz,
2079                                                                            jmethodID methodID, va_list args)
2080 {
2081         java_handle_t *o;
2082         classinfo     *c;
2083         methodinfo    *m;
2084
2085         o = (java_handle_t *) obj;
2086         c = LLNI_classinfo_unwrap(clazz);
2087         m = (methodinfo *) methodID;
2088
2089         _Jv_jni_CallVoidMethod(o, c->vftbl, m, args);
2090 }
2091
2092
2093 void _Jv_JNI_CallNonvirtualVoidMethodA(JNIEnv *env, jobject obj, jclass clazz,
2094                                                                            jmethodID methodID, const jvalue * args)
2095 {
2096         java_handle_t *o;
2097         classinfo     *c;
2098         methodinfo    *m;
2099
2100         o = (java_handle_t *) obj;
2101         c = LLNI_classinfo_unwrap(clazz);
2102         m = (methodinfo *) methodID;
2103
2104         _Jv_jni_CallVoidMethodA(o, c->vftbl, m, args);
2105 }
2106
2107
2108 /* Accessing Fields of Objects ************************************************/
2109
2110 /* GetFieldID ******************************************************************
2111
2112    Returns the field ID for an instance (nonstatic) field of a
2113    class. The field is specified by its name and signature. The
2114    Get<type>Field and Set<type>Field families of accessor functions
2115    use field IDs to retrieve object fields.
2116
2117 *******************************************************************************/
2118
2119 jfieldID _Jv_JNI_GetFieldID(JNIEnv *env, jclass clazz, const char *name,
2120                                                         const char *sig)
2121 {
2122         classinfo *c;
2123         fieldinfo *f;
2124         utf       *uname;
2125         utf       *udesc;
2126
2127         STATISTICS(jniinvokation());
2128
2129         c = LLNI_classinfo_unwrap(clazz);
2130
2131         /* XXX NPE check? */
2132
2133         uname = utf_new_char((char *) name);
2134         udesc = utf_new_char((char *) sig);
2135
2136         f = class_findfield(c, uname, udesc);
2137
2138         if (f == NULL)
2139                 exceptions_throw_nosuchfielderror(c, uname);
2140
2141         return (jfieldID) f;
2142 }
2143
2144
2145 /* Get<type>Field Routines *****************************************************
2146
2147    This family of accessor routines returns the value of an instance
2148    (nonstatic) field of an object. The field to access is specified by
2149    a field ID obtained by calling GetFieldID().
2150
2151 *******************************************************************************/
2152
2153 #define GET_FIELD(o,type,f) \
2154     *((type *) (((intptr_t) (o)) + ((intptr_t) ((fieldinfo *) (f))->offset)))
2155
2156 #define JNI_GET_FIELD(name, type, intern)                                 \
2157 type _Jv_JNI_Get##name##Field(JNIEnv *env, jobject obj, jfieldID fieldID) \
2158 {                                                                         \
2159         intern ret;                                                           \
2160                                                                           \
2161         STATISTICS(jniinvokation());                                          \
2162                                                                           \
2163         LLNI_CRITICAL_START;                                                  \
2164                                                                           \
2165         ret = GET_FIELD(LLNI_DIRECT((java_handle_t *) obj), intern, fieldID); \
2166                                                                           \
2167         LLNI_CRITICAL_END;                                                    \
2168                                                                           \
2169         return (type) ret;                                                    \
2170 }
2171
2172 JNI_GET_FIELD(Boolean, jboolean, s4)
2173 JNI_GET_FIELD(Byte,    jbyte,    s4)
2174 JNI_GET_FIELD(Char,    jchar,    s4)
2175 JNI_GET_FIELD(Short,   jshort,   s4)
2176 JNI_GET_FIELD(Int,     jint,     s4)
2177 JNI_GET_FIELD(Long,    jlong,    s8)
2178 JNI_GET_FIELD(Float,   jfloat,   float)
2179 JNI_GET_FIELD(Double,  jdouble,  double)
2180
2181
2182 jobject _Jv_JNI_GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID)
2183 {
2184         java_handle_t *o;
2185
2186         TRACEJNICALLS(("_Jv_JNI_GetObjectField(env=%p, obj=%p, fieldId=%p)", env, obj, fieldID));
2187
2188         LLNI_CRITICAL_START;
2189
2190         o = LLNI_WRAP(GET_FIELD(LLNI_DIRECT((java_handle_t *) obj), java_object_t*, fieldID));
2191
2192         LLNI_CRITICAL_END;
2193
2194         return _Jv_JNI_NewLocalRef(env, (jobject) o);
2195 }
2196
2197
2198 /* Set<type>Field Routines *****************************************************
2199
2200    This family of accessor routines sets the value of an instance
2201    (nonstatic) field of an object. The field to access is specified by
2202    a field ID obtained by calling GetFieldID().
2203
2204 *******************************************************************************/
2205
2206 #define SET_FIELD(o,type,f,value) \
2207     *((type *) (((intptr_t) (o)) + ((intptr_t) ((fieldinfo *) (f))->offset))) = (type) (value)
2208
2209 #define JNI_SET_FIELD(name, type, intern)                                  \
2210 void _Jv_JNI_Set##name##Field(JNIEnv *env, jobject obj, jfieldID fieldID,  \
2211                                                           type value)                                  \
2212 {                                                                          \
2213         STATISTICS(jniinvokation());                                           \
2214                                                                            \
2215         LLNI_CRITICAL_START;                                                   \
2216                                                                            \
2217         SET_FIELD(LLNI_DIRECT((java_handle_t *) obj), intern, fieldID, value); \
2218                                                                                \
2219         LLNI_CRITICAL_START;                                                   \
2220 }
2221
2222 JNI_SET_FIELD(Boolean, jboolean, s4)
2223 JNI_SET_FIELD(Byte,    jbyte,    s4)
2224 JNI_SET_FIELD(Char,    jchar,    s4)
2225 JNI_SET_FIELD(Short,   jshort,   s4)
2226 JNI_SET_FIELD(Int,     jint,     s4)
2227 JNI_SET_FIELD(Long,    jlong,    s8)
2228 JNI_SET_FIELD(Float,   jfloat,   float)
2229 JNI_SET_FIELD(Double,  jdouble,  double)
2230
2231
2232 void _Jv_JNI_SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID,
2233                                                         jobject value)
2234 {
2235         TRACEJNICALLS(("_Jv_JNI_SetObjectField(env=%p, obj=%p, fieldId=%p, value=%p)", env, obj, fieldID, value));
2236
2237         LLNI_CRITICAL_START;
2238
2239         SET_FIELD(obj, java_handle_t*, fieldID, LLNI_UNWRAP((java_handle_t*) value));
2240
2241         LLNI_CRITICAL_END;
2242 }
2243
2244
2245 /* Calling Static Methods *****************************************************/
2246
2247 /* GetStaticMethodID ***********************************************************
2248
2249    Returns the method ID for a static method of a class. The method is
2250    specified by its name and signature.
2251
2252    GetStaticMethodID() causes an uninitialized class to be
2253    initialized.
2254
2255 *******************************************************************************/
2256
2257 jmethodID _Jv_JNI_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name,
2258                                                                         const char *sig)
2259 {
2260         classinfo  *c;
2261         utf        *uname;
2262         utf        *udesc;
2263         methodinfo *m;
2264
2265         TRACEJNICALLS(("_Jv_JNI_GetStaticMethodID(env=%p, clazz=%p, name=%s, sig=%s)", env, clazz, name, sig));
2266
2267         c = LLNI_classinfo_unwrap(clazz);
2268
2269         if (c == NULL)
2270                 return NULL;
2271
2272         if (!(c->state & CLASS_INITIALIZED))
2273                 if (!initialize_class(c))
2274                         return NULL;
2275
2276         /* try to get the static method of the class */
2277
2278         uname = utf_new_char((char *) name);
2279         udesc = utf_new_char((char *) sig);
2280
2281         m = class_resolvemethod(c, uname, udesc);
2282
2283         if ((m == NULL) || !(m->flags & ACC_STATIC)) {
2284                 exceptions_throw_nosuchmethoderror(c, uname, udesc);
2285
2286                 return NULL;
2287         }
2288
2289         return (jmethodID) m;
2290 }
2291
2292
2293 #define JNI_CALL_STATIC_METHOD(name, type, intern)               \
2294 type _Jv_JNI_CallStatic##name##Method(JNIEnv *env, jclass clazz, \
2295                                                                           jmethodID methodID, ...)   \
2296 {                                                                \
2297         methodinfo *m;                                               \
2298         va_list     ap;                                              \
2299         type        res;                                             \
2300                                                                  \
2301         m = (methodinfo *) methodID;                                 \
2302                                                                  \
2303         va_start(ap, methodID);                                      \
2304         res = _Jv_jni_Call##intern##Method(NULL, NULL, m, ap);       \
2305         va_end(ap);                                                  \
2306                                                                  \
2307         return res;                                                  \
2308 }
2309
2310 JNI_CALL_STATIC_METHOD(Boolean, jboolean, Int)
2311 JNI_CALL_STATIC_METHOD(Byte,    jbyte,    Int)
2312 JNI_CALL_STATIC_METHOD(Char,    jchar,    Int)
2313 JNI_CALL_STATIC_METHOD(Short,   jshort,   Int)
2314 JNI_CALL_STATIC_METHOD(Int,     jint,     Int)
2315 JNI_CALL_STATIC_METHOD(Long,    jlong,    Long)
2316 JNI_CALL_STATIC_METHOD(Float,   jfloat,   Float)
2317 JNI_CALL_STATIC_METHOD(Double,  jdouble,  Double)
2318
2319
2320 #define JNI_CALL_STATIC_METHOD_V(name, type, intern)                     \
2321 type _Jv_JNI_CallStatic##name##MethodV(JNIEnv *env, jclass clazz,        \
2322                                                                            jmethodID methodID, va_list args) \
2323 {                                                                        \
2324         methodinfo *m;                                                       \
2325         type        res;                                                     \
2326                                                                          \
2327         m = (methodinfo *) methodID;                                         \
2328                                                                          \
2329         res = _Jv_jni_Call##intern##Method(NULL, NULL, m, args);             \
2330                                                                          \
2331         return res;                                                          \
2332 }
2333
2334 JNI_CALL_STATIC_METHOD_V(Boolean, jboolean, Int)
2335 JNI_CALL_STATIC_METHOD_V(Byte,    jbyte,    Int)
2336 JNI_CALL_STATIC_METHOD_V(Char,    jchar,    Int)
2337 JNI_CALL_STATIC_METHOD_V(Short,   jshort,   Int)
2338 JNI_CALL_STATIC_METHOD_V(Int,     jint,     Int)
2339 JNI_CALL_STATIC_METHOD_V(Long,    jlong,    Long)
2340 JNI_CALL_STATIC_METHOD_V(Float,   jfloat,   Float)
2341 JNI_CALL_STATIC_METHOD_V(Double,  jdouble,  Double)
2342
2343
2344 #define JNI_CALL_STATIC_METHOD_A(name, type, intern)                           \
2345 type _Jv_JNI_CallStatic##name##MethodA(JNIEnv *env, jclass clazz,              \
2346                                                                            jmethodID methodID, const jvalue *args) \
2347 {                                                                              \
2348         methodinfo *m;                                                             \
2349         type        res;                                                           \
2350                                                                                \
2351         m = (methodinfo *) methodID;                                               \
2352                                                                                \
2353         res = _Jv_jni_Call##intern##MethodA(NULL, NULL, m, args);                  \
2354                                                                                \
2355         return res;                                                                \
2356 }
2357
2358 JNI_CALL_STATIC_METHOD_A(Boolean, jboolean, Int)
2359 JNI_CALL_STATIC_METHOD_A(Byte,    jbyte,    Int)
2360 JNI_CALL_STATIC_METHOD_A(Char,    jchar,    Int)
2361 JNI_CALL_STATIC_METHOD_A(Short,   jshort,   Int)
2362 JNI_CALL_STATIC_METHOD_A(Int,     jint,     Int)
2363 JNI_CALL_STATIC_METHOD_A(Long,    jlong,    Long)
2364 JNI_CALL_STATIC_METHOD_A(Float,   jfloat,   Float)
2365 JNI_CALL_STATIC_METHOD_A(Double,  jdouble,  Double)
2366
2367
2368 jobject _Jv_JNI_CallStaticObjectMethod(JNIEnv *env, jclass clazz,
2369                                                                            jmethodID methodID, ...)
2370 {
2371         methodinfo    *m;
2372         java_handle_t *o;
2373         va_list        ap;
2374
2375         m = (methodinfo *) methodID;
2376
2377         va_start(ap, methodID);
2378         o = _Jv_jni_CallObjectMethod(NULL, NULL, m, ap);
2379         va_end(ap);
2380
2381         return _Jv_JNI_NewLocalRef(env, (jobject) o);
2382 }
2383
2384
2385 jobject _Jv_JNI_CallStaticObjectMethodV(JNIEnv *env, jclass clazz,
2386                                                                                 jmethodID methodID, va_list args)
2387 {
2388         methodinfo    *m;
2389         java_handle_t *o;
2390
2391         m = (methodinfo *) methodID;
2392
2393         o = _Jv_jni_CallObjectMethod(NULL, NULL, m, args);
2394
2395         return _Jv_JNI_NewLocalRef(env, (jobject) o);
2396 }
2397
2398
2399 jobject _Jv_JNI_CallStaticObjectMethodA(JNIEnv *env, jclass clazz,
2400                                                                                 jmethodID methodID, const jvalue *args)
2401 {
2402         methodinfo    *m;
2403         java_handle_t *o;
2404
2405         m = (methodinfo *) methodID;
2406
2407         o = _Jv_jni_CallObjectMethodA(NULL, NULL, m, args);
2408
2409         return _Jv_JNI_NewLocalRef(env, (jobject) o);
2410 }
2411
2412
2413 void _Jv_JNI_CallStaticVoidMethod(JNIEnv *env, jclass clazz,
2414                                                                   jmethodID methodID, ...)
2415 {
2416         methodinfo *m;
2417         va_list     ap;
2418
2419         m = (methodinfo *) methodID;
2420
2421         va_start(ap, methodID);
2422         _Jv_jni_CallVoidMethod(NULL, NULL, m, ap);
2423         va_end(ap);
2424 }
2425
2426
2427 void _Jv_JNI_CallStaticVoidMethodV(JNIEnv *env, jclass clazz,
2428                                                                    jmethodID methodID, va_list args)
2429 {
2430         methodinfo *m;
2431
2432         m = (methodinfo *) methodID;
2433
2434         _Jv_jni_CallVoidMethod(NULL, NULL, m, args);
2435 }
2436
2437
2438 void _Jv_JNI_CallStaticVoidMethodA(JNIEnv *env, jclass clazz,
2439                                                                    jmethodID methodID, const jvalue * args)
2440 {
2441         methodinfo *m;
2442
2443         m = (methodinfo *) methodID;
2444
2445         _Jv_jni_CallVoidMethodA(NULL, NULL, m, args);
2446 }
2447
2448
2449 /* Accessing Static Fields ****************************************************/
2450
2451 /* GetStaticFieldID ************************************************************
2452
2453    Returns the field ID for a static field of a class. The field is
2454    specified by its name and signature. The GetStatic<type>Field and
2455    SetStatic<type>Field families of accessor functions use field IDs
2456    to retrieve static fields.
2457
2458 *******************************************************************************/
2459
2460 jfieldID _Jv_JNI_GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name,
2461                                                                   const char *sig)
2462 {
2463         classinfo *c;
2464         fieldinfo *f;
2465         utf       *uname;
2466         utf       *usig;
2467
2468         STATISTICS(jniinvokation());
2469
2470         c = LLNI_classinfo_unwrap(clazz);
2471
2472         uname = utf_new_char((char *) name);
2473         usig  = utf_new_char((char *) sig);
2474
2475         f = class_findfield(c, uname, usig);
2476
2477         if (f == NULL)
2478                 exceptions_throw_nosuchfielderror(c, uname);
2479
2480         return (jfieldID) f;
2481 }
2482
2483
2484 /* GetStatic<type>Field ********************************************************
2485
2486    This family of accessor routines returns the value of a static
2487    field of an object.
2488
2489 *******************************************************************************/
2490
2491 #define JNI_GET_STATIC_FIELD(name, type, field)                \
2492 type _Jv_JNI_GetStatic##name##Field(JNIEnv *env, jclass clazz, \
2493                                                                         jfieldID fieldID)          \
2494 {                                                              \
2495         classinfo *c;                                              \
2496         fieldinfo *f;                                              \
2497                                                                \
2498         STATISTICS(jniinvokation());                               \
2499                                                                \
2500         c = LLNI_classinfo_unwrap(clazz);                          \
2501         f = (fieldinfo *) fieldID;                                 \
2502                                                                \
2503         if (!(c->state & CLASS_INITIALIZED))                       \
2504                 if (!initialize_class(c))                              \
2505                         return 0;                                          \
2506                                                                \
2507         return f->value->field;                                    \
2508 }
2509
2510 JNI_GET_STATIC_FIELD(Boolean, jboolean, i)
2511 JNI_GET_STATIC_FIELD(Byte,    jbyte,    i)
2512 JNI_GET_STATIC_FIELD(Char,    jchar,    i)
2513 JNI_GET_STATIC_FIELD(Short,   jshort,   i)
2514 JNI_GET_STATIC_FIELD(Int,     jint,     i)
2515 JNI_GET_STATIC_FIELD(Long,    jlong,    l)
2516 JNI_GET_STATIC_FIELD(Float,   jfloat,   f)
2517 JNI_GET_STATIC_FIELD(Double,  jdouble,  d)
2518
2519
2520 jobject _Jv_JNI_GetStaticObjectField(JNIEnv *env, jclass clazz,
2521                                                                          jfieldID fieldID)
2522 {
2523         classinfo     *c;
2524         fieldinfo     *f;
2525         java_handle_t *h;
2526
2527         STATISTICS(jniinvokation());
2528
2529         c = LLNI_classinfo_unwrap(clazz);
2530         f = (fieldinfo *) fieldID;
2531
2532         if (!(c->state & CLASS_INITIALIZED))
2533                 if (!initialize_class(c))
2534                         return NULL;
2535
2536         h = LLNI_WRAP(f->value->a);
2537
2538         return _Jv_JNI_NewLocalRef(env, (jobject) h);
2539 }
2540
2541
2542 /*  SetStatic<type>Field *******************************************************
2543
2544         This family of accessor routines sets the value of a static field
2545         of an object.
2546
2547 *******************************************************************************/
2548
2549 #define JNI_SET_STATIC_FIELD(name, type, field)                \
2550 void _Jv_JNI_SetStatic##name##Field(JNIEnv *env, jclass clazz, \
2551                                                                         jfieldID fieldID,          \
2552                                                                         type value)                \
2553 {                                                              \
2554         classinfo *c;                                              \
2555         fieldinfo *f;                                              \
2556                                                                \
2557         STATISTICS(jniinvokation());                               \
2558                                                                \
2559         c = LLNI_classinfo_unwrap(clazz);                          \
2560         f = (fieldinfo *) fieldID;                                 \
2561                                                                \
2562         if (!(c->state & CLASS_INITIALIZED))                       \
2563                 if (!initialize_class(c))                              \
2564                         return;                                            \
2565                                                                \
2566         f->value->field = value;                                   \
2567 }
2568
2569 JNI_SET_STATIC_FIELD(Boolean, jboolean, i)
2570 JNI_SET_STATIC_FIELD(Byte,    jbyte,    i)
2571 JNI_SET_STATIC_FIELD(Char,    jchar,    i)
2572 JNI_SET_STATIC_FIELD(Short,   jshort,   i)
2573 JNI_SET_STATIC_FIELD(Int,     jint,     i)
2574 JNI_SET_STATIC_FIELD(Long,    jlong,    l)
2575 JNI_SET_STATIC_FIELD(Float,   jfloat,   f)
2576 JNI_SET_STATIC_FIELD(Double,  jdouble,  d)
2577
2578
2579 void _Jv_JNI_SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID,
2580                                                                   jobject value)
2581 {
2582         classinfo *c;
2583         fieldinfo *f;
2584
2585         STATISTICS(jniinvokation());
2586
2587         c = LLNI_classinfo_unwrap(clazz);
2588         f = (fieldinfo *) fieldID;
2589
2590         if (!(c->state & CLASS_INITIALIZED))
2591                 if (!initialize_class(c))
2592                         return;
2593
2594         f->value->a = LLNI_UNWRAP((java_handle_t *) value);
2595 }
2596
2597
2598 /* String Operations **********************************************************/
2599
2600 /* NewString *******************************************************************
2601
2602    Create new java.lang.String object from an array of Unicode
2603    characters.
2604
2605 *******************************************************************************/
2606
2607 jstring _Jv_JNI_NewString(JNIEnv *env, const jchar *buf, jsize len)
2608 {
2609         java_lang_String        *s;
2610         java_handle_chararray_t *a;
2611         u4                       i;
2612
2613         STATISTICS(jniinvokation());
2614
2615         s = (java_lang_String *) builtin_new(class_java_lang_String);
2616         a = builtin_newarray_char(len);
2617
2618         /* javastring or characterarray could not be created */
2619         if ((a == NULL) || (s == NULL))
2620                 return NULL;
2621
2622         /* copy text */
2623         for (i = 0; i < len; i++)
2624                 LLNI_array_direct(a, i) = buf[i];
2625
2626         LLNI_field_set_ref(s, value , a);
2627         LLNI_field_set_val(s, offset, 0);
2628         LLNI_field_set_val(s, count , len);
2629
2630         return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
2631 }
2632
2633
2634 static jchar emptyStringJ[]={0,0};
2635
2636 /* GetStringLength *************************************************************
2637
2638    Returns the length (the count of Unicode characters) of a Java
2639    string.
2640
2641 *******************************************************************************/
2642
2643 jsize _Jv_JNI_GetStringLength(JNIEnv *env, jstring str)
2644 {
2645         java_lang_String *s;
2646         jsize             len;
2647
2648         TRACEJNICALLS(("_Jv_JNI_GetStringLength(env=%p, str=%p)", env, str));
2649
2650         s = (java_lang_String *) str;
2651
2652         LLNI_field_get_val(s, count, len);
2653
2654         return len;
2655 }
2656
2657
2658 /********************  convertes javastring to u2-array ****************************/
2659
2660 u2 *javastring_tou2(jstring so)
2661 {
2662         java_lang_String        *s;
2663         java_handle_chararray_t *a;
2664         u2                      *stringbuffer;
2665         u4                       i;
2666         int32_t                  count;
2667         int32_t                  offset;
2668
2669         STATISTICS(jniinvokation());
2670
2671         s = (java_lang_String *) so;
2672
2673         if (!s)
2674                 return NULL;
2675
2676         LLNI_field_get_ref(s, value, a);
2677
2678         if (!a)
2679                 return NULL;
2680
2681         LLNI_field_get_val(s, count, count);
2682         LLNI_field_get_val(s, offset, offset);
2683
2684         /* allocate memory */
2685
2686         stringbuffer = MNEW(u2, count + 1);
2687
2688         /* copy text */
2689
2690         for (i = 0; i < count; i++)
2691                 stringbuffer[i] = LLNI_array_direct(a, offset + i);
2692
2693         /* terminate string */
2694
2695         stringbuffer[i] = '\0';
2696
2697         return stringbuffer;
2698 }
2699
2700
2701 /* GetStringChars **************************************************************
2702
2703    Returns a pointer to the array of Unicode characters of the
2704    string. This pointer is valid until ReleaseStringChars() is called.
2705
2706 *******************************************************************************/
2707
2708 const jchar *_Jv_JNI_GetStringChars(JNIEnv *env, jstring str, jboolean *isCopy)
2709 {
2710         jchar *jc;
2711
2712         STATISTICS(jniinvokation());
2713
2714         jc = javastring_tou2(str);
2715
2716         if (jc) {
2717                 if (isCopy)
2718                         *isCopy = JNI_TRUE;
2719
2720                 return jc;
2721         }
2722
2723         if (isCopy)
2724                 *isCopy = JNI_TRUE;
2725
2726         return emptyStringJ;
2727 }
2728
2729
2730 /* ReleaseStringChars **********************************************************
2731
2732    Informs the VM that the native code no longer needs access to
2733    chars. The chars argument is a pointer obtained from string using
2734    GetStringChars().
2735
2736 *******************************************************************************/
2737
2738 void _Jv_JNI_ReleaseStringChars(JNIEnv *env, jstring str, const jchar *chars)
2739 {
2740         java_lang_String *s;
2741
2742         STATISTICS(jniinvokation());
2743
2744         if (chars == emptyStringJ)
2745                 return;
2746
2747         s = (java_lang_String *) str;
2748
2749         MFREE(((jchar *) chars), jchar, LLNI_field_direct(s, count) + 1);
2750 }
2751
2752
2753 /* NewStringUTF ****************************************************************
2754
2755    Constructs a new java.lang.String object from an array of UTF-8
2756    characters.
2757
2758 *******************************************************************************/
2759
2760 jstring _Jv_JNI_NewStringUTF(JNIEnv *env, const char *bytes)
2761 {
2762         java_lang_String *s;
2763
2764         TRACEJNICALLS(("_Jv_JNI_NewStringUTF(env=%p, bytes=%s)", env, bytes));
2765
2766         s = (java_lang_String *) javastring_safe_new_from_utf8(bytes);
2767
2768     return (jstring) _Jv_JNI_NewLocalRef(env, (jobject) s);
2769 }
2770
2771
2772 /****************** returns the utf8 length in bytes of a string *******************/
2773
2774 jsize _Jv_JNI_GetStringUTFLength(JNIEnv *env, jstring string)
2775 {
2776         java_lang_String *s;
2777         s4                length;
2778
2779         TRACEJNICALLS(("_Jv_JNI_GetStringUTFLength(env=%p, string=%p)", env, string));
2780
2781         s = (java_lang_String *) string;
2782
2783         length = u2_utflength(LLNI_field_direct(s, value)->data, LLNI_field_direct(s, count));
2784
2785         return length;
2786 }
2787
2788
2789 /* GetStringUTFChars ***********************************************************
2790
2791    Returns a pointer to an array of UTF-8 characters of the
2792    string. This array is valid until it is released by
2793    ReleaseStringUTFChars().
2794
2795 *******************************************************************************/
2796
2797 const char *_Jv_JNI_GetStringUTFChars(JNIEnv *env, jstring string,
2798                                                                           jboolean *isCopy)
2799 {
2800         utf *u;
2801
2802         STATISTICS(jniinvokation());
2803
2804         if (string == NULL)
2805                 return "";
2806
2807         if (isCopy)
2808                 *isCopy = JNI_TRUE;
2809
2810         u = javastring_toutf((java_handle_t *) string, false);
2811
2812         if (u != NULL)
2813                 return u->text;
2814
2815         return "";
2816 }
2817
2818
2819 /* ReleaseStringUTFChars *******************************************************
2820
2821    Informs the VM that the native code no longer needs access to
2822    utf. The utf argument is a pointer derived from string using
2823    GetStringUTFChars().
2824
2825 *******************************************************************************/
2826
2827 void _Jv_JNI_ReleaseStringUTFChars(JNIEnv *env, jstring string, const char *utf)
2828 {
2829         STATISTICS(jniinvokation());
2830
2831     /* XXX we don't release utf chars right now, perhaps that should be done
2832            later. Since there is always one reference the garbage collector will
2833            never get them */
2834 }
2835
2836
2837 /* Array Operations ***********************************************************/
2838
2839 /* GetArrayLength **************************************************************
2840
2841    Returns the number of elements in the array.
2842
2843 *******************************************************************************/
2844
2845 jsize _Jv_JNI_GetArrayLength(JNIEnv *env, jarray array)
2846 {
2847         java_handle_t *a;
2848         jsize          size;
2849
2850         STATISTICS(jniinvokation());
2851
2852         a = (java_handle_t *) array;
2853
2854         size = LLNI_array_size(a);
2855
2856         return size;
2857 }
2858
2859
2860 /* NewObjectArray **************************************************************
2861
2862    Constructs a new array holding objects in class elementClass. All
2863    elements are initially set to initialElement.
2864
2865 *******************************************************************************/
2866
2867 jobjectArray _Jv_JNI_NewObjectArray(JNIEnv *env, jsize length,
2868                                                                         jclass elementClass, jobject initialElement)
2869 {
2870         classinfo                 *c;
2871         java_handle_t             *o;
2872         java_handle_objectarray_t *oa;
2873         s4                         i;
2874
2875         STATISTICS(jniinvokation());
2876
2877         c = LLNI_classinfo_unwrap(elementClass);
2878         o = (java_handle_t *) initialElement;
2879
2880         if (length < 0) {
2881                 exceptions_throw_negativearraysizeexception();
2882                 return NULL;
2883         }
2884
2885     oa = builtin_anewarray(length, c);
2886
2887         if (oa == NULL)
2888                 return NULL;
2889
2890         /* set all elements to initialElement */
2891
2892         for (i = 0; i < length; i++)
2893                 array_objectarray_element_set(oa, i, o);
2894
2895         return (jobjectArray) _Jv_JNI_NewLocalRef(env, (jobject) oa);
2896 }
2897
2898
2899 jobject _Jv_JNI_GetObjectArrayElement(JNIEnv *env, jobjectArray array,
2900                                                                           jsize index)
2901 {
2902         java_handle_objectarray_t *oa;
2903         java_handle_t             *o;
2904
2905         STATISTICS(jniinvokation());
2906
2907         oa = (java_handle_objectarray_t *) array;
2908
2909         if (index >= LLNI_array_size(oa)) {
2910                 exceptions_throw_arrayindexoutofboundsexception();
2911                 return NULL;
2912         }
2913
2914         o = array_objectarray_element_get(oa, index);
2915
2916         return _Jv_JNI_NewLocalRef(env, (jobject) o);
2917 }
2918
2919
2920 void _Jv_JNI_SetObjectArrayElement(JNIEnv *env, jobjectArray array,
2921                                                                    jsize index, jobject val)
2922 {
2923         java_handle_objectarray_t *oa;
2924         java_handle_t             *o;
2925
2926         STATISTICS(jniinvokation());
2927
2928         oa = (java_handle_objectarray_t *) array;
2929         o  = (java_handle_t *) val;
2930
2931         if (index >= LLNI_array_size(oa)) {
2932                 exceptions_throw_arrayindexoutofboundsexception();
2933                 return;
2934         }
2935
2936         /* check if the class of value is a subclass of the element class
2937            of the array */
2938
2939         if (!builtin_canstore(oa, o))
2940                 return;
2941
2942         array_objectarray_element_set(oa, index, o);
2943 }
2944
2945
2946 #define JNI_NEW_ARRAY(name, type, intern)                \
2947 type _Jv_JNI_New##name##Array(JNIEnv *env, jsize len)    \
2948 {                                                        \
2949         java_handle_##intern##array_t *a;                    \
2950                                                          \
2951         STATISTICS(jniinvokation());                         \
2952                                                          \
2953         if (len < 0) {                                       \
2954                 exceptions_throw_negativearraysizeexception();   \
2955                 return NULL;                                     \
2956         }                                                    \
2957                                                          \
2958         a = builtin_newarray_##intern(len);                  \
2959                                                          \
2960         return (type) _Jv_JNI_NewLocalRef(env, (jobject) a); \
2961 }
2962
2963 JNI_NEW_ARRAY(Boolean, jbooleanArray, boolean)
2964 JNI_NEW_ARRAY(Byte,    jbyteArray,    byte)
2965 JNI_NEW_ARRAY(Char,    jcharArray,    char)
2966 JNI_NEW_ARRAY(Short,   jshortArray,   byte)
2967 JNI_NEW_ARRAY(Int,     jintArray,     int)
2968 JNI_NEW_ARRAY(Long,    jlongArray,    long)
2969 JNI_NEW_ARRAY(Float,   jfloatArray,   float)
2970 JNI_NEW_ARRAY(Double,  jdoubleArray,  double)
2971
2972
2973 /* Get<PrimitiveType>ArrayElements *********************************************
2974
2975    A family of functions that returns the body of the primitive array.
2976
2977 *******************************************************************************/
2978
2979 #define JNI_GET_ARRAY_ELEMENTS(name, type, intern)                     \
2980 type *_Jv_JNI_Get##name##ArrayElements(JNIEnv *env, type##Array array, \
2981                                                                                  jboolean *isCopy)             \
2982 {                                                                      \
2983         java_handle_##intern##array_t *a;                                  \
2984                                                                        \
2985         STATISTICS(jniinvokation());                                       \
2986                                                                        \
2987         a = (java_handle_##intern##array_t *) array;                       \
2988                                                                        \
2989         if (isCopy)                                                        \
2990                 *isCopy = JNI_FALSE;                                           \
2991                                                                        \
2992         return (type *) LLNI_array_data(a);                                \
2993 }
2994
2995 JNI_GET_ARRAY_ELEMENTS(Boolean, jboolean, boolean)
2996 JNI_GET_ARRAY_ELEMENTS(Byte,    jbyte,    byte)
2997 JNI_GET_ARRAY_ELEMENTS(Char,    jchar,    char)
2998 JNI_GET_ARRAY_ELEMENTS(Short,   jshort,   short)
2999 JNI_GET_ARRAY_ELEMENTS(Int,     jint,     int)
3000 JNI_GET_ARRAY_ELEMENTS(Long,    jlong,    long)
3001 JNI_GET_ARRAY_ELEMENTS(Float,   jfloat,   float)
3002 JNI_GET_ARRAY_ELEMENTS(Double,  jdouble,  double)
3003
3004
3005 /* Release<PrimitiveType>ArrayElements *****************************************
3006
3007    A family of functions that informs the VM that the native code no
3008    longer needs access to elems. The elems argument is a pointer
3009    derived from array using the corresponding
3010    Get<PrimitiveType>ArrayElements() function. If necessary, this
3011    function copies back all changes made to elems to the original
3012    array.
3013
3014 *******************************************************************************/
3015
3016 #define JNI_RELEASE_ARRAY_ELEMENTS(name, type, intern, intern2)            \
3017 void _Jv_JNI_Release##name##ArrayElements(JNIEnv *env, type##Array array,  \
3018                                                                                   type *elems, jint mode)          \
3019 {                                                                          \
3020         java_handle_##intern##array_t *a;                                      \
3021                                                                            \
3022         STATISTICS(jniinvokation());                                           \
3023                                                                            \
3024         a = (java_handle_##intern##array_t *) array;                           \
3025                                                                            \
3026         if (elems != (type *) LLNI_array_data(a)) {                            \
3027                 switch (mode) {                                                    \
3028                 case JNI_COMMIT:                                                   \
3029                         MCOPY(LLNI_array_data(a), elems, intern2, LLNI_array_size(a)); \
3030                         break;                                                         \
3031                 case 0:                                                            \
3032                         MCOPY(LLNI_array_data(a), elems, intern2, LLNI_array_size(a)); \
3033                         /* XXX TWISTI how should it be freed? */                       \
3034                         break;                                                         \
3035                 case JNI_ABORT:                                                    \
3036                         /* XXX TWISTI how should it be freed? */                       \
3037                         break;                                                         \
3038                 }                                                                  \
3039         }                                                                      \
3040 }
3041
3042 JNI_RELEASE_ARRAY_ELEMENTS(Boolean, jboolean, boolean, u1)
3043 JNI_RELEASE_ARRAY_ELEMENTS(Byte,    jbyte,    byte,    s1)
3044 JNI_RELEASE_ARRAY_ELEMENTS(Char,    jchar,    char,    u2)
3045 JNI_RELEASE_ARRAY_ELEMENTS(Short,   jshort,   short,   s2)
3046 JNI_RELEASE_ARRAY_ELEMENTS(Int,     jint,     int,     s4)
3047 JNI_RELEASE_ARRAY_ELEMENTS(Long,    jlong,    long,    s8)
3048 JNI_RELEASE_ARRAY_ELEMENTS(Float,   jfloat,   float,   float)
3049 JNI_RELEASE_ARRAY_ELEMENTS(Double,  jdouble,  double,  double)
3050
3051
3052 /*  Get<PrimitiveType>ArrayRegion **********************************************
3053
3054         A family of functions that copies a region of a primitive array
3055         into a buffer.
3056
3057 *******************************************************************************/
3058
3059 #define JNI_GET_ARRAY_REGION(name, type, intern, intern2)               \
3060 void _Jv_JNI_Get##name##ArrayRegion(JNIEnv *env, type##Array array,     \
3061                                                                         jsize start, jsize len, type *buf)  \
3062 {                                                                       \
3063         java_handle_##intern##array_t *a;                                   \
3064                                                                         \
3065         STATISTICS(jniinvokation());                                        \
3066                                                                         \
3067         a = (java_handle_##intern##array_t *) array;                        \
3068                                                                         \
3069         if ((start < 0) || (len < 0) || (start + len > LLNI_array_size(a))) \
3070                 exceptions_throw_arrayindexoutofboundsexception();              \
3071         else                                                                \
3072                 MCOPY(buf, &LLNI_array_direct(a, start), intern2, len);         \
3073 }
3074
3075 JNI_GET_ARRAY_REGION(Boolean, jboolean, boolean, u1)
3076 JNI_GET_ARRAY_REGION(Byte,    jbyte,    byte,    s1)
3077 JNI_GET_ARRAY_REGION(Char,    jchar,    char,    u2)
3078 JNI_GET_ARRAY_REGION(Short,   jshort,   short,   s2)
3079 JNI_GET_ARRAY_REGION(Int,     jint,     int,     s4)
3080 JNI_GET_ARRAY_REGION(Long,    jlong,    long,    s8)
3081 JNI_GET_ARRAY_REGION(Float,   jfloat,   float,   float)
3082 JNI_GET_ARRAY_REGION(Double,  jdouble,  double,  double)
3083
3084
3085 /*  Set<PrimitiveType>ArrayRegion **********************************************
3086
3087         A family of functions that copies back a region of a primitive
3088         array from a buffer.
3089
3090 *******************************************************************************/
3091
3092 #define JNI_SET_ARRAY_REGION(name, type, intern, intern2)                    \
3093 void _Jv_JNI_Set##name##ArrayRegion(JNIEnv *env, type##Array array,          \
3094                                                                         jsize start, jsize len, const type *buf) \
3095 {                                                                            \
3096         java_handle_##intern##array_t *a;                                        \
3097                                                                              \
3098         STATISTICS(jniinvokation());                                             \
3099                                                                              \
3100         a = (java_handle_##intern##array_t *) array;                             \
3101                                                                              \
3102         if ((start < 0) || (len < 0) || (start + len > LLNI_array_size(a)))      \
3103                 exceptions_throw_arrayindexoutofboundsexception();                   \
3104         else                                                                     \
3105                 MCOPY(&LLNI_array_direct(a, start), buf, intern2, len);              \
3106 }
3107
3108 JNI_SET_ARRAY_REGION(Boolean, jboolean, boolean, u1)
3109 JNI_SET_ARRAY_REGION(Byte,    jbyte,    byte,    s1)
3110 JNI_SET_ARRAY_REGION(Char,    jchar,    char,    u2)
3111 JNI_SET_ARRAY_REGION(Short,   jshort,   short,   s2)
3112 JNI_SET_ARRAY_REGION(Int,     jint,     int,     s4)
3113 JNI_SET_ARRAY_REGION(Long,    jlong,    long,    s8)
3114 JNI_SET_ARRAY_REGION(Float,   jfloat,   float,   float)
3115 JNI_SET_ARRAY_REGION(Double,  jdouble,  double,  double)
3116
3117
3118 /* Registering Native Methods *************************************************/
3119
3120 /* RegisterNatives *************************************************************
3121
3122    Registers native methods with the class specified by the clazz
3123    argument. The methods parameter specifies an array of
3124    JNINativeMethod structures that contain the names, signatures, and
3125    function pointers of the native methods. The nMethods parameter
3126    specifies the number of native methods in the array.
3127
3128 *******************************************************************************/
3129
3130 jint _Jv_JNI_RegisterNatives(JNIEnv *env, jclass clazz,
3131                                                          const JNINativeMethod *methods, jint nMethods)
3132 {
3133         classinfo *c;
3134
3135         STATISTICS(jniinvokation());
3136
3137         c = LLNI_classinfo_unwrap(clazz);
3138
3139         /* XXX: if implemented this needs a call to jvmti_NativeMethodBind
3140         if (jvmti) jvmti_NativeMethodBind(method, address,  new_address_ptr);
3141         */
3142
3143         native_method_register(c->name, methods, nMethods);
3144
3145     return 0;
3146 }
3147
3148
3149 /* UnregisterNatives ***********************************************************
3150
3151    Unregisters native methods of a class. The class goes back to the
3152    state before it was linked or registered with its native method
3153    functions.
3154
3155    This function should not be used in normal native code. Instead, it
3156    provides special programs a way to reload and relink native
3157    libraries.
3158
3159 *******************************************************************************/
3160
3161 jint _Jv_JNI_UnregisterNatives(JNIEnv *env, jclass clazz)
3162 {
3163         STATISTICS(jniinvokation());
3164
3165         /* XXX TWISTI hmm, maybe we should not support that (like kaffe) */
3166
3167     log_text("JNI-Call: UnregisterNatives: IMPLEMENT ME!!!");
3168
3169     return 0;
3170 }
3171
3172
3173 /* Monitor Operations *********************************************************/
3174
3175 /* MonitorEnter ****************************************************************
3176
3177    Enters the monitor associated with the underlying Java object
3178    referred to by obj.
3179
3180 *******************************************************************************/
3181
3182 jint _Jv_JNI_MonitorEnter(JNIEnv *env, jobject obj)
3183 {
3184         STATISTICS(jniinvokation());
3185
3186         if (obj == NULL) {
3187                 exceptions_throw_nullpointerexception();
3188                 return JNI_ERR;
3189         }
3190
3191         LOCK_MONITOR_ENTER(obj);
3192
3193         return JNI_OK;
3194 }
3195
3196
3197 /* MonitorExit *****************************************************************
3198
3199    The current thread must be the owner of the monitor associated with
3200    the underlying Java object referred to by obj. The thread
3201    decrements the counter indicating the number of times it has
3202    entered this monitor. If the value of the counter becomes zero, the
3203    current thread releases the monitor.
3204
3205 *******************************************************************************/
3206
3207 jint _Jv_JNI_MonitorExit(JNIEnv *env, jobject obj)
3208 {
3209         STATISTICS(jniinvokation());
3210
3211         if (obj == NULL) {
3212                 exceptions_throw_nullpointerexception();
3213                 return JNI_ERR;
3214         }
3215
3216         LOCK_MONITOR_EXIT(obj);
3217
3218         return JNI_OK;
3219 }
3220
3221
3222 /* JavaVM Interface ***********************************************************/
3223
3224 /* GetJavaVM *******************************************************************
3225
3226    Returns the Java VM interface (used in the Invocation API)
3227    associated with the current thread. The result is placed at the
3228    location pointed to by the second argument, vm.
3229
3230 *******************************************************************************/
3231
3232 jint _Jv_JNI_GetJavaVM(JNIEnv *env, JavaVM **vm)
3233 {
3234         STATISTICS(jniinvokation());
3235
3236     *vm = (JavaVM *) _Jv_jvm;
3237
3238         return 0;
3239 }
3240
3241
3242 /* GetStringRegion *************************************************************
3243
3244    Copies len number of Unicode characters beginning at offset start
3245    to the given buffer buf.
3246
3247    Throws StringIndexOutOfBoundsException on index overflow.
3248
3249 *******************************************************************************/
3250
3251 void _Jv_JNI_GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len,
3252                                                          jchar *buf)
3253 {
3254         java_lang_String        *s;
3255         java_handle_chararray_t *ca;
3256
3257         STATISTICS(jniinvokation());
3258
3259         s  = (java_lang_String *) str;
3260         LLNI_field_get_ref(s, value, ca);
3261
3262         if ((start < 0) || (len < 0) || (start > LLNI_field_direct(s, count)) ||
3263                 (start + len > LLNI_field_direct(s, count))) {
3264                 exceptions_throw_stringindexoutofboundsexception();
3265                 return;
3266         }
3267
3268         MCOPY(buf, &LLNI_array_direct(ca, start), u2, len);
3269 }
3270
3271
3272 /* GetStringUTFRegion **********************************************************
3273
3274     Translates len number of Unicode characters beginning at offset
3275     start into UTF-8 format and place the result in the given buffer
3276     buf.
3277
3278     Throws StringIndexOutOfBoundsException on index overflow.
3279
3280 *******************************************************************************/
3281
3282 void _Jv_JNI_GetStringUTFRegion(JNIEnv* env, jstring str, jsize start,
3283                                                                 jsize len, char *buf)
3284 {
3285         java_lang_String        *s;
3286         java_handle_chararray_t *ca;
3287         s4                       i;
3288         int32_t                  count;
3289         int32_t                  offset;
3290
3291         TRACEJNICALLS(("_Jv_JNI_GetStringUTFRegion(env=%p, str=%p, start=%d, len=%d, buf=%p)", env, str, start, len, buf));
3292
3293         s  = (java_lang_String *) str;
3294         LLNI_field_get_ref(s, value, ca);
3295         LLNI_field_get_val(s, count, count);
3296         LLNI_field_get_val(s, offset, offset);
3297
3298         if ((start < 0) || (len < 0) || (start > count) || (start + len > count)) {
3299                 exceptions_throw_stringindexoutofboundsexception();
3300                 return;
3301         }
3302
3303         for (i = 0; i < len; i++)
3304                 buf[i] = LLNI_array_direct(ca, offset + start + i);
3305
3306         buf[i] = '\0';
3307 }
3308
3309
3310 /* GetPrimitiveArrayCritical ***************************************************
3311
3312    Obtain a direct pointer to array elements.
3313
3314 *******************************************************************************/
3315
3316 void *_Jv_JNI_GetPrimitiveArrayCritical(JNIEnv *env, jarray array,
3317                                                                                 jboolean *isCopy)
3318 {
3319         java_handle_bytearray_t *ba;
3320         jbyte                   *bp;
3321
3322         ba = (java_handle_bytearray_t *) array;
3323
3324         /* do the same as Kaffe does */
3325
3326         bp = _Jv_JNI_GetByteArrayElements(env, (jbyteArray) ba, isCopy);
3327
3328         return (void *) bp;
3329 }
3330
3331
3332 /* ReleasePrimitiveArrayCritical ***********************************************
3333
3334    No specific documentation.
3335
3336 *******************************************************************************/
3337
3338 void _Jv_JNI_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array,
3339                                                                                    void *carray, jint mode)
3340 {
3341         STATISTICS(jniinvokation());
3342
3343         /* do the same as Kaffe does */
3344
3345         _Jv_JNI_ReleaseByteArrayElements(env, (jbyteArray) array, (jbyte *) carray,
3346                                                                          mode);
3347 }
3348
3349
3350 /* GetStringCritical ***********************************************************
3351
3352    The semantics of these two functions are similar to the existing
3353    Get/ReleaseStringChars functions.
3354
3355 *******************************************************************************/
3356
3357 const jchar *_Jv_JNI_GetStringCritical(JNIEnv *env, jstring string,
3358                                                                            jboolean *isCopy)
3359 {
3360         STATISTICS(jniinvokation());
3361
3362         return _Jv_JNI_GetStringChars(env, string, isCopy);
3363 }
3364
3365
3366 void _Jv_JNI_ReleaseStringCritical(JNIEnv *env, jstring string,
3367                                                                    const jchar *cstring)
3368 {
3369         STATISTICS(jniinvokation());
3370
3371         _Jv_JNI_ReleaseStringChars(env, string, cstring);
3372 }
3373
3374
3375 jweak _Jv_JNI_NewWeakGlobalRef(JNIEnv* env, jobject obj)
3376 {
3377         TRACEJNICALLS(("_Jv_JNI_NewWeakGlobalRef(env=%p, obj=%p): IMPLEMENT ME!", env, obj));
3378
3379         return obj;
3380 }
3381
3382
3383 void _Jv_JNI_DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
3384 {
3385         TRACEJNICALLS(("_Jv_JNI_DeleteWeakGlobalRef(env=%p, ref=%p): IMPLEMENT ME", env, ref));
3386 }
3387
3388
3389 /* NewGlobalRef ****************************************************************
3390
3391    Creates a new global reference to the object referred to by the obj
3392    argument.
3393
3394 *******************************************************************************/
3395
3396 jobject _Jv_JNI_NewGlobalRef(JNIEnv* env, jobject obj)
3397 {
3398         hashtable_global_ref_entry *gre;
3399         u4   key;                           /* hashkey                            */
3400         u4   slot;                          /* slot in hashtable                  */
3401         java_handle_t *o;
3402
3403         STATISTICS(jniinvokation());
3404
3405         o = (java_handle_t *) obj;
3406
3407         LOCK_MONITOR_ENTER(hashtable_global_ref->header);
3408
3409         LLNI_CRITICAL_START;
3410
3411         /* normally addresses are aligned to 4, 8 or 16 bytes */
3412
3413         key  = heap_hashcode(LLNI_DIRECT(o)) >> 4; /* align to 16-byte boundaries */
3414         slot = key & (hashtable_global_ref->size - 1);
3415         gre  = hashtable_global_ref->ptr[slot];
3416
3417         /* search external hash chain for the entry */
3418
3419         while (gre) {
3420                 if (gre->o == LLNI_DIRECT(o)) {
3421                         /* global object found, increment the reference */
3422
3423                         gre->refs++;
3424
3425                         break;
3426                 }
3427
3428                 gre = gre->hashlink;                /* next element in external chain */
3429         }
3430
3431         LLNI_CRITICAL_END;
3432
3433         /* global ref not found, create a new one */
3434
3435         if (gre == NULL) {
3436                 gre = NEW(hashtable_global_ref_entry);
3437
3438 #if defined(ENABLE_GC_CACAO)
3439                 /* register global ref with the GC */
3440
3441                 gc_reference_register(&(gre->o), GC_REFTYPE_JNI_GLOBALREF);
3442 #endif
3443
3444                 LLNI_CRITICAL_START;
3445
3446                 gre->o    = LLNI_DIRECT(o);
3447                 gre->refs = 1;
3448
3449                 LLNI_CRITICAL_END;
3450
3451                 /* insert entry into hashtable */
3452
3453                 gre->hashlink = hashtable_global_ref->ptr[slot];
3454
3455                 hashtable_global_ref->ptr[slot] = gre;
3456
3457                 /* update number of hashtable-entries */
3458
3459                 hashtable_global_ref->entries++;
3460         }
3461
3462         LOCK_MONITOR_EXIT(hashtable_global_ref->header);
3463
3464 #if defined(ENABLE_HANDLES)
3465         return gre;
3466 #else
3467         return obj;
3468 #endif
3469 }
3470
3471
3472 /* DeleteGlobalRef *************************************************************
3473
3474    Deletes the global reference pointed to by globalRef.
3475
3476 *******************************************************************************/
3477
3478 void _Jv_JNI_DeleteGlobalRef(JNIEnv* env, jobject globalRef)
3479 {
3480         hashtable_global_ref_entry *gre;
3481         hashtable_global_ref_entry *prevgre;
3482         u4   key;                           /* hashkey                            */
3483         u4   slot;                          /* slot in hashtable                  */
3484         java_handle_t              *o;
3485
3486         STATISTICS(jniinvokation());
3487
3488         o = (java_handle_t *) globalRef;
3489
3490         LOCK_MONITOR_ENTER(hashtable_global_ref->header);
3491
3492         LLNI_CRITICAL_START;
3493
3494         /* normally addresses are aligned to 4, 8 or 16 bytes */
3495
3496         key  = heap_hashcode(LLNI_DIRECT(o)) >> 4; /* align to 16-byte boundaries */
3497         slot = key & (hashtable_global_ref->size - 1);
3498         gre  = hashtable_global_ref->ptr[slot];
3499
3500         /* initialize prevgre */
3501
3502         prevgre = NULL;
3503
3504         /* search external hash chain for the entry */
3505
3506         while (gre) {
3507                 if (gre->o == LLNI_DIRECT(o)) {
3508                         /* global object found, decrement the reference count */
3509
3510                         gre->refs--;
3511
3512                         /* if reference count is 0, remove the entry */
3513
3514                         if (gre->refs == 0) {
3515                                 /* special handling if it's the first in the chain */
3516
3517                                 if (prevgre == NULL)
3518                                         hashtable_global_ref->ptr[slot] = gre->hashlink;
3519                                 else
3520                                         prevgre->hashlink = gre->hashlink;
3521
3522 #if defined(ENABLE_GC_CACAO)
3523                                 /* unregister global ref with the GC */
3524
3525                                 gc_reference_unregister(&(gre->o));
3526 #endif
3527
3528                                 FREE(gre, hashtable_global_ref_entry);
3529                         }
3530
3531                         LLNI_CRITICAL_END;
3532
3533                         LOCK_MONITOR_EXIT(hashtable_global_ref->header);
3534
3535                         return;
3536                 }
3537
3538                 prevgre = gre;                    /* save current pointer for removal */
3539                 gre     = gre->hashlink;            /* next element in external chain */
3540         }
3541
3542         log_println("JNI-DeleteGlobalRef: global reference not found");
3543
3544         LLNI_CRITICAL_END;
3545
3546         LOCK_MONITOR_EXIT(hashtable_global_ref->header);
3547 }
3548
3549
3550 /* ExceptionCheck **************************************************************
3551
3552    Returns JNI_TRUE when there is a pending exception; otherwise,
3553    returns JNI_FALSE.
3554
3555 *******************************************************************************/
3556
3557 jboolean _Jv_JNI_ExceptionCheck(JNIEnv *env)
3558 {
3559         java_handle_t *o;
3560
3561         STATISTICS(jniinvokation());
3562
3563         o = exceptions_get_exception();
3564
3565         return (o != NULL) ? JNI_TRUE : JNI_FALSE;
3566 }
3567
3568
3569 /* New JNI 1.4 functions ******************************************************/
3570
3571 /* NewDirectByteBuffer *********************************************************
3572
3573    Allocates and returns a direct java.nio.ByteBuffer referring to the
3574    block of memory starting at the memory address address and
3575    extending capacity bytes.
3576
3577 *******************************************************************************/
3578
3579 jobject _Jv_JNI_NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
3580 {
3581 #if defined(ENABLE_JAVASE)
3582 # if defined(WITH_CLASSPATH_GNU)
3583         java_handle_t           *nbuf;
3584
3585 # if SIZEOF_VOID_P == 8
3586         gnu_classpath_Pointer64 *paddress;
3587 # else
3588         gnu_classpath_Pointer32 *paddress;
3589 # endif
3590
3591         TRACEJNICALLS(("_Jv_JNI_NewDirectByteBuffer(env=%p, address=%p, capacity=%ld", env, address, capacity));
3592
3593         /* alocate a gnu.classpath.Pointer{32,64} object */
3594
3595 # if SIZEOF_VOID_P == 8
3596         if (!(paddress = (gnu_classpath_Pointer64 *)
3597                   builtin_new(class_gnu_classpath_Pointer64)))
3598 # else
3599         if (!(paddress = (gnu_classpath_Pointer32 *)
3600                   builtin_new(class_gnu_classpath_Pointer32)))
3601 # endif
3602                 return NULL;
3603
3604         /* fill gnu.classpath.Pointer{32,64} with address */
3605
3606         LLNI_field_set_val(paddress, data, (ptrint) address);
3607
3608         /* create a java.nio.DirectByteBufferImpl$ReadWrite object */
3609
3610         nbuf = (*env)->NewObject(env, class_java_nio_DirectByteBufferImpl_ReadWrite,
3611                                                          (jmethodID) dbbirw_init, NULL, paddress,
3612                                                          (jint) capacity, (jint) capacity, (jint) 0);
3613
3614         /* add local reference and return the value */
3615
3616         return _Jv_JNI_NewLocalRef(env, nbuf);
3617
3618 # elif defined(WITH_CLASSPATH_SUN)
3619
3620         jobject o;
3621         int64_t addr;
3622         int32_t cap;
3623
3624         TRACEJNICALLS(("_Jv_JNI_NewDirectByteBuffer(env=%p, address=%p, capacity=%ld", env, address, capacity));
3625
3626         /* Be paranoid about address sign-extension. */
3627
3628         addr = (int64_t) ((uintptr_t) address);
3629         cap  = (int32_t) capacity;
3630
3631         o = (*env)->NewObject(env, (jclass) class_java_nio_DirectByteBuffer,
3632                                                   (jmethodID) dbb_init, addr, cap);
3633
3634         /* Add local reference and return the value. */
3635
3636         return _Jv_JNI_NewLocalRef(env, o);
3637
3638 # else
3639 #  error unknown classpath configuration
3640 # endif
3641
3642 #else
3643         vm_abort("_Jv_JNI_NewDirectByteBuffer: not implemented in this configuration");
3644
3645         /* keep compiler happy */
3646
3647         return NULL;
3648 #endif
3649 }
3650
3651
3652 /* GetDirectBufferAddress ******************************************************
3653
3654    Fetches and returns the starting address of the memory region
3655    referenced by the given direct java.nio.Buffer.
3656
3657 *******************************************************************************/
3658
3659 void *_Jv_JNI_GetDirectBufferAddress(JNIEnv *env, jobject buf)
3660 {
3661 #if defined(ENABLE_JAVASE)
3662         java_handle_t                 *h;
3663
3664 # if defined(WITH_CLASSPATH_GNU)
3665
3666         java_nio_DirectByteBufferImpl *nbuf;
3667 #  if SIZEOF_VOID_P == 8
3668         gnu_classpath_Pointer64       *paddress;
3669 #  else
3670         gnu_classpath_Pointer32       *paddress;
3671 #  endif
3672         void                          *address;
3673
3674         TRACEJNICALLS(("_Jv_JNI_GetDirectBufferAddress(env=%p, buf=%p)", env, buf));
3675
3676         /* Prevent compiler warning. */
3677
3678         h = (java_handle_t *) buf;
3679
3680         if ((h != NULL) && !builtin_instanceof(h, class_java_nio_Buffer))
3681                 return NULL;
3682
3683         nbuf = (java_nio_DirectByteBufferImpl *) buf;
3684
3685         LLNI_field_get_ref(nbuf, address, paddress);
3686
3687         if (paddress == NULL)
3688                 return NULL;
3689
3690         LLNI_field_get_val(paddress, data, address);
3691         /* this was the cast to avaoid warning: (void *) paddress->data */
3692
3693         return address;
3694
3695 # elif defined(WITH_CLASSPATH_SUN)
3696
3697         java_nio_Buffer *o;
3698         int64_t          address;
3699         void            *p;
3700
3701         TRACEJNICALLS(("_Jv_JNI_GetDirectBufferAddress(env=%p, buf=%p)", env, buf));
3702
3703         /* Prevent compiler warning. */
3704
3705         h = (java_handle_t *) buf;
3706
3707         if ((h != NULL) && !builtin_instanceof(h, class_sun_nio_ch_DirectBuffer))
3708                 return NULL;
3709
3710         o = (java_nio_Buffer *) buf;
3711
3712         LLNI_field_get_val(o, address, address);
3713
3714         p = (void *) (intptr_t) address;
3715
3716         return p;
3717
3718 # else
3719 #  error unknown classpath configuration
3720 # endif
3721
3722 #else
3723
3724         vm_abort("_Jv_JNI_GetDirectBufferAddress: not implemented in this configuration");
3725
3726         /* keep compiler happy */
3727
3728         return NULL;
3729
3730 #endif
3731 }
3732
3733
3734 /* GetDirectBufferCapacity *****************************************************
3735
3736    Fetches and returns the capacity in bytes of the memory region
3737    referenced by the given direct java.nio.Buffer.
3738
3739 *******************************************************************************/
3740
3741 jlong _Jv_JNI_GetDirectBufferCapacity(JNIEnv* env, jobject buf)
3742 {
3743 #if defined(ENABLE_JAVASE) && defined(WITH_CLASSPATH_GNU)
3744         java_handle_t   *o;
3745         java_nio_Buffer *nbuf;
3746         jlong            capacity;
3747
3748         STATISTICS(jniinvokation());
3749
3750         o = (java_handle_t *) buf;
3751
3752         if (!builtin_instanceof(o, class_java_nio_DirectByteBufferImpl))
3753                 return -1;
3754
3755         nbuf = (java_nio_Buffer *) o;
3756
3757         LLNI_field_get_val(nbuf, cap, capacity);
3758
3759         return capacity;
3760 #else
3761         vm_abort("_Jv_JNI_GetDirectBufferCapacity: not implemented in this configuration");
3762
3763         /* keep compiler happy */
3764
3765         return 0;
3766 #endif
3767 }
3768
3769
3770 /* GetObjectRefType ************************************************************
3771
3772    Returns the type of the object referred to by the obj argument. The
3773    argument obj can either be a local, global or weak global
3774    reference.
3775
3776 *******************************************************************************/
3777
3778 jobjectRefType jni_GetObjectRefType(JNIEnv *env, jobject obj)
3779 {
3780         log_println("jni_GetObjectRefType: IMPLEMENT ME!");
3781
3782         return -1;
3783 }
3784
3785
3786 /* DestroyJavaVM ***************************************************************
3787
3788    Unloads a Java VM and reclaims its resources. Only the main thread
3789    can unload the VM. The system waits until the main thread is only
3790    remaining user thread before it destroys the VM.
3791
3792 *******************************************************************************/
3793
3794 jint _Jv_JNI_DestroyJavaVM(JavaVM *vm)
3795 {
3796         int32_t status;
3797
3798         TRACEJNICALLS(("_Jv_JNI_DestroyJavaVM(vm=%p)", vm));
3799
3800     status = vm_destroy(vm);
3801
3802         return status;
3803 }
3804
3805
3806 /* AttachCurrentThread *********************************************************
3807
3808    Attaches the current thread to a Java VM. Returns a JNI interface
3809    pointer in the JNIEnv argument.
3810
3811    Trying to attach a thread that is already attached is a no-op.
3812
3813    A native thread cannot be attached simultaneously to two Java VMs.
3814
3815    When a thread is attached to the VM, the context class loader is
3816    the bootstrap loader.
3817
3818 *******************************************************************************/
3819
3820 static s4 jni_attach_current_thread(void **p_env, void *thr_args, bool isdaemon)
3821 {
3822         JavaVMAttachArgs *vm_aargs;
3823
3824 #if defined(ENABLE_THREADS)
3825         if (threads_get_current_threadobject() == NULL) {
3826                 vm_aargs = (JavaVMAttachArgs *) thr_args;
3827
3828                 if (vm_aargs != NULL) {
3829                         if ((vm_aargs->version != JNI_VERSION_1_2) &&
3830                                 (vm_aargs->version != JNI_VERSION_1_4))
3831                                 return JNI_EVERSION;
3832                 }
3833
3834                 if (!threads_attach_current_thread(vm_aargs, false))
3835                         return JNI_ERR;
3836
3837                 if (!localref_table_init())
3838                         return JNI_ERR;
3839         }
3840 #endif
3841
3842         *p_env = _Jv_env;
3843
3844         return JNI_OK;
3845 }
3846
3847
3848 jint _Jv_JNI_AttachCurrentThread(JavaVM *vm, void **p_env, void *thr_args)
3849 {
3850         STATISTICS(jniinvokation());
3851
3852         return jni_attach_current_thread(p_env, thr_args, false);
3853 }
3854
3855
3856 /* DetachCurrentThread *********************************************************
3857
3858    Detaches the current thread from a Java VM. All Java monitors held
3859    by this thread are released. All Java threads waiting for this
3860    thread to die are notified.
3861
3862    In JDK 1.1, the main thread cannot be detached from the VM. It must
3863    call DestroyJavaVM to unload the entire VM.
3864
3865    In the JDK, the main thread can be detached from the VM.
3866
3867    The main thread, which is the thread that created the Java VM,
3868    cannot be detached from the VM. Instead, the main thread must call
3869    JNI_DestroyJavaVM() to unload the entire VM.
3870
3871 *******************************************************************************/
3872
3873 jint _Jv_JNI_DetachCurrentThread(JavaVM *vm)
3874 {
3875 #if defined(ENABLE_THREADS)
3876         threadobject *thread;
3877
3878         STATISTICS(jniinvokation());
3879
3880         thread = threads_get_current_threadobject();
3881
3882         if (thread == NULL)
3883                 return JNI_ERR;
3884
3885         /* We need to pop all frames before we can destroy the table. */
3886
3887         localref_frame_pop_all();
3888
3889         if (!localref_table_destroy())
3890                 return JNI_ERR;
3891
3892         if (!threads_detach_thread(thread))
3893                 return JNI_ERR;
3894 #endif
3895
3896         return JNI_OK;
3897 }
3898
3899
3900 /* GetEnv **********************************************************************
3901
3902    If the current thread is not attached to the VM, sets *env to NULL,
3903    and returns JNI_EDETACHED. If the specified version is not
3904    supported, sets *env to NULL, and returns JNI_EVERSION. Otherwise,
3905    sets *env to the appropriate interface, and returns JNI_OK.
3906
3907 *******************************************************************************/
3908
3909 jint _Jv_JNI_GetEnv(JavaVM *vm, void **env, jint version)
3910 {
3911         TRACEJNICALLS(("_Jv_JNI_GetEnv(vm=%p, env=%p, %d=version)", vm, env, version));
3912
3913 #if defined(ENABLE_THREADS)
3914         if (threads_get_current_threadobject() == NULL) {
3915                 *env = NULL;
3916
3917                 return JNI_EDETACHED;
3918         }
3919 #endif
3920
3921         /* Check the JNI version. */
3922
3923         if (jni_version_check(version) == true) {
3924                 *env = _Jv_env;
3925                 return JNI_OK;
3926         }
3927
3928 #if defined(ENABLE_JVMTI)
3929         if ((version & JVMTI_VERSION_MASK_INTERFACE_TYPE)
3930                 == JVMTI_VERSION_INTERFACE_JVMTI) {
3931
3932                 *env = (void *) jvmti_new_environment();
3933
3934                 if (env != NULL)
3935                         return JNI_OK;
3936         }
3937 #endif
3938
3939         *env = NULL;
3940
3941         return JNI_EVERSION;
3942 }
3943
3944
3945 /* AttachCurrentThreadAsDaemon *************************************************
3946
3947    Same semantics as AttachCurrentThread, but the newly-created
3948    java.lang.Thread instance is a daemon.
3949
3950    If the thread has already been attached via either
3951    AttachCurrentThread or AttachCurrentThreadAsDaemon, this routine
3952    simply sets the value pointed to by penv to the JNIEnv of the
3953    current thread. In this case neither AttachCurrentThread nor this
3954    routine have any effect on the daemon status of the thread.
3955
3956 *******************************************************************************/
3957
3958 jint _Jv_JNI_AttachCurrentThreadAsDaemon(JavaVM *vm, void **penv, void *args)
3959 {
3960         STATISTICS(jniinvokation());
3961
3962         return jni_attach_current_thread(penv, args, true);
3963 }
3964
3965
3966 /* JNI invocation table *******************************************************/
3967
3968 const struct JNIInvokeInterface_ _Jv_JNIInvokeInterface = {
3969         NULL,
3970         NULL,
3971         NULL,
3972
3973         _Jv_JNI_DestroyJavaVM,
3974         _Jv_JNI_AttachCurrentThread,
3975         _Jv_JNI_DetachCurrentThread,
3976         _Jv_JNI_GetEnv,
3977         _Jv_JNI_AttachCurrentThreadAsDaemon
3978 };
3979
3980
3981 /* JNI function table *********************************************************/
3982
3983 struct JNINativeInterface_ _Jv_JNINativeInterface = {
3984         NULL,
3985         NULL,
3986         NULL,
3987         NULL,
3988         _Jv_JNI_GetVersion,
3989
3990         _Jv_JNI_DefineClass,
3991         _Jv_JNI_FindClass,
3992         _Jv_JNI_FromReflectedMethod,
3993         _Jv_JNI_FromReflectedField,
3994         _Jv_JNI_ToReflectedMethod,
3995         _Jv_JNI_GetSuperclass,
3996         _Jv_JNI_IsAssignableFrom,
3997         _Jv_JNI_ToReflectedField,
3998
3999         _Jv_JNI_Throw,
4000         _Jv_JNI_ThrowNew,
4001         _Jv_JNI_ExceptionOccurred,
4002         _Jv_JNI_ExceptionDescribe,
4003         _Jv_JNI_ExceptionClear,
4004         _Jv_JNI_FatalError,
4005         _Jv_JNI_PushLocalFrame,
4006         _Jv_JNI_PopLocalFrame,
4007
4008         _Jv_JNI_NewGlobalRef,
4009         _Jv_JNI_DeleteGlobalRef,
4010         _Jv_JNI_DeleteLocalRef,
4011         _Jv_JNI_IsSameObject,
4012         _Jv_JNI_NewLocalRef,
4013         _Jv_JNI_EnsureLocalCapacity,
4014
4015         _Jv_JNI_AllocObject,
4016         _Jv_JNI_NewObject,
4017         _Jv_JNI_NewObjectV,
4018         _Jv_JNI_NewObjectA,
4019
4020         _Jv_JNI_GetObjectClass,
4021         _Jv_JNI_IsInstanceOf,
4022
4023         _Jv_JNI_GetMethodID,
4024
4025         _Jv_JNI_CallObjectMethod,
4026         _Jv_JNI_CallObjectMethodV,
4027         _Jv_JNI_CallObjectMethodA,
4028         _Jv_JNI_CallBooleanMethod,
4029         _Jv_JNI_CallBooleanMethodV,
4030         _Jv_JNI_CallBooleanMethodA,
4031         _Jv_JNI_CallByteMethod,
4032         _Jv_JNI_CallByteMethodV,
4033         _Jv_JNI_CallByteMethodA,
4034         _Jv_JNI_CallCharMethod,
4035         _Jv_JNI_CallCharMethodV,
4036         _Jv_JNI_CallCharMethodA,
4037         _Jv_JNI_CallShortMethod,
4038         _Jv_JNI_CallShortMethodV,
4039         _Jv_JNI_CallShortMethodA,
4040         _Jv_JNI_CallIntMethod,
4041         _Jv_JNI_CallIntMethodV,
4042         _Jv_JNI_CallIntMethodA,
4043         _Jv_JNI_CallLongMethod,
4044         _Jv_JNI_CallLongMethodV,
4045         _Jv_JNI_CallLongMethodA,
4046         _Jv_JNI_CallFloatMethod,
4047         _Jv_JNI_CallFloatMethodV,
4048         _Jv_JNI_CallFloatMethodA,
4049         _Jv_JNI_CallDoubleMethod,
4050         _Jv_JNI_CallDoubleMethodV,
4051         _Jv_JNI_CallDoubleMethodA,
4052         _Jv_JNI_CallVoidMethod,
4053         _Jv_JNI_CallVoidMethodV,
4054         _Jv_JNI_CallVoidMethodA,
4055
4056         _Jv_JNI_CallNonvirtualObjectMethod,
4057         _Jv_JNI_CallNonvirtualObjectMethodV,
4058         _Jv_JNI_CallNonvirtualObjectMethodA,
4059         _Jv_JNI_CallNonvirtualBooleanMethod,
4060         _Jv_JNI_CallNonvirtualBooleanMethodV,
4061         _Jv_JNI_CallNonvirtualBooleanMethodA,
4062         _Jv_JNI_CallNonvirtualByteMethod,
4063         _Jv_JNI_CallNonvirtualByteMethodV,
4064         _Jv_JNI_CallNonvirtualByteMethodA,
4065         _Jv_JNI_CallNonvirtualCharMethod,
4066         _Jv_JNI_CallNonvirtualCharMethodV,
4067         _Jv_JNI_CallNonvirtualCharMethodA,
4068         _Jv_JNI_CallNonvirtualShortMethod,
4069         _Jv_JNI_CallNonvirtualShortMethodV,
4070         _Jv_JNI_CallNonvirtualShortMethodA,
4071         _Jv_JNI_CallNonvirtualIntMethod,
4072         _Jv_JNI_CallNonvirtualIntMethodV,
4073         _Jv_JNI_CallNonvirtualIntMethodA,
4074         _Jv_JNI_CallNonvirtualLongMethod,
4075         _Jv_JNI_CallNonvirtualLongMethodV,
4076         _Jv_JNI_CallNonvirtualLongMethodA,
4077         _Jv_JNI_CallNonvirtualFloatMethod,
4078         _Jv_JNI_CallNonvirtualFloatMethodV,
4079         _Jv_JNI_CallNonvirtualFloatMethodA,
4080         _Jv_JNI_CallNonvirtualDoubleMethod,
4081         _Jv_JNI_CallNonvirtualDoubleMethodV,
4082         _Jv_JNI_CallNonvirtualDoubleMethodA,
4083         _Jv_JNI_CallNonvirtualVoidMethod,
4084         _Jv_JNI_CallNonvirtualVoidMethodV,
4085         _Jv_JNI_CallNonvirtualVoidMethodA,
4086
4087         _Jv_JNI_GetFieldID,
4088
4089         _Jv_JNI_GetObjectField,
4090         _Jv_JNI_GetBooleanField,
4091         _Jv_JNI_GetByteField,
4092         _Jv_JNI_GetCharField,
4093         _Jv_JNI_GetShortField,
4094         _Jv_JNI_GetIntField,
4095         _Jv_JNI_GetLongField,
4096         _Jv_JNI_GetFloatField,
4097         _Jv_JNI_GetDoubleField,
4098         _Jv_JNI_SetObjectField,
4099         _Jv_JNI_SetBooleanField,
4100         _Jv_JNI_SetByteField,
4101         _Jv_JNI_SetCharField,
4102         _Jv_JNI_SetShortField,
4103         _Jv_JNI_SetIntField,
4104         _Jv_JNI_SetLongField,
4105         _Jv_JNI_SetFloatField,
4106         _Jv_JNI_SetDoubleField,
4107
4108         _Jv_JNI_GetStaticMethodID,
4109
4110         _Jv_JNI_CallStaticObjectMethod,
4111         _Jv_JNI_CallStaticObjectMethodV,
4112         _Jv_JNI_CallStaticObjectMethodA,
4113         _Jv_JNI_CallStaticBooleanMethod,
4114         _Jv_JNI_CallStaticBooleanMethodV,
4115         _Jv_JNI_CallStaticBooleanMethodA,
4116         _Jv_JNI_CallStaticByteMethod,
4117         _Jv_JNI_CallStaticByteMethodV,
4118         _Jv_JNI_CallStaticByteMethodA,
4119         _Jv_JNI_CallStaticCharMethod,
4120         _Jv_JNI_CallStaticCharMethodV,
4121         _Jv_JNI_CallStaticCharMethodA,
4122         _Jv_JNI_CallStaticShortMethod,
4123         _Jv_JNI_CallStaticShortMethodV,
4124         _Jv_JNI_CallStaticShortMethodA,
4125         _Jv_JNI_CallStaticIntMethod,
4126         _Jv_JNI_CallStaticIntMethodV,
4127         _Jv_JNI_CallStaticIntMethodA,
4128         _Jv_JNI_CallStaticLongMethod,
4129         _Jv_JNI_CallStaticLongMethodV,
4130         _Jv_JNI_CallStaticLongMethodA,
4131         _Jv_JNI_CallStaticFloatMethod,
4132         _Jv_JNI_CallStaticFloatMethodV,
4133         _Jv_JNI_CallStaticFloatMethodA,
4134         _Jv_JNI_CallStaticDoubleMethod,
4135         _Jv_JNI_CallStaticDoubleMethodV,
4136         _Jv_JNI_CallStaticDoubleMethodA,
4137         _Jv_JNI_CallStaticVoidMethod,
4138         _Jv_JNI_CallStaticVoidMethodV,
4139         _Jv_JNI_CallStaticVoidMethodA,
4140
4141         _Jv_JNI_GetStaticFieldID,
4142
4143         _Jv_JNI_GetStaticObjectField,
4144         _Jv_JNI_GetStaticBooleanField,
4145         _Jv_JNI_GetStaticByteField,
4146         _Jv_JNI_GetStaticCharField,
4147         _Jv_JNI_GetStaticShortField,
4148         _Jv_JNI_GetStaticIntField,
4149         _Jv_JNI_GetStaticLongField,
4150         _Jv_JNI_GetStaticFloatField,
4151         _Jv_JNI_GetStaticDoubleField,
4152         _Jv_JNI_SetStaticObjectField,
4153         _Jv_JNI_SetStaticBooleanField,
4154         _Jv_JNI_SetStaticByteField,
4155         _Jv_JNI_SetStaticCharField,
4156         _Jv_JNI_SetStaticShortField,
4157         _Jv_JNI_SetStaticIntField,
4158         _Jv_JNI_SetStaticLongField,
4159         _Jv_JNI_SetStaticFloatField,
4160         _Jv_JNI_SetStaticDoubleField,
4161
4162         _Jv_JNI_NewString,
4163         _Jv_JNI_GetStringLength,
4164         _Jv_JNI_GetStringChars,
4165         _Jv_JNI_ReleaseStringChars,
4166
4167         _Jv_JNI_NewStringUTF,
4168         _Jv_JNI_GetStringUTFLength,
4169         _Jv_JNI_GetStringUTFChars,
4170         _Jv_JNI_ReleaseStringUTFChars,
4171
4172         _Jv_JNI_GetArrayLength,
4173
4174         _Jv_JNI_NewObjectArray,
4175         _Jv_JNI_GetObjectArrayElement,
4176         _Jv_JNI_SetObjectArrayElement,
4177
4178         _Jv_JNI_NewBooleanArray,
4179         _Jv_JNI_NewByteArray,
4180         _Jv_JNI_NewCharArray,
4181         _Jv_JNI_NewShortArray,
4182         _Jv_JNI_NewIntArray,
4183         _Jv_JNI_NewLongArray,
4184         _Jv_JNI_NewFloatArray,
4185         _Jv_JNI_NewDoubleArray,
4186
4187         _Jv_JNI_GetBooleanArrayElements,
4188         _Jv_JNI_GetByteArrayElements,
4189         _Jv_JNI_GetCharArrayElements,
4190         _Jv_JNI_GetShortArrayElements,
4191         _Jv_JNI_GetIntArrayElements,
4192         _Jv_JNI_GetLongArrayElements,
4193         _Jv_JNI_GetFloatArrayElements,
4194         _Jv_JNI_GetDoubleArrayElements,
4195
4196         _Jv_JNI_ReleaseBooleanArrayElements,
4197         _Jv_JNI_ReleaseByteArrayElements,
4198         _Jv_JNI_ReleaseCharArrayElements,
4199         _Jv_JNI_ReleaseShortArrayElements,
4200         _Jv_JNI_ReleaseIntArrayElements,
4201         _Jv_JNI_ReleaseLongArrayElements,
4202         _Jv_JNI_ReleaseFloatArrayElements,
4203         _Jv_JNI_ReleaseDoubleArrayElements,
4204
4205         _Jv_JNI_GetBooleanArrayRegion,
4206         _Jv_JNI_GetByteArrayRegion,
4207         _Jv_JNI_GetCharArrayRegion,
4208         _Jv_JNI_GetShortArrayRegion,
4209         _Jv_JNI_GetIntArrayRegion,
4210         _Jv_JNI_GetLongArrayRegion,
4211         _Jv_JNI_GetFloatArrayRegion,
4212         _Jv_JNI_GetDoubleArrayRegion,
4213         _Jv_JNI_SetBooleanArrayRegion,
4214         _Jv_JNI_SetByteArrayRegion,
4215         _Jv_JNI_SetCharArrayRegion,
4216         _Jv_JNI_SetShortArrayRegion,
4217         _Jv_JNI_SetIntArrayRegion,
4218         _Jv_JNI_SetLongArrayRegion,
4219         _Jv_JNI_SetFloatArrayRegion,
4220         _Jv_JNI_SetDoubleArrayRegion,
4221
4222         _Jv_JNI_RegisterNatives,
4223         _Jv_JNI_UnregisterNatives,
4224
4225         _Jv_JNI_MonitorEnter,
4226         _Jv_JNI_MonitorExit,
4227
4228         _Jv_JNI_GetJavaVM,
4229
4230         /* New JNI 1.2 functions. */
4231
4232         _Jv_JNI_GetStringRegion,
4233         _Jv_JNI_GetStringUTFRegion,
4234
4235         _Jv_JNI_GetPrimitiveArrayCritical,
4236         _Jv_JNI_ReleasePrimitiveArrayCritical,
4237
4238         _Jv_JNI_GetStringCritical,
4239         _Jv_JNI_ReleaseStringCritical,
4240
4241         _Jv_JNI_NewWeakGlobalRef,
4242         _Jv_JNI_DeleteWeakGlobalRef,
4243
4244         _Jv_JNI_ExceptionCheck,
4245
4246         /* New JNI 1.4 functions. */
4247
4248         _Jv_JNI_NewDirectByteBuffer,
4249         _Jv_JNI_GetDirectBufferAddress,
4250         _Jv_JNI_GetDirectBufferCapacity,
4251
4252         /* New JNI 1.6 functions. */
4253
4254         jni_GetObjectRefType
4255 };
4256
4257
4258 /* Invocation API Functions ***************************************************/
4259
4260 /* JNI_GetDefaultJavaVMInitArgs ************************************************
4261
4262    Returns a default configuration for the Java VM.
4263
4264 *******************************************************************************/
4265
4266 jint JNI_GetDefaultJavaVMInitArgs(void *vm_args)
4267 {
4268         JavaVMInitArgs *_vm_args;
4269
4270         _vm_args = (JavaVMInitArgs *) vm_args;
4271
4272         /* GNU classpath currently supports JNI 1.2 */
4273
4274         switch (_vm_args->version) {
4275     case JNI_VERSION_1_1:
4276                 _vm_args->version = JNI_VERSION_1_1;
4277                 break;
4278
4279     case JNI_VERSION_1_2:
4280     case JNI_VERSION_1_4:
4281                 _vm_args->ignoreUnrecognized = JNI_FALSE;
4282                 _vm_args->options = NULL;
4283                 _vm_args->nOptions = 0;
4284                 break;
4285
4286     default:
4287                 return -1;
4288         }
4289
4290         return 0;
4291 }
4292
4293
4294 /* JNI_GetCreatedJavaVMs *******************************************************
4295
4296    Returns all Java VMs that have been created. Pointers to VMs are written in
4297    the buffer vmBuf in the order they are created. At most bufLen number of
4298    entries will be written. The total number of created VMs is returned in
4299    *nVMs.
4300
4301 *******************************************************************************/
4302
4303 jint JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs)
4304 {
4305         TRACEJNICALLS(("JNI_GetCreatedJavaVMs(vmBuf=%p, jsize=%d, jsize=%p)", vmBuf, bufLen, nVMs));
4306
4307         if (bufLen <= 0)
4308                 return JNI_ERR;
4309
4310         /* We currently only support 1 VM running. */
4311
4312         vmBuf[0] = (JavaVM *) _Jv_jvm;
4313         *nVMs    = 1;
4314
4315     return JNI_OK;
4316 }
4317
4318
4319 /* JNI_CreateJavaVM ************************************************************
4320
4321    Loads and initializes a Java VM. The current thread becomes the main thread.
4322    Sets the env argument to the JNI interface pointer of the main thread.
4323
4324 *******************************************************************************/
4325
4326 jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args)
4327 {
4328         TRACEJNICALLS(("JNI_CreateJavaVM(p_vm=%p, p_env=%p, vm_args=%p)", p_vm, p_env, vm_args));
4329
4330         /* actually create the JVM */
4331
4332         if (!vm_createjvm(p_vm, p_env, vm_args))
4333                 return JNI_ERR;
4334
4335         return JNI_OK;
4336 }
4337
4338
4339 /*
4340  * These are local overrides for various environment variables in Emacs.
4341  * Please do not remove this and leave it at the end of the file, where
4342  * Emacs will automagically detect them.
4343  * ---------------------------------------------------------------------
4344  * Local variables:
4345  * mode: c
4346  * indent-tabs-mode: t
4347  * c-basic-offset: 4
4348  * tab-width: 4
4349  * End:
4350  * vim:noexpandtab:sw=4:ts=4:
4351  */