PageRenderTime 85ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 1ms

/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

Large files files are truncated, but you can click here to view the full 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 function

Large files files are truncated, but you can click here to view the full file