1 /* 2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 /* 27 * We used part of Netscape's Java Runtime Interface (JRI) as the starting 28 * point of our design and implementation. 29 */ 30 31 /****************************************************************************** 32 * Java Runtime Interface 33 * Copyright (c) 1996 Netscape Communications Corporation. All rights reserved. 34 *****************************************************************************/ 35 36 #ifndef _JAVASOFT_JNI_H_ 37 #define _JAVASOFT_JNI_H_ 38 39 #include <stdio.h> 40 #include <stdarg.h> 41 42 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint 43 and jlong */ 44 45 #include "jni_md.h" 46 47 #ifdef __cplusplus 48 extern "C" { 49 #endif 50 51 /* 52 * JNI Types 53 */ 54 55 #ifndef JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H 56 57 typedef unsigned char jboolean; 58 typedef unsigned short jchar; 59 typedef short jshort; 60 typedef float jfloat; 61 typedef double jdouble; 62 63 typedef jint jsize; 64 65 #ifdef __cplusplus 66 67 class _jobject {}; 68 class _jclass : public _jobject {}; 69 class _jthrowable : public _jobject {}; 70 class _jstring : public _jobject {}; 71 class _jarray : public _jobject {}; 72 class _jbooleanArray : public _jarray {}; 73 class _jbyteArray : public _jarray {}; 74 class _jcharArray : public _jarray {}; 75 class _jshortArray : public _jarray {}; 76 class _jintArray : public _jarray {}; 77 class _jlongArray : public _jarray {}; 78 class _jfloatArray : public _jarray {}; 79 class _jdoubleArray : public _jarray {}; 80 class _jobjectArray : public _jarray {}; 81 82 typedef _jobject *jobject; 83 typedef _jclass *jclass; 84 typedef _jthrowable *jthrowable; 85 typedef _jstring *jstring; 86 typedef _jarray *jarray; 87 typedef _jbooleanArray *jbooleanArray; 88 typedef _jbyteArray *jbyteArray; 89 typedef _jcharArray *jcharArray; 90 typedef _jshortArray *jshortArray; 91 typedef _jintArray *jintArray; 92 typedef _jlongArray *jlongArray; 93 typedef _jfloatArray *jfloatArray; 94 typedef _jdoubleArray *jdoubleArray; 95 typedef _jobjectArray *jobjectArray; 96 97 #else 98 99 struct _jobject; 100 101 typedef struct _jobject *jobject; 102 typedef jobject jclass; 103 typedef jobject jthrowable; 104 typedef jobject jstring; 105 typedef jobject jarray; 106 typedef jarray jbooleanArray; 107 typedef jarray jbyteArray; 108 typedef jarray jcharArray; 109 typedef jarray jshortArray; 110 typedef jarray jintArray; 111 typedef jarray jlongArray; 112 typedef jarray jfloatArray; 113 typedef jarray jdoubleArray; 114 typedef jarray jobjectArray; 115 116 #endif 117 118 typedef jobject jweak; 119 120 typedef union jvalue { 121 jboolean z; 122 jbyte b; 123 jchar c; 124 jshort s; 125 jint i; 126 jlong j; 127 jfloat f; 128 jdouble d; 129 jobject l; 130 } jvalue; 131 132 struct _jfieldID; 133 typedef struct _jfieldID *jfieldID; 134 135 struct _jmethodID; 136 typedef struct _jmethodID *jmethodID; 137 138 /* Return values from jobjectRefType */ 139 typedef enum _jobjectType { 140 JNIInvalidRefType = 0, 141 JNILocalRefType = 1, 142 JNIGlobalRefType = 2, 143 JNIWeakGlobalRefType = 3 144 } jobjectRefType; 145 146 147 #endif /* JNI_TYPES_ALREADY_DEFINED_IN_JNI_MD_H */ 148 149 /* 150 * jboolean constants 151 */ 152 153 #define JNI_FALSE 0 154 #define JNI_TRUE 1 155 156 /* 157 * possible return values for JNI functions. 158 */ 159 160 #define JNI_OK 0 /* success */ 161 #define JNI_ERR (-1) /* unknown error */ 162 #define JNI_EDETACHED (-2) /* thread detached from the VM */ 163 #define JNI_EVERSION (-3) /* JNI version error */ 164 #define JNI_ENOMEM (-4) /* not enough memory */ 165 #define JNI_EEXIST (-5) /* VM already created */ 166 #define JNI_EINVAL (-6) /* invalid arguments */ 167 168 /* 169 * used in ReleaseScalarArrayElements 170 */ 171 172 #define JNI_COMMIT 1 173 #define JNI_ABORT 2 174 175 /* 176 * used in RegisterNatives to describe native method name, signature, 177 * and function pointer. 178 */ 179 180 typedef struct { 181 char *name; 182 char *signature; 183 void *fnPtr; 184 } JNINativeMethod; 185 186 /* 187 * JNI Native Method Interface. 188 */ 189 190 struct JNINativeInterface_; 191 192 struct JNIEnv_; 193 194 #ifdef __cplusplus 195 typedef JNIEnv_ JNIEnv; 196 #else 197 typedef const struct JNINativeInterface_ *JNIEnv; 198 #endif 199 200 /* 201 * JNI Invocation Interface. 202 */ 203 204 struct JNIInvokeInterface_; 205 206 struct JavaVM_; 207 208 #ifdef __cplusplus 209 typedef JavaVM_ JavaVM; 210 #else 211 typedef const struct JNIInvokeInterface_ *JavaVM; 212 #endif 213 214 struct JNINativeInterface_ { 215 void *reserved0; 216 void *reserved1; 217 void *reserved2; 218 219 void *reserved3; 220 jint (JNICALL *GetVersion)(JNIEnv *env); 221 222 jclass (JNICALL *DefineClass) 223 (JNIEnv *env, const char *name, jobject loader, const jbyte *buf, 224 jsize len); 225 jclass (JNICALL *FindClass) 226 (JNIEnv *env, const char *name); 227 228 jmethodID (JNICALL *FromReflectedMethod) 229 (JNIEnv *env, jobject method); 230 jfieldID (JNICALL *FromReflectedField) 231 (JNIEnv *env, jobject field); 232 233 jobject (JNICALL *ToReflectedMethod) 234 (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic); 235 236 jclass (JNICALL *GetSuperclass) 237 (JNIEnv *env, jclass sub); 238 jboolean (JNICALL *IsAssignableFrom) 239 (JNIEnv *env, jclass sub, jclass sup); 240 241 jobject (JNICALL *ToReflectedField) 242 (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic); 243 244 jint (JNICALL *Throw) 245 (JNIEnv *env, jthrowable obj); 246 jint (JNICALL *ThrowNew) 247 (JNIEnv *env, jclass clazz, const char *msg); 248 jthrowable (JNICALL *ExceptionOccurred) 249 (JNIEnv *env); 250 void (JNICALL *ExceptionDescribe) 251 (JNIEnv *env); 252 void (JNICALL *ExceptionClear) 253 (JNIEnv *env); 254 void (JNICALL *FatalError) 255 (JNIEnv *env, const char *msg); 256 257 jint (JNICALL *PushLocalFrame) 258 (JNIEnv *env, jint capacity); 259 jobject (JNICALL *PopLocalFrame) 260 (JNIEnv *env, jobject result); 261 262 jobject (JNICALL *NewGlobalRef) 263 (JNIEnv *env, jobject lobj); 264 void (JNICALL *DeleteGlobalRef) 265 (JNIEnv *env, jobject gref); 266 void (JNICALL *DeleteLocalRef) 267 (JNIEnv *env, jobject obj); 268 jboolean (JNICALL *IsSameObject) 269 (JNIEnv *env, jobject obj1, jobject obj2); 270 jobject (JNICALL *NewLocalRef) 271 (JNIEnv *env, jobject ref); 272 jint (JNICALL *EnsureLocalCapacity) 273 (JNIEnv *env, jint capacity); 274 275 jobject (JNICALL *AllocObject) 276 (JNIEnv *env, jclass clazz); 277 jobject (JNICALL *NewObject) 278 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 279 jobject (JNICALL *NewObjectV) 280 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 281 jobject (JNICALL *NewObjectA) 282 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 283 284 jclass (JNICALL *GetObjectClass) 285 (JNIEnv *env, jobject obj); 286 jboolean (JNICALL *IsInstanceOf) 287 (JNIEnv *env, jobject obj, jclass clazz); 288 289 jmethodID (JNICALL *GetMethodID) 290 (JNIEnv *env, jclass clazz, const char *name, const char *sig); 291 292 jobject (JNICALL *CallObjectMethod) 293 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 294 jobject (JNICALL *CallObjectMethodV) 295 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 296 jobject (JNICALL *CallObjectMethodA) 297 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); 298 299 jboolean (JNICALL *CallBooleanMethod) 300 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 301 jboolean (JNICALL *CallBooleanMethodV) 302 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 303 jboolean (JNICALL *CallBooleanMethodA) 304 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); 305 306 jbyte (JNICALL *CallByteMethod) 307 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 308 jbyte (JNICALL *CallByteMethodV) 309 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 310 jbyte (JNICALL *CallByteMethodA) 311 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); 312 313 jchar (JNICALL *CallCharMethod) 314 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 315 jchar (JNICALL *CallCharMethodV) 316 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 317 jchar (JNICALL *CallCharMethodA) 318 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); 319 320 jshort (JNICALL *CallShortMethod) 321 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 322 jshort (JNICALL *CallShortMethodV) 323 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 324 jshort (JNICALL *CallShortMethodA) 325 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); 326 327 jint (JNICALL *CallIntMethod) 328 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 329 jint (JNICALL *CallIntMethodV) 330 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 331 jint (JNICALL *CallIntMethodA) 332 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); 333 334 jlong (JNICALL *CallLongMethod) 335 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 336 jlong (JNICALL *CallLongMethodV) 337 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 338 jlong (JNICALL *CallLongMethodA) 339 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); 340 341 jfloat (JNICALL *CallFloatMethod) 342 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 343 jfloat (JNICALL *CallFloatMethodV) 344 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 345 jfloat (JNICALL *CallFloatMethodA) 346 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); 347 348 jdouble (JNICALL *CallDoubleMethod) 349 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 350 jdouble (JNICALL *CallDoubleMethodV) 351 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 352 jdouble (JNICALL *CallDoubleMethodA) 353 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue *args); 354 355 void (JNICALL *CallVoidMethod) 356 (JNIEnv *env, jobject obj, jmethodID methodID, ...); 357 void (JNICALL *CallVoidMethodV) 358 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args); 359 void (JNICALL *CallVoidMethodA) 360 (JNIEnv *env, jobject obj, jmethodID methodID, const jvalue * args); 361 362 jobject (JNICALL *CallNonvirtualObjectMethod) 363 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 364 jobject (JNICALL *CallNonvirtualObjectMethodV) 365 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 366 va_list args); 367 jobject (JNICALL *CallNonvirtualObjectMethodA) 368 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 369 const jvalue * args); 370 371 jboolean (JNICALL *CallNonvirtualBooleanMethod) 372 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 373 jboolean (JNICALL *CallNonvirtualBooleanMethodV) 374 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 375 va_list args); 376 jboolean (JNICALL *CallNonvirtualBooleanMethodA) 377 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 378 const jvalue * args); 379 380 jbyte (JNICALL *CallNonvirtualByteMethod) 381 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 382 jbyte (JNICALL *CallNonvirtualByteMethodV) 383 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 384 va_list args); 385 jbyte (JNICALL *CallNonvirtualByteMethodA) 386 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 387 const jvalue *args); 388 389 jchar (JNICALL *CallNonvirtualCharMethod) 390 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 391 jchar (JNICALL *CallNonvirtualCharMethodV) 392 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 393 va_list args); 394 jchar (JNICALL *CallNonvirtualCharMethodA) 395 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 396 const jvalue *args); 397 398 jshort (JNICALL *CallNonvirtualShortMethod) 399 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 400 jshort (JNICALL *CallNonvirtualShortMethodV) 401 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 402 va_list args); 403 jshort (JNICALL *CallNonvirtualShortMethodA) 404 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 405 const jvalue *args); 406 407 jint (JNICALL *CallNonvirtualIntMethod) 408 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 409 jint (JNICALL *CallNonvirtualIntMethodV) 410 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 411 va_list args); 412 jint (JNICALL *CallNonvirtualIntMethodA) 413 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 414 const jvalue *args); 415 416 jlong (JNICALL *CallNonvirtualLongMethod) 417 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 418 jlong (JNICALL *CallNonvirtualLongMethodV) 419 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 420 va_list args); 421 jlong (JNICALL *CallNonvirtualLongMethodA) 422 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 423 const jvalue *args); 424 425 jfloat (JNICALL *CallNonvirtualFloatMethod) 426 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 427 jfloat (JNICALL *CallNonvirtualFloatMethodV) 428 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 429 va_list args); 430 jfloat (JNICALL *CallNonvirtualFloatMethodA) 431 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 432 const jvalue *args); 433 434 jdouble (JNICALL *CallNonvirtualDoubleMethod) 435 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 436 jdouble (JNICALL *CallNonvirtualDoubleMethodV) 437 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 438 va_list args); 439 jdouble (JNICALL *CallNonvirtualDoubleMethodA) 440 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 441 const jvalue *args); 442 443 void (JNICALL *CallNonvirtualVoidMethod) 444 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...); 445 void (JNICALL *CallNonvirtualVoidMethodV) 446 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 447 va_list args); 448 void (JNICALL *CallNonvirtualVoidMethodA) 449 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, 450 const jvalue * args); 451 452 jfieldID (JNICALL *GetFieldID) 453 (JNIEnv *env, jclass clazz, const char *name, const char *sig); 454 455 jobject (JNICALL *GetObjectField) 456 (JNIEnv *env, jobject obj, jfieldID fieldID); 457 jboolean (JNICALL *GetBooleanField) 458 (JNIEnv *env, jobject obj, jfieldID fieldID); 459 jbyte (JNICALL *GetByteField) 460 (JNIEnv *env, jobject obj, jfieldID fieldID); 461 jchar (JNICALL *GetCharField) 462 (JNIEnv *env, jobject obj, jfieldID fieldID); 463 jshort (JNICALL *GetShortField) 464 (JNIEnv *env, jobject obj, jfieldID fieldID); 465 jint (JNICALL *GetIntField) 466 (JNIEnv *env, jobject obj, jfieldID fieldID); 467 jlong (JNICALL *GetLongField) 468 (JNIEnv *env, jobject obj, jfieldID fieldID); 469 jfloat (JNICALL *GetFloatField) 470 (JNIEnv *env, jobject obj, jfieldID fieldID); 471 jdouble (JNICALL *GetDoubleField) 472 (JNIEnv *env, jobject obj, jfieldID fieldID); 473 474 void (JNICALL *SetObjectField) 475 (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val); 476 void (JNICALL *SetBooleanField) 477 (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val); 478 void (JNICALL *SetByteField) 479 (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val); 480 void (JNICALL *SetCharField) 481 (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val); 482 void (JNICALL *SetShortField) 483 (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val); 484 void (JNICALL *SetIntField) 485 (JNIEnv *env, jobject obj, jfieldID fieldID, jint val); 486 void (JNICALL *SetLongField) 487 (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val); 488 void (JNICALL *SetFloatField) 489 (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val); 490 void (JNICALL *SetDoubleField) 491 (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val); 492 493 jmethodID (JNICALL *GetStaticMethodID) 494 (JNIEnv *env, jclass clazz, const char *name, const char *sig); 495 496 jobject (JNICALL *CallStaticObjectMethod) 497 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 498 jobject (JNICALL *CallStaticObjectMethodV) 499 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 500 jobject (JNICALL *CallStaticObjectMethodA) 501 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 502 503 jboolean (JNICALL *CallStaticBooleanMethod) 504 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 505 jboolean (JNICALL *CallStaticBooleanMethodV) 506 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 507 jboolean (JNICALL *CallStaticBooleanMethodA) 508 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 509 510 jbyte (JNICALL *CallStaticByteMethod) 511 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 512 jbyte (JNICALL *CallStaticByteMethodV) 513 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 514 jbyte (JNICALL *CallStaticByteMethodA) 515 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 516 517 jchar (JNICALL *CallStaticCharMethod) 518 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 519 jchar (JNICALL *CallStaticCharMethodV) 520 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 521 jchar (JNICALL *CallStaticCharMethodA) 522 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 523 524 jshort (JNICALL *CallStaticShortMethod) 525 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 526 jshort (JNICALL *CallStaticShortMethodV) 527 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 528 jshort (JNICALL *CallStaticShortMethodA) 529 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 530 531 jint (JNICALL *CallStaticIntMethod) 532 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 533 jint (JNICALL *CallStaticIntMethodV) 534 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 535 jint (JNICALL *CallStaticIntMethodA) 536 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 537 538 jlong (JNICALL *CallStaticLongMethod) 539 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 540 jlong (JNICALL *CallStaticLongMethodV) 541 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 542 jlong (JNICALL *CallStaticLongMethodA) 543 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 544 545 jfloat (JNICALL *CallStaticFloatMethod) 546 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 547 jfloat (JNICALL *CallStaticFloatMethodV) 548 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 549 jfloat (JNICALL *CallStaticFloatMethodA) 550 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 551 552 jdouble (JNICALL *CallStaticDoubleMethod) 553 (JNIEnv *env, jclass clazz, jmethodID methodID, ...); 554 jdouble (JNICALL *CallStaticDoubleMethodV) 555 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args); 556 jdouble (JNICALL *CallStaticDoubleMethodA) 557 (JNIEnv *env, jclass clazz, jmethodID methodID, const jvalue *args); 558 559 void (JNICALL *CallStaticVoidMethod) 560 (JNIEnv *env, jclass cls, jmethodID methodID, ...); 561 void (JNICALL *CallStaticVoidMethodV) 562 (JNIEnv *env, jclass cls, jmethodID methodID, va_list args); 563 void (JNICALL *CallStaticVoidMethodA) 564 (JNIEnv *env, jclass cls, jmethodID methodID, const jvalue * args); 565 566 jfieldID (JNICALL *GetStaticFieldID) 567 (JNIEnv *env, jclass clazz, const char *name, const char *sig); 568 jobject (JNICALL *GetStaticObjectField) 569 (JNIEnv *env, jclass clazz, jfieldID fieldID); 570 jboolean (JNICALL *GetStaticBooleanField) 571 (JNIEnv *env, jclass clazz, jfieldID fieldID); 572 jbyte (JNICALL *GetStaticByteField) 573 (JNIEnv *env, jclass clazz, jfieldID fieldID); 574 jchar (JNICALL *GetStaticCharField) 575 (JNIEnv *env, jclass clazz, jfieldID fieldID); 576 jshort (JNICALL *GetStaticShortField) 577 (JNIEnv *env, jclass clazz, jfieldID fieldID); 578 jint (JNICALL *GetStaticIntField) 579 (JNIEnv *env, jclass clazz, jfieldID fieldID); 580 jlong (JNICALL *GetStaticLongField) 581 (JNIEnv *env, jclass clazz, jfieldID fieldID); 582 jfloat (JNICALL *GetStaticFloatField) 583 (JNIEnv *env, jclass clazz, jfieldID fieldID); 584 jdouble (JNICALL *GetStaticDoubleField) 585 (JNIEnv *env, jclass clazz, jfieldID fieldID); 586 587 void (JNICALL *SetStaticObjectField) 588 (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value); 589 void (JNICALL *SetStaticBooleanField) 590 (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value); 591 void (JNICALL *SetStaticByteField) 592 (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value); 593 void (JNICALL *SetStaticCharField) 594 (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value); 595 void (JNICALL *SetStaticShortField) 596 (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value); 597 void (JNICALL *SetStaticIntField) 598 (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value); 599 void (JNICALL *SetStaticLongField) 600 (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value); 601 void (JNICALL *SetStaticFloatField) 602 (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value); 603 void (JNICALL *SetStaticDoubleField) 604 (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value); 605 606 jstring (JNICALL *NewString) 607 (JNIEnv *env, const jchar *unicode, jsize len); 608 jsize (JNICALL *GetStringLength) 609 (JNIEnv *env, jstring str); 610 const jchar *(JNICALL *GetStringChars) 611 (JNIEnv *env, jstring str, jboolean *isCopy); 612 void (JNICALL *ReleaseStringChars) 613 (JNIEnv *env, jstring str, const jchar *chars); 614 615 jstring (JNICALL *NewStringUTF) 616 (JNIEnv *env, const char *utf); 617 jsize (JNICALL *GetStringUTFLength) 618 (JNIEnv *env, jstring str); 619 const char* (JNICALL *GetStringUTFChars) 620 (JNIEnv *env, jstring str, jboolean *isCopy); 621 void (JNICALL *ReleaseStringUTFChars) 622 (JNIEnv *env, jstring str, const char* chars); 623 624 625 jsize (JNICALL *GetArrayLength) 626 (JNIEnv *env, jarray array); 627 628 jobjectArray (JNICALL *NewObjectArray) 629 (JNIEnv *env, jsize len, jclass clazz, jobject init); 630 jobject (JNICALL *GetObjectArrayElement) 631 (JNIEnv *env, jobjectArray array, jsize index); 632 void (JNICALL *SetObjectArrayElement) 633 (JNIEnv *env, jobjectArray array, jsize index, jobject val); 634 635 jbooleanArray (JNICALL *NewBooleanArray) 636 (JNIEnv *env, jsize len); 637 jbyteArray (JNICALL *NewByteArray) 638 (JNIEnv *env, jsize len); 639 jcharArray (JNICALL *NewCharArray) 640 (JNIEnv *env, jsize len); 641 jshortArray (JNICALL *NewShortArray) 642 (JNIEnv *env, jsize len); 643 jintArray (JNICALL *NewIntArray) 644 (JNIEnv *env, jsize len); 645 jlongArray (JNICALL *NewLongArray) 646 (JNIEnv *env, jsize len); 647 jfloatArray (JNICALL *NewFloatArray) 648 (JNIEnv *env, jsize len); 649 jdoubleArray (JNICALL *NewDoubleArray) 650 (JNIEnv *env, jsize len); 651 652 jboolean * (JNICALL *GetBooleanArrayElements) 653 (JNIEnv *env, jbooleanArray array, jboolean *isCopy); 654 jbyte * (JNICALL *GetByteArrayElements) 655 (JNIEnv *env, jbyteArray array, jboolean *isCopy); 656 jchar * (JNICALL *GetCharArrayElements) 657 (JNIEnv *env, jcharArray array, jboolean *isCopy); 658 jshort * (JNICALL *GetShortArrayElements) 659 (JNIEnv *env, jshortArray array, jboolean *isCopy); 660 jint * (JNICALL *GetIntArrayElements) 661 (JNIEnv *env, jintArray array, jboolean *isCopy); 662 jlong * (JNICALL *GetLongArrayElements) 663 (JNIEnv *env, jlongArray array, jboolean *isCopy); 664 jfloat * (JNICALL *GetFloatArrayElements) 665 (JNIEnv *env, jfloatArray array, jboolean *isCopy); 666 jdouble * (JNICALL *GetDoubleArrayElements) 667 (JNIEnv *env, jdoubleArray array, jboolean *isCopy); 668 669 void (JNICALL *ReleaseBooleanArrayElements) 670 (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode); 671 void (JNICALL *ReleaseByteArrayElements) 672 (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode); 673 void (JNICALL *ReleaseCharArrayElements) 674 (JNIEnv *env, jcharArray array, jchar *elems, jint mode); 675 void (JNICALL *ReleaseShortArrayElements) 676 (JNIEnv *env, jshortArray array, jshort *elems, jint mode); 677 void (JNICALL *ReleaseIntArrayElements) 678 (JNIEnv *env, jintArray array, jint *elems, jint mode); 679 void (JNICALL *ReleaseLongArrayElements) 680 (JNIEnv *env, jlongArray array, jlong *elems, jint mode); 681 void (JNICALL *ReleaseFloatArrayElements) 682 (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode); 683 void (JNICALL *ReleaseDoubleArrayElements) 684 (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode); 685 686 void (JNICALL *GetBooleanArrayRegion) 687 (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf); 688 void (JNICALL *GetByteArrayRegion) 689 (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf); 690 void (JNICALL *GetCharArrayRegion) 691 (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf); 692 void (JNICALL *GetShortArrayRegion) 693 (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf); 694 void (JNICALL *GetIntArrayRegion) 695 (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf); 696 void (JNICALL *GetLongArrayRegion) 697 (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf); 698 void (JNICALL *GetFloatArrayRegion) 699 (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf); 700 void (JNICALL *GetDoubleArrayRegion) 701 (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf); 702 703 void (JNICALL *SetBooleanArrayRegion) 704 (JNIEnv *env, jbooleanArray array, jsize start, jsize l, const jboolean *buf); 705 void (JNICALL *SetByteArrayRegion) 706 (JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf); 707 void (JNICALL *SetCharArrayRegion) 708 (JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf); 709 void (JNICALL *SetShortArrayRegion) 710 (JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf); 711 void (JNICALL *SetIntArrayRegion) 712 (JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf); 713 void (JNICALL *SetLongArrayRegion) 714 (JNIEnv *env, jlongArray array, jsize start, jsize len, const jlong *buf); 715 void (JNICALL *SetFloatArrayRegion) 716 (JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf); 717 void (JNICALL *SetDoubleArrayRegion) 718 (JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf); 719 720 jint (JNICALL *RegisterNatives) 721 (JNIEnv *env, jclass clazz, const JNINativeMethod *methods, 722 jint nMethods); 723 jint (JNICALL *UnregisterNatives) 724 (JNIEnv *env, jclass clazz); 725 726 jint (JNICALL *MonitorEnter) 727 (JNIEnv *env, jobject obj); 728 jint (JNICALL *MonitorExit) 729 (JNIEnv *env, jobject obj); 730 731 jint (JNICALL *GetJavaVM) 732 (JNIEnv *env, JavaVM **vm); 733 734 void (JNICALL *GetStringRegion) 735 (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf); 736 void (JNICALL *GetStringUTFRegion) 737 (JNIEnv *env, jstring str, jsize start, jsize len, char *buf); 738 739 void * (JNICALL *GetPrimitiveArrayCritical) 740 (JNIEnv *env, jarray array, jboolean *isCopy); 741 void (JNICALL *ReleasePrimitiveArrayCritical) 742 (JNIEnv *env, jarray array, void *carray, jint mode); 743 744 const jchar * (JNICALL *GetStringCritical) 745 (JNIEnv *env, jstring string, jboolean *isCopy); 746 void (JNICALL *ReleaseStringCritical) 747 (JNIEnv *env, jstring string, const jchar *cstring); 748 749 jweak (JNICALL *NewWeakGlobalRef) 750 (JNIEnv *env, jobject obj); 751 void (JNICALL *DeleteWeakGlobalRef) 752 (JNIEnv *env, jweak ref); 753 754 jboolean (JNICALL *ExceptionCheck) 755 (JNIEnv *env); 756 757 jobject (JNICALL *NewDirectByteBuffer) 758 (JNIEnv* env, void* address, jlong capacity); 759 void* (JNICALL *GetDirectBufferAddress) 760 (JNIEnv* env, jobject buf); 761 jlong (JNICALL *GetDirectBufferCapacity) 762 (JNIEnv* env, jobject buf); 763 764 /* New JNI 1.6 Features */ 765 766 jobjectRefType (JNICALL *GetObjectRefType) 767 (JNIEnv* env, jobject obj); 768 769 /* Module Features */ 770 771 jobject (JNICALL *GetModule) 772 (JNIEnv* env, jclass clazz); 773 jsize (JNICALL *GetAllModules) 774 (JNIEnv* env, jobjectArray *modules); 775 }; 776 777 /* 778 * We use inlined functions for C++ so that programmers can write: 779 * 780 * env->FindClass("java/lang/String") 781 * 782 * in C++ rather than: 783 * 784 * (*env)->FindClass(env, "java/lang/String") 785 * 786 * in C. 787 */ 788 789 struct JNIEnv_ { 790 const struct JNINativeInterface_ *functions; 791 #ifdef __cplusplus 792 793 jint GetVersion() { 794 return functions->GetVersion(this); 795 } 796 jclass DefineClass(const char *name, jobject loader, const jbyte *buf, 797 jsize len) { 798 return functions->DefineClass(this, name, loader, buf, len); 799 } 800 jclass FindClass(const char *name) { 801 return functions->FindClass(this, name); 802 } 803 jmethodID FromReflectedMethod(jobject method) { 804 return functions->FromReflectedMethod(this,method); 805 } 806 jfieldID FromReflectedField(jobject field) { 807 return functions->FromReflectedField(this,field); 808 } 809 810 jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) { 811 return functions->ToReflectedMethod(this, cls, methodID, isStatic); 812 } 813 814 jclass GetSuperclass(jclass sub) { 815 return functions->GetSuperclass(this, sub); 816 } 817 jboolean IsAssignableFrom(jclass sub, jclass sup) { 818 return functions->IsAssignableFrom(this, sub, sup); 819 } 820 821 jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) { 822 return functions->ToReflectedField(this,cls,fieldID,isStatic); 823 } 824 825 jint Throw(jthrowable obj) { 826 return functions->Throw(this, obj); 827 } 828 jint ThrowNew(jclass clazz, const char *msg) { 829 return functions->ThrowNew(this, clazz, msg); 830 } 831 jthrowable ExceptionOccurred() { 832 return functions->ExceptionOccurred(this); 833 } 834 void ExceptionDescribe() { 835 functions->ExceptionDescribe(this); 836 } 837 void ExceptionClear() { 838 functions->ExceptionClear(this); 839 } 840 void FatalError(const char *msg) { 841 functions->FatalError(this, msg); 842 } 843 844 jint PushLocalFrame(jint capacity) { 845 return functions->PushLocalFrame(this,capacity); 846 } 847 jobject PopLocalFrame(jobject result) { 848 return functions->PopLocalFrame(this,result); 849 } 850 851 jobject NewGlobalRef(jobject lobj) { 852 return functions->NewGlobalRef(this,lobj); 853 } 854 void DeleteGlobalRef(jobject gref) { 855 functions->DeleteGlobalRef(this,gref); 856 } 857 void DeleteLocalRef(jobject obj) { 858 functions->DeleteLocalRef(this, obj); 859 } 860 861 jboolean IsSameObject(jobject obj1, jobject obj2) { 862 return functions->IsSameObject(this,obj1,obj2); 863 } 864 865 jobject NewLocalRef(jobject ref) { 866 return functions->NewLocalRef(this,ref); 867 } 868 jint EnsureLocalCapacity(jint capacity) { 869 return functions->EnsureLocalCapacity(this,capacity); 870 } 871 872 jobject AllocObject(jclass clazz) { 873 return functions->AllocObject(this,clazz); 874 } 875 jobject NewObject(jclass clazz, jmethodID methodID, ...) { 876 va_list args; 877 jobject result; 878 va_start(args, methodID); 879 result = functions->NewObjectV(this,clazz,methodID,args); 880 va_end(args); 881 return result; 882 } 883 jobject NewObjectV(jclass clazz, jmethodID methodID, 884 va_list args) { 885 return functions->NewObjectV(this,clazz,methodID,args); 886 } 887 jobject NewObjectA(jclass clazz, jmethodID methodID, 888 const jvalue *args) { 889 return functions->NewObjectA(this,clazz,methodID,args); 890 } 891 892 jclass GetObjectClass(jobject obj) { 893 return functions->GetObjectClass(this,obj); 894 } 895 jboolean IsInstanceOf(jobject obj, jclass clazz) { 896 return functions->IsInstanceOf(this,obj,clazz); 897 } 898 899 jmethodID GetMethodID(jclass clazz, const char *name, 900 const char *sig) { 901 return functions->GetMethodID(this,clazz,name,sig); 902 } 903 904 jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { 905 va_list args; 906 jobject result; 907 va_start(args,methodID); 908 result = functions->CallObjectMethodV(this,obj,methodID,args); 909 va_end(args); 910 return result; 911 } 912 jobject CallObjectMethodV(jobject obj, jmethodID methodID, 913 va_list args) { 914 return functions->CallObjectMethodV(this,obj,methodID,args); 915 } 916 jobject CallObjectMethodA(jobject obj, jmethodID methodID, 917 const jvalue * args) { 918 return functions->CallObjectMethodA(this,obj,methodID,args); 919 } 920 921 jboolean CallBooleanMethod(jobject obj, 922 jmethodID methodID, ...) { 923 va_list args; 924 jboolean result; 925 va_start(args,methodID); 926 result = functions->CallBooleanMethodV(this,obj,methodID,args); 927 va_end(args); 928 return result; 929 } 930 jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, 931 va_list args) { 932 return functions->CallBooleanMethodV(this,obj,methodID,args); 933 } 934 jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, 935 const jvalue * args) { 936 return functions->CallBooleanMethodA(this,obj,methodID, args); 937 } 938 939 jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { 940 va_list args; 941 jbyte result; 942 va_start(args,methodID); 943 result = functions->CallByteMethodV(this,obj,methodID,args); 944 va_end(args); 945 return result; 946 } 947 jbyte CallByteMethodV(jobject obj, jmethodID methodID, 948 va_list args) { 949 return functions->CallByteMethodV(this,obj,methodID,args); 950 } 951 jbyte CallByteMethodA(jobject obj, jmethodID methodID, 952 const jvalue * args) { 953 return functions->CallByteMethodA(this,obj,methodID,args); 954 } 955 956 jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { 957 va_list args; 958 jchar result; 959 va_start(args,methodID); 960 result = functions->CallCharMethodV(this,obj,methodID,args); 961 va_end(args); 962 return result; 963 } 964 jchar CallCharMethodV(jobject obj, jmethodID methodID, 965 va_list args) { 966 return functions->CallCharMethodV(this,obj,methodID,args); 967 } 968 jchar CallCharMethodA(jobject obj, jmethodID methodID, 969 const jvalue * args) { 970 return functions->CallCharMethodA(this,obj,methodID,args); 971 } 972 973 jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { 974 va_list args; 975 jshort result; 976 va_start(args,methodID); 977 result = functions->CallShortMethodV(this,obj,methodID,args); 978 va_end(args); 979 return result; 980 } 981 jshort CallShortMethodV(jobject obj, jmethodID methodID, 982 va_list args) { 983 return functions->CallShortMethodV(this,obj,methodID,args); 984 } 985 jshort CallShortMethodA(jobject obj, jmethodID methodID, 986 const jvalue * args) { 987 return functions->CallShortMethodA(this,obj,methodID,args); 988 } 989 990 jint CallIntMethod(jobject obj, jmethodID methodID, ...) { 991 va_list args; 992 jint result; 993 va_start(args,methodID); 994 result = functions->CallIntMethodV(this,obj,methodID,args); 995 va_end(args); 996 return result; 997 } 998 jint CallIntMethodV(jobject obj, jmethodID methodID, 999 va_list args) { 1000 return functions->CallIntMethodV(this,obj,methodID,args); 1001 } 1002 jint CallIntMethodA(jobject obj, jmethodID methodID, 1003 const jvalue * args) { 1004 return functions->CallIntMethodA(this,obj,methodID,args); 1005 } 1006 1007 jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { 1008 va_list args; 1009 jlong result; 1010 va_start(args,methodID); 1011 result = functions->CallLongMethodV(this,obj,methodID,args); 1012 va_end(args); 1013 return result; 1014 } 1015 jlong CallLongMethodV(jobject obj, jmethodID methodID, 1016 va_list args) { 1017 return functions->CallLongMethodV(this,obj,methodID,args); 1018 } 1019 jlong CallLongMethodA(jobject obj, jmethodID methodID, 1020 const jvalue * args) { 1021 return functions->CallLongMethodA(this,obj,methodID,args); 1022 } 1023 1024 jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { 1025 va_list args; 1026 jfloat result; 1027 va_start(args,methodID); 1028 result = functions->CallFloatMethodV(this,obj,methodID,args); 1029 va_end(args); 1030 return result; 1031 } 1032 jfloat CallFloatMethodV(jobject obj, jmethodID methodID, 1033 va_list args) { 1034 return functions->CallFloatMethodV(this,obj,methodID,args); 1035 } 1036 jfloat CallFloatMethodA(jobject obj, jmethodID methodID, 1037 const jvalue * args) { 1038 return functions->CallFloatMethodA(this,obj,methodID,args); 1039 } 1040 1041 jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { 1042 va_list args; 1043 jdouble result; 1044 va_start(args,methodID); 1045 result = functions->CallDoubleMethodV(this,obj,methodID,args); 1046 va_end(args); 1047 return result; 1048 } 1049 jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, 1050 va_list args) { 1051 return functions->CallDoubleMethodV(this,obj,methodID,args); 1052 } 1053 jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, 1054 const jvalue * args) { 1055 return functions->CallDoubleMethodA(this,obj,methodID,args); 1056 } 1057 1058 void CallVoidMethod(jobject obj, jmethodID methodID, ...) { 1059 va_list args; 1060 va_start(args,methodID); 1061 functions->CallVoidMethodV(this,obj,methodID,args); 1062 va_end(args); 1063 } 1064 void CallVoidMethodV(jobject obj, jmethodID methodID, 1065 va_list args) { 1066 functions->CallVoidMethodV(this,obj,methodID,args); 1067 } 1068 void CallVoidMethodA(jobject obj, jmethodID methodID, 1069 const jvalue * args) { 1070 functions->CallVoidMethodA(this,obj,methodID,args); 1071 } 1072 1073 jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, 1074 jmethodID methodID, ...) { 1075 va_list args; 1076 jobject result; 1077 va_start(args,methodID); 1078 result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, 1079 methodID,args); 1080 va_end(args); 1081 return result; 1082 } 1083 jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, 1084 jmethodID methodID, va_list args) { 1085 return functions->CallNonvirtualObjectMethodV(this,obj,clazz, 1086 methodID,args); 1087 } 1088 jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, 1089 jmethodID methodID, const jvalue * args) { 1090 return functions->CallNonvirtualObjectMethodA(this,obj,clazz, 1091 methodID,args); 1092 } 1093 1094 jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, 1095 jmethodID methodID, ...) { 1096 va_list args; 1097 jboolean result; 1098 va_start(args,methodID); 1099 result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, 1100 methodID,args); 1101 va_end(args); 1102 return result; 1103 } 1104 jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, 1105 jmethodID methodID, va_list args) { 1106 return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, 1107 methodID,args); 1108 } 1109 jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, 1110 jmethodID methodID, const jvalue * args) { 1111 return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, 1112 methodID, args); 1113 } 1114 1115 jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, 1116 jmethodID methodID, ...) { 1117 va_list args; 1118 jbyte result; 1119 va_start(args,methodID); 1120 result = functions->CallNonvirtualByteMethodV(this,obj,clazz, 1121 methodID,args); 1122 va_end(args); 1123 return result; 1124 } 1125 jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, 1126 jmethodID methodID, va_list args) { 1127 return functions->CallNonvirtualByteMethodV(this,obj,clazz, 1128 methodID,args); 1129 } 1130 jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, 1131 jmethodID methodID, const jvalue * args) { 1132 return functions->CallNonvirtualByteMethodA(this,obj,clazz, 1133 methodID,args); 1134 } 1135 1136 jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, 1137 jmethodID methodID, ...) { 1138 va_list args; 1139 jchar result; 1140 va_start(args,methodID); 1141 result = functions->CallNonvirtualCharMethodV(this,obj,clazz, 1142 methodID,args); 1143 va_end(args); 1144 return result; 1145 } 1146 jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, 1147 jmethodID methodID, va_list args) { 1148 return functions->CallNonvirtualCharMethodV(this,obj,clazz, 1149 methodID,args); 1150 } 1151 jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, 1152 jmethodID methodID, const jvalue * args) { 1153 return functions->CallNonvirtualCharMethodA(this,obj,clazz, 1154 methodID,args); 1155 } 1156 1157 jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, 1158 jmethodID methodID, ...) { 1159 va_list args; 1160 jshort result; 1161 va_start(args,methodID); 1162 result = functions->CallNonvirtualShortMethodV(this,obj,clazz, 1163 methodID,args); 1164 va_end(args); 1165 return result; 1166 } 1167 jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, 1168 jmethodID methodID, va_list args) { 1169 return functions->CallNonvirtualShortMethodV(this,obj,clazz, 1170 methodID,args); 1171 } 1172 jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, 1173 jmethodID methodID, const jvalue * args) { 1174 return functions->CallNonvirtualShortMethodA(this,obj,clazz, 1175 methodID,args); 1176 } 1177 1178 jint CallNonvirtualIntMethod(jobject obj, jclass clazz, 1179 jmethodID methodID, ...) { 1180 va_list args; 1181 jint result; 1182 va_start(args,methodID); 1183 result = functions->CallNonvirtualIntMethodV(this,obj,clazz, 1184 methodID,args); 1185 va_end(args); 1186 return result; 1187 } 1188 jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, 1189 jmethodID methodID, va_list args) { 1190 return functions->CallNonvirtualIntMethodV(this,obj,clazz, 1191 methodID,args); 1192 } 1193 jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, 1194 jmethodID methodID, const jvalue * args) { 1195 return functions->CallNonvirtualIntMethodA(this,obj,clazz, 1196 methodID,args); 1197 } 1198 1199 jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, 1200 jmethodID methodID, ...) { 1201 va_list args; 1202 jlong result; 1203 va_start(args,methodID); 1204 result = functions->CallNonvirtualLongMethodV(this,obj,clazz, 1205 methodID,args); 1206 va_end(args); 1207 return result; 1208 } 1209 jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, 1210 jmethodID methodID, va_list args) { 1211 return functions->CallNonvirtualLongMethodV(this,obj,clazz, 1212 methodID,args); 1213 } 1214 jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, 1215 jmethodID methodID, const jvalue * args) { 1216 return functions->CallNonvirtualLongMethodA(this,obj,clazz, 1217 methodID,args); 1218 } 1219 1220 jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, 1221 jmethodID methodID, ...) { 1222 va_list args; 1223 jfloat result; 1224 va_start(args,methodID); 1225 result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, 1226 methodID,args); 1227 va_end(args); 1228 return result; 1229 } 1230 jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, 1231 jmethodID methodID, 1232 va_list args) { 1233 return functions->CallNonvirtualFloatMethodV(this,obj,clazz, 1234 methodID,args); 1235 } 1236 jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, 1237 jmethodID methodID, 1238 const jvalue * args) { 1239 return functions->CallNonvirtualFloatMethodA(this,obj,clazz, 1240 methodID,args); 1241 } 1242 1243 jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, 1244 jmethodID methodID, ...) { 1245 va_list args; 1246 jdouble result; 1247 va_start(args,methodID); 1248 result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, 1249 methodID,args); 1250 va_end(args); 1251 return result; 1252 } 1253 jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, 1254 jmethodID methodID, 1255 va_list args) { 1256 return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, 1257 methodID,args); 1258 } 1259 jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, 1260 jmethodID methodID, 1261 const jvalue * args) { 1262 return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, 1263 methodID,args); 1264 } 1265 1266 void CallNonvirtualVoidMethod(jobject obj, jclass clazz, 1267 jmethodID methodID, ...) { 1268 va_list args; 1269 va_start(args,methodID); 1270 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); 1271 va_end(args); 1272 } 1273 void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, 1274 jmethodID methodID, 1275 va_list args) { 1276 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); 1277 } 1278 void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, 1279 jmethodID methodID, 1280 const jvalue * args) { 1281 functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args); 1282 } 1283 1284 jfieldID GetFieldID(jclass clazz, const char *name, 1285 const char *sig) { 1286 return functions->GetFieldID(this,clazz,name,sig); 1287 } 1288 1289 jobject GetObjectField(jobject obj, jfieldID fieldID) { 1290 return functions->GetObjectField(this,obj,fieldID); 1291 } 1292 jboolean GetBooleanField(jobject obj, jfieldID fieldID) { 1293 return functions->GetBooleanField(this,obj,fieldID); 1294 } 1295 jbyte GetByteField(jobject obj, jfieldID fieldID) { 1296 return functions->GetByteField(this,obj,fieldID); 1297 } 1298 jchar GetCharField(jobject obj, jfieldID fieldID) { 1299 return functions->GetCharField(this,obj,fieldID); 1300 } 1301 jshort GetShortField(jobject obj, jfieldID fieldID) { 1302 return functions->GetShortField(this,obj,fieldID); 1303 } 1304 jint GetIntField(jobject obj, jfieldID fieldID) { 1305 return functions->GetIntField(this,obj,fieldID); 1306 } 1307 jlong GetLongField(jobject obj, jfieldID fieldID) { 1308 return functions->GetLongField(this,obj,fieldID); 1309 } 1310 jfloat GetFloatField(jobject obj, jfieldID fieldID) { 1311 return functions->GetFloatField(this,obj,fieldID); 1312 } 1313 jdouble GetDoubleField(jobject obj, jfieldID fieldID) { 1314 return functions->GetDoubleField(this,obj,fieldID); 1315 } 1316 1317 void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { 1318 functions->SetObjectField(this,obj,fieldID,val); 1319 } 1320 void SetBooleanField(jobject obj, jfieldID fieldID, 1321 jboolean val) { 1322 functions->SetBooleanField(this,obj,fieldID,val); 1323 } 1324 void SetByteField(jobject obj, jfieldID fieldID, 1325 jbyte val) { 1326 functions->SetByteField(this,obj,fieldID,val); 1327 } 1328 void SetCharField(jobject obj, jfieldID fieldID, 1329 jchar val) { 1330 functions->SetCharField(this,obj,fieldID,val); 1331 } 1332 void SetShortField(jobject obj, jfieldID fieldID, 1333 jshort val) { 1334 functions->SetShortField(this,obj,fieldID,val); 1335 } 1336 void SetIntField(jobject obj, jfieldID fieldID, 1337 jint val) { 1338 functions->SetIntField(this,obj,fieldID,val); 1339 } 1340 void SetLongField(jobject obj, jfieldID fieldID, 1341 jlong val) { 1342 functions->SetLongField(this,obj,fieldID,val); 1343 } 1344 void SetFloatField(jobject obj, jfieldID fieldID, 1345 jfloat val) { 1346 functions->SetFloatField(this,obj,fieldID,val); 1347 } 1348 void SetDoubleField(jobject obj, jfieldID fieldID, 1349 jdouble val) { 1350 functions->SetDoubleField(this,obj,fieldID,val); 1351 } 1352 1353 jmethodID GetStaticMethodID(jclass clazz, const char *name, 1354 const char *sig) { 1355 return functions->GetStaticMethodID(this,clazz,name,sig); 1356 } 1357 1358 jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, 1359 ...) { 1360 va_list args; 1361 jobject result; 1362 va_start(args,methodID); 1363 result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); 1364 va_end(args); 1365 return result; 1366 } 1367 jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, 1368 va_list args) { 1369 return functions->CallStaticObjectMethodV(this,clazz,methodID,args); 1370 } 1371 jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, 1372 const jvalue *args) { 1373 return functions->CallStaticObjectMethodA(this,clazz,methodID,args); 1374 } 1375 1376 jboolean CallStaticBooleanMethod(jclass clazz, 1377 jmethodID methodID, ...) { 1378 va_list args; 1379 jboolean result; 1380 va_start(args,methodID); 1381 result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); 1382 va_end(args); 1383 return result; 1384 } 1385 jboolean CallStaticBooleanMethodV(jclass clazz, 1386 jmethodID methodID, va_list args) { 1387 return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); 1388 } 1389 jboolean CallStaticBooleanMethodA(jclass clazz, 1390 jmethodID methodID, const jvalue *args) { 1391 return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); 1392 } 1393 1394 jbyte CallStaticByteMethod(jclass clazz, 1395 jmethodID methodID, ...) { 1396 va_list args; 1397 jbyte result; 1398 va_start(args,methodID); 1399 result = functions->CallStaticByteMethodV(this,clazz,methodID,args); 1400 va_end(args); 1401 return result; 1402 } 1403 jbyte CallStaticByteMethodV(jclass clazz, 1404 jmethodID methodID, va_list args) { 1405 return functions->CallStaticByteMethodV(this,clazz,methodID,args); 1406 } 1407 jbyte CallStaticByteMethodA(jclass clazz, 1408 jmethodID methodID, const jvalue *args) { 1409 return functions->CallStaticByteMethodA(this,clazz,methodID,args); 1410 } 1411 1412 jchar CallStaticCharMethod(jclass clazz, 1413 jmethodID methodID, ...) { 1414 va_list args; 1415 jchar result; 1416 va_start(args,methodID); 1417 result = functions->CallStaticCharMethodV(this,clazz,methodID,args); 1418 va_end(args); 1419 return result; 1420 } 1421 jchar CallStaticCharMethodV(jclass clazz, 1422 jmethodID methodID, va_list args) { 1423 return functions->CallStaticCharMethodV(this,clazz,methodID,args); 1424 } 1425 jchar CallStaticCharMethodA(jclass clazz, 1426 jmethodID methodID, const jvalue *args) { 1427 return functions->CallStaticCharMethodA(this,clazz,methodID,args); 1428 } 1429 1430 jshort CallStaticShortMethod(jclass clazz, 1431 jmethodID methodID, ...) { 1432 va_list args; 1433 jshort result; 1434 va_start(args,methodID); 1435 result = functions->CallStaticShortMethodV(this,clazz,methodID,args); 1436 va_end(args); 1437 return result; 1438 } 1439 jshort CallStaticShortMethodV(jclass clazz, 1440 jmethodID methodID, va_list args) { 1441 return functions->CallStaticShortMethodV(this,clazz,methodID,args); 1442 } 1443 jshort CallStaticShortMethodA(jclass clazz, 1444 jmethodID methodID, const jvalue *args) { 1445 return functions->CallStaticShortMethodA(this,clazz,methodID,args); 1446 } 1447 1448 jint CallStaticIntMethod(jclass clazz, 1449 jmethodID methodID, ...) { 1450 va_list args; 1451 jint result; 1452 va_start(args,methodID); 1453 result = functions->CallStaticIntMethodV(this,clazz,methodID,args); 1454 va_end(args); 1455 return result; 1456 } 1457 jint CallStaticIntMethodV(jclass clazz, 1458 jmethodID methodID, va_list args) { 1459 return functions->CallStaticIntMethodV(this,clazz,methodID,args); 1460 } 1461 jint CallStaticIntMethodA(jclass clazz, 1462 jmethodID methodID, const jvalue *args) { 1463 return functions->CallStaticIntMethodA(this,clazz,methodID,args); 1464 } 1465 1466 jlong CallStaticLongMethod(jclass clazz, 1467 jmethodID methodID, ...) { 1468 va_list args; 1469 jlong result; 1470 va_start(args,methodID); 1471 result = functions->CallStaticLongMethodV(this,clazz,methodID,args); 1472 va_end(args); 1473 return result; 1474 } 1475 jlong CallStaticLongMethodV(jclass clazz, 1476 jmethodID methodID, va_list args) { 1477 return functions->CallStaticLongMethodV(this,clazz,methodID,args); 1478 } 1479 jlong CallStaticLongMethodA(jclass clazz, 1480 jmethodID methodID, const jvalue *args) { 1481 return functions->CallStaticLongMethodA(this,clazz,methodID,args); 1482 } 1483 1484 jfloat CallStaticFloatMethod(jclass clazz, 1485 jmethodID methodID, ...) { 1486 va_list args; 1487 jfloat result; 1488 va_start(args,methodID); 1489 result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); 1490 va_end(args); 1491 return result; 1492 } 1493 jfloat CallStaticFloatMethodV(jclass clazz, 1494 jmethodID methodID, va_list args) { 1495 return functions->CallStaticFloatMethodV(this,clazz,methodID,args); 1496 } 1497 jfloat CallStaticFloatMethodA(jclass clazz, 1498 jmethodID methodID, const jvalue *args) { 1499 return functions->CallStaticFloatMethodA(this,clazz,methodID,args); 1500 } 1501 1502 jdouble CallStaticDoubleMethod(jclass clazz, 1503 jmethodID methodID, ...) { 1504 va_list args; 1505 jdouble result; 1506 va_start(args,methodID); 1507 result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); 1508 va_end(args); 1509 return result; 1510 } 1511 jdouble CallStaticDoubleMethodV(jclass clazz, 1512 jmethodID methodID, va_list args) { 1513 return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); 1514 } 1515 jdouble CallStaticDoubleMethodA(jclass clazz, 1516 jmethodID methodID, const jvalue *args) { 1517 return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); 1518 } 1519 1520 void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { 1521 va_list args; 1522 va_start(args,methodID); 1523 functions->CallStaticVoidMethodV(this,cls,methodID,args); 1524 va_end(args); 1525 } 1526 void CallStaticVoidMethodV(jclass cls, jmethodID methodID, 1527 va_list args) { 1528 functions->CallStaticVoidMethodV(this,cls,methodID,args); 1529 } 1530 void CallStaticVoidMethodA(jclass cls, jmethodID methodID, 1531 const jvalue * args) { 1532 functions->CallStaticVoidMethodA(this,cls,methodID,args); 1533 } 1534 1535 jfieldID GetStaticFieldID(jclass clazz, const char *name, 1536 const char *sig) { 1537 return functions->GetStaticFieldID(this,clazz,name,sig); 1538 } 1539 jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { 1540 return functions->GetStaticObjectField(this,clazz,fieldID); 1541 } 1542 jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) { 1543 return functions->GetStaticBooleanField(this,clazz,fieldID); 1544 } 1545 jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) { 1546 return functions->GetStaticByteField(this,clazz,fieldID); 1547 } 1548 jchar GetStaticCharField(jclass clazz, jfieldID fieldID) { 1549 return functions->GetStaticCharField(this,clazz,fieldID); 1550 } 1551 jshort GetStaticShortField(jclass clazz, jfieldID fieldID) { 1552 return functions->GetStaticShortField(this,clazz,fieldID); 1553 } 1554 jint GetStaticIntField(jclass clazz, jfieldID fieldID) { 1555 return functions->GetStaticIntField(this,clazz,fieldID); 1556 } 1557 jlong GetStaticLongField(jclass clazz, jfieldID fieldID) { 1558 return functions->GetStaticLongField(this,clazz,fieldID); 1559 } 1560 jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) { 1561 return functions->GetStaticFloatField(this,clazz,fieldID); 1562 } 1563 jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) { 1564 return functions->GetStaticDoubleField(this,clazz,fieldID); 1565 } 1566 1567 void SetStaticObjectField(jclass clazz, jfieldID fieldID, 1568 jobject value) { 1569 functions->SetStaticObjectField(this,clazz,fieldID,value); 1570 } 1571 void SetStaticBooleanField(jclass clazz, jfieldID fieldID, 1572 jboolean value) { 1573 functions->SetStaticBooleanField(this,clazz,fieldID,value); 1574 } 1575 void SetStaticByteField(jclass clazz, jfieldID fieldID, 1576 jbyte value) { 1577 functions->SetStaticByteField(this,clazz,fieldID,value); 1578 } 1579 void SetStaticCharField(jclass clazz, jfieldID fieldID, 1580 jchar value) { 1581 functions->SetStaticCharField(this,clazz,fieldID,value); 1582 } 1583 void SetStaticShortField(jclass clazz, jfieldID fieldID, 1584 jshort value) { 1585 functions->SetStaticShortField(this,clazz,fieldID,value); 1586 } 1587 void SetStaticIntField(jclass clazz, jfieldID fieldID, 1588 jint value) { 1589 functions->SetStaticIntField(this,clazz,fieldID,value); 1590 } 1591 void SetStaticLongField(jclass clazz, jfieldID fieldID, 1592 jlong value) { 1593 functions->SetStaticLongField(this,clazz,fieldID,value); 1594 } 1595 void SetStaticFloatField(jclass clazz, jfieldID fieldID, 1596 jfloat value) { 1597 functions->SetStaticFloatField(this,clazz,fieldID,value); 1598 } 1599 void SetStaticDoubleField(jclass clazz, jfieldID fieldID, 1600 jdouble value) { 1601 functions->SetStaticDoubleField(this,clazz,fieldID,value); 1602 } 1603 1604 jstring NewString(const jchar *unicode, jsize len) { 1605 return functions->NewString(this,unicode,len); 1606 } 1607 jsize GetStringLength(jstring str) { 1608 return functions->GetStringLength(this,str); 1609 } 1610 const jchar *GetStringChars(jstring str, jboolean *isCopy) { 1611 return functions->GetStringChars(this,str,isCopy); 1612 } 1613 void ReleaseStringChars(jstring str, const jchar *chars) { 1614 functions->ReleaseStringChars(this,str,chars); 1615 } 1616 1617 jstring NewStringUTF(const char *utf) { 1618 return functions->NewStringUTF(this,utf); 1619 } 1620 jsize GetStringUTFLength(jstring str) { 1621 return functions->GetStringUTFLength(this,str); 1622 } 1623 const char* GetStringUTFChars(jstring str, jboolean *isCopy) { 1624 return functions->GetStringUTFChars(this,str,isCopy); 1625 } 1626 void ReleaseStringUTFChars(jstring str, const char* chars) { 1627 functions->ReleaseStringUTFChars(this,str,chars); 1628 } 1629 1630 jsize GetArrayLength(jarray array) { 1631 return functions->GetArrayLength(this,array); 1632 } 1633 1634 jobjectArray NewObjectArray(jsize len, jclass clazz, 1635 jobject init) { 1636 return functions->NewObjectArray(this,len,clazz,init); 1637 } 1638 jobject GetObjectArrayElement(jobjectArray array, jsize index) { 1639 return functions->GetObjectArrayElement(this,array,index); 1640 } 1641 void SetObjectArrayElement(jobjectArray array, jsize index, 1642 jobject val) { 1643 functions->SetObjectArrayElement(this,array,index,val); 1644 } 1645 1646 jbooleanArray NewBooleanArray(jsize len) { 1647 return functions->NewBooleanArray(this,len); 1648 } 1649 jbyteArray NewByteArray(jsize len) { 1650 return functions->NewByteArray(this,len); 1651 } 1652 jcharArray NewCharArray(jsize len) { 1653 return functions->NewCharArray(this,len); 1654 } 1655 jshortArray NewShortArray(jsize len) { 1656 return functions->NewShortArray(this,len); 1657 } 1658 jintArray NewIntArray(jsize len) { 1659 return functions->NewIntArray(this,len); 1660 } 1661 jlongArray NewLongArray(jsize len) { 1662 return functions->NewLongArray(this,len); 1663 } 1664 jfloatArray NewFloatArray(jsize len) { 1665 return functions->NewFloatArray(this,len); 1666 } 1667 jdoubleArray NewDoubleArray(jsize len) { 1668 return functions->NewDoubleArray(this,len); 1669 } 1670 1671 jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) { 1672 return functions->GetBooleanArrayElements(this,array,isCopy); 1673 } 1674 jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) { 1675 return functions->GetByteArrayElements(this,array,isCopy); 1676 } 1677 jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) { 1678 return functions->GetCharArrayElements(this,array,isCopy); 1679 } 1680 jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) { 1681 return functions->GetShortArrayElements(this,array,isCopy); 1682 } 1683 jint * GetIntArrayElements(jintArray array, jboolean *isCopy) { 1684 return functions->GetIntArrayElements(this,array,isCopy); 1685 } 1686 jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) { 1687 return functions->GetLongArrayElements(this,array,isCopy); 1688 } 1689 jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) { 1690 return functions->GetFloatArrayElements(this,array,isCopy); 1691 } 1692 jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) { 1693 return functions->GetDoubleArrayElements(this,array,isCopy); 1694 } 1695 1696 void ReleaseBooleanArrayElements(jbooleanArray array, 1697 jboolean *elems, 1698 jint mode) { 1699 functions->ReleaseBooleanArrayElements(this,array,elems,mode); 1700 } 1701 void ReleaseByteArrayElements(jbyteArray array, 1702 jbyte *elems, 1703 jint mode) { 1704 functions->ReleaseByteArrayElements(this,array,elems,mode); 1705 } 1706 void ReleaseCharArrayElements(jcharArray array, 1707 jchar *elems, 1708 jint mode) { 1709 functions->ReleaseCharArrayElements(this,array,elems,mode); 1710 } 1711 void ReleaseShortArrayElements(jshortArray array, 1712 jshort *elems, 1713 jint mode) { 1714 functions->ReleaseShortArrayElements(this,array,elems,mode); 1715 } 1716 void ReleaseIntArrayElements(jintArray array, 1717 jint *elems, 1718 jint mode) { 1719 functions->ReleaseIntArrayElements(this,array,elems,mode); 1720 } 1721 void ReleaseLongArrayElements(jlongArray array, 1722 jlong *elems, 1723 jint mode) { 1724 functions->ReleaseLongArrayElements(this,array,elems,mode); 1725 } 1726 void ReleaseFloatArrayElements(jfloatArray array, 1727 jfloat *elems, 1728 jint mode) { 1729 functions->ReleaseFloatArrayElements(this,array,elems,mode); 1730 } 1731 void ReleaseDoubleArrayElements(jdoubleArray array, 1732 jdouble *elems, 1733 jint mode) { 1734 functions->ReleaseDoubleArrayElements(this,array,elems,mode); 1735 } 1736 1737 void GetBooleanArrayRegion(jbooleanArray array, 1738 jsize start, jsize len, jboolean *buf) { 1739 functions->GetBooleanArrayRegion(this,array,start,len,buf); 1740 } 1741 void GetByteArrayRegion(jbyteArray array, 1742 jsize start, jsize len, jbyte *buf) { 1743 functions->GetByteArrayRegion(this,array,start,len,buf); 1744 } 1745 void GetCharArrayRegion(jcharArray array, 1746 jsize start, jsize len, jchar *buf) { 1747 functions->GetCharArrayRegion(this,array,start,len,buf); 1748 } 1749 void GetShortArrayRegion(jshortArray array, 1750 jsize start, jsize len, jshort *buf) { 1751 functions->GetShortArrayRegion(this,array,start,len,buf); 1752 } 1753 void GetIntArrayRegion(jintArray array, 1754 jsize start, jsize len, jint *buf) { 1755 functions->GetIntArrayRegion(this,array,start,len,buf); 1756 } 1757 void GetLongArrayRegion(jlongArray array, 1758 jsize start, jsize len, jlong *buf) { 1759 functions->GetLongArrayRegion(this,array,start,len,buf); 1760 } 1761 void GetFloatArrayRegion(jfloatArray array, 1762 jsize start, jsize len, jfloat *buf) { 1763 functions->GetFloatArrayRegion(this,array,start,len,buf); 1764 } 1765 void GetDoubleArrayRegion(jdoubleArray array, 1766 jsize start, jsize len, jdouble *buf) { 1767 functions->GetDoubleArrayRegion(this,array,start,len,buf); 1768 } 1769 1770 void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, 1771 const jboolean *buf) { 1772 functions->SetBooleanArrayRegion(this,array,start,len,buf); 1773 } 1774 void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, 1775 const jbyte *buf) { 1776 functions->SetByteArrayRegion(this,array,start,len,buf); 1777 } 1778 void SetCharArrayRegion(jcharArray array, jsize start, jsize len, 1779 const jchar *buf) { 1780 functions->SetCharArrayRegion(this,array,start,len,buf); 1781 } 1782 void SetShortArrayRegion(jshortArray array, jsize start, jsize len, 1783 const jshort *buf) { 1784 functions->SetShortArrayRegion(this,array,start,len,buf); 1785 } 1786 void SetIntArrayRegion(jintArray array, jsize start, jsize len, 1787 const jint *buf) { 1788 functions->SetIntArrayRegion(this,array,start,len,buf); 1789 } 1790 void SetLongArrayRegion(jlongArray array, jsize start, jsize len, 1791 const jlong *buf) { 1792 functions->SetLongArrayRegion(this,array,start,len,buf); 1793 } 1794 void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, 1795 const jfloat *buf) { 1796 functions->SetFloatArrayRegion(this,array,start,len,buf); 1797 } 1798 void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, 1799 const jdouble *buf) { 1800 functions->SetDoubleArrayRegion(this,array,start,len,buf); 1801 } 1802 1803 jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, 1804 jint nMethods) { 1805 return functions->RegisterNatives(this,clazz,methods,nMethods); 1806 } 1807 jint UnregisterNatives(jclass clazz) { 1808 return functions->UnregisterNatives(this,clazz); 1809 } 1810 1811 jint MonitorEnter(jobject obj) { 1812 return functions->MonitorEnter(this,obj); 1813 } 1814 jint MonitorExit(jobject obj) { 1815 return functions->MonitorExit(this,obj); 1816 } 1817 1818 jint GetJavaVM(JavaVM **vm) { 1819 return functions->GetJavaVM(this,vm); 1820 } 1821 1822 void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) { 1823 functions->GetStringRegion(this,str,start,len,buf); 1824 } 1825 void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) { 1826 functions->GetStringUTFRegion(this,str,start,len,buf); 1827 } 1828 1829 void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) { 1830 return functions->GetPrimitiveArrayCritical(this,array,isCopy); 1831 } 1832 void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) { 1833 functions->ReleasePrimitiveArrayCritical(this,array,carray,mode); 1834 } 1835 1836 const jchar * GetStringCritical(jstring string, jboolean *isCopy) { 1837 return functions->GetStringCritical(this,string,isCopy); 1838 } 1839 void ReleaseStringCritical(jstring string, const jchar *cstring) { 1840 functions->ReleaseStringCritical(this,string,cstring); 1841 } 1842 1843 jweak NewWeakGlobalRef(jobject obj) { 1844 return functions->NewWeakGlobalRef(this,obj); 1845 } 1846 void DeleteWeakGlobalRef(jweak ref) { 1847 functions->DeleteWeakGlobalRef(this,ref); 1848 } 1849 1850 jboolean ExceptionCheck() { 1851 return functions->ExceptionCheck(this); 1852 } 1853 1854 jobject NewDirectByteBuffer(void* address, jlong capacity) { 1855 return functions->NewDirectByteBuffer(this, address, capacity); 1856 } 1857 void* GetDirectBufferAddress(jobject buf) { 1858 return functions->GetDirectBufferAddress(this, buf); 1859 } 1860 jlong GetDirectBufferCapacity(jobject buf) { 1861 return functions->GetDirectBufferCapacity(this, buf); 1862 } 1863 jobjectRefType GetObjectRefType(jobject obj) { 1864 return functions->GetObjectRefType(this, obj); 1865 } 1866 1867 /* Module Features */ 1868 1869 jobject GetModule(jclass clazz) { 1870 return functions->GetModule(this, clazz); 1871 } 1872 jsize GetAllModules(jobjectArray *modules) { 1873 return functions->GetAllModules(this, modules); 1874 } 1875 1876 #endif /* __cplusplus */ 1877 }; 1878 1879 typedef struct JavaVMOption { 1880 char *optionString; 1881 void *extraInfo; 1882 } JavaVMOption; 1883 1884 typedef struct JavaVMInitArgs { 1885 jint version; 1886 1887 jint nOptions; 1888 JavaVMOption *options; 1889 jboolean ignoreUnrecognized; 1890 } JavaVMInitArgs; 1891 1892 typedef struct JavaVMAttachArgs { 1893 jint version; 1894 1895 char *name; 1896 jobject group; 1897 } JavaVMAttachArgs; 1898 1899 /* These will be VM-specific. */ 1900 1901 #define JDK1_2 1902 #define JDK1_4 1903 1904 /* End VM-specific. */ 1905 1906 struct JNIInvokeInterface_ { 1907 void *reserved0; 1908 void *reserved1; 1909 void *reserved2; 1910 1911 jint (JNICALL *DestroyJavaVM)(JavaVM *vm); 1912 1913 jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args); 1914 1915 jint (JNICALL *DetachCurrentThread)(JavaVM *vm); 1916 1917 jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version); 1918 1919 jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args); 1920 }; 1921 1922 struct JavaVM_ { 1923 const struct JNIInvokeInterface_ *functions; 1924 #ifdef __cplusplus 1925 1926 jint DestroyJavaVM() { 1927 return functions->DestroyJavaVM(this); 1928 } 1929 jint AttachCurrentThread(void **penv, void *args) { 1930 return functions->AttachCurrentThread(this, penv, args); 1931 } 1932 jint DetachCurrentThread() { 1933 return functions->DetachCurrentThread(this); 1934 } 1935 1936 jint GetEnv(void **penv, jint version) { 1937 return functions->GetEnv(this, penv, version); 1938 } 1939 jint AttachCurrentThreadAsDaemon(void **penv, void *args) { 1940 return functions->AttachCurrentThreadAsDaemon(this, penv, args); 1941 } 1942 #endif 1943 }; 1944 1945 #ifdef _JNI_IMPLEMENTATION_ 1946 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT 1947 #else 1948 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT 1949 #endif 1950 _JNI_IMPORT_OR_EXPORT_ jint JNICALL 1951 JNI_GetDefaultJavaVMInitArgs(void *args); 1952 1953 _JNI_IMPORT_OR_EXPORT_ jint JNICALL 1954 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args); 1955 1956 _JNI_IMPORT_OR_EXPORT_ jint JNICALL 1957 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *); 1958 1959 /* Defined by native libraries. */ 1960 JNIEXPORT jint JNICALL 1961 JNI_OnLoad(JavaVM *vm, void *reserved); 1962 1963 JNIEXPORT void JNICALL 1964 JNI_OnUnload(JavaVM *vm, void *reserved); 1965 1966 #define JNI_VERSION_1_1 0x00010001 1967 #define JNI_VERSION_1_2 0x00010002 1968 #define JNI_VERSION_1_4 0x00010004 1969 #define JNI_VERSION_1_6 0x00010006 1970 #define JNI_VERSION_1_8 0x00010008 1971 1972 #ifdef __cplusplus 1973 } /* extern "C" */ 1974 #endif /* __cplusplus */ 1975 1976 #endif /* !_JAVASOFT_JNI_H_ */