src/native/jni.cpp

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