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