OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [include/] [jni.h] - Blame information for rev 861

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.