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