1 /* ***** BEGIN LICENSE BLOCK *****
2 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
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/
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
14 * The Original Code is the Java Runtime Interface.
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.
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.
35 * ***** END LICENSE BLOCK ***** */
43 /* jni_md.h contains the machine-dependent typedefs for jbyte, jint
56 typedef unsigned char jboolean;
57 typedef unsigned short jchar;
60 typedef double jdouble;
67 class _jclass : public _jobject {};
68 class _jthrowable : public _jobject {};
69 class _jstring : public _jobject {};
70 class _jarray : public _jobject {};
71 class _jbooleanArray : public _jarray {};
72 class _jbyteArray : public _jarray {};
73 class _jcharArray : public _jarray {};
74 class _jshortArray : public _jarray {};
75 class _jintArray : public _jarray {};
76 class _jlongArray : public _jarray {};
77 class _jfloatArray : public _jarray {};
78 class _jdoubleArray : public _jarray {};
79 class _jobjectArray : public _jarray {};
81 typedef _jobject *jobject;
82 typedef _jclass *jclass;
83 typedef _jthrowable *jthrowable;
84 typedef _jstring *jstring;
85 typedef _jarray *jarray;
86 typedef _jbooleanArray *jbooleanArray;
87 typedef _jbyteArray *jbyteArray;
88 typedef _jcharArray *jcharArray;
89 typedef _jshortArray *jshortArray;
90 typedef _jintArray *jintArray;
91 typedef _jlongArray *jlongArray;
92 typedef _jfloatArray *jfloatArray;
93 typedef _jdoubleArray *jdoubleArray;
94 typedef _jobjectArray *jobjectArray;
100 typedef struct _jobject *jobject;
101 typedef jobject jclass;
102 typedef jobject jthrowable;
103 typedef jobject jstring;
104 typedef jobject jarray;
105 typedef jarray jbooleanArray;
106 typedef jarray jbyteArray;
107 typedef jarray jcharArray;
108 typedef jarray jshortArray;
109 typedef jarray jintArray;
110 typedef jarray jlongArray;
111 typedef jarray jfloatArray;
112 typedef jarray jdoubleArray;
113 typedef jarray jobjectArray;
117 #if 0 /* moved to jri_md.h */
118 typedef jobject jref; /* For transition---not meant to be part of public
122 typedef union jvalue {
135 typedef struct _jfieldID *jfieldID;
138 typedef struct _jmethodID *jmethodID;
148 * possible return values for JNI functions.
155 * used in ReleaseScalarArrayElements
162 * used in RegisterNatives to describe native method name, signature,
163 * and function pointer.
173 * JNI Native Method Interface.
176 struct JNINativeInterface_;
181 typedef JNIEnv_ JNIEnv;
183 typedef const struct JNINativeInterface_ *JNIEnv;
187 * JNI Invocation Interface.
190 struct JNIInvokeInterface_;
195 typedef JavaVM_ JavaVM;
197 typedef const struct JNIInvokeInterface_ *JavaVM;
200 struct JNINativeInterface_ {
206 jint (JNICALL *GetVersion)(JNIEnv *env);
208 jclass (JNICALL *DefineClass)
209 (JNIEnv *env, const char *name, jobject loader, const jbyte *buf,
211 jclass (JNICALL *FindClass)
212 (JNIEnv *env, const char *name);
218 jclass (JNICALL *GetSuperclass)
219 (JNIEnv *env, jclass sub);
220 jboolean (JNICALL *IsAssignableFrom)
221 (JNIEnv *env, jclass sub, jclass sup);
225 jint (JNICALL *Throw)
226 (JNIEnv *env, jthrowable obj);
227 jint (JNICALL *ThrowNew)
228 (JNIEnv *env, jclass clazz, const char *msg);
229 jthrowable (JNICALL *ExceptionOccurred)
231 void (JNICALL *ExceptionDescribe)
233 void (JNICALL *ExceptionClear)
235 void (JNICALL *FatalError)
236 (JNIEnv *env, const char *msg);
240 jobject (JNICALL *NewGlobalRef)
241 (JNIEnv *env, jobject lobj);
242 void (JNICALL *DeleteGlobalRef)
243 (JNIEnv *env, jobject gref);
244 void (JNICALL *DeleteLocalRef)
245 (JNIEnv *env, jobject obj);
246 jboolean (JNICALL *IsSameObject)
247 (JNIEnv *env, jobject obj1, jobject obj2);
251 jobject (JNICALL *AllocObject)
252 (JNIEnv *env, jclass clazz);
253 jobject (JNICALL *NewObject)
254 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
255 jobject (JNICALL *NewObjectV)
256 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
257 jobject (JNICALL *NewObjectA)
258 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
260 jclass (JNICALL *GetObjectClass)
261 (JNIEnv *env, jobject obj);
262 jboolean (JNICALL *IsInstanceOf)
263 (JNIEnv *env, jobject obj, jclass clazz);
265 jmethodID (JNICALL *GetMethodID)
266 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
268 jobject (JNICALL *CallObjectMethod)
269 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
270 jobject (JNICALL *CallObjectMethodV)
271 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
272 jobject (JNICALL *CallObjectMethodA)
273 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
275 jboolean (JNICALL *CallBooleanMethod)
276 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
277 jboolean (JNICALL *CallBooleanMethodV)
278 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
279 jboolean (JNICALL *CallBooleanMethodA)
280 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
282 jbyte (JNICALL *CallByteMethod)
283 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
284 jbyte (JNICALL *CallByteMethodV)
285 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
286 jbyte (JNICALL *CallByteMethodA)
287 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
289 jchar (JNICALL *CallCharMethod)
290 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
291 jchar (JNICALL *CallCharMethodV)
292 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
293 jchar (JNICALL *CallCharMethodA)
294 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
296 jshort (JNICALL *CallShortMethod)
297 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
298 jshort (JNICALL *CallShortMethodV)
299 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
300 jshort (JNICALL *CallShortMethodA)
301 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
303 jint (JNICALL *CallIntMethod)
304 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
305 jint (JNICALL *CallIntMethodV)
306 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
307 jint (JNICALL *CallIntMethodA)
308 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
310 jlong (JNICALL *CallLongMethod)
311 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
312 jlong (JNICALL *CallLongMethodV)
313 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
314 jlong (JNICALL *CallLongMethodA)
315 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
317 jfloat (JNICALL *CallFloatMethod)
318 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
319 jfloat (JNICALL *CallFloatMethodV)
320 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
321 jfloat (JNICALL *CallFloatMethodA)
322 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
324 jdouble (JNICALL *CallDoubleMethod)
325 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
326 jdouble (JNICALL *CallDoubleMethodV)
327 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
328 jdouble (JNICALL *CallDoubleMethodA)
329 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue *args);
331 void (JNICALL *CallVoidMethod)
332 (JNIEnv *env, jobject obj, jmethodID methodID, ...);
333 void (JNICALL *CallVoidMethodV)
334 (JNIEnv *env, jobject obj, jmethodID methodID, va_list args);
335 void (JNICALL *CallVoidMethodA)
336 (JNIEnv *env, jobject obj, jmethodID methodID, jvalue * args);
338 jobject (JNICALL *CallNonvirtualObjectMethod)
339 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
340 jobject (JNICALL *CallNonvirtualObjectMethodV)
341 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
343 jobject (JNICALL *CallNonvirtualObjectMethodA)
344 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
347 jboolean (JNICALL *CallNonvirtualBooleanMethod)
348 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
349 jboolean (JNICALL *CallNonvirtualBooleanMethodV)
350 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
352 jboolean (JNICALL *CallNonvirtualBooleanMethodA)
353 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
356 jbyte (JNICALL *CallNonvirtualByteMethod)
357 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
358 jbyte (JNICALL *CallNonvirtualByteMethodV)
359 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
361 jbyte (JNICALL *CallNonvirtualByteMethodA)
362 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
365 jchar (JNICALL *CallNonvirtualCharMethod)
366 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
367 jchar (JNICALL *CallNonvirtualCharMethodV)
368 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
370 jchar (JNICALL *CallNonvirtualCharMethodA)
371 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
374 jshort (JNICALL *CallNonvirtualShortMethod)
375 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
376 jshort (JNICALL *CallNonvirtualShortMethodV)
377 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
379 jshort (JNICALL *CallNonvirtualShortMethodA)
380 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
383 jint (JNICALL *CallNonvirtualIntMethod)
384 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
385 jint (JNICALL *CallNonvirtualIntMethodV)
386 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
388 jint (JNICALL *CallNonvirtualIntMethodA)
389 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
392 jlong (JNICALL *CallNonvirtualLongMethod)
393 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
394 jlong (JNICALL *CallNonvirtualLongMethodV)
395 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
397 jlong (JNICALL *CallNonvirtualLongMethodA)
398 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
401 jfloat (JNICALL *CallNonvirtualFloatMethod)
402 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
403 jfloat (JNICALL *CallNonvirtualFloatMethodV)
404 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
406 jfloat (JNICALL *CallNonvirtualFloatMethodA)
407 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
410 jdouble (JNICALL *CallNonvirtualDoubleMethod)
411 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
412 jdouble (JNICALL *CallNonvirtualDoubleMethodV)
413 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
415 jdouble (JNICALL *CallNonvirtualDoubleMethodA)
416 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
419 void (JNICALL *CallNonvirtualVoidMethod)
420 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID, ...);
421 void (JNICALL *CallNonvirtualVoidMethodV)
422 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
424 void (JNICALL *CallNonvirtualVoidMethodA)
425 (JNIEnv *env, jobject obj, jclass clazz, jmethodID methodID,
428 jfieldID (JNICALL *GetFieldID)
429 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
431 jobject (JNICALL *GetObjectField)
432 (JNIEnv *env, jobject obj, jfieldID fieldID);
433 jboolean (JNICALL *GetBooleanField)
434 (JNIEnv *env, jobject obj, jfieldID fieldID);
435 jbyte (JNICALL *GetByteField)
436 (JNIEnv *env, jobject obj, jfieldID fieldID);
437 jchar (JNICALL *GetCharField)
438 (JNIEnv *env, jobject obj, jfieldID fieldID);
439 jshort (JNICALL *GetShortField)
440 (JNIEnv *env, jobject obj, jfieldID fieldID);
441 jint (JNICALL *GetIntField)
442 (JNIEnv *env, jobject obj, jfieldID fieldID);
443 jlong (JNICALL *GetLongField)
444 (JNIEnv *env, jobject obj, jfieldID fieldID);
445 jfloat (JNICALL *GetFloatField)
446 (JNIEnv *env, jobject obj, jfieldID fieldID);
447 jdouble (JNICALL *GetDoubleField)
448 (JNIEnv *env, jobject obj, jfieldID fieldID);
450 void (JNICALL *SetObjectField)
451 (JNIEnv *env, jobject obj, jfieldID fieldID, jobject val);
452 void (JNICALL *SetBooleanField)
453 (JNIEnv *env, jobject obj, jfieldID fieldID, jboolean val);
454 void (JNICALL *SetByteField)
455 (JNIEnv *env, jobject obj, jfieldID fieldID, jbyte val);
456 void (JNICALL *SetCharField)
457 (JNIEnv *env, jobject obj, jfieldID fieldID, jchar val);
458 void (JNICALL *SetShortField)
459 (JNIEnv *env, jobject obj, jfieldID fieldID, jshort val);
460 void (JNICALL *SetIntField)
461 (JNIEnv *env, jobject obj, jfieldID fieldID, jint val);
462 void (JNICALL *SetLongField)
463 (JNIEnv *env, jobject obj, jfieldID fieldID, jlong val);
464 void (JNICALL *SetFloatField)
465 (JNIEnv *env, jobject obj, jfieldID fieldID, jfloat val);
466 void (JNICALL *SetDoubleField)
467 (JNIEnv *env, jobject obj, jfieldID fieldID, jdouble val);
469 jmethodID (JNICALL *GetStaticMethodID)
470 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
472 jobject (JNICALL *CallStaticObjectMethod)
473 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
474 jobject (JNICALL *CallStaticObjectMethodV)
475 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
476 jobject (JNICALL *CallStaticObjectMethodA)
477 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
479 jboolean (JNICALL *CallStaticBooleanMethod)
480 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
481 jboolean (JNICALL *CallStaticBooleanMethodV)
482 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
483 jboolean (JNICALL *CallStaticBooleanMethodA)
484 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
486 jbyte (JNICALL *CallStaticByteMethod)
487 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
488 jbyte (JNICALL *CallStaticByteMethodV)
489 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
490 jbyte (JNICALL *CallStaticByteMethodA)
491 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
493 jchar (JNICALL *CallStaticCharMethod)
494 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
495 jchar (JNICALL *CallStaticCharMethodV)
496 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
497 jchar (JNICALL *CallStaticCharMethodA)
498 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
500 jshort (JNICALL *CallStaticShortMethod)
501 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
502 jshort (JNICALL *CallStaticShortMethodV)
503 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
504 jshort (JNICALL *CallStaticShortMethodA)
505 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
507 jint (JNICALL *CallStaticIntMethod)
508 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
509 jint (JNICALL *CallStaticIntMethodV)
510 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
511 jint (JNICALL *CallStaticIntMethodA)
512 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
514 jlong (JNICALL *CallStaticLongMethod)
515 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
516 jlong (JNICALL *CallStaticLongMethodV)
517 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
518 jlong (JNICALL *CallStaticLongMethodA)
519 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
521 jfloat (JNICALL *CallStaticFloatMethod)
522 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
523 jfloat (JNICALL *CallStaticFloatMethodV)
524 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
525 jfloat (JNICALL *CallStaticFloatMethodA)
526 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
528 jdouble (JNICALL *CallStaticDoubleMethod)
529 (JNIEnv *env, jclass clazz, jmethodID methodID, ...);
530 jdouble (JNICALL *CallStaticDoubleMethodV)
531 (JNIEnv *env, jclass clazz, jmethodID methodID, va_list args);
532 jdouble (JNICALL *CallStaticDoubleMethodA)
533 (JNIEnv *env, jclass clazz, jmethodID methodID, jvalue *args);
535 void (JNICALL *CallStaticVoidMethod)
536 (JNIEnv *env, jclass cls, jmethodID methodID, ...);
537 void (JNICALL *CallStaticVoidMethodV)
538 (JNIEnv *env, jclass cls, jmethodID methodID, va_list args);
539 void (JNICALL *CallStaticVoidMethodA)
540 (JNIEnv *env, jclass cls, jmethodID methodID, jvalue * args);
542 jfieldID (JNICALL *GetStaticFieldID)
543 (JNIEnv *env, jclass clazz, const char *name, const char *sig);
544 jobject (JNICALL *GetStaticObjectField)
545 (JNIEnv *env, jclass clazz, jfieldID fieldID);
546 jboolean (JNICALL *GetStaticBooleanField)
547 (JNIEnv *env, jclass clazz, jfieldID fieldID);
548 jbyte (JNICALL *GetStaticByteField)
549 (JNIEnv *env, jclass clazz, jfieldID fieldID);
550 jchar (JNICALL *GetStaticCharField)
551 (JNIEnv *env, jclass clazz, jfieldID fieldID);
552 jshort (JNICALL *GetStaticShortField)
553 (JNIEnv *env, jclass clazz, jfieldID fieldID);
554 jint (JNICALL *GetStaticIntField)
555 (JNIEnv *env, jclass clazz, jfieldID fieldID);
556 jlong (JNICALL *GetStaticLongField)
557 (JNIEnv *env, jclass clazz, jfieldID fieldID);
558 jfloat (JNICALL *GetStaticFloatField)
559 (JNIEnv *env, jclass clazz, jfieldID fieldID);
560 jdouble (JNICALL *GetStaticDoubleField)
561 (JNIEnv *env, jclass clazz, jfieldID fieldID);
563 void (JNICALL *SetStaticObjectField)
564 (JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value);
565 void (JNICALL *SetStaticBooleanField)
566 (JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value);
567 void (JNICALL *SetStaticByteField)
568 (JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value);
569 void (JNICALL *SetStaticCharField)
570 (JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value);
571 void (JNICALL *SetStaticShortField)
572 (JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value);
573 void (JNICALL *SetStaticIntField)
574 (JNIEnv *env, jclass clazz, jfieldID fieldID, jint value);
575 void (JNICALL *SetStaticLongField)
576 (JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value);
577 void (JNICALL *SetStaticFloatField)
578 (JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value);
579 void (JNICALL *SetStaticDoubleField)
580 (JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value);
582 jstring (JNICALL *NewString)
583 (JNIEnv *env, const jchar *unicode, jsize len);
584 jsize (JNICALL *GetStringLength)
585 (JNIEnv *env, jstring str);
586 const jchar *(JNICALL *GetStringChars)
587 (JNIEnv *env, jstring str, jboolean *isCopy);
588 void (JNICALL *ReleaseStringChars)
589 (JNIEnv *env, jstring str, const jchar *chars);
591 jstring (JNICALL *NewStringUTF)
592 (JNIEnv *env, const char *utf);
593 jsize (JNICALL *GetStringUTFLength)
594 (JNIEnv *env, jstring str);
595 const char* (JNICALL *GetStringUTFChars)
596 (JNIEnv *env, jstring str, jboolean *isCopy);
597 void (JNICALL *ReleaseStringUTFChars)
598 (JNIEnv *env, jstring str, const char* chars);
601 jsize (JNICALL *GetArrayLength)
602 (JNIEnv *env, jarray array);
604 jobjectArray (JNICALL *NewObjectArray)
605 (JNIEnv *env, jsize len, jclass clazz, jobject init);
606 jobject (JNICALL *GetObjectArrayElement)
607 (JNIEnv *env, jobjectArray array, jsize index);
608 void (JNICALL *SetObjectArrayElement)
609 (JNIEnv *env, jobjectArray array, jsize index, jobject val);
611 jbooleanArray (JNICALL *NewBooleanArray)
612 (JNIEnv *env, jsize len);
613 jbyteArray (JNICALL *NewByteArray)
614 (JNIEnv *env, jsize len);
615 jcharArray (JNICALL *NewCharArray)
616 (JNIEnv *env, jsize len);
617 jshortArray (JNICALL *NewShortArray)
618 (JNIEnv *env, jsize len);
619 jintArray (JNICALL *NewIntArray)
620 (JNIEnv *env, jsize len);
621 jlongArray (JNICALL *NewLongArray)
622 (JNIEnv *env, jsize len);
623 jfloatArray (JNICALL *NewFloatArray)
624 (JNIEnv *env, jsize len);
625 jdoubleArray (JNICALL *NewDoubleArray)
626 (JNIEnv *env, jsize len);
628 jboolean * (JNICALL *GetBooleanArrayElements)
629 (JNIEnv *env, jbooleanArray array, jboolean *isCopy);
630 jbyte * (JNICALL *GetByteArrayElements)
631 (JNIEnv *env, jbyteArray array, jboolean *isCopy);
632 jchar * (JNICALL *GetCharArrayElements)
633 (JNIEnv *env, jcharArray array, jboolean *isCopy);
634 jshort * (JNICALL *GetShortArrayElements)
635 (JNIEnv *env, jshortArray array, jboolean *isCopy);
636 jint * (JNICALL *GetIntArrayElements)
637 (JNIEnv *env, jintArray array, jboolean *isCopy);
638 jlong * (JNICALL *GetLongArrayElements)
639 (JNIEnv *env, jlongArray array, jboolean *isCopy);
640 jfloat * (JNICALL *GetFloatArrayElements)
641 (JNIEnv *env, jfloatArray array, jboolean *isCopy);
642 jdouble * (JNICALL *GetDoubleArrayElements)
643 (JNIEnv *env, jdoubleArray array, jboolean *isCopy);
645 void (JNICALL *ReleaseBooleanArrayElements)
646 (JNIEnv *env, jbooleanArray array, jboolean *elems, jint mode);
647 void (JNICALL *ReleaseByteArrayElements)
648 (JNIEnv *env, jbyteArray array, jbyte *elems, jint mode);
649 void (JNICALL *ReleaseCharArrayElements)
650 (JNIEnv *env, jcharArray array, jchar *elems, jint mode);
651 void (JNICALL *ReleaseShortArrayElements)
652 (JNIEnv *env, jshortArray array, jshort *elems, jint mode);
653 void (JNICALL *ReleaseIntArrayElements)
654 (JNIEnv *env, jintArray array, jint *elems, jint mode);
655 void (JNICALL *ReleaseLongArrayElements)
656 (JNIEnv *env, jlongArray array, jlong *elems, jint mode);
657 void (JNICALL *ReleaseFloatArrayElements)
658 (JNIEnv *env, jfloatArray array, jfloat *elems, jint mode);
659 void (JNICALL *ReleaseDoubleArrayElements)
660 (JNIEnv *env, jdoubleArray array, jdouble *elems, jint mode);
662 void (JNICALL *GetBooleanArrayRegion)
663 (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
664 void (JNICALL *GetByteArrayRegion)
665 (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
666 void (JNICALL *GetCharArrayRegion)
667 (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
668 void (JNICALL *GetShortArrayRegion)
669 (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
670 void (JNICALL *GetIntArrayRegion)
671 (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
672 void (JNICALL *GetLongArrayRegion)
673 (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
674 void (JNICALL *GetFloatArrayRegion)
675 (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
676 void (JNICALL *GetDoubleArrayRegion)
677 (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
679 void (JNICALL *SetBooleanArrayRegion)
680 (JNIEnv *env, jbooleanArray array, jsize start, jsize l, jboolean *buf);
681 void (JNICALL *SetByteArrayRegion)
682 (JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf);
683 void (JNICALL *SetCharArrayRegion)
684 (JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf);
685 void (JNICALL *SetShortArrayRegion)
686 (JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf);
687 void (JNICALL *SetIntArrayRegion)
688 (JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf);
689 void (JNICALL *SetLongArrayRegion)
690 (JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf);
691 void (JNICALL *SetFloatArrayRegion)
692 (JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf);
693 void (JNICALL *SetDoubleArrayRegion)
694 (JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf);
696 jint (JNICALL *RegisterNatives)
697 (JNIEnv *env, jclass clazz, const JNINativeMethod *methods,
699 jint (JNICALL *UnregisterNatives)
700 (JNIEnv *env, jclass clazz);
702 jint (JNICALL *MonitorEnter)
703 (JNIEnv *env, jobject obj);
704 jint (JNICALL *MonitorExit)
705 (JNIEnv *env, jobject obj);
707 jint (JNICALL *GetJavaVM)
708 (JNIEnv *env, JavaVM **vm);
712 * We use inlined functions for C++ so that programmers can write:
714 * env->FindClass("java/lang/String")
716 * in C++ rather than:
718 * (*env)->FindClass(env, "java/lang/String")
724 const struct JNINativeInterface_ *functions;
730 return functions->GetVersion(this);
732 jclass DefineClass(const char *name, jobject loader, const jbyte *buf,
734 return functions->DefineClass(this, name, loader, buf, len);
736 jclass FindClass(const char *name) {
737 return functions->FindClass(this, name);
739 jclass GetSuperclass(jclass sub) {
740 return functions->GetSuperclass(this, sub);
742 jboolean IsAssignableFrom(jclass sub, jclass sup) {
743 return functions->IsAssignableFrom(this, sub, sup);
746 jint Throw(jthrowable obj) {
747 return functions->Throw(this, obj);
749 jint ThrowNew(jclass clazz, const char *msg) {
750 return functions->ThrowNew(this, clazz, msg);
752 jthrowable ExceptionOccurred() {
753 return functions->ExceptionOccurred(this);
755 void ExceptionDescribe() {
756 functions->ExceptionDescribe(this);
758 void ExceptionClear() {
759 functions->ExceptionClear(this);
761 void FatalError(const char *msg) {
762 functions->FatalError(this, msg);
765 jobject NewGlobalRef(jobject lobj) {
766 return functions->NewGlobalRef(this,lobj);
768 void DeleteGlobalRef(jobject gref) {
769 functions->DeleteGlobalRef(this,gref);
771 void DeleteLocalRef(jobject obj) {
772 functions->DeleteLocalRef(this, obj);
775 jboolean IsSameObject(jobject obj1, jobject obj2) {
776 return functions->IsSameObject(this,obj1,obj2);
779 jobject AllocObject(jclass clazz) {
780 return functions->AllocObject(this,clazz);
782 jobject NewObject(jclass clazz, jmethodID methodID, ...) {
785 va_start(args, methodID);
786 result = functions->NewObjectV(this,clazz,methodID,args);
790 jobject NewObjectV(jclass clazz, jmethodID methodID,
792 return functions->NewObjectV(this,clazz,methodID,args);
794 jobject NewObjectA(jclass clazz, jmethodID methodID,
796 return functions->NewObjectA(this,clazz,methodID,args);
799 jclass GetObjectClass(jobject obj) {
800 return functions->GetObjectClass(this,obj);
802 jboolean IsInstanceOf(jobject obj, jclass clazz) {
803 return functions->IsInstanceOf(this,obj,clazz);
806 jmethodID GetMethodID(jclass clazz, const char *name,
808 return functions->GetMethodID(this,clazz,name,sig);
811 jobject CallObjectMethod(jobject obj, jmethodID methodID, ...) {
814 va_start(args,methodID);
815 result = functions->CallObjectMethodV(this,obj,methodID,args);
819 jobject CallObjectMethodV(jobject obj, jmethodID methodID,
821 return functions->CallObjectMethodV(this,obj,methodID,args);
823 jobject CallObjectMethodA(jobject obj, jmethodID methodID,
825 return functions->CallObjectMethodA(this,obj,methodID,args);
828 jboolean CallBooleanMethod(jobject obj,
829 jmethodID methodID, ...) {
832 va_start(args,methodID);
833 result = functions->CallBooleanMethodV(this,obj,methodID,args);
837 jboolean CallBooleanMethodV(jobject obj, jmethodID methodID,
839 return functions->CallBooleanMethodV(this,obj,methodID,args);
841 jboolean CallBooleanMethodA(jobject obj, jmethodID methodID,
843 return functions->CallBooleanMethodA(this,obj,methodID, args);
846 jbyte CallByteMethod(jobject obj, jmethodID methodID, ...) {
849 va_start(args,methodID);
850 result = functions->CallByteMethodV(this,obj,methodID,args);
854 jbyte CallByteMethodV(jobject obj, jmethodID methodID,
856 return functions->CallByteMethodV(this,obj,methodID,args);
858 jbyte CallByteMethodA(jobject obj, jmethodID methodID,
860 return functions->CallByteMethodA(this,obj,methodID,args);
863 jchar CallCharMethod(jobject obj, jmethodID methodID, ...) {
866 va_start(args,methodID);
867 result = functions->CallCharMethodV(this,obj,methodID,args);
871 jchar CallCharMethodV(jobject obj, jmethodID methodID,
873 return functions->CallCharMethodV(this,obj,methodID,args);
875 jchar CallCharMethodA(jobject obj, jmethodID methodID,
877 return functions->CallCharMethodA(this,obj,methodID,args);
880 jshort CallShortMethod(jobject obj, jmethodID methodID, ...) {
883 va_start(args,methodID);
884 result = functions->CallShortMethodV(this,obj,methodID,args);
888 jshort CallShortMethodV(jobject obj, jmethodID methodID,
890 return functions->CallShortMethodV(this,obj,methodID,args);
892 jshort CallShortMethodA(jobject obj, jmethodID methodID,
894 return functions->CallShortMethodA(this,obj,methodID,args);
897 jint CallIntMethod(jobject obj, jmethodID methodID, ...) {
900 va_start(args,methodID);
901 result = functions->CallIntMethodV(this,obj,methodID,args);
905 jint CallIntMethodV(jobject obj, jmethodID methodID,
907 return functions->CallIntMethodV(this,obj,methodID,args);
909 jint CallIntMethodA(jobject obj, jmethodID methodID,
911 return functions->CallIntMethodA(this,obj,methodID,args);
914 jlong CallLongMethod(jobject obj, jmethodID methodID, ...) {
917 va_start(args,methodID);
918 result = functions->CallLongMethodV(this,obj,methodID,args);
922 jlong CallLongMethodV(jobject obj, jmethodID methodID,
924 return functions->CallLongMethodV(this,obj,methodID,args);
926 jlong CallLongMethodA(jobject obj, jmethodID methodID,
928 return functions->CallLongMethodA(this,obj,methodID,args);
931 jfloat CallFloatMethod(jobject obj, jmethodID methodID, ...) {
934 va_start(args,methodID);
935 result = functions->CallFloatMethodV(this,obj,methodID,args);
939 jfloat CallFloatMethodV(jobject obj, jmethodID methodID,
941 return functions->CallFloatMethodV(this,obj,methodID,args);
943 jfloat CallFloatMethodA(jobject obj, jmethodID methodID,
945 return functions->CallFloatMethodA(this,obj,methodID,args);
948 jdouble CallDoubleMethod(jobject obj, jmethodID methodID, ...) {
951 va_start(args,methodID);
952 result = functions->CallDoubleMethodV(this,obj,methodID,args);
956 jdouble CallDoubleMethodV(jobject obj, jmethodID methodID,
958 return functions->CallDoubleMethodV(this,obj,methodID,args);
960 jdouble CallDoubleMethodA(jobject obj, jmethodID methodID,
962 return functions->CallDoubleMethodA(this,obj,methodID,args);
965 void CallVoidMethod(jobject obj, jmethodID methodID, ...) {
967 va_start(args,methodID);
968 functions->CallVoidMethodV(this,obj,methodID,args);
971 void CallVoidMethodV(jobject obj, jmethodID methodID,
973 functions->CallVoidMethodV(this,obj,methodID,args);
975 void CallVoidMethodA(jobject obj, jmethodID methodID,
977 functions->CallVoidMethodA(this,obj,methodID,args);
980 jobject CallNonvirtualObjectMethod(jobject obj, jclass clazz,
981 jmethodID methodID, ...) {
984 va_start(args,methodID);
985 result = functions->CallNonvirtualObjectMethodV(this,obj,clazz,
990 jobject CallNonvirtualObjectMethodV(jobject obj, jclass clazz,
991 jmethodID methodID, va_list args) {
992 return functions->CallNonvirtualObjectMethodV(this,obj,clazz,
995 jobject CallNonvirtualObjectMethodA(jobject obj, jclass clazz,
996 jmethodID methodID, jvalue * args) {
997 return functions->CallNonvirtualObjectMethodA(this,obj,clazz,
1001 jboolean CallNonvirtualBooleanMethod(jobject obj, jclass clazz,
1002 jmethodID methodID, ...) {
1005 va_start(args,methodID);
1006 result = functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1011 jboolean CallNonvirtualBooleanMethodV(jobject obj, jclass clazz,
1012 jmethodID methodID, va_list args) {
1013 return functions->CallNonvirtualBooleanMethodV(this,obj,clazz,
1016 jboolean CallNonvirtualBooleanMethodA(jobject obj, jclass clazz,
1017 jmethodID methodID, jvalue * args) {
1018 return functions->CallNonvirtualBooleanMethodA(this,obj,clazz,
1022 jbyte CallNonvirtualByteMethod(jobject obj, jclass clazz,
1023 jmethodID methodID, ...) {
1026 va_start(args,methodID);
1027 result = functions->CallNonvirtualByteMethodV(this,obj,clazz,
1032 jbyte CallNonvirtualByteMethodV(jobject obj, jclass clazz,
1033 jmethodID methodID, va_list args) {
1034 return functions->CallNonvirtualByteMethodV(this,obj,clazz,
1037 jbyte CallNonvirtualByteMethodA(jobject obj, jclass clazz,
1038 jmethodID methodID, jvalue * args) {
1039 return functions->CallNonvirtualByteMethodA(this,obj,clazz,
1043 jchar CallNonvirtualCharMethod(jobject obj, jclass clazz,
1044 jmethodID methodID, ...) {
1047 va_start(args,methodID);
1048 result = functions->CallNonvirtualCharMethodV(this,obj,clazz,
1053 jchar CallNonvirtualCharMethodV(jobject obj, jclass clazz,
1054 jmethodID methodID, va_list args) {
1055 return functions->CallNonvirtualCharMethodV(this,obj,clazz,
1058 jchar CallNonvirtualCharMethodA(jobject obj, jclass clazz,
1059 jmethodID methodID, jvalue * args) {
1060 return functions->CallNonvirtualCharMethodA(this,obj,clazz,
1064 jshort CallNonvirtualShortMethod(jobject obj, jclass clazz,
1065 jmethodID methodID, ...) {
1068 va_start(args,methodID);
1069 result = functions->CallNonvirtualShortMethodV(this,obj,clazz,
1074 jshort CallNonvirtualShortMethodV(jobject obj, jclass clazz,
1075 jmethodID methodID, va_list args) {
1076 return functions->CallNonvirtualShortMethodV(this,obj,clazz,
1079 jshort CallNonvirtualShortMethodA(jobject obj, jclass clazz,
1080 jmethodID methodID, jvalue * args) {
1081 return functions->CallNonvirtualShortMethodA(this,obj,clazz,
1085 jint CallNonvirtualIntMethod(jobject obj, jclass clazz,
1086 jmethodID methodID, ...) {
1089 va_start(args,methodID);
1090 result = functions->CallNonvirtualIntMethodV(this,obj,clazz,
1095 jint CallNonvirtualIntMethodV(jobject obj, jclass clazz,
1096 jmethodID methodID, va_list args) {
1097 return functions->CallNonvirtualIntMethodV(this,obj,clazz,
1100 jint CallNonvirtualIntMethodA(jobject obj, jclass clazz,
1101 jmethodID methodID, jvalue * args) {
1102 return functions->CallNonvirtualIntMethodA(this,obj,clazz,
1106 jlong CallNonvirtualLongMethod(jobject obj, jclass clazz,
1107 jmethodID methodID, ...) {
1110 va_start(args,methodID);
1111 result = functions->CallNonvirtualLongMethodV(this,obj,clazz,
1116 jlong CallNonvirtualLongMethodV(jobject obj, jclass clazz,
1117 jmethodID methodID, va_list args) {
1118 return functions->CallNonvirtualLongMethodV(this,obj,clazz,
1121 jlong CallNonvirtualLongMethodA(jobject obj, jclass clazz,
1122 jmethodID methodID, jvalue * args) {
1123 return functions->CallNonvirtualLongMethodA(this,obj,clazz,
1127 jfloat CallNonvirtualFloatMethod(jobject obj, jclass clazz,
1128 jmethodID methodID, ...) {
1131 va_start(args,methodID);
1132 result = functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1137 jfloat CallNonvirtualFloatMethodV(jobject obj, jclass clazz,
1140 return functions->CallNonvirtualFloatMethodV(this,obj,clazz,
1143 jfloat CallNonvirtualFloatMethodA(jobject obj, jclass clazz,
1146 return functions->CallNonvirtualFloatMethodA(this,obj,clazz,
1150 jdouble CallNonvirtualDoubleMethod(jobject obj, jclass clazz,
1151 jmethodID methodID, ...) {
1154 va_start(args,methodID);
1155 result = functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1160 jdouble CallNonvirtualDoubleMethodV(jobject obj, jclass clazz,
1163 return functions->CallNonvirtualDoubleMethodV(this,obj,clazz,
1166 jdouble CallNonvirtualDoubleMethodA(jobject obj, jclass clazz,
1169 return functions->CallNonvirtualDoubleMethodA(this,obj,clazz,
1173 void CallNonvirtualVoidMethod(jobject obj, jclass clazz,
1174 jmethodID methodID, ...) {
1176 va_start(args,methodID);
1177 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1180 void CallNonvirtualVoidMethodV(jobject obj, jclass clazz,
1183 functions->CallNonvirtualVoidMethodV(this,obj,clazz,methodID,args);
1185 void CallNonvirtualVoidMethodA(jobject obj, jclass clazz,
1188 functions->CallNonvirtualVoidMethodA(this,obj,clazz,methodID,args);
1191 jfieldID GetFieldID(jclass clazz, const char *name,
1193 return functions->GetFieldID(this,clazz,name,sig);
1196 jobject GetObjectField(jobject obj, jfieldID fieldID) {
1197 return functions->GetObjectField(this,obj,fieldID);
1199 jboolean GetBooleanField(jobject obj, jfieldID fieldID) {
1200 return functions->GetBooleanField(this,obj,fieldID);
1202 jbyte GetByteField(jobject obj, jfieldID fieldID) {
1203 return functions->GetByteField(this,obj,fieldID);
1205 jchar GetCharField(jobject obj, jfieldID fieldID) {
1206 return functions->GetCharField(this,obj,fieldID);
1208 jshort GetShortField(jobject obj, jfieldID fieldID) {
1209 return functions->GetShortField(this,obj,fieldID);
1211 jint GetIntField(jobject obj, jfieldID fieldID) {
1212 return functions->GetIntField(this,obj,fieldID);
1214 jlong GetLongField(jobject obj, jfieldID fieldID) {
1215 return functions->GetLongField(this,obj,fieldID);
1217 jfloat GetFloatField(jobject obj, jfieldID fieldID) {
1218 return functions->GetFloatField(this,obj,fieldID);
1220 jdouble GetDoubleField(jobject obj, jfieldID fieldID) {
1221 return functions->GetDoubleField(this,obj,fieldID);
1224 void SetObjectField(jobject obj, jfieldID fieldID, jobject val) {
1225 functions->SetObjectField(this,obj,fieldID,val);
1227 void SetBooleanField(jobject obj, jfieldID fieldID,
1229 functions->SetBooleanField(this,obj,fieldID,val);
1231 void SetByteField(jobject obj, jfieldID fieldID,
1233 functions->SetByteField(this,obj,fieldID,val);
1235 void SetCharField(jobject obj, jfieldID fieldID,
1237 functions->SetCharField(this,obj,fieldID,val);
1239 void SetShortField(jobject obj, jfieldID fieldID,
1241 functions->SetShortField(this,obj,fieldID,val);
1243 void SetIntField(jobject obj, jfieldID fieldID,
1245 functions->SetIntField(this,obj,fieldID,val);
1247 void SetLongField(jobject obj, jfieldID fieldID,
1249 functions->SetLongField(this,obj,fieldID,val);
1251 void SetFloatField(jobject obj, jfieldID fieldID,
1253 functions->SetFloatField(this,obj,fieldID,val);
1255 void SetDoubleField(jobject obj, jfieldID fieldID,
1257 functions->SetDoubleField(this,obj,fieldID,val);
1260 jmethodID GetStaticMethodID(jclass clazz, const char *name,
1262 return functions->GetStaticMethodID(this,clazz,name,sig);
1265 jobject CallStaticObjectMethod(jclass clazz, jmethodID methodID,
1269 va_start(args,methodID);
1270 result = functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1274 jobject CallStaticObjectMethodV(jclass clazz, jmethodID methodID,
1276 return functions->CallStaticObjectMethodV(this,clazz,methodID,args);
1278 jobject CallStaticObjectMethodA(jclass clazz, jmethodID methodID,
1280 return functions->CallStaticObjectMethodA(this,clazz,methodID,args);
1283 jboolean CallStaticBooleanMethod(jclass clazz,
1284 jmethodID methodID, ...) {
1287 va_start(args,methodID);
1288 result = functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1292 jboolean CallStaticBooleanMethodV(jclass clazz,
1293 jmethodID methodID, va_list args) {
1294 return functions->CallStaticBooleanMethodV(this,clazz,methodID,args);
1296 jboolean CallStaticBooleanMethodA(jclass clazz,
1297 jmethodID methodID, jvalue *args) {
1298 return functions->CallStaticBooleanMethodA(this,clazz,methodID,args);
1301 jbyte CallStaticByteMethod(jclass clazz,
1302 jmethodID methodID, ...) {
1305 va_start(args,methodID);
1306 result = functions->CallStaticByteMethodV(this,clazz,methodID,args);
1310 jbyte CallStaticByteMethodV(jclass clazz,
1311 jmethodID methodID, va_list args) {
1312 return functions->CallStaticByteMethodV(this,clazz,methodID,args);
1314 jbyte CallStaticByteMethodA(jclass clazz,
1315 jmethodID methodID, jvalue *args) {
1316 return functions->CallStaticByteMethodA(this,clazz,methodID,args);
1319 jchar CallStaticCharMethod(jclass clazz,
1320 jmethodID methodID, ...) {
1323 va_start(args,methodID);
1324 result = functions->CallStaticCharMethodV(this,clazz,methodID,args);
1328 jchar CallStaticCharMethodV(jclass clazz,
1329 jmethodID methodID, va_list args) {
1330 return functions->CallStaticCharMethodV(this,clazz,methodID,args);
1332 jchar CallStaticCharMethodA(jclass clazz,
1333 jmethodID methodID, jvalue *args) {
1334 return functions->CallStaticCharMethodA(this,clazz,methodID,args);
1337 jshort CallStaticShortMethod(jclass clazz,
1338 jmethodID methodID, ...) {
1341 va_start(args,methodID);
1342 result = functions->CallStaticShortMethodV(this,clazz,methodID,args);
1346 jshort CallStaticShortMethodV(jclass clazz,
1347 jmethodID methodID, va_list args) {
1348 return functions->CallStaticShortMethodV(this,clazz,methodID,args);
1350 jshort CallStaticShortMethodA(jclass clazz,
1351 jmethodID methodID, jvalue *args) {
1352 return functions->CallStaticShortMethodA(this,clazz,methodID,args);
1355 jint CallStaticIntMethod(jclass clazz,
1356 jmethodID methodID, ...) {
1359 va_start(args,methodID);
1360 result = functions->CallStaticIntMethodV(this,clazz,methodID,args);
1364 jint CallStaticIntMethodV(jclass clazz,
1365 jmethodID methodID, va_list args) {
1366 return functions->CallStaticIntMethodV(this,clazz,methodID,args);
1368 jint CallStaticIntMethodA(jclass clazz,
1369 jmethodID methodID, jvalue *args) {
1370 return functions->CallStaticIntMethodA(this,clazz,methodID,args);
1373 jlong CallStaticLongMethod(jclass clazz,
1374 jmethodID methodID, ...) {
1377 va_start(args,methodID);
1378 result = functions->CallStaticLongMethodV(this,clazz,methodID,args);
1382 jlong CallStaticLongMethodV(jclass clazz,
1383 jmethodID methodID, va_list args) {
1384 return functions->CallStaticLongMethodV(this,clazz,methodID,args);
1386 jlong CallStaticLongMethodA(jclass clazz,
1387 jmethodID methodID, jvalue *args) {
1388 return functions->CallStaticLongMethodA(this,clazz,methodID,args);
1391 jfloat CallStaticFloatMethod(jclass clazz,
1392 jmethodID methodID, ...) {
1395 va_start(args,methodID);
1396 result = functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1400 jfloat CallStaticFloatMethodV(jclass clazz,
1401 jmethodID methodID, va_list args) {
1402 return functions->CallStaticFloatMethodV(this,clazz,methodID,args);
1404 jfloat CallStaticFloatMethodA(jclass clazz,
1405 jmethodID methodID, jvalue *args) {
1406 return functions->CallStaticFloatMethodA(this,clazz,methodID,args);
1409 jdouble CallStaticDoubleMethod(jclass clazz,
1410 jmethodID methodID, ...) {
1413 va_start(args,methodID);
1414 result = functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1418 jdouble CallStaticDoubleMethodV(jclass clazz,
1419 jmethodID methodID, va_list args) {
1420 return functions->CallStaticDoubleMethodV(this,clazz,methodID,args);
1422 jdouble CallStaticDoubleMethodA(jclass clazz,
1423 jmethodID methodID, jvalue *args) {
1424 return functions->CallStaticDoubleMethodA(this,clazz,methodID,args);
1427 void CallStaticVoidMethod(jclass cls, jmethodID methodID, ...) {
1429 va_start(args,methodID);
1430 functions->CallStaticVoidMethodV(this,cls,methodID,args);
1433 void CallStaticVoidMethodV(jclass cls, jmethodID methodID,
1435 functions->CallStaticVoidMethodV(this,cls,methodID,args);
1437 void CallStaticVoidMethodA(jclass cls, jmethodID methodID,
1439 functions->CallStaticVoidMethodA(this,cls,methodID,args);
1442 jfieldID GetStaticFieldID(jclass clazz, const char *name,
1444 return functions->GetStaticFieldID(this,clazz,name,sig);
1446 jobject GetStaticObjectField(jclass clazz, jfieldID fieldID) {
1447 return functions->GetStaticObjectField(this,clazz,fieldID);
1449 jboolean GetStaticBooleanField(jclass clazz, jfieldID fieldID) {
1450 return functions->GetStaticBooleanField(this,clazz,fieldID);
1452 jbyte GetStaticByteField(jclass clazz, jfieldID fieldID) {
1453 return functions->GetStaticByteField(this,clazz,fieldID);
1455 jchar GetStaticCharField(jclass clazz, jfieldID fieldID) {
1456 return functions->GetStaticCharField(this,clazz,fieldID);
1458 jshort GetStaticShortField(jclass clazz, jfieldID fieldID) {
1459 return functions->GetStaticShortField(this,clazz,fieldID);
1461 jint GetStaticIntField(jclass clazz, jfieldID fieldID) {
1462 return functions->GetStaticIntField(this,clazz,fieldID);
1464 jlong GetStaticLongField(jclass clazz, jfieldID fieldID) {
1465 return functions->GetStaticLongField(this,clazz,fieldID);
1467 jfloat GetStaticFloatField(jclass clazz, jfieldID fieldID) {
1468 return functions->GetStaticFloatField(this,clazz,fieldID);
1470 jdouble GetStaticDoubleField(jclass clazz, jfieldID fieldID) {
1471 return functions->GetStaticDoubleField(this,clazz,fieldID);
1474 void SetStaticObjectField(jclass clazz, jfieldID fieldID,
1476 functions->SetStaticObjectField(this,clazz,fieldID,value);
1478 void SetStaticBooleanField(jclass clazz, jfieldID fieldID,
1480 functions->SetStaticBooleanField(this,clazz,fieldID,value);
1482 void SetStaticByteField(jclass clazz, jfieldID fieldID,
1484 functions->SetStaticByteField(this,clazz,fieldID,value);
1486 void SetStaticCharField(jclass clazz, jfieldID fieldID,
1488 functions->SetStaticCharField(this,clazz,fieldID,value);
1490 void SetStaticShortField(jclass clazz, jfieldID fieldID,
1492 functions->SetStaticShortField(this,clazz,fieldID,value);
1494 void SetStaticIntField(jclass clazz, jfieldID fieldID,
1496 functions->SetStaticIntField(this,clazz,fieldID,value);
1498 void SetStaticLongField(jclass clazz, jfieldID fieldID,
1500 functions->SetStaticLongField(this,clazz,fieldID,value);
1502 void SetStaticFloatField(jclass clazz, jfieldID fieldID,
1504 functions->SetStaticFloatField(this,clazz,fieldID,value);
1506 void SetStaticDoubleField(jclass clazz, jfieldID fieldID,
1508 functions->SetStaticDoubleField(this,clazz,fieldID,value);
1511 jstring NewString(const jchar *unicode, jsize len) {
1512 return functions->NewString(this,unicode,len);
1514 jsize GetStringLength(jstring str) {
1515 return functions->GetStringLength(this,str);
1517 const jchar *GetStringChars(jstring str, jboolean *isCopy) {
1518 return functions->GetStringChars(this,str,isCopy);
1520 void ReleaseStringChars(jstring str, const jchar *chars) {
1521 functions->ReleaseStringChars(this,str,chars);
1524 jstring NewStringUTF(const char *utf) {
1525 return functions->NewStringUTF(this,utf);
1527 jsize GetStringUTFLength(jstring str) {
1528 return functions->GetStringUTFLength(this,str);
1530 const char* GetStringUTFChars(jstring str, jboolean *isCopy) {
1531 return functions->GetStringUTFChars(this,str,isCopy);
1533 void ReleaseStringUTFChars(jstring str, const char* chars) {
1534 functions->ReleaseStringUTFChars(this,str,chars);
1537 jsize GetArrayLength(jarray array) {
1538 return functions->GetArrayLength(this,array);
1541 jobjectArray NewObjectArray(jsize len, jclass clazz,
1543 return functions->NewObjectArray(this,len,clazz,init);
1545 jobject GetObjectArrayElement(jobjectArray array, jsize index) {
1546 return functions->GetObjectArrayElement(this,array,index);
1548 void SetObjectArrayElement(jobjectArray array, jsize index,
1550 functions->SetObjectArrayElement(this,array,index,val);
1553 jbooleanArray NewBooleanArray(jsize len) {
1554 return functions->NewBooleanArray(this,len);
1556 jbyteArray NewByteArray(jsize len) {
1557 return functions->NewByteArray(this,len);
1559 jcharArray NewCharArray(jsize len) {
1560 return functions->NewCharArray(this,len);
1562 jshortArray NewShortArray(jsize len) {
1563 return functions->NewShortArray(this,len);
1565 jintArray NewIntArray(jsize len) {
1566 return functions->NewIntArray(this,len);
1568 jlongArray NewLongArray(jsize len) {
1569 return functions->NewLongArray(this,len);
1571 jfloatArray NewFloatArray(jsize len) {
1572 return functions->NewFloatArray(this,len);
1574 jdoubleArray NewDoubleArray(jsize len) {
1575 return functions->NewDoubleArray(this,len);
1578 jboolean * GetBooleanArrayElements(jbooleanArray array, jboolean *isCopy) {
1579 return functions->GetBooleanArrayElements(this,array,isCopy);
1581 jbyte * GetByteArrayElements(jbyteArray array, jboolean *isCopy) {
1582 return functions->GetByteArrayElements(this,array,isCopy);
1584 jchar * GetCharArrayElements(jcharArray array, jboolean *isCopy) {
1585 return functions->GetCharArrayElements(this,array,isCopy);
1587 jshort * GetShortArrayElements(jshortArray array, jboolean *isCopy) {
1588 return functions->GetShortArrayElements(this,array,isCopy);
1590 jint * GetIntArrayElements(jintArray array, jboolean *isCopy) {
1591 return functions->GetIntArrayElements(this,array,isCopy);
1593 jlong * GetLongArrayElements(jlongArray array, jboolean *isCopy) {
1594 return functions->GetLongArrayElements(this,array,isCopy);
1596 jfloat * GetFloatArrayElements(jfloatArray array, jboolean *isCopy) {
1597 return functions->GetFloatArrayElements(this,array,isCopy);
1599 jdouble * GetDoubleArrayElements(jdoubleArray array, jboolean *isCopy) {
1600 return functions->GetDoubleArrayElements(this,array,isCopy);
1603 void ReleaseBooleanArrayElements(jbooleanArray array,
1606 functions->ReleaseBooleanArrayElements(this,array,elems,mode);
1608 void ReleaseByteArrayElements(jbyteArray array,
1611 functions->ReleaseByteArrayElements(this,array,elems,mode);
1613 void ReleaseCharArrayElements(jcharArray array,
1616 functions->ReleaseCharArrayElements(this,array,elems,mode);
1618 void ReleaseShortArrayElements(jshortArray array,
1621 functions->ReleaseShortArrayElements(this,array,elems,mode);
1623 void ReleaseIntArrayElements(jintArray array,
1626 functions->ReleaseIntArrayElements(this,array,elems,mode);
1628 void ReleaseLongArrayElements(jlongArray array,
1631 functions->ReleaseLongArrayElements(this,array,elems,mode);
1633 void ReleaseFloatArrayElements(jfloatArray array,
1636 functions->ReleaseFloatArrayElements(this,array,elems,mode);
1638 void ReleaseDoubleArrayElements(jdoubleArray array,
1641 functions->ReleaseDoubleArrayElements(this,array,elems,mode);
1644 void GetBooleanArrayRegion(jbooleanArray array,
1645 jsize start, jsize len, jboolean *buf) {
1646 functions->GetBooleanArrayRegion(this,array,start,len,buf);
1648 void GetByteArrayRegion(jbyteArray array,
1649 jsize start, jsize len, jbyte *buf) {
1650 functions->GetByteArrayRegion(this,array,start,len,buf);
1652 void GetCharArrayRegion(jcharArray array,
1653 jsize start, jsize len, jchar *buf) {
1654 functions->GetCharArrayRegion(this,array,start,len,buf);
1656 void GetShortArrayRegion(jshortArray array,
1657 jsize start, jsize len, jshort *buf) {
1658 functions->GetShortArrayRegion(this,array,start,len,buf);
1660 void GetIntArrayRegion(jintArray array,
1661 jsize start, jsize len, jint *buf) {
1662 functions->GetIntArrayRegion(this,array,start,len,buf);
1664 void GetLongArrayRegion(jlongArray array,
1665 jsize start, jsize len, jlong *buf) {
1666 functions->GetLongArrayRegion(this,array,start,len,buf);
1668 void GetFloatArrayRegion(jfloatArray array,
1669 jsize start, jsize len, jfloat *buf) {
1670 functions->GetFloatArrayRegion(this,array,start,len,buf);
1672 void GetDoubleArrayRegion(jdoubleArray array,
1673 jsize start, jsize len, jdouble *buf) {
1674 functions->GetDoubleArrayRegion(this,array,start,len,buf);
1677 void SetBooleanArrayRegion(jbooleanArray array, jsize start, jsize len,
1679 functions->SetBooleanArrayRegion(this,array,start,len,buf);
1681 void SetByteArrayRegion(jbyteArray array, jsize start, jsize len,
1683 functions->SetByteArrayRegion(this,array,start,len,buf);
1685 void SetCharArrayRegion(jcharArray array, jsize start, jsize len,
1687 functions->SetCharArrayRegion(this,array,start,len,buf);
1689 void SetShortArrayRegion(jshortArray array, jsize start, jsize len,
1691 functions->SetShortArrayRegion(this,array,start,len,buf);
1693 void SetIntArrayRegion(jintArray array, jsize start, jsize len,
1695 functions->SetIntArrayRegion(this,array,start,len,buf);
1697 void SetLongArrayRegion(jlongArray array, jsize start, jsize len,
1699 functions->SetLongArrayRegion(this,array,start,len,buf);
1701 void SetFloatArrayRegion(jfloatArray array, jsize start, jsize len,
1703 functions->SetFloatArrayRegion(this,array,start,len,buf);
1705 void SetDoubleArrayRegion(jdoubleArray array, jsize start, jsize len,
1707 functions->SetDoubleArrayRegion(this,array,start,len,buf);
1710 jint RegisterNatives(jclass clazz, const JNINativeMethod *methods,
1712 return functions->RegisterNatives(this,clazz,methods,nMethods);
1714 jint UnregisterNatives(jclass clazz) {
1715 return functions->UnregisterNatives(this,clazz);
1718 jint MonitorEnter(jobject obj) {
1719 return functions->MonitorEnter(this,obj);
1721 jint MonitorExit(jobject obj) {
1722 return functions->MonitorExit(this,obj);
1725 jint GetJavaVM(JavaVM **vm) {
1726 return functions->GetJavaVM(this,vm);
1729 #endif /* __cplusplus */
1732 /* These structures will be VM-specific. */
1734 typedef struct JDK1_1InitArgs {
1739 jint nativeStackSize;
1746 jint (JNICALL *vfprintf)(FILE *fp, const char *format, va_list args);
1747 void (JNICALL *exit)(jint code);
1748 void (JNICALL *abort)();
1751 jint enableVerboseGC;
1752 jint disableAsyncGC;
1758 typedef struct JDK1_1AttachArgs {
1759 void * __padding; /* C compilers don't allow empty structures. */
1762 /* End VM-specific. */
1764 struct JNIInvokeInterface_ {
1769 jint (JNICALL *DestroyJavaVM)(JavaVM *vm);
1771 jint (JNICALL *AttachCurrentThread)
1772 (JavaVM *vm, JNIEnv **penv, void *args);
1774 jint (JNICALL *DetachCurrentThread)(JavaVM *vm);
1778 const struct JNIInvokeInterface_ *functions;
1784 jint DestroyJavaVM() {
1785 return functions->DestroyJavaVM(this);
1787 jint AttachCurrentThread(JNIEnv **penv, void *args) {
1788 return functions->AttachCurrentThread(this, penv, args);
1790 jint DetachCurrentThread() {
1791 return functions->DetachCurrentThread(this);
1797 JNI_PUBLIC_API(void) JNI_GetDefaultJavaVMInitArgs(void *);
1799 JNI_PUBLIC_API(jint) JNI_CreateJavaVM(JavaVM **, JNIEnv **, void *);
1801 JNI_PUBLIC_API(jint) JNI_GetCreatedJavaVMs(JavaVM **, jsize, jsize *);
1802 JNI_PUBLIC_API(jref) JNI_MakeLocalRef(JNIEnv *pJNIEnv, void *pHObject);
1806 #endif /* __cplusplus */