src/native/jni.cpp

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