00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #ifndef JNI_H
00038 #define JNI_H
00039
00040 #include <stdio.h>
00041 #include <stdarg.h>
00042
00043
00044
00045
00046 #include "jni_md.h"
00047
00048 #ifdef __cplusplus
00049 extern "C" {
00050 #endif
00051
00052
00053
00054
00055
00056 typedef unsigned char jboolean;
00057 typedef unsigned short jchar;
00058 typedef short jshort;
00059 typedef float jfloat;
00060 typedef double jdouble;
00061
00062 typedef jint jsize;
00063
00064 #ifdef __cplusplus
00065
00066 class _jobject {};
00067 class _jclass : public _jobject {};
00068 class _jthrowable : public _jobject {};
00069 class _jstring : public _jobject {};
00070 class _jarray : public _jobject {};
00071 class _jbooleanArray : public _jarray {};
00072 class _jbyteArray : public _jarray {};
00073 class _jcharArray : public _jarray {};
00074 class _jshortArray : public _jarray {};
00075 class _jintArray : public _jarray {};
00076 class _jlongArray : public _jarray {};
00077 class _jfloatArray : public _jarray {};
00078 class _jdoubleArray : public _jarray {};
00079 class _jobjectArray : public _jarray {};
00080
00081 typedef _jobject *jobject;
00082 typedef _jclass *jclass;
00083 typedef _jthrowable *jthrowable;
00084 typedef _jstring *jstring;
00085 typedef _jarray *jarray;
00086 typedef _jbooleanArray *jbooleanArray;
00087 typedef _jbyteArray *jbyteArray;
00088 typedef _jcharArray *jcharArray;
00089 typedef _jshortArray *jshortArray;
00090 typedef _jintArray *jintArray;
00091 typedef _jlongArray *jlongArray;
00092 typedef _jfloatArray *jfloatArray;
00093 typedef _jdoubleArray *jdoubleArray;
00094 typedef _jobjectArray *jobjectArray;
00095
00096 #else
00097
00098 struct _jobject;
00099
00100 typedef struct _jobject *jobject;
00101 typedef jobject jclass;
00102 typedef jobject jthrowable;
00103 typedef jobject jstring;
00104 typedef jobject jarray;
00105 typedef jarray jbooleanArray;
00106 typedef jarray jbyteArray;
00107 typedef jarray jcharArray;
00108 typedef jarray jshortArray;
00109 typedef jarray jintArray;
00110 typedef jarray jlongArray;
00111 typedef jarray jfloatArray;
00112 typedef jarray jdoubleArray;
00113 typedef jarray jobjectArray;
00114
00115 #endif
00116
00117 typedef jobject jweak;
00118
00119 #if 0
00120 typedef jobject jref;
00121
00122 #endif
00123
00124 typedef union jvalue {
00125 jboolean z;
00126 jbyte b;
00127 jchar c;
00128 jshort s;
00129 jint i;
00130 jlong j;
00131 jfloat f;
00132 jdouble d;
00133 jobject l;
00134 } jvalue;
00135
00136 struct _jfieldID;
00137 typedef struct _jfieldID *jfieldID;
00138
00139 struct _jmethodID;
00140 typedef struct _jmethodID *jmethodID;
00141
00142
00143
00144
00145
00146 #define JNI_FALSE 0
00147 #define JNI_TRUE 1
00148
00149
00150
00151
00152
00153 #define JNI_OK 0
00154 #define JNI_ERR (-1)
00155 #define JNI_EDETACHED (-2)
00156 #define JNI_EVERSION (-3)
00157 #define JNI_ENOMEM (-4)
00158 #define JNI_EEXIST (-5)
00159 #define JNI_EINVAL (-6)
00160
00161
00162
00163
00164
00165 #define JNI_COMMIT 1
00166 #define JNI_ABORT 2
00167
00168
00169
00170
00171
00172
00173 typedef struct {
00174 char *name;
00175 char *signature;
00176 void *fnPtr;
00177 } JNINativeMethod;
00178
00179
00180
00181
00182
00183 struct JNINativeInterface_;
00184
00185 struct JNIEnv_;
00186
00187 #ifdef __cplusplus
00188 typedef JNIEnv_ JNIEnv;
00189 #else
00190 typedef const struct JNINativeInterface_ *JNIEnv;
00191 #endif
00192
00193
00194
00195
00196
00197 struct JNIInvokeInterface_;
00198
00199 struct JavaVM_;
00200
00201 #ifdef __cplusplus
00202 typedef JavaVM_ JavaVM;
00203 #else
00204 typedef const struct JNIInvokeInterface_ *JavaVM;
00205 #endif
00206
00207 struct JNINativeInterface_ {
00208 void *reserved0;
00209 void *reserved1;
00210 void *reserved2;
00211
00212 void *reserved3;
00213 jint (JNICALL *GetVersion)(JNIEnv *env);
00214
00215 jclass (JNICALL *DefineClass)
00216 (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
00217 jsize len);
00218 jclass (JNICALL *FindClass)
00219 (JNIEnv *env, const char *name);
00220
00221 jmethodID (JNICALL *FromReflectedMethod)
00222 (JNIEnv *env, jobject method);
00223 jfieldID (JNICALL *FromReflectedField)
00224 (JNIEnv *env, jobject field);
00225
00226 jobject (JNICALL *ToReflectedMethod)
00227 (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
00228
00229 jclass (JNICALL *GetSuperclass)
00230 (JNIEnv *env, jclass sub);
00231 jboolean (JNICALL *IsAssignableFrom)
00232 (JNIEnv *env, jclass sub, jclass sup);
00233
00234 jobject (JNICALL *ToReflectedField)
00235 (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
00236
00237 jint (JNICALL *Throw)
00238 (JNIEnv *env, jthrowable obj);
00239 jint (JNICALL *ThrowNew)
00240 (JNIEnv *env, jclass clazz, const char *msg);
00241 jthrowable (JNICALL *ExceptionOccurred)
00242 (JNIEnv *env);
00243 void (JNICALL *ExceptionDescribe)
00244 (JNIEnv *env);
00245 void (JNICALL *ExceptionClear)
00246 (JNIEnv *env);
00247 void (JNICALL *FatalError)
00248 (JNIEnv *env, const char *msg);
00249
00250 jint (JNICALL *PushLocalFrame)
00251 (JNIEnv *env, jint capacity);
00252 jobject (JNICALL *PopLocalFrame)
00253 (JNIEnv *env, jobject result);
00254
00255 jobject (JNICALL *NewGlobalRef)
00256 (JNIEnv *env, jobject lobj);
00257 void (JNICALL *DeleteGlobalRef)
00258 (JNIEnv *env, jobject gref);
00259 void (JNICALL *DeleteLocalRef)
00260 (JNIEnv *env, jobject obj);
00261 jboolean (JNICALL *IsSameObject)
00262 (JNIEnv *env, jobject obj1, jobject obj2);
00263 jobject (JNICALL *NewLocalRef)
00264 (JNIEnv *env, jobject ref);
00265 jint (JNICALL *EnsureLocalCapacity)
00266 (JNIEnv *env, jint capacity);
00267
00268 jobject (JNICALL *AllocObject)
00269 (JNIEnv *env, jclass clazz);
00270 jobject (JNICALL *NewObject)
00271 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00272 jobject (JNICALL *NewObjectV)
00273 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00274 jobject (JNICALL *NewObjectA)
00275 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00276
00277 jclass (JNICALL *GetObjectClass)
00278 (JNIEnv *env, jobject obj);
00279 jboolean (JNICALL *IsInstanceOf)
00280 (JNIEnv *env, jobject obj, jclass clazz);
00281
00282 jmethodID (JNICALL *GetMethodID)
00283 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00284
00285 jobject (JNICALL *CallObjectMethod)
00286 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00287 jobject (JNICALL *CallObjectMethodV)
00288 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00289 jobject (JNICALL *CallObjectMethodA)
00290 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
00291
00292 jboolean (JNICALL *CallBooleanMethod)
00293 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00294 jboolean (JNICALL *CallBooleanMethodV)
00295 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00296 jboolean (JNICALL *CallBooleanMethodA)
00297 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
00298
00299 jbyte (JNICALL *CallByteMethod)
00300 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00301 jbyte (JNICALL *CallByteMethodV)
00302 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00303 jbyte (JNICALL *CallByteMethodA)
00304 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00305
00306 jchar (JNICALL *CallCharMethod)
00307 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00308 jchar (JNICALL *CallCharMethodV)
00309 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00310 jchar (JNICALL *CallCharMethodA)
00311 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00312
00313 jshort (JNICALL *CallShortMethod)
00314 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00315 jshort (JNICALL *CallShortMethodV)
00316 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00317 jshort (JNICALL *CallShortMethodA)
00318 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00319
00320 jint (JNICALL *CallIntMethod)
00321 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00322 jint (JNICALL *CallIntMethodV)
00323 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00324 jint (JNICALL *CallIntMethodA)
00325 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00326
00327 jlong (JNICALL *CallLongMethod)
00328 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00329 jlong (JNICALL *CallLongMethodV)
00330 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00331 jlong (JNICALL *CallLongMethodA)
00332 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00333
00334 jfloat (JNICALL *CallFloatMethod)
00335 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00336 jfloat (JNICALL *CallFloatMethodV)
00337 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00338 jfloat (JNICALL *CallFloatMethodA)
00339 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00340
00341 jdouble (JNICALL *CallDoubleMethod)
00342 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00343 jdouble (JNICALL *CallDoubleMethodV)
00344 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00345 jdouble (JNICALL *CallDoubleMethodA)
00346 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
00347
00348 void (JNICALL *CallVoidMethod)
00349 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
00350 void (JNICALL *CallVoidMethodV)
00351 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
00352 void (JNICALL *CallVoidMethodA)
00353 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
00354
00355 jobject (JNICALL *CallNonvirtualObjectMethod)
00356 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00357 jobject (JNICALL *CallNonvirtualObjectMethodV)
00358 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00359 va_list args);
00360 jobject (JNICALL *CallNonvirtualObjectMethodA)
00361 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00362 jvalue * args);
00363
00364 jboolean (JNICALL *CallNonvirtualBooleanMethod)
00365 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00366 jboolean (JNICALL *CallNonvirtualBooleanMethodV)
00367 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00368 va_list args);
00369 jboolean (JNICALL *CallNonvirtualBooleanMethodA)
00370 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00371 jvalue * args);
00372
00373 jbyte (JNICALL *CallNonvirtualByteMethod)
00374 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00375 jbyte (JNICALL *CallNonvirtualByteMethodV)
00376 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00377 va_list args);
00378 jbyte (JNICALL *CallNonvirtualByteMethodA)
00379 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00380 jvalue *args);
00381
00382 jchar (JNICALL *CallNonvirtualCharMethod)
00383 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00384 jchar (JNICALL *CallNonvirtualCharMethodV)
00385 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00386 va_list args);
00387 jchar (JNICALL *CallNonvirtualCharMethodA)
00388 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00389 jvalue *args);
00390
00391 jshort (JNICALL *CallNonvirtualShortMethod)
00392 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00393 jshort (JNICALL *CallNonvirtualShortMethodV)
00394 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00395 va_list args);
00396 jshort (JNICALL *CallNonvirtualShortMethodA)
00397 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00398 jvalue *args);
00399
00400 jint (JNICALL *CallNonvirtualIntMethod)
00401 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00402 jint (JNICALL *CallNonvirtualIntMethodV)
00403 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00404 va_list args);
00405 jint (JNICALL *CallNonvirtualIntMethodA)
00406 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00407 jvalue *args);
00408
00409 jlong (JNICALL *CallNonvirtualLongMethod)
00410 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00411 jlong (JNICALL *CallNonvirtualLongMethodV)
00412 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00413 va_list args);
00414 jlong (JNICALL *CallNonvirtualLongMethodA)
00415 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00416 jvalue *args);
00417
00418 jfloat (JNICALL *CallNonvirtualFloatMethod)
00419 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00420 jfloat (JNICALL *CallNonvirtualFloatMethodV)
00421 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00422 va_list args);
00423 jfloat (JNICALL *CallNonvirtualFloatMethodA)
00424 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00425 jvalue *args);
00426
00427 jdouble (JNICALL *CallNonvirtualDoubleMethod)
00428 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00429 jdouble (JNICALL *CallNonvirtualDoubleMethodV)
00430 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00431 va_list args);
00432 jdouble (JNICALL *CallNonvirtualDoubleMethodA)
00433 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00434 jvalue *args);
00435
00436 void (JNICALL *CallNonvirtualVoidMethod)
00437 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
00438 void (JNICALL *CallNonvirtualVoidMethodV)
00439 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00440 va_list args);
00441 void (JNICALL *CallNonvirtualVoidMethodA)
00442 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
00443 jvalue * args);
00444
00445 jfieldID (JNICALL *GetFieldID)
00446 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00447
00448 jobject (JNICALL *GetObjectField)
00449 (JNIEnv *env, jobject obj, jfieldID fieldID);
00450 jboolean (JNICALL *GetBooleanField)
00451 (JNIEnv *env, jobject obj, jfieldID fieldID);
00452 jbyte (JNICALL *GetByteField)
00453 (JNIEnv *env, jobject obj, jfieldID fieldID);
00454 jchar (JNICALL *GetCharField)
00455 (JNIEnv *env, jobject obj, jfieldID fieldID);
00456 jshort (JNICALL *GetShortField)
00457 (JNIEnv *env, jobject obj, jfieldID fieldID);
00458 jint (JNICALL *GetIntField)
00459 (JNIEnv *env, jobject obj, jfieldID fieldID);
00460 jlong (JNICALL *GetLongField)
00461 (JNIEnv *env, jobject obj, jfieldID fieldID);
00462 jfloat (JNICALL *GetFloatField)
00463 (JNIEnv *env, jobject obj, jfieldID fieldID);
00464 jdouble (JNICALL *GetDoubleField)
00465 (JNIEnv *env, jobject obj, jfieldID fieldID);
00466
00467 void (JNICALL *SetObjectField)
00468 (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
00469 void (JNICALL *SetBooleanField)
00470 (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
00471 void (JNICALL *SetByteField)
00472 (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
00473 void (JNICALL *SetCharField)
00474 (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
00475 void (JNICALL *SetShortField)
00476 (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
00477 void (JNICALL *SetIntField)
00478 (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
00479 void (JNICALL *SetLongField)
00480 (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
00481 void (JNICALL *SetFloatField)
00482 (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
00483 void (JNICALL *SetDoubleField)
00484 (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
00485
00486 jmethodID (JNICALL *GetStaticMethodID)
00487 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00488
00489 jobject (JNICALL *CallStaticObjectMethod)
00490 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00491 jobject (JNICALL *CallStaticObjectMethodV)
00492 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00493 jobject (JNICALL *CallStaticObjectMethodA)
00494 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00495
00496 jboolean (JNICALL *CallStaticBooleanMethod)
00497 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00498 jboolean (JNICALL *CallStaticBooleanMethodV)
00499 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00500 jboolean (JNICALL *CallStaticBooleanMethodA)
00501 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00502
00503 jbyte (JNICALL *CallStaticByteMethod)
00504 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00505 jbyte (JNICALL *CallStaticByteMethodV)
00506 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00507 jbyte (JNICALL *CallStaticByteMethodA)
00508 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00509
00510 jchar (JNICALL *CallStaticCharMethod)
00511 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00512 jchar (JNICALL *CallStaticCharMethodV)
00513 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00514 jchar (JNICALL *CallStaticCharMethodA)
00515 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00516
00517 jshort (JNICALL *CallStaticShortMethod)
00518 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00519 jshort (JNICALL *CallStaticShortMethodV)
00520 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00521 jshort (JNICALL *CallStaticShortMethodA)
00522 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00523
00524 jint (JNICALL *CallStaticIntMethod)
00525 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00526 jint (JNICALL *CallStaticIntMethodV)
00527 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00528 jint (JNICALL *CallStaticIntMethodA)
00529 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00530
00531 jlong (JNICALL *CallStaticLongMethod)
00532 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00533 jlong (JNICALL *CallStaticLongMethodV)
00534 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00535 jlong (JNICALL *CallStaticLongMethodA)
00536 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00537
00538 jfloat (JNICALL *CallStaticFloatMethod)
00539 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00540 jfloat (JNICALL *CallStaticFloatMethodV)
00541 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00542 jfloat (JNICALL *CallStaticFloatMethodA)
00543 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00544
00545 jdouble (JNICALL *CallStaticDoubleMethod)
00546 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
00547 jdouble (JNICALL *CallStaticDoubleMethodV)
00548 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
00549 jdouble (JNICALL *CallStaticDoubleMethodA)
00550 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
00551
00552 void (JNICALL *CallStaticVoidMethod)
00553 (JNIEnv *env, jclass cls, jmethodID methodID, ...);
00554 void (JNICALL *CallStaticVoidMethodV)
00555 (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
00556 void (JNICALL *CallStaticVoidMethodA)
00557 (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
00558
00559 jfieldID (JNICALL *GetStaticFieldID)
00560 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
00561 jobject (JNICALL *GetStaticObjectField)
00562 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00563 jboolean (JNICALL *GetStaticBooleanField)
00564 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00565 jbyte (JNICALL *GetStaticByteField)
00566 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00567 jchar (JNICALL *GetStaticCharField)
00568 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00569 jshort (JNICALL *GetStaticShortField)
00570 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00571 jint (JNICALL *GetStaticIntField)
00572 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00573 jlong (JNICALL *GetStaticLongField)
00574 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00575 jfloat (JNICALL *GetStaticFloatField)
00576 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00577 jdouble (JNICALL *GetStaticDoubleField)
00578 (JNIEnv *env, jclass clazz, jfieldID fieldID);
00579
00580 void (JNICALL *SetStaticObjectField)
00581 (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
00582 void (JNICALL *SetStaticBooleanField)
00583 (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
00584 void (JNICALL *SetStaticByteField)
00585 (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
00586 void (JNICALL *SetStaticCharField)
00587 (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
00588 void (JNICALL *SetStaticShortField)
00589 (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
00590 void (JNICALL *SetStaticIntField)
00591 (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
00592 void (JNICALL *SetStaticLongField)
00593 (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
00594 void (JNICALL *SetStaticFloatField)
00595 (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
00596 void (JNICALL *SetStaticDoubleField)
00597 (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
00598
00599 jstring (JNICALL *NewString)
00600 (JNIEnv *env, const jchar *unicode, jsize len);
00601 jsize (JNICALL *GetStringLength)
00602 (JNIEnv *env, jstring str);
00603 const jchar *(JNICALL *GetStringChars)
00604 (JNIEnv *env, jstring str, jboolean *isCopy);
00605 void (JNICALL *ReleaseStringChars)
00606 (JNIEnv *env, jstring str, const jchar *chars);
00607
00608 jstring (JNICALL *NewStringUTF)
00609 (JNIEnv *env, const char *utf);
00610 jsize (JNICALL *GetStringUTFLength)
00611 (JNIEnv *env, jstring str);
00612 const char* (JNICALL *GetStringUTFChars)
00613 (JNIEnv *env, jstring str, jboolean *isCopy);
00614 void (JNICALL *ReleaseStringUTFChars)
00615 (JNIEnv *env, jstring str, const char* chars);
00616
00617
00618 jsize (JNICALL *GetArrayLength)
00619 (JNIEnv *env, jarray array);
00620
00621 jobjectArray (JNICALL *NewObjectArray)
00622 (JNIEnv *env, jsize len, jclass clazz, jobject init);
00623 jobject (JNICALL *GetObjectArrayElement)
00624 (JNIEnv *env, jobjectArray array, jsize index);
00625 void (JNICALL *SetObjectArrayElement)
00626 (JNIEnv *env, jobjectArray array, jsize index, jobject val);
00627
00628 jbooleanArray (JNICALL *NewBooleanArray)
00629 (JNIEnv *env, jsize len);
00630 jbyteArray (JNICALL *NewByteArray)
00631 (JNIEnv *env, jsize len);
00632 jcharArray (JNICALL *NewCharArray)
00633 (JNIEnv *env, jsize len);
00634 jshortArray (JNICALL *NewShortArray)
00635 (JNIEnv *env, jsize len);
00636 jintArray (JNICALL *NewIntArray)
00637 (JNIEnv *env, jsize len);
00638 jlongArray (JNICALL *NewLongArray)
00639 (JNIEnv *env, jsize len);
00640 jfloatArray (JNICALL *NewFloatArray)
00641 (JNIEnv *env, jsize len);
00642 jdoubleArray (JNICALL *NewDoubleArray)
00643 (JNIEnv *env, jsize len);
00644
00645 jboolean * (JNICALL *GetBooleanArrayElements)
00646 (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
00647 jbyte * (JNICALL *GetByteArrayElements)
00648 (JNIEnv *env, jbyteArray array, jboolean *isCopy);
00649 jchar * (JNICALL *GetCharArrayElements)
00650 (JNIEnv *env, jcharArray array, jboolean *isCopy);
00651 jshort * (JNICALL *GetShortArrayElements)
00652 (JNIEnv *env, jshortArray array, jboolean *isCopy);
00653 jint * (JNICALL *GetIntArrayElements)
00654 (JNIEnv *env, jintArray array, jboolean *isCopy);
00655 jlong * (JNICALL *GetLongArrayElements)
00656 (JNIEnv *env, jlongArray array, jboolean *isCopy);
00657 jfloat * (JNICALL *GetFloatArrayElements)
00658 (JNIEnv *env, jfloatArray array, jboolean *isCopy);
00659 jdouble * (JNICALL *GetDoubleArrayElements)
00660 (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
00661
00662 void (JNICALL *ReleaseBooleanArrayElements)
00663 (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
00664 void (JNICALL *ReleaseByteArrayElements)
00665 (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
00666 void (JNICALL *ReleaseCharArrayElements)
00667 (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
00668 void (JNICALL *ReleaseShortArrayElements)
00669 (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
00670 void (JNICALL *ReleaseIntArrayElements)
00671 (JNIEnv *env, jintArray array, jint *elems, jint mode);
00672 void (JNICALL *ReleaseLongArrayElements)
00673 (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
00674 void (JNICALL *ReleaseFloatArrayElements)
00675 (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
00676 void (JNICALL *ReleaseDoubleArrayElements)
00677 (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
00678
00679 void (JNICALL *GetBooleanArrayRegion)
00680 (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
00681 void (JNICALL *GetByteArrayRegion)
00682 (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
00683 void (JNICALL *GetCharArrayRegion)
00684 (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
00685 void (JNICALL *GetShortArrayRegion)
00686 (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
00687 void (JNICALL *GetIntArrayRegion)
00688 (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
00689 void (JNICALL *GetLongArrayRegion)
00690 (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
00691 void (JNICALL *GetFloatArrayRegion)
00692 (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
00693 void (JNICALL *GetDoubleArrayRegion)
00694 (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
00695
00696 void (JNICALL *SetBooleanArrayRegion)
00697 (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
00698 void (JNICALL *SetByteArrayRegion)
00699 (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
00700 void (JNICALL *SetCharArrayRegion)
00701 (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
00702 void (JNICALL *SetShortArrayRegion)
00703 (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
00704 void (JNICALL *SetIntArrayRegion)
00705 (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
00706 void (JNICALL *SetLongArrayRegion)
00707 (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
00708 void (JNICALL *SetFloatArrayRegion)
00709 (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
00710 void (JNICALL *SetDoubleArrayRegion)
00711 (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
00712
00713 jint (JNICALL *RegisterNatives)
00714 (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
00715 jint nMethods);
00716 jint (JNICALL *UnregisterNatives)
00717 (JNIEnv *env, jclass clazz);
00718
00719 jint (JNICALL *MonitorEnter)
00720 (JNIEnv *env, jobject obj);
00721 jint (JNICALL *MonitorExit)
00722 (JNIEnv *env, jobject obj);
00723
00724 jint (JNICALL *GetJavaVM)
00725 (JNIEnv *env, JavaVM **vm);
00726
00727 void (JNICALL *GetStringRegion)
00728 (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
00729 void (JNICALL *GetStringUTFRegion)
00730 (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
00731
00732 void * (JNICALL *GetPrimitiveArrayCritical)
00733 (JNIEnv *env, jarray array, jboolean *isCopy);
00734 void (JNICALL *ReleasePrimitiveArrayCritical)
00735 (JNIEnv *env, jarray array, void *carray, jint mode);
00736
00737 const jchar * (JNICALL *GetStringCritical)
00738 (JNIEnv *env, jstring string, jboolean *isCopy);
00739 void (JNICALL *ReleaseStringCritical)
00740 (JNIEnv *env, jstring string, const jchar *cstring);
00741
00742 jweak (JNICALL *NewWeakGlobalRef)
00743 (JNIEnv *env, jobject obj);
00744 void (JNICALL *DeleteWeakGlobalRef)
00745 (JNIEnv *env, jweak ref);
00746
00747 jboolean (JNICALL *ExceptionCheck)
00748 (JNIEnv *env);
00749
00750 jobject (JNICALL *NewDirectByteBuffer)
00751 (JNIEnv* env, void* address, jlong capacity);
00752 void* (JNICALL *GetDirectBufferAddress)
00753 (JNIEnv* env, jobject buf);
00754 jlong (JNICALL *GetDirectBufferCapacity)
00755 (JNIEnv* env, jobject buf);
00756 };
00757
00758
00759
00760
00761
00762
00763
00764
00765
00766
00767
00768
00769
00770 struct JNIEnv_ {
00771 const struct JNINativeInterface_ *functions;
00772 #ifdef __cplusplus
00773
00774 jint GetVersion() {
00775 return functions->GetVersion(this);
00776 }
00777 jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
00778 jsize len) {
00779 return functions->DefineClass(this, name, loader, buf, len);
00780 }
00781 jclass FindClass(const char *name) {
00782 return functions->FindClass(this, name);
00783 }
00784 jmethodID FromReflectedMethod(jobject method) {
00785 return functions->FromReflectedMethod(this,method);
00786 }
00787 jfieldID FromReflectedField(jobject field) {
00788 return functions->FromReflectedField(this,field);
00789 }
00790
00791 jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
00792 return functions->ToReflectedMethod(this, cls, methodID, isStatic);
00793 }
00794
00795 jclass GetSuperclass(jclass sub) {
00796 return functions->GetSuperclass(this, sub);
00797 }
00798 jboolean IsAssignableFrom(jclass sub, jclass sup) {
00799 return functions->IsAssignableFrom(this, sub, sup);
00800 }
00801
00802 jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
00803 return functions->ToReflectedField(this,cls,fieldID,isStatic);
00804 }
00805
00806 jint Throw(jthrowable obj) {
00807 return functions->Throw(this, obj);
00808 }
00809 jint ThrowNew(jclass clazz, const char *msg) {
00810 return functions->ThrowNew(this, clazz, msg);
00811 }
00812 jthrowable ExceptionOccurred() {
00813 return functions->ExceptionOccurred(this);
00814 }
00815 void ExceptionDescribe() {
00816 functions->ExceptionDescribe(this);
00817 }
00818 void ExceptionClear() {
00819 functions->ExceptionClear(this);
00820 }
00821 void FatalError(const char *msg) {
00822 functions->FatalError(this, msg);
00823 }
00824
00825 jint PushLocalFrame(jint capacity) {
00826 return functions->PushLocalFrame(this,capacity);
00827 }
00828 jobject PopLocalFrame(jobject result) {
00829 return functions->PopLocalFrame(this,result);
00830 }
00831
00832 jobject NewGlobalRef(jobject lobj) {
00833 return functions->NewGlobalRef(this,lobj);
00834 }
00835 void DeleteGlobalRef(jobject gref) {
00836 functions->DeleteGlobalRef(this,gref);
00837 }
00838 void DeleteLocalRef(jobject obj) {
00839 functions->DeleteLocalRef(this, obj);
00840 }
00841
00842 jboolean IsSameObject(jobject obj1, jobject obj2) {
00843 return functions->IsSameObject(this,obj1,obj2);
00844 }
00845
00846 jobject NewLocalRef(jobject ref) {
00847 return functions->NewLocalRef(this,ref);
00848 }
00849 jint EnsureLocalCapacity(jint capacity) {
00850 return functions->EnsureLocalCapacity(this,capacity);
00851 }
00852
00853 jobject AllocObject(jclass clazz) {
00854 return functions->AllocObject(this,clazz);
00855 }
00856 jobject NewObject(jclass clazz, jmethodID methodID, ...) {
00857 va_list args;
00858 jobject result;
00859 va_start(args, methodID);
00860 result = functions->NewObjectV(this,clazz,methodID,args);
00861 va_end(args);
00862 return result;
00863 }
00864 jobject NewObjectV(jclass clazz, jmethodID methodID,
00865 va_list args) {
00866 return functions->NewObjectV(this,clazz,methodID,args);
00867 }
00868 jobject NewObjectA(jclass clazz, jmethodID methodID,
00869 jvalue *args) {
00870 return functions->NewObjectA(this,clazz,methodID,args);
00871 }
00872
00873 jclass GetObjectClass(jobject obj) {
00874 return functions->GetObjectClass(this,obj);
00875 }
00876 jboolean IsInstanceOf(jobject obj, jclass clazz) {
00877 return functions->IsInstanceOf(this,obj,clazz);
00878 }
00879
00880 jmethodID GetMethodID(jclass clazz, const char *name,
00881 const char *sig) {
00882 return functions->GetMethodID(this,clazz,name,sig);
00883 }
00884
00885 jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
00886 va_list args;
00887 jobject result;
00888 va_start(args,methodID);
00889 result = functions->CallObjectMethodV(this,obj,methodID,args);
00890 va_end(args);
00891 return result;
00892 }
00893 jobject CallObjectMethodV(jobject obj, jmethodID methodID,
00894 va_list args) {
00895 return functions->CallObjectMethodV(this,obj,methodID,args);
00896 }
00897 jobject CallObjectMethodA(jobject obj, jmethodID methodID,
00898 jvalue * args) {
00899 return functions->CallObjectMethodA(this,obj,methodID,args);
00900 }
00901
00902 jboolean CallBooleanMethod(jobject obj,
00903 jmethodID methodID, ...) {
00904 va_list args;
00905 jboolean result;
00906 va_start(args,methodID);
00907 result = functions->CallBooleanMethodV(this,obj,methodID,args);
00908 va_end(args);
00909 return result;
00910 }
00911 jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
00912 va_list args) {
00913 return functions->CallBooleanMethodV(this,obj,methodID,args);
00914 }
00915 jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
00916 jvalue * args) {
00917 return functions->CallBooleanMethodA(this,obj,methodID, args);
00918 }
00919
00920 jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
00921 va_list args;
00922 jbyte result;
00923 va_start(args,methodID);
00924 result = functions->CallByteMethodV(this,obj,methodID,args);
00925 va_end(args);
00926 return result;
00927 }
00928 jbyte CallByteMethodV(jobject obj, jmethodID methodID,
00929 va_list args) {
00930 return functions->CallByteMethodV(this,obj,methodID,args);
00931 }
00932 jbyte CallByteMethodA(jobject obj, jmethodID methodID,
00933 jvalue * args) {
00934 return functions->CallByteMethodA(this,obj,methodID,args);
00935 }
00936
00937 jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
00938 va_list args;
00939 jchar result;
00940 va_start(args,methodID);
00941 result = functions->CallCharMethodV(this,obj,methodID,args);
00942 va_end(args);
00943 return result;
00944 }
00945 jchar CallCharMethodV(jobject obj, jmethodID methodID,
00946 va_list args) {
00947 return functions->CallCharMethodV(this,obj,methodID,args);
00948 }
00949 jchar CallCharMethodA(jobject obj, jmethodID methodID,
00950 jvalue * args) {
00951 return functions->CallCharMethodA(this,obj,methodID,args);
00952 }
00953
00954 jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
00955 va_list args;
00956 jshort result;
00957 va_start(args,methodID);
00958 result = functions->CallShortMethodV(this,obj,methodID,args);
00959 va_end(args);
00960 return result;
00961 }
00962 jshort CallShortMethodV(jobject obj, jmethodID methodID,
00963 va_list args) {
00964 return functions->CallShortMethodV(this,obj,methodID,args);
00965 }
00966 jshort CallShortMethodA(jobject obj, jmethodID methodID,
00967 jvalue * args) {
00968 return functions->CallShortMethodA(this,obj,methodID,args);
00969 }
00970
00971 jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
00972 va_list args;
00973 jint result;
00974 va_start(args,methodID);
00975 result = functions->CallIntMethodV(this,obj,methodID,args);
00976 va_end(args);
00977 return result;
00978 }
00979 jint CallIntMethodV(jobject obj, jmethodID methodID,
00980 va_list args) {
00981 return functions->CallIntMethodV(this,obj,methodID,args);
00982 }
00983 jint CallIntMethodA(jobject obj, jmethodID methodID,
00984 jvalue * args) {
00985 return functions->CallIntMethodA(this,obj,methodID,args);
00986 }
00987
00988 jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
00989 va_list args;
00990 jlong result;
00991 va_start(args,methodID);
00992 result = functions->CallLongMethodV(this,obj,methodID,args);
00993 va_end(args);
00994 return result;
00995 }
00996 jlong CallLongMethodV(jobject obj, jmethodID methodID,
00997 va_list args) {
00998 return functions->CallLongMethodV(this,obj,methodID,args);
00999 }
01000 jlong CallLongMethodA(jobject obj, jmethodID methodID,
01001 jvalue * args) {
01002 return functions->CallLongMethodA(this,obj,methodID,args);
01003 }
01004
01005 jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
01006 va_list args;
01007 jfloat result;
01008 va_start(args,methodID);
01009 result = functions->CallFloatMethodV(this,obj,methodID,args);
01010 va_end(args);
01011 return result;
01012 }
01013 jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
01014 va_list args) {
01015 return functions->CallFloatMethodV(this,obj,methodID,args);
01016 }
01017 jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
01018 jvalue * args) {
01019 return functions->CallFloatMethodA(this,obj,methodID,args);
01020 }
01021
01022 jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
01023 va_list args;
01024 jdouble result;
01025 va_start(args,methodID);
01026 result = functions->CallDoubleMethodV(this,obj,methodID,args);
01027 va_end(args);
01028 return result;
01029 }
01030 jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
01031 va_list args) {
01032 return functions->CallDoubleMethodV(this,obj,methodID,args);
01033 }
01034 jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
01035 jvalue * args) {
01036 return functions->CallDoubleMethodA(this,obj,methodID,args);
01037 }
01038
01039 void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
01040 va_list args;
01041 va_start(args,methodID);
01042 functions->CallVoidMethodV(this,obj,methodID,args);
01043 va_end(args);
01044 }
01045 void CallVoidMethodV(jobject obj, jmethodID methodID,
01046 va_list args) {
01047 functions->CallVoidMethodV(this,obj,methodID,args);
01048 }
01049 void CallVoidMethodA(jobject obj, jmethodID methodID,
01050 jvalue * args) {
01051 functions->CallVoidMethodA(this,obj,methodID,args);
01052 }
01053
01054 jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
01055 jmethodID methodID, ...) {
01056 va_list args;
01057 jobject result;
01058 va_start(args,methodID);
01059 result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
01060 methodID,args);
01061 va_end(args);
01062 return result;
01063 }
01064 jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
01065 jmethodID methodID, va_list args) {
01066 return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
01067 methodID,args);
01068 }
01069 jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
01070 jmethodID methodID, jvalue * args) {
01071 return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
01072 methodID,args);
01073 }
01074
01075 jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
01076 jmethodID methodID, ...) {
01077 va_list args;
01078 jboolean result;
01079 va_start(args,methodID);
01080 result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
01081 methodID,args);
01082 va_end(args);
01083 return result;
01084 }
01085 jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
01086 jmethodID methodID, va_list args) {
01087 return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
01088 methodID,args);
01089 }
01090 jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
01091 jmethodID methodID, jvalue * args) {
01092 return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
01093 methodID, args);
01094 }
01095
01096 jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
01097 jmethodID methodID, ...) {
01098 va_list args;
01099 jbyte result;
01100 va_start(args,methodID);
01101 result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
01102 methodID,args);
01103 va_end(args);
01104 return result;
01105 }
01106 jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
01107 jmethodID methodID, va_list args) {
01108 return functions->CallNonvirtualByteMethodV(this,obj,clazz,
01109 methodID,args);
01110 }
01111 jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
01112 jmethodID methodID, jvalue * args) {
01113 return functions->CallNonvirtualByteMethodA(this,obj,clazz,
01114 methodID,args);
01115 }
01116
01117 jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
01118 jmethodID methodID, ...) {
01119 va_list args;
01120 jchar result;
01121 va_start(args,methodID);
01122 result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
01123 methodID,args);
01124 va_end(args);
01125 return result;
01126 }
01127 jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
01128 jmethodID methodID, va_list args) {
01129 return functions->CallNonvirtualCharMethodV(this,obj,clazz,
01130 methodID,args);
01131 }
01132 jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
01133 jmethodID methodID, jvalue * args) {
01134 return functions->CallNonvirtualCharMethodA(this,obj,clazz,
01135 methodID,args);
01136 }
01137
01138 jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
01139 jmethodID methodID, ...) {
01140 va_list args;
01141 jshort result;
01142 va_start(args,methodID);
01143 result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
01144 methodID,args);
01145 va_end(args);
01146 return result;
01147 }
01148 jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
01149 jmethodID methodID, va_list args) {
01150 return functions->CallNonvirtualShortMethodV(this,obj,clazz,
01151 methodID,args);
01152 }
01153 jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
01154 jmethodID methodID, jvalue * args) {
01155 return functions->CallNonvirtualShortMethodA(this,obj,clazz,
01156 methodID,args);
01157 }
01158
01159 jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
01160 jmethodID methodID, ...) {
01161 va_list args;
01162 jint result;
01163 va_start(args,methodID);
01164 result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
01165 methodID,args);
01166 va_end(args);
01167 return result;
01168 }
01169 jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
01170 jmethodID methodID, va_list args) {
01171 return functions->CallNonvirtualIntMethodV(this,obj,clazz,
01172 methodID,args);
01173 }
01174 jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
01175 jmethodID methodID, jvalue * args) {
01176 return functions->CallNonvirtualIntMethodA(this,obj,clazz,
01177 methodID,args);
01178 }
01179
01180 jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
01181 jmethodID methodID, ...) {
01182 va_list args;
01183 jlong result;
01184 va_start(args,methodID);
01185 result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
01186 methodID,args);
01187 va_end(args);
01188 return result;
01189 }
01190 jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
01191 jmethodID methodID, va_list args) {
01192 return functions->CallNonvirtualLongMethodV(this,obj,clazz,
01193 methodID,args);
01194 }
01195 jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
01196 jmethodID methodID, jvalue * args) {
01197 return functions->CallNonvirtualLongMethodA(this,obj,clazz,
01198 methodID,args);
01199 }
01200
01201 jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
01202 jmethodID methodID, ...) {
01203 va_list args;
01204 jfloat result;
01205 va_start(args,methodID);
01206 result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
01207 methodID,args);
01208 va_end(args);
01209 return result;
01210 }
01211 jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
01212 jmethodID methodID,
01213 va_list args) {
01214 return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
01215 methodID,args);
01216 }
01217 jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
01218 jmethodID methodID,
01219 jvalue * args) {
01220 return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
01221 methodID,args);
01222 }
01223
01224 jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
01225 jmethodID methodID, ...) {
01226 va_list args;
01227 jdouble result;
01228 va_start(args,methodID);
01229 result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
01230 methodID,args);
01231 va_end(args);
01232 return result;
01233 }
01234 jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
01235 jmethodID methodID,
01236 va_list args) {
01237 return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
01238 methodID,args);
01239 }
01240 jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
01241 jmethodID methodID,
01242 jvalue * args) {
01243 return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
01244 methodID,args);
01245 }
01246
01247 void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
01248 jmethodID methodID, ...) {
01249 va_list args;
01250 va_start(args,methodID);
01251 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
01252 va_end(args);
01253 }
01254 void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
01255 jmethodID methodID,
01256 va_list args) {
01257 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
01258 }
01259 void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
01260 jmethodID methodID,
01261 jvalue * args) {
01262 functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
01263 }
01264
01265 jfieldID GetFieldID(jclass clazz, const char *name,
01266 const char *sig) {
01267 return functions->GetFieldID(this,clazz,name,sig);
01268 }
01269
01270 jobject GetObjectField(jobject obj, jfieldID fieldID) {
01271 return functions->GetObjectField(this,obj,fieldID);
01272 }
01273 jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
01274 return functions->GetBooleanField(this,obj,fieldID);
01275 }
01276 jbyte GetByteField(jobject obj, jfieldID fieldID) {
01277 return functions->GetByteField(this,obj,fieldID);
01278 }
01279 jchar GetCharField(jobject obj, jfieldID fieldID) {
01280 return functions->GetCharField(this,obj,fieldID);
01281 }
01282 jshort GetShortField(jobject obj, jfieldID fieldID) {
01283 return functions->GetShortField(this,obj,fieldID);
01284 }
01285 jint GetIntField(jobject obj, jfieldID fieldID) {
01286 return functions->GetIntField(this,obj,fieldID);
01287 }
01288 jlong GetLongField(jobject obj, jfieldID fieldID) {
01289 return functions->GetLongField(this,obj,fieldID);
01290 }
01291 jfloat GetFloatField(jobject obj, jfieldID fieldID) {
01292 return functions->GetFloatField(this,obj,fieldID);
01293 }
01294 jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
01295 return functions->GetDoubleField(this,obj,fieldID);
01296 }
01297
01298 void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
01299 functions->SetObjectField(this,obj,fieldID,val);
01300 }
01301 void SetBooleanField(jobject obj, jfieldID fieldID,
01302 jboolean val) {
01303 functions->SetBooleanField(this,obj,fieldID,val);
01304 }
01305 void SetByteField(jobject obj, jfieldID fieldID,
01306 jbyte val) {
01307 functions->SetByteField(this,obj,fieldID,val);
01308 }
01309 void SetCharField(jobject obj, jfieldID fieldID,
01310 jchar val) {
01311 functions->SetCharField(this,obj,fieldID,val);
01312 }
01313 void SetShortField(jobject obj, jfieldID fieldID,
01314 jshort val) {
01315 functions->SetShortField(this,obj,fieldID,val);
01316 }
01317 void SetIntField(jobject obj, jfieldID fieldID,
01318 jint val) {
01319 functions->SetIntField(this,obj,fieldID,val);
01320 }
01321 void SetLongField(jobject obj, jfieldID fieldID,
01322 jlong val) {
01323 functions->SetLongField(this,obj,fieldID,val);
01324 }
01325 void SetFloatField(jobject obj, jfieldID fieldID,
01326 jfloat val) {
01327 functions->SetFloatField(this,obj,fieldID,val);
01328 }
01329 void SetDoubleField(jobject obj, jfieldID fieldID,
01330 jdouble val) {
01331 functions->SetDoubleField(this,obj,fieldID,val);
01332 }
01333
01334 jmethodID GetStaticMethodID(jclass clazz, const char *name,
01335 const char *sig) {
01336 return functions->GetStaticMethodID(this,clazz,name,sig);
01337 }
01338
01339 jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
01340 ...) {
01341 va_list args;
01342 jobject result;
01343 va_start(args,methodID);
01344 result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
01345 va_end(args);
01346 return result;
01347 }
01348 jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
01349 va_list args) {
01350 return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
01351 }
01352 jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
01353 jvalue *args) {
01354 return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
01355 }
01356
01357 jboolean CallStaticBooleanMethod(jclass clazz,
01358 jmethodID methodID, ...) {
01359 va_list args;
01360 jboolean result;
01361 va_start(args,methodID);
01362 result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
01363 va_end(args);
01364 return result;
01365 }
01366 jboolean CallStaticBooleanMethodV(jclass clazz,
01367 jmethodID methodID, va_list args) {
01368 return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
01369 }
01370 jboolean CallStaticBooleanMethodA(jclass clazz,
01371 jmethodID methodID, jvalue *args) {
01372 return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
01373 }
01374
01375 jbyte CallStaticByteMethod(jclass clazz,
01376 jmethodID methodID, ...) {
01377 va_list args;
01378 jbyte result;
01379 va_start(args,methodID);
01380 result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
01381 va_end(args);
01382 return result;
01383 }
01384 jbyte CallStaticByteMethodV(jclass clazz,
01385 jmethodID methodID, va_list args) {
01386 return functions->CallStaticByteMethodV(this,clazz,methodID,args);
01387 }
01388 jbyte CallStaticByteMethodA(jclass clazz,
01389 jmethodID methodID, jvalue *args) {
01390 return functions->CallStaticByteMethodA(this,clazz,methodID,args);
01391 }
01392
01393 jchar CallStaticCharMethod(jclass clazz,
01394 jmethodID methodID, ...) {
01395 va_list args;
01396 jchar result;
01397 va_start(args,methodID);
01398 result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
01399 va_end(args);
01400 return result;
01401 }
01402 jchar CallStaticCharMethodV(jclass clazz,
01403 jmethodID methodID, va_list args) {
01404 return functions->CallStaticCharMethodV(this,clazz,methodID,args);
01405 }
01406 jchar CallStaticCharMethodA(jclass clazz,
01407 jmethodID methodID, jvalue *args) {
01408 return functions->CallStaticCharMethodA(this,clazz,methodID,args);
01409 }
01410
01411 jshort CallStaticShortMethod(jclass clazz,
01412 jmethodID methodID, ...) {
01413 va_list args;
01414 jshort result;
01415 va_start(args,methodID);
01416 result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
01417 va_end(args);
01418 return result;
01419 }
01420 jshort CallStaticShortMethodV(jclass clazz,
01421 jmethodID methodID, va_list args) {
01422 return functions->CallStaticShortMethodV(this,clazz,methodID,args);
01423 }
01424 jshort CallStaticShortMethodA(jclass clazz,
01425 jmethodID methodID, jvalue *args) {
01426 return functions->CallStaticShortMethodA(this,clazz,methodID,args);
01427 }
01428
01429 jint CallStaticIntMethod(jclass clazz,
01430 jmethodID methodID, ...) {
01431 va_list args;
01432 jint result;
01433 va_start(args,methodID);
01434 result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
01435 va_end(args);
01436 return result;
01437 }
01438 jint CallStaticIntMethodV(jclass clazz,
01439 jmethodID methodID, va_list args) {
01440 return functions->CallStaticIntMethodV(this,clazz,methodID,args);
01441 }
01442 jint CallStaticIntMethodA(jclass clazz,
01443 jmethodID methodID, jvalue *args) {
01444 return functions->CallStaticIntMethodA(this,clazz,methodID,args);
01445 }
01446
01447 jlong CallStaticLongMethod(jclass clazz,
01448 jmethodID methodID, ...) {
01449 va_list args;
01450 jlong result;
01451 va_start(args,methodID);
01452 result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
01453 va_end(args);
01454 return result;
01455 }
01456 jlong CallStaticLongMethodV(jclass clazz,
01457 jmethodID methodID, va_list args) {
01458 return functions->CallStaticLongMethodV(this,clazz,methodID,args);
01459 }
01460 jlong CallStaticLongMethodA(jclass clazz,
01461 jmethodID methodID, jvalue *args) {
01462 return functions->CallStaticLongMethodA(this,clazz,methodID,args);
01463 }
01464
01465 jfloat CallStaticFloatMethod(jclass clazz,
01466 jmethodID methodID, ...) {
01467 va_list args;
01468 jfloat result;
01469 va_start(args,methodID);
01470 result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
01471 va_end(args);
01472 return result;
01473 }
01474 jfloat CallStaticFloatMethodV(jclass clazz,
01475 jmethodID methodID, va_list args) {
01476 return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
01477 }
01478 jfloat CallStaticFloatMethodA(jclass clazz,
01479 jmethodID methodID, jvalue *args) {
01480 return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
01481 }
01482
01483 jdouble CallStaticDoubleMethod(jclass clazz,
01484 jmethodID methodID, ...) {
01485 va_list args;
01486 jdouble result;
01487 va_start(args,methodID);
01488 result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
01489 va_end(args);
01490 return result;
01491 }
01492 jdouble CallStaticDoubleMethodV(jclass clazz,
01493 jmethodID methodID, va_list args) {
01494 return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
01495 }
01496 jdouble CallStaticDoubleMethodA(jclass clazz,
01497 jmethodID methodID, jvalue *args) {
01498 return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
01499 }
01500
01501 void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
01502 va_list args;
01503 va_start(args,methodID);
01504 functions->CallStaticVoidMethodV(this,cls,methodID,args);
01505 va_end(args);
01506 }
01507 void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
01508 va_list args) {
01509 functions->CallStaticVoidMethodV(this,cls,methodID,args);
01510 }
01511 void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
01512 jvalue * args) {
01513 functions->CallStaticVoidMethodA(this,cls,methodID,args);
01514 }
01515
01516 jfieldID GetStaticFieldID(jclass clazz, const char *name,
01517 const char *sig) {
01518 return functions->GetStaticFieldID(this,clazz,name,sig);
01519 }
01520 jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
01521 return functions->GetStaticObjectField(this,clazz,fieldID);
01522 }
01523 jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
01524 return functions->GetStaticBooleanField(this,clazz,fieldID);
01525 }
01526 jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
01527 return functions->GetStaticByteField(this,clazz,fieldID);
01528 }
01529 jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
01530 return functions->GetStaticCharField(this,clazz,fieldID);
01531 }
01532 jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
01533 return functions->GetStaticShortField(this,clazz,fieldID);
01534 }
01535 jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
01536 return functions->GetStaticIntField(this,clazz,fieldID);
01537 }
01538 jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
01539 return functions->GetStaticLongField(this,clazz,fieldID);
01540 }
01541 jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
01542 return functions->GetStaticFloatField(this,clazz,fieldID);
01543 }
01544 jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
01545 return functions->GetStaticDoubleField(this,clazz,fieldID);
01546 }
01547
01548 void SetStaticObjectField(jclass clazz, jfieldID fieldID,
01549 jobject value) {
01550 functions->SetStaticObjectField(this,clazz,fieldID,value);
01551 }
01552 void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
01553 jboolean value) {
01554 functions->SetStaticBooleanField(this,clazz,fieldID,value);
01555 }
01556 void SetStaticByteField(jclass clazz, jfieldID fieldID,
01557 jbyte value) {
01558 functions->SetStaticByteField(this,clazz,fieldID,value);
01559 }
01560 void SetStaticCharField(jclass clazz, jfieldID fieldID,
01561 jchar value) {
01562 functions->SetStaticCharField(this,clazz,fieldID,value);
01563 }
01564 void SetStaticShortField(jclass clazz, jfieldID fieldID,
01565 jshort value) {
01566 functions->SetStaticShortField(this,clazz,fieldID,value);
01567 }
01568 void SetStaticIntField(jclass clazz, jfieldID fieldID,
01569 jint value) {
01570 functions->SetStaticIntField(this,clazz,fieldID,value);
01571 }
01572 void SetStaticLongField(jclass clazz, jfieldID fieldID,
01573 jlong value) {
01574 functions->SetStaticLongField(this,clazz,fieldID,value);
01575 }
01576 void SetStaticFloatField(jclass clazz, jfieldID fieldID,
01577 jfloat value) {
01578 functions->SetStaticFloatField(this,clazz,fieldID,value);
01579 }
01580 void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
01581 jdouble value) {
01582 functions->SetStaticDoubleField(this,clazz,fieldID,value);
01583 }
01584
01585 jstring NewString(const jchar *unicode, jsize len) {
01586 return functions->NewString(this,unicode,len);
01587 }
01588 jsize GetStringLength(jstring str) {
01589 return functions->GetStringLength(this,str);
01590 }
01591 const jchar *GetStringChars(jstring str, jboolean *isCopy) {
01592 return functions->GetStringChars(this,str,isCopy);
01593 }
01594 void ReleaseStringChars(jstring str, const jchar *chars) {
01595 functions->ReleaseStringChars(this,str,chars);
01596 }
01597
01598 jstring NewStringUTF(const char *utf) {
01599 return functions->NewStringUTF(this,utf);
01600 }
01601 jsize GetStringUTFLength(jstring str) {
01602 return functions->GetStringUTFLength(this,str);
01603 }
01604 const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
01605 return functions->GetStringUTFChars(this,str,isCopy);
01606 }
01607 void ReleaseStringUTFChars(jstring str, const char* chars) {
01608 functions->ReleaseStringUTFChars(this,str,chars);
01609 }
01610
01611 jsize GetArrayLength(jarray array) {
01612 return functions->GetArrayLength(this,array);
01613 }
01614
01615 jobjectArray NewObjectArray(jsize len, jclass clazz,
01616 jobject init) {
01617 return functions->NewObjectArray(this,len,clazz,init);
01618 }
01619 jobject GetObjectArrayElement(jobjectArray array, jsize index) {
01620 return functions->GetObjectArrayElement(this,array,index);
01621 }
01622 void SetObjectArrayElement(jobjectArray array, jsize index,
01623 jobject val) {
01624 functions->SetObjectArrayElement(this,array,index,val);
01625 }
01626
01627 jbooleanArray NewBooleanArray(jsize len) {
01628 return functions->NewBooleanArray(this,len);
01629 }
01630 jbyteArray NewByteArray(jsize len) {
01631 return functions->NewByteArray(this,len);
01632 }
01633 jcharArray NewCharArray(jsize len) {
01634 return functions->NewCharArray(this,len);
01635 }
01636 jshortArray NewShortArray(jsize len) {
01637 return functions->NewShortArray(this,len);
01638 }
01639 jintArray NewIntArray(jsize len) {
01640 return functions->NewIntArray(this,len);
01641 }
01642 jlongArray NewLongArray(jsize len) {
01643 return functions->NewLongArray(this,len);
01644 }
01645 jfloatArray NewFloatArray(jsize len) {
01646 return functions->NewFloatArray(this,len);
01647 }
01648 jdoubleArray NewDoubleArray(jsize len) {
01649 return functions->NewDoubleArray(this,len);
01650 }
01651
01652 jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
01653 return functions->GetBooleanArrayElements(this,array,isCopy);
01654 }
01655 jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
01656 return functions->GetByteArrayElements(this,array,isCopy);
01657 }
01658 jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
01659 return functions->GetCharArrayElements(this,array,isCopy);
01660 }
01661 jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
01662 return functions->GetShortArrayElements(this,array,isCopy);
01663 }
01664 jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
01665 return functions->GetIntArrayElements(this,array,isCopy);
01666 }
01667 jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
01668 return functions->GetLongArrayElements(this,array,isCopy);
01669 }
01670 jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
01671 return functions->GetFloatArrayElements(this,array,isCopy);
01672 }
01673 jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
01674 return functions->GetDoubleArrayElements(this,array,isCopy);
01675 }
01676
01677 void ReleaseBooleanArrayElements(jbooleanArray array,
01678 jboolean *elems,
01679 jint mode) {
01680 functions->ReleaseBooleanArrayElements(this,array,elems,mode);
01681 }
01682 void ReleaseByteArrayElements(jbyteArray array,
01683 jbyte *elems,
01684 jint mode) {
01685 functions->ReleaseByteArrayElements(this,array,elems,mode);
01686 }
01687 void ReleaseCharArrayElements(jcharArray array,
01688 jchar *elems,
01689 jint mode) {
01690 functions->ReleaseCharArrayElements(this,array,elems,mode);
01691 }
01692 void ReleaseShortArrayElements(jshortArray array,
01693 jshort *elems,
01694 jint mode) {
01695 functions->ReleaseShortArrayElements(this,array,elems,mode);
01696 }
01697 void ReleaseIntArrayElements(jintArray array,
01698 jint *elems,
01699 jint mode) {
01700 functions->ReleaseIntArrayElements(this,array,elems,mode);
01701 }
01702 void ReleaseLongArrayElements(jlongArray array,
01703 jlong *elems,
01704 jint mode) {
01705 functions->ReleaseLongArrayElements(this,array,elems,mode);
01706 }
01707 void ReleaseFloatArrayElements(jfloatArray array,
01708 jfloat *elems,
01709 jint mode) {
01710 functions->ReleaseFloatArrayElements(this,array,elems,mode);
01711 }
01712 void ReleaseDoubleArrayElements(jdoubleArray array,
01713 jdouble *elems,
01714 jint mode) {
01715 functions->ReleaseDoubleArrayElements(this,array,elems,mode);
01716 }
01717
01718 void GetBooleanArrayRegion(jbooleanArray array,
01719 jsize start, jsize len, jboolean *buf) {
01720 functions->GetBooleanArrayRegion(this,array,start,len,buf);
01721 }
01722 void GetByteArrayRegion(jbyteArray array,
01723 jsize start, jsize len, jbyte *buf) {
01724 functions->GetByteArrayRegion(this,array,start,len,buf);
01725 }
01726 void GetCharArrayRegion(jcharArray array,
01727 jsize start, jsize len, jchar *buf) {
01728 functions->GetCharArrayRegion(this,array,start,len,buf);
01729 }
01730 void GetShortArrayRegion(jshortArray array,
01731 jsize start, jsize len, jshort *buf) {
01732 functions->GetShortArrayRegion(this,array,start,len,buf);
01733 }
01734 void GetIntArrayRegion(jintArray array,
01735 jsize start, jsize len, jint *buf) {
01736 functions->GetIntArrayRegion(this,array,start,len,buf);
01737 }
01738 void GetLongArrayRegion(jlongArray array,
01739 jsize start, jsize len, jlong *buf) {
01740 functions->GetLongArrayRegion(this,array,start,len,buf);
01741 }
01742 void GetFloatArrayRegion(jfloatArray array,
01743 jsize start, jsize len, jfloat *buf) {
01744 functions->GetFloatArrayRegion(this,array,start,len,buf);
01745 }
01746 void GetDoubleArrayRegion(jdoubleArray array,
01747 jsize start, jsize len, jdouble *buf) {
01748 functions->GetDoubleArrayRegion(this,array,start,len,buf);
01749 }
01750
01751 void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
01752 jboolean *buf) {
01753 functions->SetBooleanArrayRegion(this,array,start,len,buf);
01754 }
01755 void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
01756 jbyte *buf) {
01757 functions->SetByteArrayRegion(this,array,start,len,buf);
01758 }
01759 void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
01760 jchar *buf) {
01761 functions->SetCharArrayRegion(this,array,start,len,buf);
01762 }
01763 void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
01764 jshort *buf) {
01765 functions->SetShortArrayRegion(this,array,start,len,buf);
01766 }
01767 void SetIntArrayRegion(jintArray array, jsize start, jsize len,
01768 jint *buf) {
01769 functions->SetIntArrayRegion(this,array,start,len,buf);
01770 }
01771 void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
01772 jlong *buf) {
01773 functions->SetLongArrayRegion(this,array,start,len,buf);
01774 }
01775 void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
01776 jfloat *buf) {
01777 functions->SetFloatArrayRegion(this,array,start,len,buf);
01778 }
01779 void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
01780 jdouble *buf) {
01781 functions->SetDoubleArrayRegion(this,array,start,len,buf);
01782 }
01783
01784 jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
01785 jint nMethods) {
01786 return functions->RegisterNatives(this,clazz,methods,nMethods);
01787 }
01788 jint UnregisterNatives(jclass clazz) {
01789 return functions->UnregisterNatives(this,clazz);
01790 }
01791
01792 jint MonitorEnter(jobject obj) {
01793 return functions->MonitorEnter(this,obj);
01794 }
01795 jint MonitorExit(jobject obj) {
01796 return functions->MonitorExit(this,obj);
01797 }
01798
01799 jint GetJavaVM(JavaVM **vm) {
01800 return functions->GetJavaVM(this,vm);
01801 }
01802
01803 void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
01804 functions->GetStringRegion(this,str,start,len,buf);
01805 }
01806 void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
01807 functions->GetStringUTFRegion(this,str,start,len,buf);
01808 }
01809
01810 void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
01811 return functions->GetPrimitiveArrayCritical(this,array,isCopy);
01812 }
01813 void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
01814 functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
01815 }
01816
01817 const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
01818 return functions->GetStringCritical(this,string,isCopy);
01819 }
01820 void ReleaseStringCritical(jstring string, const jchar *cstring) {
01821 functions->ReleaseStringCritical(this,string,cstring);
01822 }
01823
01824 jweak NewWeakGlobalRef(jobject obj) {
01825 return functions->NewWeakGlobalRef(this,obj);
01826 }
01827 void DeleteWeakGlobalRef(jweak ref) {
01828 functions->DeleteWeakGlobalRef(this,ref);
01829 }
01830
01831 jboolean ExceptionCheck() {
01832 return functions->ExceptionCheck(this);
01833 }
01834
01835 jobject NewDirectByteBuffer(void* address, jlong capacity) {
01836 return functions->NewDirectByteBuffer(this, address, capacity);
01837 }
01838 void* GetDirectBufferAddress(jobject buf) {
01839 return functions->GetDirectBufferAddress(this, buf);
01840 }
01841 jlong GetDirectBufferCapacity(jobject buf) {
01842 return functions->GetDirectBufferCapacity(this, buf);
01843 }
01844
01845 #endif
01846 };
01847
01848 typedef struct JavaVMOption {
01849 char *optionString;
01850 void *extraInfo;
01851 } JavaVMOption;
01852
01853 typedef struct JavaVMInitArgs {
01854 jint version;
01855
01856 jint nOptions;
01857 JavaVMOption *options;
01858 jboolean ignoreUnrecognized;
01859 } JavaVMInitArgs;
01860
01861 typedef struct JavaVMAttachArgs {
01862 jint version;
01863
01864 char *name;
01865 jobject group;
01866 } JavaVMAttachArgs;
01867
01868
01869
01870 typedef struct JDK1_1InitArgs {
01871 jint version;
01872
01873 char **properties;
01874 jint checkSource;
01875 jint nativeStackSize;
01876 jint javaStackSize;
01877 jint minHeapSize;
01878 jint maxHeapSize;
01879 jint verifyMode;
01880 char *classpath;
01881
01882 jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
01883 void (JNICALL *exit)(jint code);
01884 void (JNICALL *abort)(void);
01885
01886 jint enableClassGC;
01887 jint enableVerboseGC;
01888 jint disableAsyncGC;
01889 jint verbose;
01890 jboolean debugging;
01891 jint debugPort;
01892 } JDK1_1InitArgs;
01893
01894 typedef struct JDK1_1AttachArgs {
01895 void * __padding;
01896 } JDK1_1AttachArgs;
01897
01898 #define JDK1_2
01899 #define JDK1_4
01900
01901
01902
01903 struct JNIInvokeInterface_ {
01904 void *reserved0;
01905 void *reserved1;
01906 void *reserved2;
01907
01908 jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
01909
01910 jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
01911
01912 jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
01913
01914 jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
01915
01916 jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
01917 };
01918
01919 struct JavaVM_ {
01920 const struct JNIInvokeInterface_ *functions;
01921 #ifdef __cplusplus
01922
01923 jint DestroyJavaVM() {
01924 return functions->DestroyJavaVM(this);
01925 }
01926 jint AttachCurrentThread(void **penv, void *args) {
01927 return functions->AttachCurrentThread(this, penv, args);
01928 }
01929 jint DetachCurrentThread() {
01930 return functions->DetachCurrentThread(this);
01931 }
01932
01933 jint GetEnv(void **penv, jint version) {
01934 return functions->GetEnv(this, penv, version);
01935 }
01936 jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
01937 return functions->AttachCurrentThreadAsDaemon(this, penv, args);
01938 }
01939 #endif
01940 };
01941
01942 #ifdef _JNI_IMPLEMENTATION_
01943 #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
01944 #else
01945 #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
01946 #endif
01947 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
01948 JNI_GetDefaultJavaVMInitArgs(void *args);
01949
01950 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
01951 JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
01952
01953 _JNI_IMPORT_OR_EXPORT_ jint JNICALL
01954 JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
01955
01956
01957 JNIEXPORT jint JNICALL
01958 JNI_OnLoad(JavaVM *vm, void *reserved);
01959
01960 JNIEXPORT void JNICALL
01961 JNI_OnUnload(JavaVM *vm, void *reserved);
01962
01963 #define JNI_VERSION_1_1 0x00010001
01964 #define JNI_VERSION_1_2 0x00010002
01965 #define JNI_VERSION_1_4 0x00010004
01966
01967 #ifdef __cplusplus
01968 }
01969 #endif
01970
01971 #endif
01972
01973