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