PageRenderTime 50ms CodeModel.GetById 13ms RepoModel.GetById 1ms app.codeStats 0ms

/gecko_api/include/jni.h

http://firefox-mac-pdf.googlecode.com/
C++ Header | 1973 lines | 1694 code | 205 blank | 74 comment | 0 complexity | 92dd7f72ca8fe0dc87d0bab25d47f3b1 MD5 | raw file
  1. /* ***** BEGIN LICENSE BLOCK *****
  2. * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3. *
  4. * The contents of this file are subject to the Mozilla Public License Version
  5. * 1.1 (the "License"); you may not use this file except in compliance with
  6. * the License. You may obtain a copy of the License at
  7. * http://www.mozilla.org/MPL/
  8. *
  9. * Software distributed under the License is distributed on an "AS IS" basis,
  10. * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11. * for the specific language governing rights and limitations under the
  12. * License.
  13. *
  14. * The Original Code is the Java Runtime Interface.
  15. *
  16. * The Initial Developer of the Original Code is
  17. * Netscape Communications Corporation and Sun Microsystems, Inc.
  18. * Portions created by the Initial Developer are Copyright (C) 1993-1996
  19. * the Initial Developer. All Rights Reserved.
  20. *
  21. * Contributor(s):
  22. *
  23. * Alternatively, the contents of this file may be used under the terms of
  24. * either the GNU General Public License Version 2 or later (the "GPL"), or
  25. * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26. * in which case the provisions of the GPL or the LGPL are applicable instead
  27. * of those above. If you wish to allow use of your version of this file only
  28. * under the terms of either the GPL or the LGPL, and not to allow others to
  29. * use your version of this file under the terms of the MPL, indicate your
  30. * decision by deleting the provisions above and replace them with the notice
  31. * and other provisions required by the GPL or the LGPL. If you do not delete
  32. * the provisions above, a recipient may use your version of this file under
  33. * the terms of any one of the MPL, the GPL or the LGPL.
  34. *
  35. * ***** END LICENSE BLOCK ***** */
  36. #ifndef JNI_H
  37. #define JNI_H
  38. #include <stdio.h>
  39. #include <stdarg.h>
  40. /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
  41. and jlong */
  42. #include "jni_md.h"
  43. #ifdef __cplusplus
  44. extern "C" {
  45. #endif
  46. /*
  47. * JNI Types
  48. */
  49. typedef unsigned char jboolean;
  50. typedef unsigned short jchar;
  51. typedef short jshort;
  52. typedef float jfloat;
  53. typedef double jdouble;
  54. typedef jint jsize;
  55. #ifdef __cplusplus
  56. class _jobject {};
  57. class _jclass : public _jobject {};
  58. class _jthrowable : public _jobject {};
  59. class _jstring : public _jobject {};
  60. class _jarray : public _jobject {};
  61. class _jbooleanArray : public _jarray {};
  62. class _jbyteArray : public _jarray {};
  63. class _jcharArray : public _jarray {};
  64. class _jshortArray : public _jarray {};
  65. class _jintArray : public _jarray {};
  66. class _jlongArray : public _jarray {};
  67. class _jfloatArray : public _jarray {};
  68. class _jdoubleArray : public _jarray {};
  69. class _jobjectArray : public _jarray {};
  70. typedef _jobject *jobject;
  71. typedef _jclass *jclass;
  72. typedef _jthrowable *jthrowable;
  73. typedef _jstring *jstring;
  74. typedef _jarray *jarray;
  75. typedef _jbooleanArray *jbooleanArray;
  76. typedef _jbyteArray *jbyteArray;
  77. typedef _jcharArray *jcharArray;
  78. typedef _jshortArray *jshortArray;
  79. typedef _jintArray *jintArray;
  80. typedef _jlongArray *jlongArray;
  81. typedef _jfloatArray *jfloatArray;
  82. typedef _jdoubleArray *jdoubleArray;
  83. typedef _jobjectArray *jobjectArray;
  84. #else
  85. struct _jobject;
  86. typedef struct _jobject *jobject;
  87. typedef jobject jclass;
  88. typedef jobject jthrowable;
  89. typedef jobject jstring;
  90. typedef jobject jarray;
  91. typedef jarray jbooleanArray;
  92. typedef jarray jbyteArray;
  93. typedef jarray jcharArray;
  94. typedef jarray jshortArray;
  95. typedef jarray jintArray;
  96. typedef jarray jlongArray;
  97. typedef jarray jfloatArray;
  98. typedef jarray jdoubleArray;
  99. typedef jarray jobjectArray;
  100. #endif
  101. typedef jobject jweak;
  102. #if 0 /* moved to jri_md.h */
  103. typedef jobject jref; /* For transition---not meant to be part of public
  104. API anymore.*/
  105. #endif
  106. typedef union jvalue {
  107. jboolean z;
  108. jbyte b;
  109. jchar c;
  110. jshort s;
  111. jint i;
  112. jlong j;
  113. jfloat f;
  114. jdouble d;
  115. jobject l;
  116. } jvalue;
  117. struct _jfieldID;
  118. typedef struct _jfieldID *jfieldID;
  119. struct _jmethodID;
  120. typedef struct _jmethodID *jmethodID;
  121. /*
  122. * jboolean constants
  123. */
  124. #define JNI_FALSE 0
  125. #define JNI_TRUE 1
  126. /*
  127. * possible return values for JNI functions.
  128. */
  129. #define JNI_OK 0 /* success */
  130. #define JNI_ERR (-1) /* unknown error */
  131. #define JNI_EDETACHED (-2) /* thread detached from the VM */
  132. #define JNI_EVERSION (-3) /* JNI version error */
  133. #define JNI_ENOMEM (-4) /* not enough memory */
  134. #define JNI_EEXIST (-5) /* VM already created */
  135. #define JNI_EINVAL (-6) /* invalid arguments */
  136. /*
  137. * used in ReleaseScalarArrayElements
  138. */
  139. #define JNI_COMMIT 1
  140. #define JNI_ABORT 2
  141. /*
  142. * used in RegisterNatives to describe native method name, signature,
  143. * and function pointer.
  144. */
  145. typedef struct {
  146. char *name;
  147. char *signature;
  148. void *fnPtr;
  149. } JNINativeMethod;
  150. /*
  151. * JNI Native Method Interface.
  152. */
  153. struct JNINativeInterface_;
  154. struct JNIEnv_;
  155. #ifdef __cplusplus
  156. typedef JNIEnv_ JNIEnv;
  157. #else
  158. typedef const struct JNINativeInterface_ *JNIEnv;
  159. #endif
  160. /*
  161. * JNI Invocation Interface.
  162. */
  163. struct JNIInvokeInterface_;
  164. struct JavaVM_;
  165. #ifdef __cplusplus
  166. typedef JavaVM_ JavaVM;
  167. #else
  168. typedef const struct JNIInvokeInterface_ *JavaVM;
  169. #endif
  170. struct JNINativeInterface_ {
  171. void *reserved0;
  172. void *reserved1;
  173. void *reserved2;
  174. void *reserved3;
  175. jint (JNICALL *GetVersion)(JNIEnv *env);
  176. jclass (JNICALL *DefineClass)
  177. (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
  178. jsize len);
  179. jclass (JNICALL *FindClass)
  180. (JNIEnv *env, const char *name);
  181. jmethodID (JNICALL *FromReflectedMethod)
  182. (JNIEnv *env, jobject method);
  183. jfieldID (JNICALL *FromReflectedField)
  184. (JNIEnv *env, jobject field);
  185. jobject (JNICALL *ToReflectedMethod)
  186. (JNIEnv *env, jclass cls, jmethodID methodID, jboolean isStatic);
  187. jclass (JNICALL *GetSuperclass)
  188. (JNIEnv *env, jclass sub);
  189. jboolean (JNICALL *IsAssignableFrom)
  190. (JNIEnv *env, jclass sub, jclass sup);
  191. jobject (JNICALL *ToReflectedField)
  192. (JNIEnv *env, jclass cls, jfieldID fieldID, jboolean isStatic);
  193. jint (JNICALL *Throw)
  194. (JNIEnv *env, jthrowable obj);
  195. jint (JNICALL *ThrowNew)
  196. (JNIEnv *env, jclass clazz, const char *msg);
  197. jthrowable (JNICALL *ExceptionOccurred)
  198. (JNIEnv *env);
  199. void (JNICALL *ExceptionDescribe)
  200. (JNIEnv *env);
  201. void (JNICALL *ExceptionClear)
  202. (JNIEnv *env);
  203. void (JNICALL *FatalError)
  204. (JNIEnv *env, const char *msg);
  205. jint (JNICALL *PushLocalFrame)
  206. (JNIEnv *env, jint capacity);
  207. jobject (JNICALL *PopLocalFrame)
  208. (JNIEnv *env, jobject result);
  209. jobject (JNICALL *NewGlobalRef)
  210. (JNIEnv *env, jobject lobj);
  211. void (JNICALL *DeleteGlobalRef)
  212. (JNIEnv *env, jobject gref);
  213. void (JNICALL *DeleteLocalRef)
  214. (JNIEnv *env, jobject obj);
  215. jboolean (JNICALL *IsSameObject)
  216. (JNIEnv *env, jobject obj1, jobject obj2);
  217. jobject (JNICALL *NewLocalRef)
  218. (JNIEnv *env, jobject ref);
  219. jint (JNICALL *EnsureLocalCapacity)
  220. (JNIEnv *env, jint capacity);
  221. jobject (JNICALL *AllocObject)
  222. (JNIEnv *env, jclass clazz);
  223. jobject (JNICALL *NewObject)
  224. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  225. jobject (JNICALL *NewObjectV)
  226. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  227. jobject (JNICALL *NewObjectA)
  228. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  229. jclass (JNICALL *GetObjectClass)
  230. (JNIEnv *env, jobject obj);
  231. jboolean (JNICALL *IsInstanceOf)
  232. (JNIEnv *env, jobject obj, jclass clazz);
  233. jmethodID (JNICALL *GetMethodID)
  234. (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  235. jobject (JNICALL *CallObjectMethod)
  236. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  237. jobject (JNICALL *CallObjectMethodV)
  238. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  239. jobject (JNICALL *CallObjectMethodA)
  240. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  241. jboolean (JNICALL *CallBooleanMethod)
  242. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  243. jboolean (JNICALL *CallBooleanMethodV)
  244. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  245. jboolean (JNICALL *CallBooleanMethodA)
  246. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  247. jbyte (JNICALL *CallByteMethod)
  248. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  249. jbyte (JNICALL *CallByteMethodV)
  250. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  251. jbyte (JNICALL *CallByteMethodA)
  252. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  253. jchar (JNICALL *CallCharMethod)
  254. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  255. jchar (JNICALL *CallCharMethodV)
  256. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  257. jchar (JNICALL *CallCharMethodA)
  258. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  259. jshort (JNICALL *CallShortMethod)
  260. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  261. jshort (JNICALL *CallShortMethodV)
  262. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  263. jshort (JNICALL *CallShortMethodA)
  264. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  265. jint (JNICALL *CallIntMethod)
  266. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  267. jint (JNICALL *CallIntMethodV)
  268. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  269. jint (JNICALL *CallIntMethodA)
  270. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  271. jlong (JNICALL *CallLongMethod)
  272. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  273. jlong (JNICALL *CallLongMethodV)
  274. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  275. jlong (JNICALL *CallLongMethodA)
  276. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  277. jfloat (JNICALL *CallFloatMethod)
  278. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  279. jfloat (JNICALL *CallFloatMethodV)
  280. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  281. jfloat (JNICALL *CallFloatMethodA)
  282. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  283. jdouble (JNICALL *CallDoubleMethod)
  284. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  285. jdouble (JNICALL *CallDoubleMethodV)
  286. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  287. jdouble (JNICALL *CallDoubleMethodA)
  288. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
  289. void (JNICALL *CallVoidMethod)
  290. (JNIEnv *env, jobject obj, jmethodID methodID, ...);
  291. void (JNICALL *CallVoidMethodV)
  292. (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
  293. void (JNICALL *CallVoidMethodA)
  294. (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
  295. jobject (JNICALL *CallNonvirtualObjectMethod)
  296. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  297. jobject (JNICALL *CallNonvirtualObjectMethodV)
  298. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  299. va_list args);
  300. jobject (JNICALL *CallNonvirtualObjectMethodA)
  301. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  302. jvalue * args);
  303. jboolean (JNICALL *CallNonvirtualBooleanMethod)
  304. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  305. jboolean (JNICALL *CallNonvirtualBooleanMethodV)
  306. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  307. va_list args);
  308. jboolean (JNICALL *CallNonvirtualBooleanMethodA)
  309. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  310. jvalue * args);
  311. jbyte (JNICALL *CallNonvirtualByteMethod)
  312. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  313. jbyte (JNICALL *CallNonvirtualByteMethodV)
  314. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  315. va_list args);
  316. jbyte (JNICALL *CallNonvirtualByteMethodA)
  317. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  318. jvalue *args);
  319. jchar (JNICALL *CallNonvirtualCharMethod)
  320. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  321. jchar (JNICALL *CallNonvirtualCharMethodV)
  322. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  323. va_list args);
  324. jchar (JNICALL *CallNonvirtualCharMethodA)
  325. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  326. jvalue *args);
  327. jshort (JNICALL *CallNonvirtualShortMethod)
  328. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  329. jshort (JNICALL *CallNonvirtualShortMethodV)
  330. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  331. va_list args);
  332. jshort (JNICALL *CallNonvirtualShortMethodA)
  333. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  334. jvalue *args);
  335. jint (JNICALL *CallNonvirtualIntMethod)
  336. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  337. jint (JNICALL *CallNonvirtualIntMethodV)
  338. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  339. va_list args);
  340. jint (JNICALL *CallNonvirtualIntMethodA)
  341. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  342. jvalue *args);
  343. jlong (JNICALL *CallNonvirtualLongMethod)
  344. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  345. jlong (JNICALL *CallNonvirtualLongMethodV)
  346. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  347. va_list args);
  348. jlong (JNICALL *CallNonvirtualLongMethodA)
  349. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  350. jvalue *args);
  351. jfloat (JNICALL *CallNonvirtualFloatMethod)
  352. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  353. jfloat (JNICALL *CallNonvirtualFloatMethodV)
  354. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  355. va_list args);
  356. jfloat (JNICALL *CallNonvirtualFloatMethodA)
  357. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  358. jvalue *args);
  359. jdouble (JNICALL *CallNonvirtualDoubleMethod)
  360. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  361. jdouble (JNICALL *CallNonvirtualDoubleMethodV)
  362. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  363. va_list args);
  364. jdouble (JNICALL *CallNonvirtualDoubleMethodA)
  365. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  366. jvalue *args);
  367. void (JNICALL *CallNonvirtualVoidMethod)
  368. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
  369. void (JNICALL *CallNonvirtualVoidMethodV)
  370. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  371. va_list args);
  372. void (JNICALL *CallNonvirtualVoidMethodA)
  373. (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
  374. jvalue * args);
  375. jfieldID (JNICALL *GetFieldID)
  376. (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  377. jobject (JNICALL *GetObjectField)
  378. (JNIEnv *env, jobject obj, jfieldID fieldID);
  379. jboolean (JNICALL *GetBooleanField)
  380. (JNIEnv *env, jobject obj, jfieldID fieldID);
  381. jbyte (JNICALL *GetByteField)
  382. (JNIEnv *env, jobject obj, jfieldID fieldID);
  383. jchar (JNICALL *GetCharField)
  384. (JNIEnv *env, jobject obj, jfieldID fieldID);
  385. jshort (JNICALL *GetShortField)
  386. (JNIEnv *env, jobject obj, jfieldID fieldID);
  387. jint (JNICALL *GetIntField)
  388. (JNIEnv *env, jobject obj, jfieldID fieldID);
  389. jlong (JNICALL *GetLongField)
  390. (JNIEnv *env, jobject obj, jfieldID fieldID);
  391. jfloat (JNICALL *GetFloatField)
  392. (JNIEnv *env, jobject obj, jfieldID fieldID);
  393. jdouble (JNICALL *GetDoubleField)
  394. (JNIEnv *env, jobject obj, jfieldID fieldID);
  395. void (JNICALL *SetObjectField)
  396. (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
  397. void (JNICALL *SetBooleanField)
  398. (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
  399. void (JNICALL *SetByteField)
  400. (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
  401. void (JNICALL *SetCharField)
  402. (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
  403. void (JNICALL *SetShortField)
  404. (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
  405. void (JNICALL *SetIntField)
  406. (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
  407. void (JNICALL *SetLongField)
  408. (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
  409. void (JNICALL *SetFloatField)
  410. (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
  411. void (JNICALL *SetDoubleField)
  412. (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
  413. jmethodID (JNICALL *GetStaticMethodID)
  414. (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  415. jobject (JNICALL *CallStaticObjectMethod)
  416. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  417. jobject (JNICALL *CallStaticObjectMethodV)
  418. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  419. jobject (JNICALL *CallStaticObjectMethodA)
  420. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  421. jboolean (JNICALL *CallStaticBooleanMethod)
  422. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  423. jboolean (JNICALL *CallStaticBooleanMethodV)
  424. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  425. jboolean (JNICALL *CallStaticBooleanMethodA)
  426. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  427. jbyte (JNICALL *CallStaticByteMethod)
  428. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  429. jbyte (JNICALL *CallStaticByteMethodV)
  430. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  431. jbyte (JNICALL *CallStaticByteMethodA)
  432. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  433. jchar (JNICALL *CallStaticCharMethod)
  434. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  435. jchar (JNICALL *CallStaticCharMethodV)
  436. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  437. jchar (JNICALL *CallStaticCharMethodA)
  438. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  439. jshort (JNICALL *CallStaticShortMethod)
  440. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  441. jshort (JNICALL *CallStaticShortMethodV)
  442. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  443. jshort (JNICALL *CallStaticShortMethodA)
  444. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  445. jint (JNICALL *CallStaticIntMethod)
  446. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  447. jint (JNICALL *CallStaticIntMethodV)
  448. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  449. jint (JNICALL *CallStaticIntMethodA)
  450. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  451. jlong (JNICALL *CallStaticLongMethod)
  452. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  453. jlong (JNICALL *CallStaticLongMethodV)
  454. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  455. jlong (JNICALL *CallStaticLongMethodA)
  456. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  457. jfloat (JNICALL *CallStaticFloatMethod)
  458. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  459. jfloat (JNICALL *CallStaticFloatMethodV)
  460. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  461. jfloat (JNICALL *CallStaticFloatMethodA)
  462. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  463. jdouble (JNICALL *CallStaticDoubleMethod)
  464. (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
  465. jdouble (JNICALL *CallStaticDoubleMethodV)
  466. (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
  467. jdouble (JNICALL *CallStaticDoubleMethodA)
  468. (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
  469. void (JNICALL *CallStaticVoidMethod)
  470. (JNIEnv *env, jclass cls, jmethodID methodID, ...);
  471. void (JNICALL *CallStaticVoidMethodV)
  472. (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
  473. void (JNICALL *CallStaticVoidMethodA)
  474. (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
  475. jfieldID (JNICALL *GetStaticFieldID)
  476. (JNIEnv *env, jclass clazz, const char *name, const char *sig);
  477. jobject (JNICALL *GetStaticObjectField)
  478. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  479. jboolean (JNICALL *GetStaticBooleanField)
  480. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  481. jbyte (JNICALL *GetStaticByteField)
  482. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  483. jchar (JNICALL *GetStaticCharField)
  484. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  485. jshort (JNICALL *GetStaticShortField)
  486. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  487. jint (JNICALL *GetStaticIntField)
  488. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  489. jlong (JNICALL *GetStaticLongField)
  490. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  491. jfloat (JNICALL *GetStaticFloatField)
  492. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  493. jdouble (JNICALL *GetStaticDoubleField)
  494. (JNIEnv *env, jclass clazz, jfieldID fieldID);
  495. void (JNICALL *SetStaticObjectField)
  496. (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
  497. void (JNICALL *SetStaticBooleanField)
  498. (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
  499. void (JNICALL *SetStaticByteField)
  500. (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
  501. void (JNICALL *SetStaticCharField)
  502. (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
  503. void (JNICALL *SetStaticShortField)
  504. (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
  505. void (JNICALL *SetStaticIntField)
  506. (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
  507. void (JNICALL *SetStaticLongField)
  508. (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
  509. void (JNICALL *SetStaticFloatField)
  510. (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
  511. void (JNICALL *SetStaticDoubleField)
  512. (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
  513. jstring (JNICALL *NewString)
  514. (JNIEnv *env, const jchar *unicode, jsize len);
  515. jsize (JNICALL *GetStringLength)
  516. (JNIEnv *env, jstring str);
  517. const jchar *(JNICALL *GetStringChars)
  518. (JNIEnv *env, jstring str, jboolean *isCopy);
  519. void (JNICALL *ReleaseStringChars)
  520. (JNIEnv *env, jstring str, const jchar *chars);
  521. jstring (JNICALL *NewStringUTF)
  522. (JNIEnv *env, const char *utf);
  523. jsize (JNICALL *GetStringUTFLength)
  524. (JNIEnv *env, jstring str);
  525. const char* (JNICALL *GetStringUTFChars)
  526. (JNIEnv *env, jstring str, jboolean *isCopy);
  527. void (JNICALL *ReleaseStringUTFChars)
  528. (JNIEnv *env, jstring str, const char* chars);
  529. jsize (JNICALL *GetArrayLength)
  530. (JNIEnv *env, jarray array);
  531. jobjectArray (JNICALL *NewObjectArray)
  532. (JNIEnv *env, jsize len, jclass clazz, jobject init);
  533. jobject (JNICALL *GetObjectArrayElement)
  534. (JNIEnv *env, jobjectArray array, jsize index);
  535. void (JNICALL *SetObjectArrayElement)
  536. (JNIEnv *env, jobjectArray array, jsize index, jobject val);
  537. jbooleanArray (JNICALL *NewBooleanArray)
  538. (JNIEnv *env, jsize len);
  539. jbyteArray (JNICALL *NewByteArray)
  540. (JNIEnv *env, jsize len);
  541. jcharArray (JNICALL *NewCharArray)
  542. (JNIEnv *env, jsize len);
  543. jshortArray (JNICALL *NewShortArray)
  544. (JNIEnv *env, jsize len);
  545. jintArray (JNICALL *NewIntArray)
  546. (JNIEnv *env, jsize len);
  547. jlongArray (JNICALL *NewLongArray)
  548. (JNIEnv *env, jsize len);
  549. jfloatArray (JNICALL *NewFloatArray)
  550. (JNIEnv *env, jsize len);
  551. jdoubleArray (JNICALL *NewDoubleArray)
  552. (JNIEnv *env, jsize len);
  553. jboolean * (JNICALL *GetBooleanArrayElements)
  554. (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
  555. jbyte * (JNICALL *GetByteArrayElements)
  556. (JNIEnv *env, jbyteArray array, jboolean *isCopy);
  557. jchar * (JNICALL *GetCharArrayElements)
  558. (JNIEnv *env, jcharArray array, jboolean *isCopy);
  559. jshort * (JNICALL *GetShortArrayElements)
  560. (JNIEnv *env, jshortArray array, jboolean *isCopy);
  561. jint * (JNICALL *GetIntArrayElements)
  562. (JNIEnv *env, jintArray array, jboolean *isCopy);
  563. jlong * (JNICALL *GetLongArrayElements)
  564. (JNIEnv *env, jlongArray array, jboolean *isCopy);
  565. jfloat * (JNICALL *GetFloatArrayElements)
  566. (JNIEnv *env, jfloatArray array, jboolean *isCopy);
  567. jdouble * (JNICALL *GetDoubleArrayElements)
  568. (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
  569. void (JNICALL *ReleaseBooleanArrayElements)
  570. (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
  571. void (JNICALL *ReleaseByteArrayElements)
  572. (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
  573. void (JNICALL *ReleaseCharArrayElements)
  574. (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
  575. void (JNICALL *ReleaseShortArrayElements)
  576. (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
  577. void (JNICALL *ReleaseIntArrayElements)
  578. (JNIEnv *env, jintArray array, jint *elems, jint mode);
  579. void (JNICALL *ReleaseLongArrayElements)
  580. (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
  581. void (JNICALL *ReleaseFloatArrayElements)
  582. (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
  583. void (JNICALL *ReleaseDoubleArrayElements)
  584. (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
  585. void (JNICALL *GetBooleanArrayRegion)
  586. (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  587. void (JNICALL *GetByteArrayRegion)
  588. (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  589. void (JNICALL *GetCharArrayRegion)
  590. (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  591. void (JNICALL *GetShortArrayRegion)
  592. (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  593. void (JNICALL *GetIntArrayRegion)
  594. (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  595. void (JNICALL *GetLongArrayRegion)
  596. (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  597. void (JNICALL *GetFloatArrayRegion)
  598. (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  599. void (JNICALL *GetDoubleArrayRegion)
  600. (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  601. void (JNICALL *SetBooleanArrayRegion)
  602. (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
  603. void (JNICALL *SetByteArrayRegion)
  604. (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
  605. void (JNICALL *SetCharArrayRegion)
  606. (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
  607. void (JNICALL *SetShortArrayRegion)
  608. (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
  609. void (JNICALL *SetIntArrayRegion)
  610. (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
  611. void (JNICALL *SetLongArrayRegion)
  612. (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
  613. void (JNICALL *SetFloatArrayRegion)
  614. (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
  615. void (JNICALL *SetDoubleArrayRegion)
  616. (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
  617. jint (JNICALL *RegisterNatives)
  618. (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
  619. jint nMethods);
  620. jint (JNICALL *UnregisterNatives)
  621. (JNIEnv *env, jclass clazz);
  622. jint (JNICALL *MonitorEnter)
  623. (JNIEnv *env, jobject obj);
  624. jint (JNICALL *MonitorExit)
  625. (JNIEnv *env, jobject obj);
  626. jint (JNICALL *GetJavaVM)
  627. (JNIEnv *env, JavaVM **vm);
  628. void (JNICALL *GetStringRegion)
  629. (JNIEnv *env, jstring str, jsize start, jsize len, jchar *buf);
  630. void (JNICALL *GetStringUTFRegion)
  631. (JNIEnv *env, jstring str, jsize start, jsize len, char *buf);
  632. void * (JNICALL *GetPrimitiveArrayCritical)
  633. (JNIEnv *env, jarray array, jboolean *isCopy);
  634. void (JNICALL *ReleasePrimitiveArrayCritical)
  635. (JNIEnv *env, jarray array, void *carray, jint mode);
  636. const jchar * (JNICALL *GetStringCritical)
  637. (JNIEnv *env, jstring string, jboolean *isCopy);
  638. void (JNICALL *ReleaseStringCritical)
  639. (JNIEnv *env, jstring string, const jchar *cstring);
  640. jweak (JNICALL *NewWeakGlobalRef)
  641. (JNIEnv *env, jobject obj);
  642. void (JNICALL *DeleteWeakGlobalRef)
  643. (JNIEnv *env, jweak ref);
  644. jboolean (JNICALL *ExceptionCheck)
  645. (JNIEnv *env);
  646. jobject (JNICALL *NewDirectByteBuffer)
  647. (JNIEnv* env, void* address, jlong capacity);
  648. void* (JNICALL *GetDirectBufferAddress)
  649. (JNIEnv* env, jobject buf);
  650. jlong (JNICALL *GetDirectBufferCapacity)
  651. (JNIEnv* env, jobject buf);
  652. };
  653. /*
  654. * We use inlined functions for C++ so that programmers can write:
  655. *
  656. * env->FindClass("java/lang/String")
  657. *
  658. * in C++ rather than:
  659. *
  660. * (*env)->FindClass(env, "java/lang/String")
  661. *
  662. * in C.
  663. */
  664. struct JNIEnv_ {
  665. const struct JNINativeInterface_ *functions;
  666. #ifdef __cplusplus
  667. jint GetVersion() {
  668. return functions->GetVersion(this);
  669. }
  670. jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
  671. jsize len) {
  672. return functions->DefineClass(this, name, loader, buf, len);
  673. }
  674. jclass FindClass(const char *name) {
  675. return functions->FindClass(this, name);
  676. }
  677. jmethodID FromReflectedMethod(jobject method) {
  678. return functions->FromReflectedMethod(this,method);
  679. }
  680. jfieldID FromReflectedField(jobject field) {
  681. return functions->FromReflectedField(this,field);
  682. }
  683. jobject ToReflectedMethod(jclass cls, jmethodID methodID, jboolean isStatic) {
  684. return functions->ToReflectedMethod(this, cls, methodID, isStatic);
  685. }
  686. jclass GetSuperclass(jclass sub) {
  687. return functions->GetSuperclass(this, sub);
  688. }
  689. jboolean IsAssignableFrom(jclass sub, jclass sup) {
  690. return functions->IsAssignableFrom(this, sub, sup);
  691. }
  692. jobject ToReflectedField(jclass cls, jfieldID fieldID, jboolean isStatic) {
  693. return functions->ToReflectedField(this,cls,fieldID,isStatic);
  694. }
  695. jint Throw(jthrowable obj) {
  696. return functions->Throw(this, obj);
  697. }
  698. jint ThrowNew(jclass clazz, const char *msg) {
  699. return functions->ThrowNew(this, clazz, msg);
  700. }
  701. jthrowable ExceptionOccurred() {
  702. return functions->ExceptionOccurred(this);
  703. }
  704. void ExceptionDescribe() {
  705. functions->ExceptionDescribe(this);
  706. }
  707. void ExceptionClear() {
  708. functions->ExceptionClear(this);
  709. }
  710. void FatalError(const char *msg) {
  711. functions->FatalError(this, msg);
  712. }
  713. jint PushLocalFrame(jint capacity) {
  714. return functions->PushLocalFrame(this,capacity);
  715. }
  716. jobject PopLocalFrame(jobject result) {
  717. return functions->PopLocalFrame(this,result);
  718. }
  719. jobject NewGlobalRef(jobject lobj) {
  720. return functions->NewGlobalRef(this,lobj);
  721. }
  722. void DeleteGlobalRef(jobject gref) {
  723. functions->DeleteGlobalRef(this,gref);
  724. }
  725. void DeleteLocalRef(jobject obj) {
  726. functions->DeleteLocalRef(this, obj);
  727. }
  728. jboolean IsSameObject(jobject obj1, jobject obj2) {
  729. return functions->IsSameObject(this,obj1,obj2);
  730. }
  731. jobject NewLocalRef(jobject ref) {
  732. return functions->NewLocalRef(this,ref);
  733. }
  734. jint EnsureLocalCapacity(jint capacity) {
  735. return functions->EnsureLocalCapacity(this,capacity);
  736. }
  737. jobject AllocObject(jclass clazz) {
  738. return functions->AllocObject(this,clazz);
  739. }
  740. jobject NewObject(jclass clazz, jmethodID methodID, ...) {
  741. va_list args;
  742. jobject result;
  743. va_start(args, methodID);
  744. result = functions->NewObjectV(this,clazz,methodID,args);
  745. va_end(args);
  746. return result;
  747. }
  748. jobject NewObjectV(jclass clazz, jmethodID methodID,
  749. va_list args) {
  750. return functions->NewObjectV(this,clazz,methodID,args);
  751. }
  752. jobject NewObjectA(jclass clazz, jmethodID methodID,
  753. jvalue *args) {
  754. return functions->NewObjectA(this,clazz,methodID,args);
  755. }
  756. jclass GetObjectClass(jobject obj) {
  757. return functions->GetObjectClass(this,obj);
  758. }
  759. jboolean IsInstanceOf(jobject obj, jclass clazz) {
  760. return functions->IsInstanceOf(this,obj,clazz);
  761. }
  762. jmethodID GetMethodID(jclass clazz, const char *name,
  763. const char *sig) {
  764. return functions->GetMethodID(this,clazz,name,sig);
  765. }
  766. jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
  767. va_list args;
  768. jobject result;
  769. va_start(args,methodID);
  770. result = functions->CallObjectMethodV(this,obj,methodID,args);
  771. va_end(args);
  772. return result;
  773. }
  774. jobject CallObjectMethodV(jobject obj, jmethodID methodID,
  775. va_list args) {
  776. return functions->CallObjectMethodV(this,obj,methodID,args);
  777. }
  778. jobject CallObjectMethodA(jobject obj, jmethodID methodID,
  779. jvalue * args) {
  780. return functions->CallObjectMethodA(this,obj,methodID,args);
  781. }
  782. jboolean CallBooleanMethod(jobject obj,
  783. jmethodID methodID, ...) {
  784. va_list args;
  785. jboolean result;
  786. va_start(args,methodID);
  787. result = functions->CallBooleanMethodV(this,obj,methodID,args);
  788. va_end(args);
  789. return result;
  790. }
  791. jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
  792. va_list args) {
  793. return functions->CallBooleanMethodV(this,obj,methodID,args);
  794. }
  795. jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
  796. jvalue * args) {
  797. return functions->CallBooleanMethodA(this,obj,methodID, args);
  798. }
  799. jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
  800. va_list args;
  801. jbyte result;
  802. va_start(args,methodID);
  803. result = functions->CallByteMethodV(this,obj,methodID,args);
  804. va_end(args);
  805. return result;
  806. }
  807. jbyte CallByteMethodV(jobject obj, jmethodID methodID,
  808. va_list args) {
  809. return functions->CallByteMethodV(this,obj,methodID,args);
  810. }
  811. jbyte CallByteMethodA(jobject obj, jmethodID methodID,
  812. jvalue * args) {
  813. return functions->CallByteMethodA(this,obj,methodID,args);
  814. }
  815. jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
  816. va_list args;
  817. jchar result;
  818. va_start(args,methodID);
  819. result = functions->CallCharMethodV(this,obj,methodID,args);
  820. va_end(args);
  821. return result;
  822. }
  823. jchar CallCharMethodV(jobject obj, jmethodID methodID,
  824. va_list args) {
  825. return functions->CallCharMethodV(this,obj,methodID,args);
  826. }
  827. jchar CallCharMethodA(jobject obj, jmethodID methodID,
  828. jvalue * args) {
  829. return functions->CallCharMethodA(this,obj,methodID,args);
  830. }
  831. jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
  832. va_list args;
  833. jshort result;
  834. va_start(args,methodID);
  835. result = functions->CallShortMethodV(this,obj,methodID,args);
  836. va_end(args);
  837. return result;
  838. }
  839. jshort CallShortMethodV(jobject obj, jmethodID methodID,
  840. va_list args) {
  841. return functions->CallShortMethodV(this,obj,methodID,args);
  842. }
  843. jshort CallShortMethodA(jobject obj, jmethodID methodID,
  844. jvalue * args) {
  845. return functions->CallShortMethodA(this,obj,methodID,args);
  846. }
  847. jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
  848. va_list args;
  849. jint result;
  850. va_start(args,methodID);
  851. result = functions->CallIntMethodV(this,obj,methodID,args);
  852. va_end(args);
  853. return result;
  854. }
  855. jint CallIntMethodV(jobject obj, jmethodID methodID,
  856. va_list args) {
  857. return functions->CallIntMethodV(this,obj,methodID,args);
  858. }
  859. jint CallIntMethodA(jobject obj, jmethodID methodID,
  860. jvalue * args) {
  861. return functions->CallIntMethodA(this,obj,methodID,args);
  862. }
  863. jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
  864. va_list args;
  865. jlong result;
  866. va_start(args,methodID);
  867. result = functions->CallLongMethodV(this,obj,methodID,args);
  868. va_end(args);
  869. return result;
  870. }
  871. jlong CallLongMethodV(jobject obj, jmethodID methodID,
  872. va_list args) {
  873. return functions->CallLongMethodV(this,obj,methodID,args);
  874. }
  875. jlong CallLongMethodA(jobject obj, jmethodID methodID,
  876. jvalue * args) {
  877. return functions->CallLongMethodA(this,obj,methodID,args);
  878. }
  879. jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
  880. va_list args;
  881. jfloat result;
  882. va_start(args,methodID);
  883. result = functions->CallFloatMethodV(this,obj,methodID,args);
  884. va_end(args);
  885. return result;
  886. }
  887. jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
  888. va_list args) {
  889. return functions->CallFloatMethodV(this,obj,methodID,args);
  890. }
  891. jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
  892. jvalue * args) {
  893. return functions->CallFloatMethodA(this,obj,methodID,args);
  894. }
  895. jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
  896. va_list args;
  897. jdouble result;
  898. va_start(args,methodID);
  899. result = functions->CallDoubleMethodV(this,obj,methodID,args);
  900. va_end(args);
  901. return result;
  902. }
  903. jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
  904. va_list args) {
  905. return functions->CallDoubleMethodV(this,obj,methodID,args);
  906. }
  907. jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
  908. jvalue * args) {
  909. return functions->CallDoubleMethodA(this,obj,methodID,args);
  910. }
  911. void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
  912. va_list args;
  913. va_start(args,methodID);
  914. functions->CallVoidMethodV(this,obj,methodID,args);
  915. va_end(args);
  916. }
  917. void CallVoidMethodV(jobject obj, jmethodID methodID,
  918. va_list args) {
  919. functions->CallVoidMethodV(this,obj,methodID,args);
  920. }
  921. void CallVoidMethodA(jobject obj, jmethodID methodID,
  922. jvalue * args) {
  923. functions->CallVoidMethodA(this,obj,methodID,args);
  924. }
  925. jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
  926. jmethodID methodID, ...) {
  927. va_list args;
  928. jobject result;
  929. va_start(args,methodID);
  930. result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  931. methodID,args);
  932. va_end(args);
  933. return result;
  934. }
  935. jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
  936. jmethodID methodID, va_list args) {
  937. return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
  938. methodID,args);
  939. }
  940. jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
  941. jmethodID methodID, jvalue * args) {
  942. return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
  943. methodID,args);
  944. }
  945. jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
  946. jmethodID methodID, ...) {
  947. va_list args;
  948. jboolean result;
  949. va_start(args,methodID);
  950. result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  951. methodID,args);
  952. va_end(args);
  953. return result;
  954. }
  955. jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
  956. jmethodID methodID, va_list args) {
  957. return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
  958. methodID,args);
  959. }
  960. jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
  961. jmethodID methodID, jvalue * args) {
  962. return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
  963. methodID, args);
  964. }
  965. jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
  966. jmethodID methodID, ...) {
  967. va_list args;
  968. jbyte result;
  969. va_start(args,methodID);
  970. result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
  971. methodID,args);
  972. va_end(args);
  973. return result;
  974. }
  975. jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
  976. jmethodID methodID, va_list args) {
  977. return functions->CallNonvirtualByteMethodV(this,obj,clazz,
  978. methodID,args);
  979. }
  980. jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
  981. jmethodID methodID, jvalue * args) {
  982. return functions->CallNonvirtualByteMethodA(this,obj,clazz,
  983. methodID,args);
  984. }
  985. jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
  986. jmethodID methodID, ...) {
  987. va_list args;
  988. jchar result;
  989. va_start(args,methodID);
  990. result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
  991. methodID,args);
  992. va_end(args);
  993. return result;
  994. }
  995. jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
  996. jmethodID methodID, va_list args) {
  997. return functions->CallNonvirtualCharMethodV(this,obj,clazz,
  998. methodID,args);
  999. }
  1000. jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
  1001. jmethodID methodID, jvalue * args) {
  1002. return functions->CallNonvirtualCharMethodA(this,obj,clazz,
  1003. methodID,args);
  1004. }
  1005. jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
  1006. jmethodID methodID, ...) {
  1007. va_list args;
  1008. jshort result;
  1009. va_start(args,methodID);
  1010. result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1011. methodID,args);
  1012. va_end(args);
  1013. return result;
  1014. }
  1015. jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
  1016. jmethodID methodID, va_list args) {
  1017. return functions->CallNonvirtualShortMethodV(this,obj,clazz,
  1018. methodID,args);
  1019. }
  1020. jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
  1021. jmethodID methodID, jvalue * args) {
  1022. return functions->CallNonvirtualShortMethodA(this,obj,clazz,
  1023. methodID,args);
  1024. }
  1025. jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
  1026. jmethodID methodID, ...) {
  1027. va_list args;
  1028. jint result;
  1029. va_start(args,methodID);
  1030. result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1031. methodID,args);
  1032. va_end(args);
  1033. return result;
  1034. }
  1035. jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
  1036. jmethodID methodID, va_list args) {
  1037. return functions->CallNonvirtualIntMethodV(this,obj,clazz,
  1038. methodID,args);
  1039. }
  1040. jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
  1041. jmethodID methodID, jvalue * args) {
  1042. return functions->CallNonvirtualIntMethodA(this,obj,clazz,
  1043. methodID,args);
  1044. }
  1045. jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
  1046. jmethodID methodID, ...) {
  1047. va_list args;
  1048. jlong result;
  1049. va_start(args,methodID);
  1050. result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1051. methodID,args);
  1052. va_end(args);
  1053. return result;
  1054. }
  1055. jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
  1056. jmethodID methodID, va_list args) {
  1057. return functions->CallNonvirtualLongMethodV(this,obj,clazz,
  1058. methodID,args);
  1059. }
  1060. jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
  1061. jmethodID methodID, jvalue * args) {
  1062. return functions->CallNonvirtualLongMethodA(this,obj,clazz,
  1063. methodID,args);
  1064. }
  1065. jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
  1066. jmethodID methodID, ...) {
  1067. va_list args;
  1068. jfloat result;
  1069. va_start(args,methodID);
  1070. result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1071. methodID,args);
  1072. va_end(args);
  1073. return result;
  1074. }
  1075. jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
  1076. jmethodID methodID,
  1077. va_list args) {
  1078. return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
  1079. methodID,args);
  1080. }
  1081. jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
  1082. jmethodID methodID,
  1083. jvalue * args) {
  1084. return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
  1085. methodID,args);
  1086. }
  1087. jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
  1088. jmethodID methodID, ...) {
  1089. va_list args;
  1090. jdouble result;
  1091. va_start(args,methodID);
  1092. result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1093. methodID,args);
  1094. va_end(args);
  1095. return result;
  1096. }
  1097. jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
  1098. jmethodID methodID,
  1099. va_list args) {
  1100. return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
  1101. methodID,args);
  1102. }
  1103. jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
  1104. jmethodID methodID,
  1105. jvalue * args) {
  1106. return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
  1107. methodID,args);
  1108. }
  1109. void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
  1110. jmethodID methodID, ...) {
  1111. va_list args;
  1112. va_start(args,methodID);
  1113. functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1114. va_end(args);
  1115. }
  1116. void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
  1117. jmethodID methodID,
  1118. va_list args) {
  1119. functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
  1120. }
  1121. void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
  1122. jmethodID methodID,
  1123. jvalue * args) {
  1124. functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
  1125. }
  1126. jfieldID GetFieldID(jclass clazz, const char *name,
  1127. const char *sig) {
  1128. return functions->GetFieldID(this,clazz,name,sig);
  1129. }
  1130. jobject GetObjectField(jobject obj, jfieldID fieldID) {
  1131. return functions->GetObjectField(this,obj,fieldID);
  1132. }
  1133. jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
  1134. return functions->GetBooleanField(this,obj,fieldID);
  1135. }
  1136. jbyte GetByteField(jobject obj, jfieldID fieldID) {
  1137. return functions->GetByteField(this,obj,fieldID);
  1138. }
  1139. jchar GetCharField(jobject obj, jfieldID fieldID) {
  1140. return functions->GetCharField(this,obj,fieldID);
  1141. }
  1142. jshort GetShortField(jobject obj, jfieldID fieldID) {
  1143. return functions->GetShortField(this,obj,fieldID);
  1144. }
  1145. jint GetIntField(jobject obj, jfieldID fieldID) {
  1146. return functions->GetIntField(this,obj,fieldID);
  1147. }
  1148. jlong GetLongField(jobject obj, jfieldID fieldID) {
  1149. return functions->GetLongField(this,obj,fieldID);
  1150. }
  1151. jfloat GetFloatField(jobject obj, jfieldID fieldID) {
  1152. return functions->GetFloatField(this,obj,fieldID);
  1153. }
  1154. jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
  1155. return functions->GetDoubleField(this,obj,fieldID);
  1156. }
  1157. void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
  1158. functions->SetObjectField(this,obj,fieldID,val);
  1159. }
  1160. void SetBooleanField(jobject obj, jfieldID fieldID,
  1161. jboolean val) {
  1162. functions->SetBooleanField(this,obj,fieldID,val);
  1163. }
  1164. void SetByteField(jobject obj, jfieldID fieldID,
  1165. jbyte val) {
  1166. functions->SetByteField(this,obj,fieldID,val);
  1167. }
  1168. void SetCharField(jobject obj, jfieldID fieldID,
  1169. jchar val) {
  1170. functions->SetCharField(this,obj,fieldID,val);
  1171. }
  1172. void SetShortField(jobject obj, jfieldID fieldID,
  1173. jshort val) {
  1174. functions->SetShortField(this,obj,fieldID,val);
  1175. }
  1176. void SetIntField(jobject obj, jfieldID fieldID,
  1177. jint val) {
  1178. functions->SetIntField(this,obj,fieldID,val);
  1179. }
  1180. void SetLongField(jobject obj, jfieldID fieldID,
  1181. jlong val) {
  1182. functions->SetLongField(this,obj,fieldID,val);
  1183. }
  1184. void SetFloatField(jobject obj, jfieldID fieldID,
  1185. jfloat val) {
  1186. functions->SetFloatField(this,obj,fieldID,val);
  1187. }
  1188. void SetDoubleField(jobject obj, jfieldID fieldID,
  1189. jdouble val) {
  1190. functions->SetDoubleField(this,obj,fieldID,val);
  1191. }
  1192. jmethodID GetStaticMethodID(jclass clazz, const char *name,
  1193. const char *sig) {
  1194. return functions->GetStaticMethodID(this,clazz,name,sig);
  1195. }
  1196. jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
  1197. ...) {
  1198. va_list args;
  1199. jobject result;
  1200. va_start(args,methodID);
  1201. result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1202. va_end(args);
  1203. return result;
  1204. }
  1205. jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
  1206. va_list args) {
  1207. return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
  1208. }
  1209. jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
  1210. jvalue *args) {
  1211. return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
  1212. }
  1213. jboolean CallStaticBooleanMethod(jclass clazz,
  1214. jmethodID methodID, ...) {
  1215. va_list args;
  1216. jboolean result;
  1217. va_start(args,methodID);
  1218. result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1219. va_end(args);
  1220. return result;
  1221. }
  1222. jboolean CallStaticBooleanMethodV(jclass clazz,
  1223. jmethodID methodID, va_list args) {
  1224. return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
  1225. }
  1226. jboolean CallStaticBooleanMethodA(jclass clazz,
  1227. jmethodID methodID, jvalue *args) {
  1228. return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
  1229. }
  1230. jbyte CallStaticByteMethod(jclass clazz,
  1231. jmethodID methodID, ...) {
  1232. va_list args;
  1233. jbyte result;
  1234. va_start(args,methodID);
  1235. result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1236. va_end(args);
  1237. return result;
  1238. }
  1239. jbyte CallStaticByteMethodV(jclass clazz,
  1240. jmethodID methodID, va_list args) {
  1241. return functions->CallStaticByteMethodV(this,clazz,methodID,args);
  1242. }
  1243. jbyte CallStaticByteMethodA(jclass clazz,
  1244. jmethodID methodID, jvalue *args) {
  1245. return functions->CallStaticByteMethodA(this,clazz,methodID,args);
  1246. }
  1247. jchar CallStaticCharMethod(jclass clazz,
  1248. jmethodID methodID, ...) {
  1249. va_list args;
  1250. jchar result;
  1251. va_start(args,methodID);
  1252. result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1253. va_end(args);
  1254. return result;
  1255. }
  1256. jchar CallStaticCharMethodV(jclass clazz,
  1257. jmethodID methodID, va_list args) {
  1258. return functions->CallStaticCharMethodV(this,clazz,methodID,args);
  1259. }
  1260. jchar CallStaticCharMethodA(jclass clazz,
  1261. jmethodID methodID, jvalue *args) {
  1262. return functions->CallStaticCharMethodA(this,clazz,methodID,args);
  1263. }
  1264. jshort CallStaticShortMethod(jclass clazz,
  1265. jmethodID methodID, ...) {
  1266. va_list args;
  1267. jshort result;
  1268. va_start(args,methodID);
  1269. result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1270. va_end(args);
  1271. return result;
  1272. }
  1273. jshort CallStaticShortMethodV(jclass clazz,
  1274. jmethodID methodID, va_list args) {
  1275. return functions->CallStaticShortMethodV(this,clazz,methodID,args);
  1276. }
  1277. jshort CallStaticShortMethodA(jclass clazz,
  1278. jmethodID methodID, jvalue *args) {
  1279. return functions->CallStaticShortMethodA(this,clazz,methodID,args);
  1280. }
  1281. jint CallStaticIntMethod(jclass clazz,
  1282. jmethodID methodID, ...) {
  1283. va_list args;
  1284. jint result;
  1285. va_start(args,methodID);
  1286. result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1287. va_end(args);
  1288. return result;
  1289. }
  1290. jint CallStaticIntMethodV(jclass clazz,
  1291. jmethodID methodID, va_list args) {
  1292. return functions->CallStaticIntMethodV(this,clazz,methodID,args);
  1293. }
  1294. jint CallStaticIntMethodA(jclass clazz,
  1295. jmethodID methodID, jvalue *args) {
  1296. return functions->CallStaticIntMethodA(this,clazz,methodID,args);
  1297. }
  1298. jlong CallStaticLongMethod(jclass clazz,
  1299. jmethodID methodID, ...) {
  1300. va_list args;
  1301. jlong result;
  1302. va_start(args,methodID);
  1303. result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1304. va_end(args);
  1305. return result;
  1306. }
  1307. jlong CallStaticLongMethodV(jclass clazz,
  1308. jmethodID methodID, va_list args) {
  1309. return functions->CallStaticLongMethodV(this,clazz,methodID,args);
  1310. }
  1311. jlong CallStaticLongMethodA(jclass clazz,
  1312. jmethodID methodID, jvalue *args) {
  1313. return functions->CallStaticLongMethodA(this,clazz,methodID,args);
  1314. }
  1315. jfloat CallStaticFloatMethod(jclass clazz,
  1316. jmethodID methodID, ...) {
  1317. va_list args;
  1318. jfloat result;
  1319. va_start(args,methodID);
  1320. result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1321. va_end(args);
  1322. return result;
  1323. }
  1324. jfloat CallStaticFloatMethodV(jclass clazz,
  1325. jmethodID methodID, va_list args) {
  1326. return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
  1327. }
  1328. jfloat CallStaticFloatMethodA(jclass clazz,
  1329. jmethodID methodID, jvalue *args) {
  1330. return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
  1331. }
  1332. jdouble CallStaticDoubleMethod(jclass clazz,
  1333. jmethodID methodID, ...) {
  1334. va_list args;
  1335. jdouble result;
  1336. va_start(args,methodID);
  1337. result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1338. va_end(args);
  1339. return result;
  1340. }
  1341. jdouble CallStaticDoubleMethodV(jclass clazz,
  1342. jmethodID methodID, va_list args) {
  1343. return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
  1344. }
  1345. jdouble CallStaticDoubleMethodA(jclass clazz,
  1346. jmethodID methodID, jvalue *args) {
  1347. return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
  1348. }
  1349. void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
  1350. va_list args;
  1351. va_start(args,methodID);
  1352. functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1353. va_end(args);
  1354. }
  1355. void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
  1356. va_list args) {
  1357. functions->CallStaticVoidMethodV(this,cls,methodID,args);
  1358. }
  1359. void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
  1360. jvalue * args) {
  1361. functions->CallStaticVoidMethodA(this,cls,methodID,args);
  1362. }
  1363. jfieldID GetStaticFieldID(jclass clazz, const char *name,
  1364. const char *sig) {
  1365. return functions->GetStaticFieldID(this,clazz,name,sig);
  1366. }
  1367. jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
  1368. return functions->GetStaticObjectField(this,clazz,fieldID);
  1369. }
  1370. jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
  1371. return functions->GetStaticBooleanField(this,clazz,fieldID);
  1372. }
  1373. jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
  1374. return functions->GetStaticByteField(this,clazz,fieldID);
  1375. }
  1376. jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
  1377. return functions->GetStaticCharField(this,clazz,fieldID);
  1378. }
  1379. jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
  1380. return functions->GetStaticShortField(this,clazz,fieldID);
  1381. }
  1382. jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
  1383. return functions->GetStaticIntField(this,clazz,fieldID);
  1384. }
  1385. jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
  1386. return functions->GetStaticLongField(this,clazz,fieldID);
  1387. }
  1388. jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
  1389. return functions->GetStaticFloatField(this,clazz,fieldID);
  1390. }
  1391. jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
  1392. return functions->GetStaticDoubleField(this,clazz,fieldID);
  1393. }
  1394. void SetStaticObjectField(jclass clazz, jfieldID fieldID,
  1395. jobject value) {
  1396. functions->SetStaticObjectField(this,clazz,fieldID,value);
  1397. }
  1398. void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
  1399. jboolean value) {
  1400. functions->SetStaticBooleanField(this,clazz,fieldID,value);
  1401. }
  1402. void SetStaticByteField(jclass clazz, jfieldID fieldID,
  1403. jbyte value) {
  1404. functions->SetStaticByteField(this,clazz,fieldID,value);
  1405. }
  1406. void SetStaticCharField(jclass clazz, jfieldID fieldID,
  1407. jchar value) {
  1408. functions->SetStaticCharField(this,clazz,fieldID,value);
  1409. }
  1410. void SetStaticShortField(jclass clazz, jfieldID fieldID,
  1411. jshort value) {
  1412. functions->SetStaticShortField(this,clazz,fieldID,value);
  1413. }
  1414. void SetStaticIntField(jclass clazz, jfieldID fieldID,
  1415. jint value) {
  1416. functions->SetStaticIntField(this,clazz,fieldID,value);
  1417. }
  1418. void SetStaticLongField(jclass clazz, jfieldID fieldID,
  1419. jlong value) {
  1420. functions->SetStaticLongField(this,clazz,fieldID,value);
  1421. }
  1422. void SetStaticFloatField(jclass clazz, jfieldID fieldID,
  1423. jfloat value) {
  1424. functions->SetStaticFloatField(this,clazz,fieldID,value);
  1425. }
  1426. void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
  1427. jdouble value) {
  1428. functions->SetStaticDoubleField(this,clazz,fieldID,value);
  1429. }
  1430. jstring NewString(const jchar *unicode, jsize len) {
  1431. return functions->NewString(this,unicode,len);
  1432. }
  1433. jsize GetStringLength(jstring str) {
  1434. return functions->GetStringLength(this,str);
  1435. }
  1436. const jchar *GetStringChars(jstring str, jboolean *isCopy) {
  1437. return functions->GetStringChars(this,str,isCopy);
  1438. }
  1439. void ReleaseStringChars(jstring str, const jchar *chars) {
  1440. functions->ReleaseStringChars(this,str,chars);
  1441. }
  1442. jstring NewStringUTF(const char *utf) {
  1443. return functions->NewStringUTF(this,utf);
  1444. }
  1445. jsize GetStringUTFLength(jstring str) {
  1446. return functions->GetStringUTFLength(this,str);
  1447. }
  1448. const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
  1449. return functions->GetStringUTFChars(this,str,isCopy);
  1450. }
  1451. void ReleaseStringUTFChars(jstring str, const char* chars) {
  1452. functions->ReleaseStringUTFChars(this,str,chars);
  1453. }
  1454. jsize GetArrayLength(jarray array) {
  1455. return functions->GetArrayLength(this,array);
  1456. }
  1457. jobjectArray NewObjectArray(jsize len, jclass clazz,
  1458. jobject init) {
  1459. return functions->NewObjectArray(this,len,clazz,init);
  1460. }
  1461. jobject GetObjectArrayElement(jobjectArray array, jsize index) {
  1462. return functions->GetObjectArrayElement(this,array,index);
  1463. }
  1464. void SetObjectArrayElement(jobjectArray array, jsize index,
  1465. jobject val) {
  1466. functions->SetObjectArrayElement(this,array,index,val);
  1467. }
  1468. jbooleanArray NewBooleanArray(jsize len) {
  1469. return functions->NewBooleanArray(this,len);
  1470. }
  1471. jbyteArray NewByteArray(jsize len) {
  1472. return functions->NewByteArray(this,len);
  1473. }
  1474. jcharArray NewCharArray(jsize len) {
  1475. return functions->NewCharArray(this,len);
  1476. }
  1477. jshortArray NewShortArray(jsize len) {
  1478. return functions->NewShortArray(this,len);
  1479. }
  1480. jintArray NewIntArray(jsize len) {
  1481. return functions->NewIntArray(this,len);
  1482. }
  1483. jlongArray NewLongArray(jsize len) {
  1484. return functions->NewLongArray(this,len);
  1485. }
  1486. jfloatArray NewFloatArray(jsize len) {
  1487. return functions->NewFloatArray(this,len);
  1488. }
  1489. jdoubleArray NewDoubleArray(jsize len) {
  1490. return functions->NewDoubleArray(this,len);
  1491. }
  1492. jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
  1493. return functions->GetBooleanArrayElements(this,array,isCopy);
  1494. }
  1495. jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
  1496. return functions->GetByteArrayElements(this,array,isCopy);
  1497. }
  1498. jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
  1499. return functions->GetCharArrayElements(this,array,isCopy);
  1500. }
  1501. jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
  1502. return functions->GetShortArrayElements(this,array,isCopy);
  1503. }
  1504. jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
  1505. return functions->GetIntArrayElements(this,array,isCopy);
  1506. }
  1507. jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
  1508. return functions->GetLongArrayElements(this,array,isCopy);
  1509. }
  1510. jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
  1511. return functions->GetFloatArrayElements(this,array,isCopy);
  1512. }
  1513. jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
  1514. return functions->GetDoubleArrayElements(this,array,isCopy);
  1515. }
  1516. void ReleaseBooleanArrayElements(jbooleanArray array,
  1517. jboolean *elems,
  1518. jint mode) {
  1519. functions->ReleaseBooleanArrayElements(this,array,elems,mode);
  1520. }
  1521. void ReleaseByteArrayElements(jbyteArray array,
  1522. jbyte *elems,
  1523. jint mode) {
  1524. functions->ReleaseByteArrayElements(this,array,elems,mode);
  1525. }
  1526. void ReleaseCharArrayElements(jcharArray array,
  1527. jchar *elems,
  1528. jint mode) {
  1529. functions->ReleaseCharArrayElements(this,array,elems,mode);
  1530. }
  1531. void ReleaseShortArrayElements(jshortArray array,
  1532. jshort *elems,
  1533. jint mode) {
  1534. functions->ReleaseShortArrayElements(this,array,elems,mode);
  1535. }
  1536. void ReleaseIntArrayElements(jintArray array,
  1537. jint *elems,
  1538. jint mode) {
  1539. functions->ReleaseIntArrayElements(this,array,elems,mode);
  1540. }
  1541. void ReleaseLongArrayElements(jlongArray array,
  1542. jlong *elems,
  1543. jint mode) {
  1544. functions->ReleaseLongArrayElements(this,array,elems,mode);
  1545. }
  1546. void ReleaseFloatArrayElements(jfloatArray array,
  1547. jfloat *elems,
  1548. jint mode) {
  1549. functions->ReleaseFloatArrayElements(this,array,elems,mode);
  1550. }
  1551. void ReleaseDoubleArrayElements(jdoubleArray array,
  1552. jdouble *elems,
  1553. jint mode) {
  1554. functions->ReleaseDoubleArrayElements(this,array,elems,mode);
  1555. }
  1556. void GetBooleanArrayRegion(jbooleanArray array,
  1557. jsize start, jsize len, jboolean *buf) {
  1558. functions->GetBooleanArrayRegion(this,array,start,len,buf);
  1559. }
  1560. void GetByteArrayRegion(jbyteArray array,
  1561. jsize start, jsize len, jbyte *buf) {
  1562. functions->GetByteArrayRegion(this,array,start,len,buf);
  1563. }
  1564. void GetCharArrayRegion(jcharArray array,
  1565. jsize start, jsize len, jchar *buf) {
  1566. functions->GetCharArrayRegion(this,array,start,len,buf);
  1567. }
  1568. void GetShortArrayRegion(jshortArray array,
  1569. jsize start, jsize len, jshort *buf) {
  1570. functions->GetShortArrayRegion(this,array,start,len,buf);
  1571. }
  1572. void GetIntArrayRegion(jintArray array,
  1573. jsize start, jsize len, jint *buf) {
  1574. functions->GetIntArrayRegion(this,array,start,len,buf);
  1575. }
  1576. void GetLongArrayRegion(jlongArray array,
  1577. jsize start, jsize len, jlong *buf) {
  1578. functions->GetLongArrayRegion(this,array,start,len,buf);
  1579. }
  1580. void GetFloatArrayRegion(jfloatArray array,
  1581. jsize start, jsize len, jfloat *buf) {
  1582. functions->GetFloatArrayRegion(this,array,start,len,buf);
  1583. }
  1584. void GetDoubleArrayRegion(jdoubleArray array,
  1585. jsize start, jsize len, jdouble *buf) {
  1586. functions->GetDoubleArrayRegion(this,array,start,len,buf);
  1587. }
  1588. void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
  1589. jboolean *buf) {
  1590. functions->SetBooleanArrayRegion(this,array,start,len,buf);
  1591. }
  1592. void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
  1593. jbyte *buf) {
  1594. functions->SetByteArrayRegion(this,array,start,len,buf);
  1595. }
  1596. void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
  1597. jchar *buf) {
  1598. functions->SetCharArrayRegion(this,array,start,len,buf);
  1599. }
  1600. void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
  1601. jshort *buf) {
  1602. functions->SetShortArrayRegion(this,array,start,len,buf);
  1603. }
  1604. void SetIntArrayRegion(jintArray array, jsize start, jsize len,
  1605. jint *buf) {
  1606. functions->SetIntArrayRegion(this,array,start,len,buf);
  1607. }
  1608. void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
  1609. jlong *buf) {
  1610. functions->SetLongArrayRegion(this,array,start,len,buf);
  1611. }
  1612. void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
  1613. jfloat *buf) {
  1614. functions->SetFloatArrayRegion(this,array,start,len,buf);
  1615. }
  1616. void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
  1617. jdouble *buf) {
  1618. functions->SetDoubleArrayRegion(this,array,start,len,buf);
  1619. }
  1620. jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
  1621. jint nMethods) {
  1622. return functions->RegisterNatives(this,clazz,methods,nMethods);
  1623. }
  1624. jint UnregisterNatives(jclass clazz) {
  1625. return functions->UnregisterNatives(this,clazz);
  1626. }
  1627. jint MonitorEnter(jobject obj) {
  1628. return functions->MonitorEnter(this,obj);
  1629. }
  1630. jint MonitorExit(jobject obj) {
  1631. return functions->MonitorExit(this,obj);
  1632. }
  1633. jint GetJavaVM(JavaVM **vm) {
  1634. return functions->GetJavaVM(this,vm);
  1635. }
  1636. void GetStringRegion(jstring str, jsize start, jsize len, jchar *buf) {
  1637. functions->GetStringRegion(this,str,start,len,buf);
  1638. }
  1639. void GetStringUTFRegion(jstring str, jsize start, jsize len, char *buf) {
  1640. functions->GetStringUTFRegion(this,str,start,len,buf);
  1641. }
  1642. void * GetPrimitiveArrayCritical(jarray array, jboolean *isCopy) {
  1643. return functions->GetPrimitiveArrayCritical(this,array,isCopy);
  1644. }
  1645. void ReleasePrimitiveArrayCritical(jarray array, void *carray, jint mode) {
  1646. functions->ReleasePrimitiveArrayCritical(this,array,carray,mode);
  1647. }
  1648. const jchar * GetStringCritical(jstring string, jboolean *isCopy) {
  1649. return functions->GetStringCritical(this,string,isCopy);
  1650. }
  1651. void ReleaseStringCritical(jstring string, const jchar *cstring) {
  1652. functions->ReleaseStringCritical(this,string,cstring);
  1653. }
  1654. jweak NewWeakGlobalRef(jobject obj) {
  1655. return functions->NewWeakGlobalRef(this,obj);
  1656. }
  1657. void DeleteWeakGlobalRef(jweak ref) {
  1658. functions->DeleteWeakGlobalRef(this,ref);
  1659. }
  1660. jboolean ExceptionCheck() {
  1661. return functions->ExceptionCheck(this);
  1662. }
  1663. jobject NewDirectByteBuffer(void* address, jlong capacity) {
  1664. return functions->NewDirectByteBuffer(this, address, capacity);
  1665. }
  1666. void* GetDirectBufferAddress(jobject buf) {
  1667. return functions->GetDirectBufferAddress(this, buf);
  1668. }
  1669. jlong GetDirectBufferCapacity(jobject buf) {
  1670. return functions->GetDirectBufferCapacity(this, buf);
  1671. }
  1672. #endif /* __cplusplus */
  1673. };
  1674. typedef struct JavaVMOption {
  1675. char *optionString;
  1676. void *extraInfo;
  1677. } JavaVMOption;
  1678. typedef struct JavaVMInitArgs {
  1679. jint version;
  1680. jint nOptions;
  1681. JavaVMOption *options;
  1682. jboolean ignoreUnrecognized;
  1683. } JavaVMInitArgs;
  1684. typedef struct JavaVMAttachArgs {
  1685. jint version;
  1686. char *name;
  1687. jobject group;
  1688. } JavaVMAttachArgs;
  1689. /* These structures will be VM-specific. */
  1690. typedef struct JDK1_1InitArgs {
  1691. jint version;
  1692. char **properties;
  1693. jint checkSource;
  1694. jint nativeStackSize;
  1695. jint javaStackSize;
  1696. jint minHeapSize;
  1697. jint maxHeapSize;
  1698. jint verifyMode;
  1699. char *classpath;
  1700. jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
  1701. void (JNICALL *exit)(jint code);
  1702. void (JNICALL *abort)(void);
  1703. jint enableClassGC;
  1704. jint enableVerboseGC;
  1705. jint disableAsyncGC;
  1706. jint verbose;
  1707. jboolean debugging;
  1708. jint debugPort;
  1709. } JDK1_1InitArgs;
  1710. typedef struct JDK1_1AttachArgs {
  1711. void * __padding; /* C compilers don't allow empty structures. */
  1712. } JDK1_1AttachArgs;
  1713. #define JDK1_2
  1714. #define JDK1_4
  1715. /* End VM-specific. */
  1716. struct JNIInvokeInterface_ {
  1717. void *reserved0;
  1718. void *reserved1;
  1719. void *reserved2;
  1720. jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
  1721. jint (JNICALL *AttachCurrentThread)(JavaVM *vm, void **penv, void *args);
  1722. jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
  1723. jint (JNICALL *GetEnv)(JavaVM *vm, void **penv, jint version);
  1724. jint (JNICALL *AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);
  1725. };
  1726. struct JavaVM_ {
  1727. const struct JNIInvokeInterface_ *functions;
  1728. #ifdef __cplusplus
  1729. jint DestroyJavaVM() {
  1730. return functions->DestroyJavaVM(this);
  1731. }
  1732. jint AttachCurrentThread(void **penv, void *args) {
  1733. return functions->AttachCurrentThread(this, penv, args);
  1734. }
  1735. jint DetachCurrentThread() {
  1736. return functions->DetachCurrentThread(this);
  1737. }
  1738. jint GetEnv(void **penv, jint version) {
  1739. return functions->GetEnv(this, penv, version);
  1740. }
  1741. jint AttachCurrentThreadAsDaemon(void **penv, void *args) {
  1742. return functions->AttachCurrentThreadAsDaemon(this, penv, args);
  1743. }
  1744. #endif
  1745. };
  1746. #ifdef _JNI_IMPLEMENTATION_
  1747. #define _JNI_IMPORT_OR_EXPORT_ JNIEXPORT
  1748. #else
  1749. #define _JNI_IMPORT_OR_EXPORT_ JNIIMPORT
  1750. #endif
  1751. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1752. JNI_GetDefaultJavaVMInitArgs(void *args);
  1753. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1754. JNI_CreateJavaVM(JavaVM **pvm, void **penv, void *args);
  1755. _JNI_IMPORT_OR_EXPORT_ jint JNICALL
  1756. JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
  1757. /* Defined by native libraries. */
  1758. JNIEXPORT jint JNICALL
  1759. JNI_OnLoad(JavaVM *vm, void *reserved);
  1760. JNIEXPORT void JNICALL
  1761. JNI_OnUnload(JavaVM *vm, void *reserved);
  1762. #define JNI_VERSION_1_1 0x00010001
  1763. #define JNI_VERSION_1_2 0x00010002
  1764. #define JNI_VERSION_1_4 0x00010004
  1765. #ifdef __cplusplus
  1766. } /* extern "C" */
  1767. #endif /* __cplusplus */
  1768. #endif /* JNI_H */