Mercurial > hg > graal-compiler
annotate src/share/vm/prims/jni.h @ 3917:eca1193ca245
4965777: GC changes to support use of discovered field for pending references
Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose.
Reviewed-by: jcoomes, mchung, stefank
| author | ysr |
|---|---|
| date | Wed, 07 Sep 2011 13:55:42 -0700 |
| parents | f95d63e2154a |
| children | 499ccc15bbc8 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
7 * published by the Free Software Foundation. Oracle designates this |
| 0 | 8 * particular file as subject to the "Classpath" exception as provided |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
9 * by Oracle in the LICENSE file that accompanied this code. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
22 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
23 * questions. |
| 0 | 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 | |
| 1955 #ifdef __cplusplus | |
| 1956 } /* extern "C" */ | |
| 1957 #endif /* __cplusplus */ | |
| 1958 | |
| 1959 #endif /* !_JAVASOFT_JNI_H_ */ |