1 /* 2 * Copyright (c) 1997, 2016, 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 }; 774 775 /* 776 * We use inlined functions for C++ so that programmers can write: 777 * 778 * env->FindClass("java/lang/String") 779 * 780 * in C++ rather than: 781 * 782 * (*env)->FindClass(env, "java/lang/String") 783 * 784 * in C. 785 */ 786 787 struct JNIEnv_ { 788 const struct JNINativeInterface_ *functions; 789 #ifdef __cplusplus 790 791 jint GetVersion() { 792 return functions->GetVersion(this); 793 } 794 jclass DefineClass(const char *name, jobject loader, const jbyte *buf, 795 jsize len) { 796 return functions->DefineClass(this, name, loader, buf, len); 797 } 798 jclass FindClass(const char *name) { 799 return functions->FindClass(this, name); 800 } 801 jmethodID FromReflectedMethod(jobject method) { 802 return functions->FromReflectedMethod(this,method); 803 } 804 jfieldID FromReflectedField(jobject field) { 805 return functions->FromReflectedField(this,field); 806 } 807 808 jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) { 809 return functions->ToReflectedMethod(this, cls, methodID, isStatic); 810 } 811 812 jclass GetSuperclass(jclass sub) { 813 return functions->GetSuperclass(this, sub); 814 } 815 jboolean IsAssignableFrom(jclass sub, jclass sup) { 816 return functions->IsAssignableFrom(this, sub, sup); 817 } 818 819 jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) { 820 return functions->ToReflectedField(this,cls,fieldID,isStatic); 821 } 822 823 jint Throw(jthrowable obj) { 824 return functions->Throw(this, obj); 825 } 826 jint ThrowNew(jclass clazz, const char *msg) { 827 return functions->ThrowNew(this, clazz, msg); 828 } 829 jthrowable ExceptionOccurred() { 830 return functions->ExceptionOccurred(this); 831 } 832 void ExceptionDescribe() { 833 functions->ExceptionDescribe(this); 834 } 835 void ExceptionClear() { 836 functions->ExceptionClear(this); 837 } 838 void FatalError(const char *msg) { 839 functions->FatalError(this, msg); 840 } 841 842 jint PushLocalFrame(jint capacity) { 843 return functions->PushLocalFrame(this,capacity); 844 } 845 jobject PopLocalFrame(jobject result) { 846 return functions->PopLocalFrame(this,result); 847 } 848 849 jobject NewGlobalRef(jobject lobj) { 850 return functions->NewGlobalRef(this,lobj); 851 } 852 void DeleteGlobalRef(jobject gref) { 853 functions->DeleteGlobalRef(this,gref); 854 } 855 void DeleteLocalRef(jobject obj) { 856 functions->DeleteLocalRef(this, obj); 857 } 858 859 jboolean IsSameObject(jobject obj1, jobject obj2) { 860 return functions->IsSameObject(this,obj1,obj2); 861 } 862 863 jobject NewLocalRef(jobject ref) { 864 return functions->NewLocalRef(this,ref); 865 } 866 jint EnsureLocalCapacity(jint capacity) { 867 return functions->EnsureLocalCapacity(this,capacity); 868 } 869 870 jobject AllocObject(jclass clazz) { 871 return functions->AllocObject(this,clazz); 872 } 873 jobject NewObject(jclass clazz, jmethodID methodID, ...) { 874 va_list args; 875 jobject result; 876 va_start(args, methodID); 877 result = functions->NewObjectV(this,clazz,methodID,args); 878 va_end(args); 879 return result; 880 } 881 jobject NewObjectV(jclass clazz, jmethodID methodID, 882 va_list args) { 883 return functions->NewObjectV(this,clazz,methodID,args); 884 } 885 jobject NewObjectA(jclass clazz, jmethodID methodID, 886 const jvalue *args) { 887 return functions->NewObjectA(this,clazz,methodID,args); 888 } 889 890 jclass GetObjectClass(jobject obj) { 891 return functions->GetObjectClass(this,obj); 892 } 893 jboolean IsInstanceOf(jobject obj, jclass clazz) { 894 return functions->IsInstanceOf(this,obj,clazz); 895 } 896 897 jmethodID GetMethodID(jclass clazz, const char *name, 898 const char *sig) { 899 return functions->GetMethodID(this,clazz,name,sig); 900 } 901 902 jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) { 903 va_list args; 904 jobject result; 905 va_start(args,methodID); 906 result = functions->CallObjectMethodV(this,obj,methodID,args); 907 va_end(args); 908 return result; 909 } 910 jobject CallObjectMethodV(jobject obj, jmethodID methodID, 911 va_list args) { 912 return functions->CallObjectMethodV(this,obj,methodID,args); 913 } 914 jobject CallObjectMethodA(jobject obj, jmethodID methodID, 915 const jvalue * args) { 916 return functions->CallObjectMethodA(this,obj,methodID,args); 917 } 918 919 jboolean CallBooleanMethod(jobject obj, 920 jmethodID methodID, ...) { 921 va_list args; 922 jboolean result; 923 va_start(args,methodID); 924 result = functions->CallBooleanMethodV(this,obj,methodID,args); 925 va_end(args); 926 return result; 927 } 928 jboolean CallBooleanMethodV(jobject obj, jmethodID methodID, 929 va_list args) { 930 return functions->CallBooleanMethodV(this,obj,methodID,args); 931 } 932 jboolean CallBooleanMethodA(jobject obj, jmethodID methodID, 933 const jvalue * args) { 934 return functions->CallBooleanMethodA(this,obj,methodID, args); 935 } 936 937 jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) { 938 va_list args; 939 jbyte result; 940 va_start(args,methodID); 941 result = functions->CallByteMethodV(this,obj,methodID,args); 942 va_end(args); 943 return result; 944 } 945 jbyte CallByteMethodV(jobject obj, jmethodID methodID, 946 va_list args) { 947 return functions->CallByteMethodV(this,obj,methodID,args); 948 } 949 jbyte CallByteMethodA(jobject obj, jmethodID methodID, 950 const jvalue * args) { 951 return functions->CallByteMethodA(this,obj,methodID,args); 952 } 953 954 jchar CallCharMethod(jobject obj, jmethodID methodID, ...) { 955 va_list args; 956 jchar result; 957 va_start(args,methodID); 958 result = functions->CallCharMethodV(this,obj,methodID,args); 959 va_end(args); 960 return result; 961 } 962 jchar CallCharMethodV(jobject obj, jmethodID methodID, 963 va_list args) { 964 return functions->CallCharMethodV(this,obj,methodID,args); 965 } 966 jchar CallCharMethodA(jobject obj, jmethodID methodID, 967 const jvalue * args) { 968 return functions->CallCharMethodA(this,obj,methodID,args); 969 } 970 971 jshort CallShortMethod(jobject obj, jmethodID methodID, ...) { 972 va_list args; 973 jshort result; 974 va_start(args,methodID); 975 result = functions->CallShortMethodV(this,obj,methodID,args); 976 va_end(args); 977 return result; 978 } 979 jshort CallShortMethodV(jobject obj, jmethodID methodID, 980 va_list args) { 981 return functions->CallShortMethodV(this,obj,methodID,args); 982 } 983 jshort CallShortMethodA(jobject obj, jmethodID methodID, 984 const jvalue * args) { 985 return functions->CallShortMethodA(this,obj,methodID,args); 986 } 987 988 jint CallIntMethod(jobject obj, jmethodID methodID, ...) { 989 va_list args; 990 jint result; 991 va_start(args,methodID); 992 result = functions->CallIntMethodV(this,obj,methodID,args); 993 va_end(args); 994 return result; 995 } 996 jint CallIntMethodV(jobject obj, jmethodID methodID, 997 va_list args) { 998 return functions->CallIntMethodV(this,obj,methodID,args); 999 } 1000 jint CallIntMethodA(jobject obj, jmethodID methodID, 1001 const jvalue * args) { 1002 return functions->CallIntMethodA(this,obj,methodID,args); 1003 } 1004 1005 jlong CallLongMethod(jobject obj, jmethodID methodID, ...) { 1006 va_list args; 1007 jlong result; 1008 va_start(args,methodID); 1009 result = functions->CallLongMethodV(this,obj,methodID,args); 1010 va_end(args); 1011 return result; 1012 } 1013 jlong CallLongMethodV(jobject obj, jmethodID methodID, 1014 va_list args) { 1015 return functions->CallLongMethodV(this,obj,methodID,args); 1016 } 1017 jlong CallLongMethodA(jobject obj, jmethodID methodID, 1018 const jvalue * args) { 1019 return functions->CallLongMethodA(this,obj,methodID,args); 1020 } 1021 1022 jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) { 1023 va_list args; 1024 jfloat result; 1025 va_start(args,methodID); 1026 result = functions->CallFloatMethodV(this,obj,methodID,args); 1027 va_end(args); 1028 return result; 1029 } 1030 jfloat CallFloatMethodV(jobject obj, jmethodID methodID, 1031 va_list args) { 1032 return functions->CallFloatMethodV(this,obj,methodID,args); 1033 } 1034 jfloat CallFloatMethodA(jobject obj, jmethodID methodID, 1035 const jvalue * args) { 1036 return functions->CallFloatMethodA(this,obj,methodID,args); 1037 } 1038 1039 jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) { 1040 va_list args; 1041 jdouble result; 1042 va_start(args,methodID); 1043 result = functions->CallDoubleMethodV(this,obj,methodID,args); 1044 va_end(args); 1045 return result; 1046 } 1047 jdouble CallDoubleMethodV(jobject obj, jmethodID methodID, 1048 va_list args) { 1049 return functions->CallDoubleMethodV(this,obj,methodID,args); 1050 } 1051 jdouble CallDoubleMethodA(jobject obj, jmethodID methodID, 1052 const jvalue * args) { 1053 return functions->CallDoubleMethodA(this,obj,methodID,args); 1054 } 1055 1056 void CallVoidMethod(jobject obj, jmethodID methodID, ...) { 1057 va_list args; 1058 va_start(args,methodID); 1059 functions->CallVoidMethodV(this,obj,methodID,args); 1060 va_end(args); 1061 } 1062 void CallVoidMethodV(jobject obj, jmethodID methodID, 1063 va_list args) { 1064 functions->CallVoidMethodV(this,obj,methodID,args); 1065 } 1066 void CallVoidMethodA(jobject obj, jmethodID methodID, 1067 const jvalue * args) { 1068 functions->CallVoidMethodA(this,obj,methodID,args); 1069 } 1070 1071 jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz, 1072 jmethodID methodID, ...) { 1073 va_list args; 1074 jobject result; 1075 va_start(args,methodID); 1076 result = functions->CallNonvirtualObjectMethodV(this,obj,clazz, 1077 methodID,args); 1078 va_end(args); 1079 return result; 1080 } 1081 jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz, 1082 jmethodID methodID, va_list args) { 1083 return functions->CallNonvirtualObjectMethodV(this,obj,clazz, 1084 methodID,args); 1085 } 1086 jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz, 1087 jmethodID methodID, const jvalue * args) { 1088 return functions->CallNonvirtualObjectMethodA(this,obj,clazz, 1089 methodID,args); 1090 } 1091 1092 jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz, 1093 jmethodID methodID, ...) { 1094 va_list args; 1095 jboolean result; 1096 va_start(args,methodID); 1097 result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz, 1098 methodID,args); 1099 va_end(args); 1100 return result; 1101 } 1102 jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz, 1103 jmethodID methodID, va_list args) { 1104 return functions->CallNonvirtualBooleanMethodV(this,obj,clazz, 1105 methodID,args); 1106 } 1107 jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz, 1108 jmethodID methodID, const jvalue * args) { 1109 return functions->CallNonvirtualBooleanMethodA(this,obj,clazz, 1110 methodID, args); 1111 } 1112 1113 jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz, 1114 jmethodID methodID, ...) { 1115 va_list args; 1116 jbyte result; 1117 va_start(args,methodID); 1118 result = functions->CallNonvirtualByteMethodV(this,obj,clazz, 1119 methodID,args); 1120 va_end(args); 1121 return result; 1122 } 1123 jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz, 1124 jmethodID methodID, va_list args) { 1125 return functions->CallNonvirtualByteMethodV(this,obj,clazz, 1126 methodID,args); 1127 } 1128 jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz, 1129 jmethodID methodID, const jvalue * args) { 1130 return functions->CallNonvirtualByteMethodA(this,obj,clazz, 1131 methodID,args); 1132 } 1133 1134 jchar CallNonvirtualCharMethod(jobject obj, jclass clazz, 1135 jmethodID methodID, ...) { 1136 va_list args; 1137 jchar result; 1138 va_start(args,methodID); 1139 result = functions->CallNonvirtualCharMethodV(this,obj,clazz, 1140 methodID,args); 1141 va_end(args); 1142 return result; 1143 } 1144 jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz, 1145 jmethodID methodID, va_list args) { 1146 return functions->CallNonvirtualCharMethodV(this,obj,clazz, 1147 methodID,args); 1148 } 1149 jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz, 1150 jmethodID methodID, const jvalue * args) { 1151 return functions->CallNonvirtualCharMethodA(this,obj,clazz, 1152 methodID,args); 1153 } 1154 1155 jshort CallNonvirtualShortMethod(jobject obj, jclass clazz, 1156 jmethodID methodID, ...) { 1157 va_list args; 1158 jshort result; 1159 va_start(args,methodID); 1160 result = functions->CallNonvirtualShortMethodV(this,obj,clazz, 1161 methodID,args); 1162 va_end(args); 1163 return result; 1164 } 1165 jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz, 1166 jmethodID methodID, va_list args) { 1167 return functions->CallNonvirtualShortMethodV(this,obj,clazz, 1168 methodID,args); 1169 } 1170 jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz, 1171 jmethodID methodID, const jvalue * args) { 1172 return functions->CallNonvirtualShortMethodA(this,obj,clazz, 1173 methodID,args); 1174 } 1175 1176 jint CallNonvirtualIntMethod(jobject obj, jclass clazz, 1177 jmethodID methodID, ...) { 1178 va_list args; 1179 jint result; 1180 va_start(args,methodID); 1181 result = functions->CallNonvirtualIntMethodV(this,obj,clazz, 1182 methodID,args); 1183 va_end(args); 1184 return result; 1185 } 1186 jint CallNonvirtualIntMethodV(jobject obj, jclass clazz, 1187 jmethodID methodID, va_list args) { 1188 return functions->CallNonvirtualIntMethodV(this,obj,clazz, 1189 methodID,args); 1190 } 1191 jint CallNonvirtualIntMethodA(jobject obj, jclass clazz, 1192 jmethodID methodID, const jvalue * args) { 1193 return functions->CallNonvirtualIntMethodA(this,obj,clazz, 1194 methodID,args); 1195 } 1196 1197 jlong CallNonvirtualLongMethod(jobject obj, jclass clazz, 1198 jmethodID methodID, ...) { 1199 va_list args; 1200 jlong result; 1201 va_start(args,methodID); 1202 result = functions->CallNonvirtualLongMethodV(this,obj,clazz, 1203 methodID,args); 1204 va_end(args); 1205 return result; 1206 } 1207 jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz, 1208 jmethodID methodID, va_list args) { 1209 return functions->CallNonvirtualLongMethodV(this,obj,clazz, 1210 methodID,args); 1211 } 1212 jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz, 1213 jmethodID methodID, const jvalue * args) { 1214 return functions->CallNonvirtualLongMethodA(this,obj,clazz, 1215 methodID,args); 1216 } 1217 1218 jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz, 1219 jmethodID methodID, ...) { 1220 va_list args; 1221 jfloat result; 1222 va_start(args,methodID); 1223 result = functions->CallNonvirtualFloatMethodV(this,obj,clazz, 1224 methodID,args); 1225 va_end(args); 1226 return result; 1227 } 1228 jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz, 1229 jmethodID methodID, 1230 va_list args) { 1231 return functions->CallNonvirtualFloatMethodV(this,obj,clazz, 1232 methodID,args); 1233 } 1234 jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz, 1235 jmethodID methodID, 1236 const jvalue * args) { 1237 return functions->CallNonvirtualFloatMethodA(this,obj,clazz, 1238 methodID,args); 1239 } 1240 1241 jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz, 1242 jmethodID methodID, ...) { 1243 va_list args; 1244 jdouble result; 1245 va_start(args,methodID); 1246 result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz, 1247 methodID,args); 1248 va_end(args); 1249 return result; 1250 } 1251 jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz, 1252 jmethodID methodID, 1253 va_list args) { 1254 return functions->CallNonvirtualDoubleMethodV(this,obj,clazz, 1255 methodID,args); 1256 } 1257 jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz, 1258 jmethodID methodID, 1259 const jvalue * args) { 1260 return functions->CallNonvirtualDoubleMethodA(this,obj,clazz, 1261 methodID,args); 1262 } 1263 1264 void CallNonvirtualVoidMethod(jobject obj, jclass clazz, 1265 jmethodID methodID, ...) { 1266 va_list args; 1267 va_start(args,methodID); 1268 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); 1269 va_end(args); 1270 } 1271 void CallNonvirtualVoidMethodV(jobject obj, jclass clazz, 1272 jmethodID methodID, 1273 va_list args) { 1274 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args); 1275 } 1276 void CallNonvirtualVoidMethodA(jobject obj, jclass clazz, 1277 jmethodID methodID, 1278 const jvalue * args) { 1279 functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args); 1280 } 1281 1282 jfieldID GetFieldID(jclass clazz, const char *name, 1283 const char *sig) { 1284 return functions->GetFieldID(this,clazz,name,sig); 1285 } 1286 1287 jobject GetObjectField(jobject obj, jfieldID fieldID) { 1288 return functions->GetObjectField(this,obj,fieldID); 1289 } 1290 jboolean GetBooleanField(jobject obj, jfieldID fieldID) { 1291 return functions->GetBooleanField(this,obj,fieldID); 1292 } 1293 jbyte GetByteField(jobject obj, jfieldID fieldID) { 1294 return functions->GetByteField(this,obj,fieldID); 1295 } 1296 jchar GetCharField(jobject obj, jfieldID fieldID) { 1297 return functions->GetCharField(this,obj,fieldID); 1298 } 1299 jshort GetShortField(jobject obj, jfieldID fieldID) { 1300 return functions->GetShortField(this,obj,fieldID); 1301 } 1302 jint GetIntField(jobject obj, jfieldID fieldID) { 1303 return functions->GetIntField(this,obj,fieldID); 1304 } 1305 jlong GetLongField(jobject obj, jfieldID fieldID) { 1306 return functions->GetLongField(this,obj,fieldID); 1307 } 1308 jfloat GetFloatField(jobject obj, jfieldID fieldID) { 1309 return functions->GetFloatField(this,obj,fieldID); 1310 } 1311 jdouble GetDoubleField(jobject obj, jfieldID fieldID) { 1312 return functions->GetDoubleField(this,obj,fieldID); 1313 } 1314 1315 void SetObjectField(jobject obj, jfieldID fieldID, jobject val) { 1316 functions->SetObjectField(this,obj,fieldID,val); 1317 } 1318 void SetBooleanField(jobject obj, jfieldID fieldID, 1319 jboolean val) { 1320 functions->SetBooleanField(this,obj,fieldID,val); 1321 } 1322 void SetByteField(jobject obj, jfieldID fieldID, 1323 jbyte val) { 1324 functions->SetByteField(this,obj,fieldID,val); 1325 } 1326 void SetCharField(jobject obj, jfieldID fieldID, 1327 jchar val) { 1328 functions->SetCharField(this,obj,fieldID,val); 1329 } 1330 void SetShortField(jobject obj, jfieldID fieldID, 1331 jshort val) { 1332 functions->SetShortField(this,obj,fieldID,val); 1333 } 1334 void SetIntField(jobject obj, jfieldID fieldID, 1335 jint val) { 1336 functions->SetIntField(this,obj,fieldID,val); 1337 } 1338 void SetLongField(jobject obj, jfieldID fieldID, 1339 jlong val) { 1340 functions->SetLongField(this,obj,fieldID,val); 1341 } 1342 void SetFloatField(jobject obj, jfieldID fieldID, 1343 jfloat val) { 1344 functions->SetFloatField(this,obj,fieldID,val); 1345 } 1346 void SetDoubleField(jobject obj, jfieldID fieldID, 1347 jdouble val) { 1348 functions->SetDoubleField(this,obj,fieldID,val); 1349 } 1350 1351 jmethodID GetStaticMethodID(jclass clazz, const char *name, 1352 const char *sig) { 1353 return functions->GetStaticMethodID(this,clazz,name,sig); 1354 } 1355 1356 jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID, 1357 ...) { 1358 va_list args; 1359 jobject result; 1360 va_start(args,methodID); 1361 result = functions->CallStaticObjectMethodV(this,clazz,methodID,args); 1362 va_end(args); 1363 return result; 1364 } 1365 jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID, 1366 va_list args) { 1367 return functions->CallStaticObjectMethodV(this,clazz,methodID,args); 1368 } 1369 jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID, 1370 const jvalue *args) { 1371 return functions->CallStaticObjectMethodA(this,clazz,methodID,args); 1372 } 1373 1374 jboolean CallStaticBooleanMethod(jclass clazz, 1375 jmethodID methodID, ...) { 1376 va_list args; 1377 jboolean result; 1378 va_start(args,methodID); 1379 result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args); 1380 va_end(args); 1381 return result; 1382 } 1383 jboolean CallStaticBooleanMethodV(jclass clazz, 1384 jmethodID methodID, va_list args) { 1385 return functions->CallStaticBooleanMethodV(this,clazz,methodID,args); 1386 } 1387 jboolean CallStaticBooleanMethodA(jclass clazz, 1388 jmethodID methodID, const jvalue *args) { 1389 return functions->CallStaticBooleanMethodA(this,clazz,methodID,args); 1390 } 1391 1392 jbyte CallStaticByteMethod(jclass clazz, 1393 jmethodID methodID, ...) { 1394 va_list args; 1395 jbyte result; 1396 va_start(args,methodID); 1397 result = functions->CallStaticByteMethodV(this,clazz,methodID,args); 1398 va_end(args); 1399 return result; 1400 } 1401 jbyte CallStaticByteMethodV(jclass clazz, 1402 jmethodID methodID, va_list args) { 1403 return functions->CallStaticByteMethodV(this,clazz,methodID,args); 1404 } 1405 jbyte CallStaticByteMethodA(jclass clazz, 1406 jmethodID methodID, const jvalue *args) { 1407 return functions->CallStaticByteMethodA(this,clazz,methodID,args); 1408 } 1409 1410 jchar CallStaticCharMethod(jclass clazz, 1411 jmethodID methodID, ...) { 1412 va_list args; 1413 jchar result; 1414 va_start(args,methodID); 1415 result = functions->CallStaticCharMethodV(this,clazz,methodID,args); 1416 va_end(args); 1417 return result; 1418 } 1419 jchar CallStaticCharMethodV(jclass clazz, 1420 jmethodID methodID, va_list args) { 1421 return functions->CallStaticCharMethodV(this,clazz,methodID,args); 1422 } 1423 jchar CallStaticCharMethodA(jclass clazz, 1424 jmethodID methodID, const jvalue *args) { 1425 return functions->CallStaticCharMethodA(this,clazz,methodID,args); 1426 } 1427 1428 jshort CallStaticShortMethod(jclass clazz, 1429 jmethodID methodID, ...) { 1430 va_list args; 1431 jshort result; 1432 va_start(args,methodID); 1433 result = functions->CallStaticShortMethodV(this,clazz,methodID,args); 1434 va_end(args); 1435 return result; 1436 } 1437 jshort CallStaticShortMethodV(jclass clazz, 1438 jmethodID methodID, va_list args) { 1439 return functions->CallStaticShortMethodV(this,clazz,methodID,args); 1440 } 1441 jshort CallStaticShortMethodA(jclass clazz, 1442 jmethodID methodID, const jvalue *args) { 1443 return functions->CallStaticShortMethodA(this,clazz,methodID,args); 1444 } 1445 1446 jint CallStaticIntMethod(jclass clazz, 1447 jmethodID methodID, ...) { 1448 va_list args; 1449 jint result; 1450 va_start(args,methodID); 1451 result = functions->CallStaticIntMethodV(this,clazz,methodID,args); 1452 va_end(args); 1453 return result; 1454 } 1455 jint CallStaticIntMethodV(jclass clazz, 1456 jmethodID methodID, va_list args) { 1457 return functions->CallStaticIntMethodV(this,clazz,methodID,args); 1458 } 1459 jint CallStaticIntMethodA(jclass clazz, 1460 jmethodID methodID, const jvalue *args) { 1461 return functions->CallStaticIntMethodA(this,clazz,methodID,args); 1462 } 1463 1464 jlong CallStaticLongMethod(jclass clazz, 1465 jmethodID methodID, ...) { 1466 va_list args; 1467 jlong result; 1468 va_start(args,methodID); 1469 result = functions->CallStaticLongMethodV(this,clazz,methodID,args); 1470 va_end(args); 1471 return result; 1472 } 1473 jlong CallStaticLongMethodV(jclass clazz, 1474 jmethodID methodID, va_list args) { 1475 return functions->CallStaticLongMethodV(this,clazz,methodID,args); 1476 } 1477 jlong CallStaticLongMethodA(jclass clazz, 1478 jmethodID methodID, const jvalue *args) { 1479 return functions->CallStaticLongMethodA(this,clazz,methodID,args); 1480 } 1481 1482 jfloat CallStaticFloatMethod(jclass clazz, 1483 jmethodID methodID, ...) { 1484 va_list args; 1485 jfloat result; 1486 va_start(args,methodID); 1487 result = functions->CallStaticFloatMethodV(this,clazz,methodID,args); 1488 va_end(args); 1489 return result; 1490 } 1491 jfloat CallStaticFloatMethodV(jclass clazz, 1492 jmethodID methodID, va_list args) { 1493 return functions->CallStaticFloatMethodV(this,clazz,methodID,args); 1494 } 1495 jfloat CallStaticFloatMethodA(jclass clazz, 1496 jmethodID methodID, const jvalue *args) { 1497 return functions->CallStaticFloatMethodA(this,clazz,methodID,args); 1498 } 1499 1500 jdouble CallStaticDoubleMethod(jclass clazz, 1501 jmethodID methodID, ...) { 1502 va_list args; 1503 jdouble result; 1504 va_start(args,methodID); 1505 result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args); 1506 va_end(args); 1507 return result; 1508 } 1509 jdouble CallStaticDoubleMethodV(jclass clazz, 1510 jmethodID methodID, va_list args) { 1511 return functions->CallStaticDoubleMethodV(this,clazz,methodID,args); 1512 } 1513 jdouble CallStaticDoubleMethodA(jclass clazz, 1514 jmethodID methodID, const jvalue *args) { 1515 return functions->CallStaticDoubleMethodA(this,clazz,methodID,args); 1516 } 1517 1518 void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) { 1519 va_list args; 1520 va_start(args,methodID); 1521 functions->CallStaticVoidMethodV(this,cls,methodID,args); 1522 va_end(args); 1523 } 1524 void CallStaticVoidMethodV(jclass cls, jmethodID methodID, 1525 va_list args) { 1526 functions->CallStaticVoidMethodV(this,cls,methodID,args); 1527 } 1528 void CallStaticVoidMethodA(jclass cls, jmethodID methodID, 1529 const jvalue * args) { 1530 functions->CallStaticVoidMethodA(this,cls,methodID,args); 1531 } 1532 1533 jfieldID GetStaticFieldID(jclass clazz, const char *name, 1534 const char *sig) { 1535 return functions->GetStaticFieldID(this,clazz,name,sig); 1536 } 1537 jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) { 1538 return functions->GetStaticObjectField(this,clazz,fieldID); 1539 } 1540 jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) { 1541 return functions->GetStaticBooleanField(this,clazz,fieldID); 1542 } 1543 jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) { 1544 return functions->GetStaticByteField(this,clazz,fieldID); 1545 } 1546 jchar GetStaticCharField(jclass clazz, jfieldID fieldID) { 1547 return functions->GetStaticCharField(this,clazz,fieldID); 1548 } 1549 jshort GetStaticShortField(jclass clazz, jfieldID fieldID) { 1550 return functions->GetStaticShortField(this,clazz,fieldID); 1551 } 1552 jint GetStaticIntField(jclass clazz, jfieldID fieldID) { 1553 return functions->GetStaticIntField(this,clazz,fieldID); 1554 } 1555 jlong GetStaticLongField(jclass clazz, jfieldID fieldID) { 1556 return functions->GetStaticLongField(this,clazz,fieldID); 1557 } 1558 jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) { 1559 return functions->GetStaticFloatField(this,clazz,fieldID); 1560 } 1561 jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) { 1562 return functions->GetStaticDoubleField(this,clazz,fieldID); 1563 } 1564 1565 void SetStaticObjectField(jclass clazz, jfieldID fieldID, 1566 jobject value) { 1567 functions->SetStaticObjectField(this,clazz,fieldID,value); 1568 } 1569 void SetStaticBooleanField(jclass clazz, jfieldID fieldID, 1570 jboolean value) { 1571 functions->SetStaticBooleanField(this,clazz,fieldID,value); 1572 } 1573 void SetStaticByteField(jclass clazz, jfieldID fieldID, 1574 jbyte value) { 1575 functions->SetStaticByteField(this,clazz,fieldID,value); 1576 } 1577 void SetStaticCharField(jclass clazz, jfieldID fieldID, 1578 jchar value) { 1579 functions->SetStaticCharField(this,clazz,fieldID,value); 1580 } 1581 void SetStaticShortField(jclass clazz, jfieldID fieldID, 1582 jshort value) { 1583 functions->SetStaticShortField(this,clazz,fieldID,value); 1584 } 1585 void SetStaticIntField(jclass clazz, jfieldID fieldID, 1586 jint value) { 1587 functions->SetStaticIntField(this,clazz,fieldID,value); 1588 } 1589 void SetStaticLongField(jclass clazz, jfieldID fieldID, 1590 jlong value) { 1591 functions->SetStaticLongField(this,clazz,fieldID,value); 1592 } 1593 void SetStaticFloatField(jclass clazz, jfieldID fieldID, 1594 jfloat value) { 1595 functions->SetStaticFloatField(this,clazz,fieldID,value); 1596 } 1597 void SetStaticDoubleField(jclass clazz, jfieldID fieldID, 1598 jdouble value) { 1599 functions->SetStaticDoubleField(this,clazz,fieldID,value); 1600 } 1601 1602 jstring NewString(const jchar *unicode, jsize len) { 1603 return functions->NewString(this,unicode,len); 1604 } 1605 jsize GetStringLength(jstring str) { 1606 return functions->GetStringLength(this,str); 1607 } 1608 const jchar *GetStringChars(jstring str, jboolean *isCopy) { 1609 return functions->GetStringChars(this,str,isCopy); 1610 } 1611 void ReleaseStringChars(jstring str, const jchar *chars) { 1612 functions->ReleaseStringChars(this,str,chars); 1613 } 1614 1615 jstring NewStringUTF(const char *utf) { 1616 return functions->NewStringUTF(this,utf); 1617 } 1618 jsize GetStringUTFLength(jstring str) { 1619 return functions->GetStringUTFLength(this,str); 1620 } 1621 const char* GetStringUTFChars(jstring str, jboolean *isCopy) { 1622 return functions->GetStringUTFChars(this,str,isCopy); 1623 } 1624 void ReleaseStringUTFChars(jstring str, const char* chars) { 1625 functions->ReleaseStringUTFChars(this,str,chars); 1626 } 1627 1628 jsize GetArrayLength(jarray array) { 1629 return functions->GetArrayLength(this,array); 1630 } 1631 1632 jobjectArray NewObjectArray(jsize len, jclass clazz, 1633 jobject init) { 1634 return functions->NewObjectArray(this,len,clazz,init); 1635 } 1636 jobject GetObjectArrayElement(jobjectArray array, jsize index) { 1637 return functions->GetObjectArrayElement(this,array,index); 1638 } 1639 void SetObjectArrayElement(jobjectArray array, jsize index, 1640 jobject val) { 1641 functions->SetObjectArrayElement(this,array,index,val); 1642 } 1643 1644 jbooleanArray NewBooleanArray(jsize len) { 1645 return functions->NewBooleanArray(this,len); 1646 } 1647 jbyteArray NewByteArray(jsize len) { 1648 return functions->NewByteArray(this,len); 1649 } 1650 jcharArray NewCharArray(jsize len) { 1651 return functions->NewCharArray(this,len); 1652 } 1653 jshortArray NewShortArray(jsize len) { 1654 return functions->NewShortArray(this,len); 1655 } 1656 jintArray NewIntArray(jsize len) { 1657 return functions->NewIntArray(this,len); 1658 } 1659 jlongArray NewLongArray(jsize len) { 1660 return functions->NewLongArray(this,len); 1661 } 1662 jfloatArray NewFloatArray(jsize len) { 1663 return functions->NewFloatArray(this,len); 1664 } 1665 jdoubleArray NewDoubleArray(jsize len) { 1666 return functions->NewDoubleArray(this,len); 1667 } 1668 1669 jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) { 1670 return functions->GetBooleanArrayElements(this,array,isCopy); 1671 } 1672 jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) { 1673 return functions->GetByteArrayElements(this,array,isCopy); 1674 } 1675 jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) { 1676 return functions->GetCharArrayElements(this,array,isCopy); 1677 } 1678 jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) { 1679 return functions->GetShortArrayElements(this,array,isCopy); 1680 } 1681 jint * GetIntArrayElements(jintArray array, jboolean *isCopy) { 1682 return functions->GetIntArrayElements(this,array,isCopy); 1683 } 1684 jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) { 1685 return functions->GetLongArrayElements(this,array,isCopy); 1686 } 1687 jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) { 1688 return functions->GetFloatArrayElements(this,array,isCopy); 1689 } 1690 jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) { 1691 return functions->GetDoubleArrayElements(this,array,isCopy); 1692 } 1693 1694 void ReleaseBooleanArrayElements(jbooleanArray array, 1695 jboolean *elems, 1696 jint mode) { 1697 functions->ReleaseBooleanArrayElements(this,array,elems,mode); 1698 } 1699 void ReleaseByteArrayElements(jbyteArray array, 1700 jbyte *elems, 1701 jint mode) { 1702 functions->ReleaseByteArrayElements(this,array,elems,mode); 1703 } 1704 void ReleaseCharArrayElements(jcharArray array, 1705 jchar *elems, 1706 jint mode) { 1707 functions->ReleaseCharArrayElements(this,array,elems,mode); 1708 } 1709 void ReleaseShortArrayElements(jshortArray array, 1710 jshort *elems, 1711 jint mode) { 1712 functions->ReleaseShortArrayElements(this,array,elems,mode); 1713 } 1714 void ReleaseIntArrayElements(jintArray array, 1715 jint *elems, 1716 jint mode) { 1717 functions->ReleaseIntArrayElements(this,array,elems,mode); 1718 } 1719 void ReleaseLongArrayElements(jlongArray array, 1720 jlong *elems, 1721 jint mode) { 1722 functions->ReleaseLongArrayElements(this,array,elems,mode); 1723 } 1724 void ReleaseFloatArrayElements(jfloatArray array, 1725 jfloat *elems, 1726 jint mode) { 1727 functions->ReleaseFloatArrayElements(this,array,elems,mode); 1728 } 1729 void ReleaseDoubleArrayElements(jdoubleArray array, 1730 jdouble *elems, 1731 jint mode) { 1732 functions->ReleaseDoubleArrayElements(this,array,elems,mode); 1733 } 1734 1735 void GetBooleanArrayRegion(jbooleanArray array, 1736 jsize start, jsize len, jboolean *buf) { 1737 functions->GetBooleanArrayRegion(this,array,start,len,buf); 1738 } 1739 void GetByteArrayRegion(jbyteArray array, 1740 jsize start, jsize len, jbyte *buf) { 1741 functions->GetByteArrayRegion(this,array,start,len,buf); 1742 } 1743 void GetCharArrayRegion(jcharArray array, 1744 jsize start, jsize len, jchar *buf) { 1745 functions->GetCharArrayRegion(this,array,start,len,buf); 1746 } 1747 void GetShortArrayRegion(jshortArray array, 1748 jsize start, jsize len, jshort *buf) { 1749 functions->GetShortArrayRegion(this,array,start,len,buf); 1750 } 1751 void GetIntArrayRegion(jintArray array, 1752 jsize start, jsize len, jint *buf) { 1753 functions->GetIntArrayRegion(this,array,start,len,buf); 1754 } 1755 void GetLongArrayRegion(jlongArray array, 1756 jsize start, jsize len, jlong *buf) { 1757 functions->GetLongArrayRegion(this,array,start,len,buf); 1758 } 1759 void GetFloatArrayRegion(jfloatArray array, 1760 jsize start, jsize len, jfloat *buf) { 1761 functions->GetFloatArrayRegion(this,array,start,len,buf); 1762 } 1763 void GetDoubleArrayRegion(jdoubleArray array, 1764 jsize start, jsize len, jdouble *buf) { 1765 functions->GetDoubleArrayRegion(this,array,start,len,buf); 1766 } 1767 1768 void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len, 1769 const jboolean *buf) { 1770 functions->SetBooleanArrayRegion(this,array,start,len,buf); 1771 } 1772 void SetByteArrayRegion(jbyteArray array, jsize start, jsize len, 1773 const jbyte *buf) { 1774 functions->SetByteArrayRegion(this,array,start,len,buf); 1775 } 1776 void SetCharArrayRegion(jcharArray array, jsize start, jsize len, 1777 const jchar *buf) { 1778 functions->SetCharArrayRegion(this,array,start,len,buf); 1779 } 1780 void SetShortArrayRegion(jshortArray array, jsize start, jsize len, 1781 const jshort *buf) { 1782 functions->SetShortArrayRegion(this,array,start,len,buf); 1783 } 1784 void SetIntArrayRegion(jintArray array, jsize start, jsize len, 1785 const jint *buf) { 1786 functions->SetIntArrayRegion(this,array,start,len,buf); 1787 } 1788 void SetLongArrayRegion(jlongArray array, jsize start, jsize len, 1789 const jlong *buf) { 1790 functions->SetLongArrayRegion(this,array,start,len,buf); 1791 } 1792 void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len, 1793 const jfloat *buf) { 1794 functions->SetFloatArrayRegion(this,array,start,len,buf); 1795 } 1796 void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len, 1797 const jdouble *buf) { 1798 functions->SetDoubleArrayRegion(this,array,start,len,buf); 1799 } 1800 1801 jint RegisterNatives(jclass clazz, const JNINativeMethod *methods, 1802 jint nMethods) { 1803 return functions->RegisterNatives(this,clazz,methods,nMethods); 1804 } 1805 jint UnregisterNatives(jclass clazz) { 1806 return functions->UnregisterNatives(this,clazz); 1807 } 1808 1809 jint MonitorEnter(jobject obj) { 1810 return functions->MonitorEnter(this,obj); 1811 } 1812 jint MonitorExit(jobject obj) { 1813 return functions->MonitorExit(this,obj); 1814 } 1815 1816 jint GetJavaVM(JavaVM **vm) { 1817 return functions->GetJavaVM(this,vm); 1818 } 1819 1820 void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) { 1821 functions->GetStringRegion(this,str,start,len,buf); 1822 } 1823 void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) { 1824 functions->GetStringUTFRegion(this,str,start,len,buf); 1825 } 1826 1827 void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) { 1828 return functions->GetPrimitiveArrayCritical(this,array,isCopy); 1829 } 1830 void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) { 1831 functions->ReleasePrimitiveArrayCritical(this,array,carray,mode); 1832 } 1833 1834 const jchar * GetStringCritical(jstring string, jboolean *isCopy) { 1835 return functions->GetStringCritical(this,string,isCopy); 1836 } 1837 void ReleaseStringCritical(jstring string, const jchar *cstring) { 1838 functions->ReleaseStringCritical(this,string,cstring); 1839 } 1840 1841 jweak NewWeakGlobalRef(jobject obj) { 1842 return functions->NewWeakGlobalRef(this,obj); 1843 } 1844 void DeleteWeakGlobalRef(jweak ref) { 1845 functions->DeleteWeakGlobalRef(this,ref); 1846 } 1847 1848 jboolean ExceptionCheck() { 1849 return functions->ExceptionCheck(this); 1850 } 1851 1852 jobject NewDirectByteBuffer(void* address, jlong capacity) { 1853 return functions->NewDirectByteBuffer(this, address, capacity); 1854 } 1855 void* GetDirectBufferAddress(jobject buf) { 1856 return functions->GetDirectBufferAddress(this, buf); 1857 } 1858 jlong GetDirectBufferCapacity(jobject buf) { 1859 return functions->GetDirectBufferCapacity(this, buf); 1860 } 1861 jobjectRefType GetObjectRefType(jobject obj) { 1862 return functions->GetObjectRefType(this, obj); 1863 } 1864 1865 /* Module Features */ 1866 1867 jobject GetModule(jclass clazz) { 1868 return functions->GetModule(this, clazz); 1869 } 1870 1871 #endif /* __cplusplus */ 1872 }; 1873 1874 typedef struct JavaVMOption { 1875 char *optionString; 1876 void *extraInfo; 1877 } JavaVMOption; 1878 1879 typedef struct JavaVMInitArgs { 1880 jint version; 1881 1882 jint nOptions; 1883 JavaVMOption *options; 1884 jboolean ignoreUnrecognized; 1885 } JavaVMInitArgs; 1886 1887 typedef struct JavaVMAttachArgs { 1888 jint version; 1889 1890 char *name; 1891 jobject group; 1892 } JavaVMAttachArgs; 1893 1894 /* These will be VM-specific. */ 1895 1896 #define JDK1_2 1897 #define JDK1_4 1898 1899 /* End VM-specific. */ 1900 1901 struct JNIInvokeInterface_ { 1902 void *reserved0; 1903 void *reserved1; 1904 void *reserved2; 1905 1906 jint (JNICALL *DestroyJavaVM)(JavaVM *vm); 1907 1908 jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args); 1909 1910 jint (JNICALL *DetachCurrentThread)(JavaVM *vm); 1911 1912 jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version); 1913 1914 jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args); 1915 }; 1916 1917 struct JavaVM_ { 1918 const struct JNIInvokeInterface_ *functions; 1919 #ifdef __cplusplus 1920 1921 jint DestroyJavaVM() { 1922 return functions->DestroyJavaVM(this); 1923 } 1924 jint AttachCurrentThread(void **penv, void *args) { 1925 return functions->AttachCurrentThread(this, penv, args); 1926 } 1927 jint DetachCurrentThread() { 1928 return functions->DetachCurrentThread(this); 1929 } 1930 1931 jint GetEnv(void **penv, jint version) { 1932 return functions->GetEnv(this, penv, version); 1933 } 1934 jint AttachCurrentThreadAsDaemon(void **penv, void *args) { 1935 return functions->AttachCurrentThreadAsDaemon(this, penv, args); 1936 } 1937 #endif 1938 }; 1939 1940 #ifdef _JNI_IMPLEMENTATION_ 1941 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT 1942 #else 1943 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT 1944 #endif 1945 _JNI_IMPORT_OR_EXPORT_ jint JNICALL 1946 JNI_GetDefaultJavaVMInitArgs(void *args); 1947 1948 _JNI_IMPORT_OR_EXPORT_ jint JNICALL 1949 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args); 1950 1951 _JNI_IMPORT_OR_EXPORT_ jint JNICALL 1952 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *); 1953 1954 /* Defined by native libraries. */ 1955 JNIEXPORT jint JNICALL 1956 JNI_OnLoad(JavaVM *vm, void *reserved); 1957 1958 JNIEXPORT void JNICALL 1959 JNI_OnUnload(JavaVM *vm, void *reserved); 1960 1961 #define JNI_VERSION_1_1 0x00010001 1962 #define JNI_VERSION_1_2 0x00010002 1963 #define JNI_VERSION_1_4 0x00010004 1964 #define JNI_VERSION_1_6 0x00010006 1965 #define JNI_VERSION_1_8 0x00010008 1966 #define JNI_VERSION_9 0x00090000 1967 1968 #ifdef __cplusplus 1969 } /* extern "C" */ 1970 #endif /* __cplusplus */ 1971 1972 #endif /* !_JAVASOFT_JNI_H_ */