src/native/jni.cpp

   1 /* src/native/jni.cpp - implementation of the Java Native Interface functions
   2
   3    Copyright (C) 1996-2011
   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,    s1)
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,    s1)
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,    s1)
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         NativeMethods& nm = VM::get_current()->get_nativemethods();
2983         nm.register_methods(c->name, methods, nMethods);
2984
2985         return 0;
2986 }
2987
2988
2989 /* UnregisterNatives ***********************************************************
2990
2991    Unregisters native methods of a class. The class goes back to the
2992    state before it was linked or registered with its native method
2993    functions.
2994
2995    This function should not be used in normal native code. Instead, it
2996    provides special programs a way to reload and relink native
2997    libraries.
2998
2999 *******************************************************************************/
3000
3001 jint _Jv_JNI_UnregisterNatives(JNIEnv *env, jclass clazz)
3002 {
3003         STATISTICS(jniinvokation());
3004
3005         /* XXX TWISTI hmm, maybe we should not support that (like kaffe) */
3006
3007     log_text("JNI-Call: UnregisterNatives: IMPLEMENT ME!!!");
3008
3009     return 0;
3010 }
3011
3012
3013 /* Monitor Operations *********************************************************/
3014
3015 /* MonitorEnter ****************************************************************
3016
3017    Enters the monitor associated with the underlying Java object
3018    referred to by obj.
3019
3020 *******************************************************************************/
3021
3022 jint _Jv_JNI_MonitorEnter(JNIEnv *env, jobject obj)
3023 {
3024         STATISTICS(jniinvokation());
3025
3026         if (obj == NULL) {
3027                 exceptions_throw_nullpointerexception();
3028                 return JNI_ERR;
3029         }
3030
3031         LOCK_MONITOR_ENTER(obj);
3032
3033         return JNI_OK;
3034 }
3035
3036
3037 /* MonitorExit *****************************************************************
3038
3039    The current thread must be the owner of the monitor associated with
3040    the underlying Java object referred to by obj. The thread
3041    decrements the counter indicating the number of times it has
3042    entered this monitor. If the value of the counter becomes zero, the
3043    current thread releases the monitor.
3044
3045 *******************************************************************************/
3046
3047 jint _Jv_JNI_MonitorExit(JNIEnv *env, jobject obj)
3048 {
3049         STATISTICS(jniinvokation());
3050
3051         if (obj == NULL) {
3052                 exceptions_throw_nullpointerexception();
3053                 return JNI_ERR;
3054         }
3055
3056         LOCK_MONITOR_EXIT(obj);
3057
3058         return JNI_OK;
3059 }
3060
3061
3062 /* JavaVM Interface ***********************************************************/
3063
3064 /* GetJavaVM *******************************************************************
3065
3066    Returns the Java VM interface (used in the Invocation API)
3067    associated with the current thread. The result is placed at the
3068    location pointed to by the second argument, vm.
3069
3070 *******************************************************************************/
3071
3072 jint _Jv_JNI_GetJavaVM(JNIEnv *env, JavaVM **javavm)
3073 {
3074         STATISTICS(jniinvokation());
3075
3076     *javavm = VM::get_current()->get_javavm();
3077
3078         return 0;
3079 }
3080
3081
3082 /* GetStringRegion *************************************************************
3083
3084    Copies len number of Unicode characters beginning at offset start
3085    to the given buffer buf.
3086
3087    Throws StringIndexOutOfBoundsException on index overflow.
3088
3089 *******************************************************************************/
3090
3091 void jni_GetStringRegion(JNIEnv* env, jstring str, jsize start, jsize len, jchar *buf)
3092 {
3093         java_lang_String s(str);
3094         CharArray        ca(s.get_value());
3095         int32_t          count = s.get_count();
3096
3097         if ((start < 0) || (len < 0) || (start > count) || (start + len > count)) {
3098                 exceptions_throw_stringindexoutofboundsexception();
3099                 return;
3100         }
3101
3102         ca.get_region(start, len, buf);
3103 }
3104
3105
3106 /* GetStringUTFRegion **********************************************************
3107
3108     Translates len number of Unicode characters beginning at offset
3109     start into UTF-8 format and place the result in the given buffer
3110     buf.
3111
3112     Throws StringIndexOutOfBoundsException on index overflow.
3113
3114 *******************************************************************************/
3115
3116 void jni_GetStringUTFRegion(JNIEnv* env, jstring str, jsize start, jsize len, char *buf)
3117 {
3118         TRACEJNICALLS(("jni_GetStringUTFRegion(env=%p, str=%p, start=%d, len=%d, buf=%p)", env, str, start, len, buf));
3119
3120         java_lang_String s(str);
3121
3122         CharArray ca(s.get_value());
3123
3124         int32_t count  = s.get_count();
3125         int32_t offset = s.get_offset();
3126
3127         if ((start < 0) || (len < 0) || (start > count) || (start + len > count)) {
3128                 exceptions_throw_stringindexoutofboundsexception();
3129                 return;
3130         }
3131
3132         int32_t i;
3133
3134         // XXX: Fix me!
3135         uint16_t* ptr = (uint16_t*) ca.get_raw_data_ptr();
3136         for (i = 0; i < len; i++)
3137                 buf[i] = ptr[offset + start + i];
3138
3139         buf[i] = '\0';
3140 }
3141
3142
3143 /* GetPrimitiveArrayCritical ***************************************************
3144
3145    Obtain a direct pointer to array elements.
3146
3147    ATTENTION: Critical section keeps open when this function returns!
3148    See ReleasePrimitiveArrayCritical.
3149
3150 *******************************************************************************/
3151
3152 void* jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)
3153 {
3154         java_handle_t*   h;
3155         java_array_t*    a;
3156         arraydescriptor* ad;
3157         void*            data;
3158
3159         TRACEJNICALLS(("jni_GetPrimitiveArrayCritical(env=%p, array=%p, isCopy=%d)", env, array, isCopy));
3160
3161         if (isCopy != NULL) {
3162                 *isCopy = JNI_FALSE;
3163         }
3164
3165         LLNI_CRITICAL_START;
3166
3167         h  = (java_handle_t*) array;
3168         a  = (java_array_t*) LLNI_UNWRAP(h);
3169         ad = a->objheader.vftbl->arraydesc;
3170
3171         /* Sanity check. */
3172
3173         assert(ad != NULL);
3174
3175         data = (void*) (((intptr_t) a) + ad->dataoffset);
3176
3177         return data;
3178 }
3179
3180
3181 /* ReleasePrimitiveArrayCritical ***********************************************
3182
3183    No specific documentation.
3184
3185    ATTENTION: This function closes the critical section opened in
3186    GetPrimitiveArrayCritical!
3187
3188 *******************************************************************************/
3189
3190 void jni_ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode)
3191 {
3192         TRACEJNICALLS(("jni_ReleasePrimitiveArrayCritical(env=%p, array=%p, carray=%p, mode=%d)", env, array, carray, mode));
3193
3194         LLNI_CRITICAL_END;
3195 }
3196
3197
3198 /* GetStringCritical ***********************************************************
3199
3200    The semantics of these two functions are similar to the existing
3201    Get/ReleaseStringChars functions.
3202
3203 *******************************************************************************/
3204
3205 const jchar *_Jv_JNI_GetStringCritical(JNIEnv *env, jstring string,
3206                                                                            jboolean *isCopy)
3207 {
3208         STATISTICS(jniinvokation());
3209
3210         return jni_GetStringChars(env, string, isCopy);
3211 }
3212
3213
3214 void _Jv_JNI_ReleaseStringCritical(JNIEnv *env, jstring string,
3215                                                                    const jchar *cstring)
3216 {
3217         STATISTICS(jniinvokation());
3218
3219         _Jv_JNI_ReleaseStringChars(env, string, cstring);
3220 }
3221
3222
3223 jweak _Jv_JNI_NewWeakGlobalRef(JNIEnv* env, jobject obj)
3224 {
3225         TRACEJNICALLS(("_Jv_JNI_NewWeakGlobalRef(env=%p, obj=%p): IMPLEMENT ME!", env, obj));
3226
3227         return (jweak) obj;
3228 }
3229
3230
3231 void _Jv_JNI_DeleteWeakGlobalRef(JNIEnv* env, jweak ref)
3232 {
3233         TRACEJNICALLS(("_Jv_JNI_DeleteWeakGlobalRef(env=%p, ref=%p): IMPLEMENT ME", env, ref));
3234 }
3235
3236
3237 /* NewGlobalRef ****************************************************************
3238
3239    Creates a new global reference to the object referred to by the obj
3240    argument.
3241
3242 *******************************************************************************/
3243
3244 jobject jni_NewGlobalRef(JNIEnv* env, jobject obj)
3245 {
3246         hashtable_global_ref_entry *gre;
3247         u4   key;                           /* hashkey                            */
3248         u4   slot;                          /* slot in hashtable                  */
3249         java_handle_t *o;
3250
3251         TRACEJNICALLS(("jni_NewGlobalRef(env=%p, obj=%p)", env, obj));
3252
3253         o = (java_handle_t *) obj;
3254
3255         hashtable_global_ref->mutex->lock();
3256
3257         LLNI_CRITICAL_START;
3258
3259         /* normally addresses are aligned to 4, 8 or 16 bytes */
3260
3261         key  = heap_hashcode(LLNI_DIRECT(o)) >> 4; /* align to 16-byte boundaries */
3262         slot = key & (hashtable_global_ref->size - 1);
3263         gre  = (hashtable_global_ref_entry*) hashtable_global_ref->ptr[slot];
3264
3265         /* search external hash chain for the entry */
3266
3267         while (gre) {
3268                 if (gre->o == LLNI_DIRECT(o)) {
3269                         /* global object found, increment the reference */
3270
3271                         gre->refs++;
3272
3273                         break;
3274                 }
3275
3276                 gre = gre->hashlink;                /* next element in external chain */
3277         }
3278
3279         LLNI_CRITICAL_END;
3280
3281         /* global ref not found, create a new one */
3282
3283         if (gre == NULL) {
3284                 gre = (hashtable_global_ref_entry*) heap_alloc_uncollectable(sizeof(hashtable_global_ref_entry));
3285
3286 #if defined(ENABLE_GC_CACAO)
3287                 /* register global ref with the GC */
3288
3289                 gc_reference_register(&(gre->o), GC_REFTYPE_JNI_GLOBALREF);
3290 #endif
3291
3292                 LLNI_CRITICAL_START;
3293
3294                 gre->o    = LLNI_DIRECT(o);
3295                 gre->refs = 1;
3296
3297                 LLNI_CRITICAL_END;
3298
3299                 /* insert entry into hashtable */
3300
3301                 gre->hashlink = (hashtable_global_ref_entry*) hashtable_global_ref->ptr[slot];
3302
3303                 hashtable_global_ref->ptr[slot] = gre;
3304
3305                 /* update number of hashtable-entries */
3306
3307                 hashtable_global_ref->entries++;
3308         }
3309
3310         hashtable_global_ref->mutex->unlock();
3311
3312 #if defined(ENABLE_HANDLES)
3313         return gre;
3314 #else
3315         return obj;
3316 #endif
3317 }
3318
3319
3320 /* DeleteGlobalRef *************************************************************
3321
3322    Deletes the global reference pointed to by globalRef.
3323
3324 *******************************************************************************/
3325
3326 void jni_DeleteGlobalRef(JNIEnv* env, jobject globalRef)
3327 {
3328         hashtable_global_ref_entry *gre;
3329         hashtable_global_ref_entry *prevgre;
3330         u4   key;                           /* hashkey                            */
3331         u4   slot;                          /* slot in hashtable                  */
3332         java_handle_t              *o;
3333
3334         TRACEJNICALLS(("jni_DeleteGlobalRef(env=%p, globalRef=%p)", env, globalRef));
3335
3336         o = (java_handle_t *) globalRef;
3337
3338         hashtable_global_ref->mutex->lock();
3339
3340         LLNI_CRITICAL_START;
3341
3342         /* normally addresses are aligned to 4, 8 or 16 bytes */
3343
3344         key  = heap_hashcode(LLNI_DIRECT(o)) >> 4; /* align to 16-byte boundaries */
3345         slot = key & (hashtable_global_ref->size - 1);
3346         gre  = (hashtable_global_ref_entry*) hashtable_global_ref->ptr[slot];
3347
3348         /* initialize prevgre */
3349
3350         prevgre = NULL;
3351
3352         /* search external hash chain for the entry */
3353
3354         while (gre) {
3355                 if (gre->o == LLNI_DIRECT(o)) {
3356                         /* global object found, decrement the reference count */
3357
3358                         gre->refs--;
3359
3360                         /* if reference count is 0, remove the entry */
3361
3362                         if (gre->refs == 0) {
3363                                 /* special handling if it's the first in the chain */
3364
3365                                 if (prevgre == NULL)
3366                                         hashtable_global_ref->ptr[slot] = gre->hashlink;
3367                                 else
3368                                         prevgre->hashlink = gre->hashlink;
3369
3370 #if defined(ENABLE_GC_CACAO)
3371                                 /* unregister global ref with the GC */
3372
3373                                 gc_reference_unregister(&(gre->o));
3374 #endif
3375
3376                                 heap_free(gre);
3377                         }
3378
3379                         LLNI_CRITICAL_END;
3380
3381                         hashtable_global_ref->mutex->unlock();
3382
3383                         return;
3384                 }
3385
3386                 prevgre = gre;                    /* save current pointer for removal */
3387                 gre     = gre->hashlink;            /* next element in external chain */
3388         }
3389
3390         log_println("jni_DeleteGlobalRef: Global reference not found.");
3391
3392         LLNI_CRITICAL_END;
3393
3394         hashtable_global_ref->mutex->unlock();
3395 }
3396
3397
3398 /* ExceptionCheck **************************************************************
3399
3400    Returns JNI_TRUE when there is a pending exception; otherwise,
3401    returns JNI_FALSE.
3402
3403 *******************************************************************************/
3404
3405 jboolean _Jv_JNI_ExceptionCheck(JNIEnv *env)
3406 {
3407         java_handle_t *o;
3408
3409         STATISTICS(jniinvokation());
3410
3411         o = exceptions_get_exception();
3412
3413         return (o != NULL) ? JNI_TRUE : JNI_FALSE;
3414 }
3415
3416
3417 /* New JNI 1.4 functions ******************************************************/
3418
3419 /* NewDirectByteBuffer *********************************************************
3420
3421    Allocates and returns a direct java.nio.ByteBuffer referring to the
3422    block of memory starting at the memory address address and
3423    extending capacity bytes.
3424
3425 *******************************************************************************/
3426
3427 jobject jni_NewDirectByteBuffer(JNIEnv *env, void *address, jlong capacity)
3428 {
3429 #if defined(ENABLE_JAVASE)
3430 # if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
3431         TRACEJNICALLSENTER(("jni_NewDirectByteBuffer(env=%p, address=%p, capacity=%ld)", env, address, capacity));
3432
3433         // Allocate a gnu.classpath.Pointer{32,64} object.
3434
3435 # if SIZEOF_VOID_P == 8
3436         java_handle_t* h = builtin_new(class_gnu_classpath_Pointer64);
3437 # else
3438         java_handle_t* h = builtin_new(class_gnu_classpath_Pointer32);
3439 # endif
3440
3441         if (h == NULL)
3442                 return NULL;
3443
3444         gnu_classpath_Pointer p(h, address);
3445
3446         // Create a java.nio.DirectByteBufferImpl$ReadWrite object.
3447
3448         java_handle_t* nbuf =
3449                 (java_handle_t*) jni_NewObject(env, (jclass) class_java_nio_DirectByteBufferImpl_ReadWrite,
3450                                                                            (jmethodID) dbbirw_init, NULL, p.get_handle(),
3451                                                                            (jint) capacity, (jint) capacity, (jint) 0);
3452
3453         // Add a local reference and return the value.
3454
3455         TRACEJNICALLSEXIT(("->%p", nbuf));
3456
3457         return jni_NewLocalRef(env, (jobject) nbuf);
3458
3459 # elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
3460
3461         jobject o;
3462         int64_t addr;
3463         int32_t cap;
3464
3465         TRACEJNICALLSENTER(("jni_NewDirectByteBuffer(env=%p, address=%p, capacity=%ld)", env, address, capacity));
3466
3467         /* Be paranoid about address sign-extension. */
3468
3469         addr = (int64_t) ((uintptr_t) address);
3470         cap  = (int32_t) capacity;
3471
3472         o = jni_NewObject(env, (jclass) class_java_nio_DirectByteBuffer,
3473                                           (jmethodID) dbb_init, addr, cap);
3474
3475         /* Add local reference and return the value. */
3476
3477         TRACEJNICALLSEXIT(("->%p", o));
3478
3479         return jni_NewLocalRef(env, o);
3480
3481 # else
3482 #  error unknown classpath configuration
3483 # endif
3484
3485 #else
3486         vm_abort("jni_NewDirectByteBuffer: Not implemented in this configuration.");
3487
3488         /* keep compiler happy */
3489
3490         return NULL;
3491 #endif
3492 }
3493
3494
3495 /* GetDirectBufferAddress ******************************************************
3496
3497    Fetches and returns the starting address of the memory region
3498    referenced by the given direct java.nio.Buffer.
3499
3500 *******************************************************************************/
3501
3502 void* jni_GetDirectBufferAddress(JNIEnv *env, jobject buf)
3503 {
3504 #if defined(ENABLE_JAVASE)
3505 # if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
3506
3507         TRACEJNICALLSENTER(("jni_GetDirectBufferAddress(env=%p, buf=%p)", env, buf));
3508
3509         /* Prevent compiler warning. */
3510
3511         java_handle_t* h = (java_handle_t *) buf;
3512
3513         if ((h != NULL) && !builtin_instanceof(h, class_java_nio_Buffer))
3514                 return NULL;
3515
3516         java_nio_DirectByteBufferImpl dbb(buf);
3517         java_handle_t* address = dbb.get_address();
3518
3519         if (address == NULL) {
3520                 TRACEJNICALLSEXIT(("->%p", NULL));
3521                 return NULL;
3522         }
3523
3524         gnu_classpath_Pointer p(address);
3525         void* data = p.get_data();
3526
3527         TRACEJNICALLSEXIT(("->%p", data));
3528
3529         return data;
3530
3531 # elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
3532
3533         TRACEJNICALLS(("jni_GetDirectBufferAddress(env=%p, buf=%p)", env, buf));
3534
3535         java_nio_Buffer jnb(buf);
3536
3537         if (jnb.is_non_null() && !builtin_instanceof(jnb.get_handle(), class_sun_nio_ch_DirectBuffer))
3538                 return NULL;
3539
3540         void* address = jnb.get_address();
3541
3542         return address;
3543
3544 # else
3545 #  error unknown classpath configuration
3546 # endif
3547
3548 #else
3549
3550         vm_abort("jni_GetDirectBufferAddress: Not implemented in this configuration.");
3551
3552         // Keep compiler happy.
3553         return NULL;
3554
3555 #endif
3556 }
3557
3558
3559 /* GetDirectBufferCapacity *****************************************************
3560
3561    Fetches and returns the capacity in bytes of the memory region
3562    referenced by the given direct java.nio.Buffer.
3563
3564 *******************************************************************************/
3565
3566 jlong jni_GetDirectBufferCapacity(JNIEnv* env, jobject buf)
3567 {
3568 #if defined(ENABLE_JAVASE)
3569 # if defined(WITH_JAVA_RUNTIME_LIBRARY_GNU_CLASSPATH)
3570         TRACEJNICALLS(("jni_GetDirectBufferCapacity(env=%p, buf=%p)", env, buf));
3571
3572         java_handle_t* h = (java_handle_t *) buf;
3573
3574         if (!builtin_instanceof(h, class_java_nio_DirectByteBufferImpl))
3575                 return -1;
3576
3577         java_nio_Buffer b(h);
3578         jlong capacity = b.get_cap();
3579
3580         return capacity;
3581 # elif defined(WITH_JAVA_RUNTIME_LIBRARY_OPENJDK)
3582
3583         TRACEJNICALLS(("jni_GetDirectBufferCapacity(env=%p, buf=%p)", env, buf));
3584
3585         java_nio_Buffer jnb(buf);
3586
3587         if (!builtin_instanceof(jnb.get_handle(), class_sun_nio_ch_DirectBuffer))
3588                 return -1;
3589
3590         jlong capacity = jnb.get_capacity();
3591
3592         return capacity;
3593
3594 # else
3595 #  error unknown classpath configuration
3596 # endif
3597
3598 #else
3599         vm_abort("jni_GetDirectBufferCapacity: not implemented in this configuration");
3600
3601         // Keep compiler happy.
3602
3603         return 0;
3604 #endif
3605 }
3606
3607
3608 /* GetObjectRefType ************************************************************
3609
3610    Returns the type of the object referred to by the obj argument. The
3611    argument obj can either be a local, global or weak global
3612    reference.
3613
3614 *******************************************************************************/
3615
3616 jobjectRefType jni_GetObjectRefType(JNIEnv *env, jobject obj)
3617 {
3618         log_println("jni_GetObjectRefType: IMPLEMENT ME!");
3619
3620         return (jobjectRefType) NULL;
3621 }
3622
3623
3624 /* DestroyJavaVM ***************************************************************
3625
3626    Unloads a Java VM and reclaims its resources. Only the main thread
3627    can unload the VM. The system waits until the main thread is only
3628    remaining user thread before it destroys the VM.
3629
3630 *******************************************************************************/
3631
3632 jint _Jv_JNI_DestroyJavaVM(JavaVM *javavm)
3633 {
3634         int status;
3635
3636         TRACEJNICALLS(("_Jv_JNI_DestroyJavaVM(javavm=%p)", javavm));
3637
3638         if (VM::get_current()->is_created() == false)
3639                 return JNI_ERR;
3640
3641     status = vm_destroy(javavm);
3642
3643         return status;
3644 }
3645
3646
3647 /* AttachCurrentThread *********************************************************
3648
3649    Attaches the current thread to a Java VM. Returns a JNI interface
3650    pointer in the JNIEnv argument.
3651
3652    Trying to attach a thread that is already attached is a no-op.
3653
3654    A native thread cannot be attached simultaneously to two Java VMs.
3655
3656    When a thread is attached to the VM, the context class loader is
3657    the bootstrap loader.
3658
3659 *******************************************************************************/
3660
3661 static int jni_attach_current_thread(void **p_env, void *thr_args, bool isdaemon)
3662 {
3663 #if defined(ENABLE_THREADS)
3664         JavaVMAttachArgs *vm_aargs;
3665         bool              result;
3666
3667     /* If the current thread has already been attached, this operation
3668            is a no-op. */
3669
3670         result = thread_current_is_attached();
3671
3672         if (result == true) {
3673                 *p_env = VM::get_current()->get_jnienv();
3674                 return JNI_OK;
3675         }
3676
3677         vm_aargs = (JavaVMAttachArgs *) thr_args;
3678
3679         if (vm_aargs != NULL) {
3680                 if ((vm_aargs->version != JNI_VERSION_1_2) &&
3681                         (vm_aargs->version != JNI_VERSION_1_4))
3682                         return JNI_EVERSION;
3683         }
3684
3685         if (!thread_attach_current_external_thread(vm_aargs, false))
3686                 return JNI_ERR;
3687
3688         if (!localref_table_init())
3689                 return JNI_ERR;
3690 #endif
3691
3692         *p_env = VM::get_current()->get_jnienv();
3693
3694         return JNI_OK;
3695 }
3696
3697
3698 jint jni_AttachCurrentThread(JavaVM *javavm, void **p_env, void *thr_args)
3699 {
3700         int result;
3701
3702         TRACEJNICALLS(("jni_AttachCurrentThread(javavm=%p, p_env=%p, thr_args=%p)", javavm, p_env, thr_args));
3703
3704         if (VM::get_current()->is_created() == false)
3705                 return JNI_ERR;
3706
3707         result = jni_attach_current_thread(p_env, thr_args, false);
3708
3709         return result;
3710 }
3711
3712
3713 /* DetachCurrentThread *********************************************************
3714
3715    Detaches the current thread from a Java VM. All Java monitors held
3716    by this thread are released. All Java threads waiting for this
3717    thread to die are notified.
3718
3719    In JDK 1.1, the main thread cannot be detached from the VM. It must
3720    call DestroyJavaVM to unload the entire VM.
3721
3722    In the JDK, the main thread can be detached from the VM.
3723
3724    The main thread, which is the thread that created the Java VM,
3725    cannot be detached from the VM. Instead, the main thread must call
3726    JNI_DestroyJavaVM() to unload the entire VM.
3727
3728 *******************************************************************************/
3729
3730 jint jni_DetachCurrentThread(JavaVM *vm)
3731 {
3732 #if defined(ENABLE_THREADS)
3733         bool result;
3734
3735         TRACEJNICALLS(("jni_DetachCurrentThread(vm=%p)", vm));
3736
3737     /* If the current thread has already been detached, this operation
3738            is a no-op. */
3739
3740         result = thread_current_is_attached();
3741
3742         if (result == false)
3743                 return true;
3744
3745         /* We need to pop all frames before we can destroy the table. */
3746
3747         localref_frame_pop_all();
3748
3749         if (!localref_table_destroy())
3750                 return JNI_ERR;
3751
3752         if (!thread_detach_current_external_thread())
3753                 return JNI_ERR;
3754 #endif
3755
3756         return JNI_OK;
3757 }
3758
3759
3760 /* GetEnv **********************************************************************
3761
3762    If the current thread is not attached to the VM, sets *env to NULL,
3763    and returns JNI_EDETACHED. If the specified version is not
3764    supported, sets *env to NULL, and returns JNI_EVERSION. Otherwise,
3765    sets *env to the appropriate interface, and returns JNI_OK.
3766
3767 *******************************************************************************/
3768
3769 jint jni_GetEnv(JavaVM *javavm, void **env, jint version)
3770 {
3771         TRACEJNICALLS(("jni_GetEnv(javavm=%p, env=%p, version=%d)", javavm, env, version));
3772
3773         if (VM::get_current()->is_created() == false) {
3774                 *env = NULL;
3775                 return JNI_EDETACHED;
3776         }
3777
3778 #if defined(ENABLE_THREADS)
3779         if (thread_get_current() == NULL) {
3780                 *env = NULL;
3781
3782                 return JNI_EDETACHED;
3783         }
3784 #endif
3785
3786         /* Check the JNI version. */
3787
3788         if (jni_version_check(version) == true) {
3789                 *env = VM::get_current()->get_jnienv();
3790                 return JNI_OK;
3791         }
3792
3793 #if defined(ENABLE_JVMTI)
3794         if ((version & JVMTI_VERSION_MASK_INTERFACE_TYPE)
3795                 == JVMTI_VERSION_INTERFACE_JVMTI) {
3796
3797                 *env = (void *) jvmti_new_environment();
3798
3799                 if (env != NULL)
3800                         return JNI_OK;
3801         }
3802 #endif
3803
3804         *env = NULL;
3805
3806         return JNI_EVERSION;
3807 }
3808
3809
3810 /* AttachCurrentThreadAsDaemon *************************************************
3811
3812    Same semantics as AttachCurrentThread, but the newly-created
3813    java.lang.Thread instance is a daemon.
3814
3815    If the thread has already been attached via either
3816    AttachCurrentThread or AttachCurrentThreadAsDaemon, this routine
3817    simply sets the value pointed to by penv to the JNIEnv of the
3818    current thread. In this case neither AttachCurrentThread nor this
3819    routine have any effect on the daemon status of the thread.
3820
3821 *******************************************************************************/
3822
3823 jint jni_AttachCurrentThreadAsDaemon(JavaVM *javavm, void **penv, void *args)
3824 {
3825         int result;
3826
3827         TRACEJNICALLS(("jni_AttachCurrentThreadAsDaemon(javavm=%p, penv=%p, args=%p)", javavm, penv, args));
3828
3829         if (VM::get_current()->is_created() == false)
3830                 return JNI_ERR;
3831
3832         result = jni_attach_current_thread(penv, args, true);
3833
3834         return result;
3835 }
3836
3837
3838 /* JNI invocation table *******************************************************/
3839
3840 const struct JNIInvokeInterface_ _Jv_JNIInvokeInterface = {
3841         NULL,
3842         NULL,
3843         NULL,
3844
3845         _Jv_JNI_DestroyJavaVM,
3846         jni_AttachCurrentThread,
3847         jni_DetachCurrentThread,
3848         jni_GetEnv,
3849         jni_AttachCurrentThreadAsDaemon
3850 };
3851
3852
3853 /* JNI function table *********************************************************/
3854
3855 struct JNINativeInterface_ _Jv_JNINativeInterface = {
3856         NULL,
3857         NULL,
3858         NULL,
3859         NULL,
3860         _Jv_JNI_GetVersion,
3861
3862         jni_DefineClass,
3863         jni_FindClass,
3864         jni_FromReflectedMethod,
3865         jni_FromReflectedField,
3866         jni_ToReflectedMethod,
3867         jni_GetSuperclass,
3868         _Jv_JNI_IsAssignableFrom,
3869         _Jv_JNI_ToReflectedField,
3870
3871         _Jv_JNI_Throw,
3872         _Jv_JNI_ThrowNew,
3873         _Jv_JNI_ExceptionOccurred,
3874         jni_ExceptionDescribe,
3875         jni_ExceptionClear,
3876         _Jv_JNI_FatalError,
3877         jni_PushLocalFrame,
3878         jni_PopLocalFrame,
3879
3880         jni_NewGlobalRef,
3881         jni_DeleteGlobalRef,
3882         jni_DeleteLocalRef,
3883         _Jv_JNI_IsSameObject,
3884         jni_NewLocalRef,
3885         jni_EnsureLocalCapacity,
3886
3887         _Jv_JNI_AllocObject,
3888         jni_NewObject,
3889         _Jv_JNI_NewObjectV,
3890         _Jv_JNI_NewObjectA,
3891
3892         jni_GetObjectClass,
3893         _Jv_JNI_IsInstanceOf,
3894
3895         _Jv_JNI_GetMethodID,
3896
3897         _Jv_JNI_CallObjectMethod,
3898         _Jv_JNI_CallObjectMethodV,
3899         _Jv_JNI_CallObjectMethodA,
3900         _Jv_JNI_CallBooleanMethod,
3901         _Jv_JNI_CallBooleanMethodV,
3902         _Jv_JNI_CallBooleanMethodA,
3903         _Jv_JNI_CallByteMethod,
3904         _Jv_JNI_CallByteMethodV,
3905         _Jv_JNI_CallByteMethodA,
3906         _Jv_JNI_CallCharMethod,
3907         _Jv_JNI_CallCharMethodV,
3908         _Jv_JNI_CallCharMethodA,
3909         _Jv_JNI_CallShortMethod,
3910         _Jv_JNI_CallShortMethodV,
3911         _Jv_JNI_CallShortMethodA,
3912         _Jv_JNI_CallIntMethod,
3913         _Jv_JNI_CallIntMethodV,
3914         _Jv_JNI_CallIntMethodA,
3915         _Jv_JNI_CallLongMethod,
3916         _Jv_JNI_CallLongMethodV,
3917         _Jv_JNI_CallLongMethodA,
3918         _Jv_JNI_CallFloatMethod,
3919         _Jv_JNI_CallFloatMethodV,
3920         _Jv_JNI_CallFloatMethodA,
3921         _Jv_JNI_CallDoubleMethod,
3922         _Jv_JNI_CallDoubleMethodV,
3923         _Jv_JNI_CallDoubleMethodA,
3924         _Jv_JNI_CallVoidMethod,
3925         _Jv_JNI_CallVoidMethodV,
3926         _Jv_JNI_CallVoidMethodA,
3927
3928         _Jv_JNI_CallNonvirtualObjectMethod,
3929         _Jv_JNI_CallNonvirtualObjectMethodV,
3930         _Jv_JNI_CallNonvirtualObjectMethodA,
3931         _Jv_JNI_CallNonvirtualBooleanMethod,
3932         _Jv_JNI_CallNonvirtualBooleanMethodV,
3933         _Jv_JNI_CallNonvirtualBooleanMethodA,
3934         _Jv_JNI_CallNonvirtualByteMethod,
3935         _Jv_JNI_CallNonvirtualByteMethodV,
3936         _Jv_JNI_CallNonvirtualByteMethodA,
3937         _Jv_JNI_CallNonvirtualCharMethod,
3938         _Jv_JNI_CallNonvirtualCharMethodV,
3939         _Jv_JNI_CallNonvirtualCharMethodA,
3940         _Jv_JNI_CallNonvirtualShortMethod,
3941         _Jv_JNI_CallNonvirtualShortMethodV,
3942         _Jv_JNI_CallNonvirtualShortMethodA,
3943         _Jv_JNI_CallNonvirtualIntMethod,
3944         _Jv_JNI_CallNonvirtualIntMethodV,
3945         _Jv_JNI_CallNonvirtualIntMethodA,
3946         _Jv_JNI_CallNonvirtualLongMethod,
3947         _Jv_JNI_CallNonvirtualLongMethodV,
3948         _Jv_JNI_CallNonvirtualLongMethodA,
3949         _Jv_JNI_CallNonvirtualFloatMethod,
3950         _Jv_JNI_CallNonvirtualFloatMethodV,
3951         _Jv_JNI_CallNonvirtualFloatMethodA,
3952         _Jv_JNI_CallNonvirtualDoubleMethod,
3953         _Jv_JNI_CallNonvirtualDoubleMethodV,
3954         _Jv_JNI_CallNonvirtualDoubleMethodA,
3955         _Jv_JNI_CallNonvirtualVoidMethod,
3956         _Jv_JNI_CallNonvirtualVoidMethodV,
3957         _Jv_JNI_CallNonvirtualVoidMethodA,
3958
3959         _Jv_JNI_GetFieldID,
3960
3961         _Jv_JNI_GetObjectField,
3962         _Jv_JNI_GetBooleanField,
3963         _Jv_JNI_GetByteField,
3964         _Jv_JNI_GetCharField,
3965         _Jv_JNI_GetShortField,
3966         _Jv_JNI_GetIntField,
3967         _Jv_JNI_GetLongField,
3968         _Jv_JNI_GetFloatField,
3969         _Jv_JNI_GetDoubleField,
3970         _Jv_JNI_SetObjectField,
3971         _Jv_JNI_SetBooleanField,
3972         _Jv_JNI_SetByteField,
3973         _Jv_JNI_SetCharField,
3974         _Jv_JNI_SetShortField,
3975         _Jv_JNI_SetIntField,
3976         _Jv_JNI_SetLongField,
3977         _Jv_JNI_SetFloatField,
3978         _Jv_JNI_SetDoubleField,
3979
3980         _Jv_JNI_GetStaticMethodID,
3981
3982         _Jv_JNI_CallStaticObjectMethod,
3983         _Jv_JNI_CallStaticObjectMethodV,
3984         _Jv_JNI_CallStaticObjectMethodA,
3985         _Jv_JNI_CallStaticBooleanMethod,
3986         _Jv_JNI_CallStaticBooleanMethodV,
3987         _Jv_JNI_CallStaticBooleanMethodA,
3988         _Jv_JNI_CallStaticByteMethod,
3989         _Jv_JNI_CallStaticByteMethodV,
3990         _Jv_JNI_CallStaticByteMethodA,
3991         _Jv_JNI_CallStaticCharMethod,
3992         _Jv_JNI_CallStaticCharMethodV,
3993         _Jv_JNI_CallStaticCharMethodA,
3994         _Jv_JNI_CallStaticShortMethod,
3995         _Jv_JNI_CallStaticShortMethodV,
3996         _Jv_JNI_CallStaticShortMethodA,
3997         _Jv_JNI_CallStaticIntMethod,
3998         _Jv_JNI_CallStaticIntMethodV,
3999         _Jv_JNI_CallStaticIntMethodA,
4000         _Jv_JNI_CallStaticLongMethod,
4001         _Jv_JNI_CallStaticLongMethodV,
4002         _Jv_JNI_CallStaticLongMethodA,
4003         _Jv_JNI_CallStaticFloatMethod,
4004         _Jv_JNI_CallStaticFloatMethodV,
4005         _Jv_JNI_CallStaticFloatMethodA,
4006         _Jv_JNI_CallStaticDoubleMethod,
4007         _Jv_JNI_CallStaticDoubleMethodV,
4008         _Jv_JNI_CallStaticDoubleMethodA,
4009         _Jv_JNI_CallStaticVoidMethod,
4010         _Jv_JNI_CallStaticVoidMethodV,
4011         _Jv_JNI_CallStaticVoidMethodA,
4012
4013         _Jv_JNI_GetStaticFieldID,
4014
4015         _Jv_JNI_GetStaticObjectField,
4016         _Jv_JNI_GetStaticBooleanField,
4017         _Jv_JNI_GetStaticByteField,
4018         _Jv_JNI_GetStaticCharField,
4019         _Jv_JNI_GetStaticShortField,
4020         _Jv_JNI_GetStaticIntField,
4021         _Jv_JNI_GetStaticLongField,
4022         _Jv_JNI_GetStaticFloatField,
4023         _Jv_JNI_GetStaticDoubleField,
4024         _Jv_JNI_SetStaticObjectField,
4025         _Jv_JNI_SetStaticBooleanField,
4026         _Jv_JNI_SetStaticByteField,
4027         _Jv_JNI_SetStaticCharField,
4028         _Jv_JNI_SetStaticShortField,
4029         _Jv_JNI_SetStaticIntField,
4030         _Jv_JNI_SetStaticLongField,
4031         _Jv_JNI_SetStaticFloatField,
4032         _Jv_JNI_SetStaticDoubleField,
4033
4034         jni_NewString,
4035         jni_GetStringLength,
4036         jni_GetStringChars,
4037         _Jv_JNI_ReleaseStringChars,
4038
4039         jni_NewStringUTF,
4040         jni_GetStringUTFLength,
4041         _Jv_JNI_GetStringUTFChars,
4042         _Jv_JNI_ReleaseStringUTFChars,
4043
4044         _Jv_JNI_GetArrayLength,
4045
4046         _Jv_JNI_NewObjectArray,
4047         _Jv_JNI_GetObjectArrayElement,
4048         _Jv_JNI_SetObjectArrayElement,
4049
4050         _Jv_JNI_NewBooleanArray,
4051         _Jv_JNI_NewByteArray,
4052         _Jv_JNI_NewCharArray,
4053         _Jv_JNI_NewShortArray,
4054         _Jv_JNI_NewIntArray,
4055         _Jv_JNI_NewLongArray,
4056         _Jv_JNI_NewFloatArray,
4057         _Jv_JNI_NewDoubleArray,
4058
4059         _Jv_JNI_GetBooleanArrayElements,
4060         _Jv_JNI_GetByteArrayElements,
4061         _Jv_JNI_GetCharArrayElements,
4062         _Jv_JNI_GetShortArrayElements,
4063         _Jv_JNI_GetIntArrayElements,
4064         _Jv_JNI_GetLongArrayElements,
4065         _Jv_JNI_GetFloatArrayElements,
4066         _Jv_JNI_GetDoubleArrayElements,
4067
4068         _Jv_JNI_ReleaseBooleanArrayElements,
4069         _Jv_JNI_ReleaseByteArrayElements,
4070         _Jv_JNI_ReleaseCharArrayElements,
4071         _Jv_JNI_ReleaseShortArrayElements,
4072         _Jv_JNI_ReleaseIntArrayElements,
4073         _Jv_JNI_ReleaseLongArrayElements,
4074         _Jv_JNI_ReleaseFloatArrayElements,
4075         _Jv_JNI_ReleaseDoubleArrayElements,
4076
4077         _Jv_JNI_GetBooleanArrayRegion,
4078         _Jv_JNI_GetByteArrayRegion,
4079         _Jv_JNI_GetCharArrayRegion,
4080         _Jv_JNI_GetShortArrayRegion,
4081         _Jv_JNI_GetIntArrayRegion,
4082         _Jv_JNI_GetLongArrayRegion,
4083         _Jv_JNI_GetFloatArrayRegion,
4084         _Jv_JNI_GetDoubleArrayRegion,
4085         _Jv_JNI_SetBooleanArrayRegion,
4086         _Jv_JNI_SetByteArrayRegion,
4087         _Jv_JNI_SetCharArrayRegion,
4088         _Jv_JNI_SetShortArrayRegion,
4089         _Jv_JNI_SetIntArrayRegion,
4090         _Jv_JNI_SetLongArrayRegion,
4091         _Jv_JNI_SetFloatArrayRegion,
4092         _Jv_JNI_SetDoubleArrayRegion,
4093
4094         jni_RegisterNatives,
4095         _Jv_JNI_UnregisterNatives,
4096
4097         _Jv_JNI_MonitorEnter,
4098         _Jv_JNI_MonitorExit,
4099
4100         _Jv_JNI_GetJavaVM,
4101
4102         /* New JNI 1.2 functions. */
4103
4104         jni_GetStringRegion,
4105         jni_GetStringUTFRegion,
4106
4107         jni_GetPrimitiveArrayCritical,
4108         jni_ReleasePrimitiveArrayCritical,
4109
4110         _Jv_JNI_GetStringCritical,
4111         _Jv_JNI_ReleaseStringCritical,
4112
4113         _Jv_JNI_NewWeakGlobalRef,
4114         _Jv_JNI_DeleteWeakGlobalRef,
4115
4116         _Jv_JNI_ExceptionCheck,
4117
4118         /* New JNI 1.4 functions. */
4119
4120         jni_NewDirectByteBuffer,
4121         jni_GetDirectBufferAddress,
4122         jni_GetDirectBufferCapacity,
4123
4124         /* New JNI 1.6 functions. */
4125
4126         jni_GetObjectRefType
4127 };
4128
4129
4130 /* Invocation API Functions ***************************************************/
4131
4132 /* JNI_GetDefaultJavaVMInitArgs ************************************************
4133
4134    Returns a default configuration for the Java VM.
4135
4136 *******************************************************************************/
4137
4138 jint JNI_GetDefaultJavaVMInitArgs(void *vm_args)
4139 {
4140         JavaVMInitArgs *_vm_args;
4141
4142         _vm_args = (JavaVMInitArgs *) vm_args;
4143
4144         /* GNU classpath currently supports JNI 1.2 */
4145
4146         switch (_vm_args->version) {
4147         case JNI_VERSION_1_1:
4148                 _vm_args->version = JNI_VERSION_1_1;
4149                 break;
4150
4151         case JNI_VERSION_1_2:
4152         case JNI_VERSION_1_4:
4153                 _vm_args->ignoreUnrecognized = JNI_FALSE;
4154                 _vm_args->options = NULL;
4155                 _vm_args->nOptions = 0;
4156                 break;
4157
4158         case JNI_VERSION_CACAO:
4159                 // We reveal ourselves by accepting this version number,
4160                 // this actually means we are using the supported JNI version.
4161                 _vm_args->version = JNI_VERSION_SUPPORTED;
4162                 break;
4163
4164         default:
4165                 return JNI_ERR;
4166         }
4167
4168         return JNI_OK;
4169 }
4170
4171
4172 /* JNI_GetCreatedJavaVMs *******************************************************
4173
4174    Returns all Java VMs that have been created. Pointers to VMs are written in
4175    the buffer vmBuf in the order they are created. At most bufLen number of
4176    entries will be written. The total number of created VMs is returned in
4177    *nVMs.
4178
4179 *******************************************************************************/
4180
4181 jint JNI_GetCreatedJavaVMs(JavaVM **vmBuf, jsize bufLen, jsize *nVMs)
4182 {
4183         TRACEJNICALLS(("JNI_GetCreatedJavaVMs(vmBuf=%p, jsize=%d, jsize=%p)", vmBuf, bufLen, nVMs));
4184
4185         if (bufLen <= 0)
4186                 return JNI_ERR;
4187
4188         // We currently only support 1 VM running.
4189
4190         vmBuf[0] = VM::get_current()->get_javavm();
4191         *nVMs    = 1;
4192
4193     return JNI_OK;
4194 }
4195
4196
4197 /* JNI_CreateJavaVM ************************************************************
4198
4199    Loads and initializes a Java VM. The current thread becomes the main thread.
4200    Sets the env argument to the JNI interface pointer of the main thread.
4201
4202 *******************************************************************************/
4203
4204 jint JNI_CreateJavaVM(JavaVM **p_vm, void **p_env, void *vm_args)
4205 {
4206         TRACEJNICALLS(("JNI_CreateJavaVM(p_vm=%p, p_env=%p, vm_args=%p)", p_vm, p_env, vm_args));
4207
4208         /* actually create the JVM */
4209
4210         if (!VM_create(p_vm, p_env, vm_args))
4211                 return JNI_ERR;
4212
4213         return JNI_OK;
4214 }
4215
4216 } // extern "C"
4217
4218
4219 /*
4220  * These are local overrides for various environment variables in Emacs.
4221  * Please do not remove this and leave it at the end of the file, where
4222  * Emacs will automagically detect them.
4223  * ---------------------------------------------------------------------
4224  * Local variables:
4225  * mode: c++
4226  * indent-tabs-mode: t
4227  * c-basic-offset: 4
4228  * tab-width: 4
4229  * End:
4230  * vim:noexpandtab:sw=4:ts=4:
4231  */