src/native/jni.cpp

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