Context Navigation

JNI.xs

Visit:

Last change on this file was 3181, checked in by bird, 18 years ago
perl 5.8.8
File size: 64.5 KB

Line
1	/*
2	* Copyright 1997, O'Reilly & Associate, Inc.
3	*
4	* This package may be copied under the same terms as Perl itself.
5	*/
6
7	#include "EXTERN.h"
8	#include "perl.h"
9	#include "XSUB.h"
10
11	#include <stdio.h>
12	#include <jni.h>
13
14	#ifndef PERL_VERSION
15	# include <patchlevel.h>
16	# define PERL_REVISION 5
17	# define PERL_VERSION PATCHLEVEL
18	# define PERL_SUBVERSION SUBVERSION
19	#endif
20
21	#if PERL_REVISION == 5 && (PERL_VERSION < 4 \|\| (PERL_VERSION == 4 && PERL_SUBVERSION <= 75))
22	# define PL_na na
23	# define PL_sv_no sv_no
24	# define PL_sv_undef sv_undef
25	# define PL_dowarn dowarn
26	#endif
27
28	#ifndef newSVpvn
29	# define newSVpvn(a,b) newSVpv(a,b)
30	#endif
31
32	#ifndef pTHX
33	# define pTHX void
34	# define pTHX_
35	# define aTHX
36	# define aTHX_
37	# define dTHX extern int JNI___notused
38	#endif
39
40	#ifndef WIN32
41	# include <dlfcn.h>
42	#endif
43
44	#ifdef EMBEDDEDPERL
45	extern JNIEnv* jplcurenv;
46	extern int jpldebug;
47	#else
48	JNIEnv* jplcurenv;
49	int jpldebug = 1;
50	#endif
51
52	#define SysRet jint
53
54	#ifdef WIN32
55	static void JNICALL call_my_exit(jint status)
56	{
57	my_exit(status);
58	}
59	#else
60	static void call_my_exit(jint status)
61	{
62	my_exit(status);
63	}
64	#endif
65
66	jvalue*
67	makeargs(char sig, SV* svp, int items)
68	{
69	jvalue* jv = (jvalue)safemalloc(sizeof(jvalue) items);
70	int ix = 0;
71	char *s = sig;
72	JNIEnv* env = jplcurenv;
73	char *start;
74	STRLEN n_a;
75
76	if (jpldebug)
77	fprintf(stderr, "sig = %s, items = %d\n", sig, items);
78	if (*s++ != '(')
79	goto cleanup;
80
81	while (items--) {
82	SV sv = svp++;
83	start = s;
84	switch (*s++) {
85	case 'Z':
86	jv[ix++].z = (jboolean)(SvIV(sv) != 0);
87	break;
88	case 'B':
89	jv[ix++].b = (jbyte)SvIV(sv);
90	break;
91	case 'C':
92	jv[ix++].c = (jchar)SvIV(sv);
93	break;
94	case 'S':
95	jv[ix++].s = (jshort)SvIV(sv);
96	break;
97	case 'I':
98	jv[ix++].i = (jint)SvIV(sv);
99	break;
100	case 'J':
101	jv[ix++].j = (jlong)SvNV(sv);
102	break;
103	case 'F':
104	jv[ix++].f = (jfloat)SvNV(sv);
105	break;
106	case 'D':
107	jv[ix++].d = (jdouble)SvNV(sv);
108	break;
109	case '[':
110	switch (*s++) {
111	case 'Z':
112	if (SvROK(sv)) {
113	SV* rv = (SV*)SvRV(sv);
114	if (SvOBJECT(rv))
115	jv[ix++].l = (jobject)(void*)SvIV(rv);
116	else if (SvTYPE(rv) == SVt_PVAV) {
117	jsize len = av_len((AV*)rv) + 1;
118	jboolean* buf = (jboolean)malloc(len sizeof(jboolean));
119	int i;
120	SV** esv;
121
122	jbooleanArray ja = (*env)->NewBooleanArray(env, len);
123	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
124	buf[i] = (jboolean)SvIV(*esv);
125	(*env)->SetBooleanArrayRegion(env, ja, 0, len, buf);
126	free((void*)buf);
127	jv[ix++].l = (jobject)ja;
128	}
129	else
130	jv[ix++].l = (jobject)(void*)0;
131	}
132	else if (SvPOK(sv)) {
133	jsize len = sv_len(sv) / sizeof(jboolean);
134
135	jbooleanArray ja = (*env)->NewBooleanArray(env, len);
136	(env)->SetBooleanArrayRegion(env, ja, 0, len, (jboolean)SvPV(sv,n_a));
137	jv[ix++].l = (jobject)ja;
138	}
139	else
140	jv[ix++].l = (jobject)(void*)0;
141	break;
142	case 'B':
143	if (SvROK(sv)) {
144	SV* rv = (SV*)SvRV(sv);
145	if (SvOBJECT(rv))
146	jv[ix++].l = (jobject)(void*)SvIV(rv);
147	else if (SvTYPE(rv) == SVt_PVAV) {
148	jsize len = av_len((AV*)rv) + 1;
149	jbyte* buf = (jbyte)malloc(len sizeof(jbyte));
150	int i;
151	SV** esv;
152
153	jbyteArray ja = (*env)->NewByteArray(env, len);
154	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
155	buf[i] = (jbyte)SvIV(*esv);
156	(*env)->SetByteArrayRegion(env, ja, 0, len, buf);
157	free((void*)buf);
158	jv[ix++].l = (jobject)ja;
159	}
160	else
161	jv[ix++].l = (jobject)(void*)0;
162	}
163	else if (SvPOK(sv)) {
164	jsize len = sv_len(sv) / sizeof(jbyte);
165
166	jbyteArray ja = (*env)->NewByteArray(env, len);
167	(env)->SetByteArrayRegion(env, ja, 0, len, (jbyte)SvPV(sv,n_a));
168	jv[ix++].l = (jobject)ja;
169	}
170	else
171	jv[ix++].l = (jobject)(void*)0;
172	break;
173	case 'C':
174	if (SvROK(sv)) {
175	SV* rv = (SV*)SvRV(sv);
176	if (SvOBJECT(rv))
177	jv[ix++].l = (jobject)(void*)SvIV(rv);
178	else if (SvTYPE(rv) == SVt_PVAV) {
179	jsize len = av_len((AV*)rv) + 1;
180	jchar* buf = (jchar)malloc(len sizeof(jchar));
181	int i;
182	SV** esv;
183
184	jcharArray ja = (*env)->NewCharArray(env, len);
185	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
186	buf[i] = (jchar)SvIV(*esv);
187	(*env)->SetCharArrayRegion(env, ja, 0, len, buf);
188	free((void*)buf);
189	jv[ix++].l = (jobject)ja;
190	}
191	else
192	jv[ix++].l = (jobject)(void*)0;
193	}
194	else if (SvPOK(sv)) {
195	jsize len = sv_len(sv) / sizeof(jchar);
196
197	jcharArray ja = (*env)->NewCharArray(env, len);
198	(env)->SetCharArrayRegion(env, ja, 0, len, (jchar)SvPV(sv,n_a));
199	jv[ix++].l = (jobject)ja;
200	}
201	else
202	jv[ix++].l = (jobject)(void*)0;
203	break;
204	case 'S':
205	if (SvROK(sv)) {
206	SV* rv = (SV*)SvRV(sv);
207	if (SvOBJECT(rv))
208	jv[ix++].l = (jobject)(void*)SvIV(rv);
209	else if (SvTYPE(rv) == SVt_PVAV) {
210	jsize len = av_len((AV*)rv) + 1;
211	jshort* buf = (jshort)malloc(len sizeof(jshort));
212	int i;
213	SV** esv;
214
215	jshortArray ja = (*env)->NewShortArray(env, len);
216	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
217	buf[i] = (jshort)SvIV(*esv);
218	(*env)->SetShortArrayRegion(env, ja, 0, len, buf);
219	free((void*)buf);
220	jv[ix++].l = (jobject)ja;
221	}
222	else
223	jv[ix++].l = (jobject)(void*)0;
224	}
225	else if (SvPOK(sv)) {
226	jsize len = sv_len(sv) / sizeof(jshort);
227
228	jshortArray ja = (*env)->NewShortArray(env, len);
229	(env)->SetShortArrayRegion(env, ja, 0, len, (jshort)SvPV(sv,n_a));
230	jv[ix++].l = (jobject)ja;
231	}
232	else
233	jv[ix++].l = (jobject)(void*)0;
234	break;
235	case 'I':
236	if (SvROK(sv)) {
237	SV* rv = (SV*)SvRV(sv);
238	if (SvOBJECT(rv))
239	jv[ix++].l = (jobject)(void*)SvIV(rv);
240	else if (SvTYPE(rv) == SVt_PVAV) {
241	jsize len = av_len((AV*)rv) + 1;
242	jint* buf = (jint)malloc(len sizeof(jint));
243	int i;
244	SV** esv;
245
246	jintArray ja = (*env)->NewIntArray(env, len);
247	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
248	buf[i] = (jint)SvIV(*esv);
249	(*env)->SetIntArrayRegion(env, ja, 0, len, buf);
250	free((void*)buf);
251	jv[ix++].l = (jobject)ja;
252	}
253	else
254	jv[ix++].l = (jobject)(void*)0;
255	}
256	else if (SvPOK(sv)) {
257	jsize len = sv_len(sv) / sizeof(jint);
258
259	jintArray ja = (*env)->NewIntArray(env, len);
260	(env)->SetIntArrayRegion(env, ja, 0, len, (jint)SvPV(sv,n_a));
261	jv[ix++].l = (jobject)ja;
262	}
263	else
264	jv[ix++].l = (jobject)(void*)0;
265	break;
266	case 'J':
267	if (SvROK(sv)) {
268	SV* rv = (SV*)SvRV(sv);
269	if (SvOBJECT(rv))
270	jv[ix++].l = (jobject)(void*)SvIV(rv);
271	else if (SvTYPE(rv) == SVt_PVAV) {
272	jsize len = av_len((AV*)rv) + 1;
273	jlong* buf = (jlong)malloc(len sizeof(jlong));
274	int i;
275	SV** esv;
276
277	jlongArray ja = (*env)->NewLongArray(env, len);
278	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
279	buf[i] = (jlong)SvNV(*esv);
280	(*env)->SetLongArrayRegion(env, ja, 0, len, buf);
281	free((void*)buf);
282	jv[ix++].l = (jobject)ja;
283	}
284	else
285	jv[ix++].l = (jobject)(void*)0;
286	}
287	else if (SvPOK(sv)) {
288	jsize len = sv_len(sv) / sizeof(jlong);
289
290	jlongArray ja = (*env)->NewLongArray(env, len);
291	(env)->SetLongArrayRegion(env, ja, 0, len, (jlong)SvPV(sv,n_a));
292	jv[ix++].l = (jobject)ja;
293	}
294	else
295	jv[ix++].l = (jobject)(void*)0;
296	break;
297	case 'F':
298	if (SvROK(sv)) {
299	SV* rv = (SV*)SvRV(sv);
300	if (SvOBJECT(rv))
301	jv[ix++].l = (jobject)(void*)SvIV(rv);
302	else if (SvTYPE(rv) == SVt_PVAV) {
303	jsize len = av_len((AV*)rv) + 1;
304	jfloat* buf = (jfloat)malloc(len sizeof(jfloat));
305	int i;
306	SV** esv;
307
308	jfloatArray ja = (*env)->NewFloatArray(env, len);
309	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
310	buf[i] = (jfloat)SvNV(*esv);
311	(*env)->SetFloatArrayRegion(env, ja, 0, len, buf);
312	free((void*)buf);
313	jv[ix++].l = (jobject)ja;
314	}
315	else
316	jv[ix++].l = (jobject)(void*)0;
317	}
318	else if (SvPOK(sv)) {
319	jsize len = sv_len(sv) / sizeof(jfloat);
320
321	jfloatArray ja = (*env)->NewFloatArray(env, len);
322	(env)->SetFloatArrayRegion(env, ja, 0, len, (jfloat)SvPV(sv,n_a));
323	jv[ix++].l = (jobject)ja;
324	}
325	else
326	jv[ix++].l = (jobject)(void*)0;
327	break;
328	case 'D':
329	if (SvROK(sv)) {
330	SV* rv = (SV*)SvRV(sv);
331	if (SvOBJECT(rv))
332	jv[ix++].l = (jobject)(void*)SvIV(rv);
333	else if (SvTYPE(rv) == SVt_PVAV) {
334	jsize len = av_len((AV*)rv) + 1;
335	jdouble* buf = (jdouble)malloc(len sizeof(jdouble));
336	int i;
337	SV** esv;
338
339	jdoubleArray ja = (*env)->NewDoubleArray(env, len);
340	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++)
341	buf[i] = (jdouble)SvNV(*esv);
342	(*env)->SetDoubleArrayRegion(env, ja, 0, len, buf);
343	free((void*)buf);
344	jv[ix++].l = (jobject)ja;
345	}
346	else
347	jv[ix++].l = (jobject)(void*)0;
348	}
349	else if (SvPOK(sv)) {
350	jsize len = sv_len(sv) / sizeof(jdouble);
351
352	jdoubleArray ja = (*env)->NewDoubleArray(env, len);
353	(env)->SetDoubleArrayRegion(env, ja, 0, len, (jdouble)SvPV(sv,n_a));
354	jv[ix++].l = (jobject)ja;
355	}
356	else
357	jv[ix++].l = (jobject)(void*)0;
358	break;
359	case 'L':
360	while (*s != ';') s++;
361	s++;
362	if (strnEQ(start, "[Ljava/lang/String;", 19)) {
363	if (SvROK(sv)) {
364	SV* rv = (SV*)SvRV(sv);
365	if (SvOBJECT(rv))
366	jv[ix++].l = (jobject)(void*)SvIV(rv);
367	else if (SvTYPE(rv) == SVt_PVAV) {
368	jsize len = av_len((AV*)rv) + 1;
369	int i;
370	SV** esv;
371	static jclass jcl = 0;
372	jobjectArray ja;
373
374	if (!jcl)
375	jcl = (*env)->FindClass(env, "java/lang/String");
376	ja = (*env)->NewObjectArray(env, len, jcl, 0);
377	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
378	jobject str = (jobject)(env)->NewStringUTF(env, SvPV(esv,n_a));
379	(*env)->SetObjectArrayElement(env, ja, i, str);
380	}
381	jv[ix++].l = (jobject)ja;
382	}
383	else
384	jv[ix++].l = (jobject)(void*)0;
385	}
386	else
387	jv[ix++].l = (jobject)(void*)0;
388	break;
389	}
390	/* FALL THROUGH */
391	default:
392	if (SvROK(sv)) {
393	SV* rv = (SV*)SvRV(sv);
394	if (SvOBJECT(rv))
395	jv[ix++].l = (jobject)(void*)SvIV(rv);
396	else if (SvTYPE(rv) == SVt_PVAV) {
397	jsize len = av_len((AV*)rv) + 1;
398	int i;
399	SV** esv;
400	static jclass jcl = 0;
401	jobjectArray ja;
402
403	if (!jcl)
404	jcl = (*env)->FindClass(env, "java/lang/Object");
405	ja = (*env)->NewObjectArray(env, len, jcl, 0);
406	for (esv = AvARRAY((AV*)rv), i = 0; i < len; esv++, i++) {
407	if (SvROK(esv) && (rv = SvRV(esv)) && SvOBJECT(rv)) {
408	(env)->SetObjectArrayElement(env, ja, i, (jobject)(void)SvIV(rv));
409	}
410	else {
411	jobject str = (jobject)(env)->NewStringUTF(env, SvPV(esv,n_a));
412	(*env)->SetObjectArrayElement(env, ja, i, str);
413	}
414	}
415	jv[ix++].l = (jobject)ja;
416	}
417	else
418	jv[ix++].l = (jobject)(void*)0;
419	}
420	else
421	jv[ix++].l = (jobject)(void*)0;
422	break;
423	}
424	break;
425	case 'L':
426	if (!SvROK(sv) \|\| strnEQ(s, "java/lang/String;", 17)) {
427	s += 17;
428	jv[ix++].l = (jobject)(env)->NewStringUTF(env, (char) SvPV(sv,n_a));
429	break;
430	}
431	while (*s != ';') s++;
432	s++;
433	if (SvROK(sv)) {
434	SV* rv = SvRV(sv);
435	jv[ix++].l = (jobject)(void*)SvIV(rv);
436	}
437	break;
438	case ')':
439	croak("too many arguments, signature: %s", sig);
440	goto cleanup;
441	default:
442	croak("panic: malformed signature: %s", s-1);
443	goto cleanup;
444	}
445
446	}
447	if (*s != ')') {
448	croak("not enough arguments, signature: %s", sig);
449	goto cleanup;
450	}
451	return jv;
452
453	cleanup:
454	safefree((char*)jv);
455	return 0;
456	}
457
458	static int
459	not_here(char *s)
460	{
461	croak("%s not implemented on this architecture", s);
462	return -1;
463	}
464
465	static double
466	constant(char *name, int arg)
467	{
468	errno = 0;
469	switch (*name) {
470	case 'A':
471	break;
472	case 'B':
473	break;
474	case 'C':
475	break;
476	case 'D':
477	break;
478	case 'E':
479	break;
480	case 'F':
481	break;
482	case 'G':
483	break;
484	case 'H':
485	break;
486	case 'I':
487	break;
488	case 'J':
489	if (strEQ(name, "JNI_ABORT"))
490	#ifdef JNI_ABORT
491	return JNI_ABORT;
492	#else
493	goto not_there;
494	#endif
495	if (strEQ(name, "JNI_COMMIT"))
496	#ifdef JNI_COMMIT
497	return JNI_COMMIT;
498	#else
499	goto not_there;
500	#endif
501	if (strEQ(name, "JNI_ERR"))
502	#ifdef JNI_ERR
503	return JNI_ERR;
504	#else
505	goto not_there;
506	#endif
507	if (strEQ(name, "JNI_FALSE"))
508	#ifdef JNI_FALSE
509	return JNI_FALSE;
510	#else
511	goto not_there;
512	#endif
513	if (strEQ(name, "JNI_H"))
514	#ifdef JNI_H
515	#ifdef WIN32
516	return 1;
517	#else
518	return JNI_H;
519	#endif
520	#else
521	goto not_there;
522	#endif
523	if (strEQ(name, "JNI_OK"))
524	#ifdef JNI_OK
525	return JNI_OK;
526	#else
527	goto not_there;
528	#endif
529	if (strEQ(name, "JNI_TRUE"))
530	#ifdef JNI_TRUE
531	return JNI_TRUE;
532	#else
533	goto not_there;
534	#endif
535	break;
536	case 'K':
537	break;
538	case 'L':
539	break;
540	case 'M':
541	break;
542	case 'N':
543	break;
544	case 'O':
545	break;
546	case 'P':
547	break;
548	case 'Q':
549	break;
550	case 'R':
551	break;
552	case 'S':
553	break;
554	case 'T':
555	break;
556	case 'U':
557	break;
558	case 'V':
559	break;
560	case 'W':
561	break;
562	case 'X':
563	break;
564	case 'Y':
565	break;
566	case 'Z':
567	break;
568	}
569	errno = EINVAL;
570	return 0;
571
572	not_there:
573	errno = ENOENT;
574	return 0;
575	}
576
577	#define FETCHENV jplcurenv
578	#define RESTOREENV jplcurenv = env
579
580	MODULE = JNI PACKAGE = JNI
581
582	PROTOTYPES: ENABLE
583
584	double
585	constant(name,arg)
586	char * name
587	int arg
588
589	jint
590	GetVersion()
591	JNIEnv * env = FETCHENV;
592	CODE:
593	{
594	RETVAL = (*env)->GetVersion(env);
595	RESTOREENV;
596	}
597	OUTPUT:
598	RETVAL
599
600	jclass
601	DefineClass(name, loader, buf)
602	JNIEnv * env = FETCHENV;
603	STRLEN tmplen = NO_INIT;
604	jsize buf_len_ = NO_INIT;
605	const char * name
606	jobject loader
607	const jbyte * buf
608	CODE:
609	{
610	#ifdef KAFFE
611	RETVAL = (*env)->DefineClass(env, loader, buf, (jsize)buf_len_);
612	#else
613	RETVAL = (*env)->DefineClass(env, name, loader, buf, (jsize)buf_len_);
614	#endif
615	RESTOREENV;
616	}
617	OUTPUT:
618	RETVAL
619
620	jclass
621	FindClass(name)
622	JNIEnv * env = FETCHENV;
623	const char * name
624	CODE:
625	{
626	RETVAL = (*env)->FindClass(env, name);
627	RESTOREENV;
628	}
629	OUTPUT:
630	RETVAL
631
632	jclass
633	GetSuperclass(sub)
634	JNIEnv * env = FETCHENV;
635	jclass sub
636	CODE:
637	{
638	RETVAL = (*env)->GetSuperclass(env, sub);
639	RESTOREENV;
640	}
641	OUTPUT:
642	RETVAL
643
644	jboolean
645	IsAssignableFrom(sub, sup)
646	JNIEnv * env = FETCHENV;
647	jclass sub
648	jclass sup
649	CODE:
650	{
651	RETVAL = (*env)->IsAssignableFrom(env, sub, sup);
652	RESTOREENV;
653	}
654	OUTPUT:
655	RETVAL
656
657	SysRet
658	Throw(obj)
659	JNIEnv * env = FETCHENV;
660	jthrowable obj
661	CODE:
662	{
663	RETVAL = (*env)->Throw(env, obj);
664	RESTOREENV;
665	}
666	OUTPUT:
667	RETVAL
668
669	SysRet
670	ThrowNew(clazz, msg)
671	JNIEnv * env = FETCHENV;
672	jclass clazz
673	const char * msg
674	CODE:
675	{
676	RETVAL = (*env)->ThrowNew(env, clazz, msg);
677	RESTOREENV;
678	}
679	OUTPUT:
680	RETVAL
681
682	jthrowable
683	ExceptionOccurred()
684	JNIEnv * env = FETCHENV;
685	CODE:
686	{
687	RETVAL = (*env)->ExceptionOccurred(env);
688	RESTOREENV;
689	}
690	OUTPUT:
691	RETVAL
692
693	void
694	ExceptionDescribe()
695	JNIEnv * env = FETCHENV;
696	CODE:
697	{
698	(*env)->ExceptionDescribe(env);
699	RESTOREENV;
700	}
701
702	void
703	ExceptionClear()
704	JNIEnv * env = FETCHENV;
705	CODE:
706	{
707	(*env)->ExceptionClear(env);
708	RESTOREENV;
709	}
710
711	void
712	FatalError(msg)
713	JNIEnv * env = FETCHENV;
714	const char * msg
715	CODE:
716	{
717	(*env)->FatalError(env, msg);
718	RESTOREENV;
719	}
720
721	jobject
722	NewGlobalRef(lobj)
723	JNIEnv * env = FETCHENV;
724	jobject lobj
725	CODE:
726	{
727	RETVAL = (*env)->NewGlobalRef(env, lobj);
728	RESTOREENV;
729	}
730	OUTPUT:
731	RETVAL
732
733	void
734	DeleteGlobalRef(gref)
735	JNIEnv * env = FETCHENV;
736	jobject gref
737	CODE:
738	{
739	(*env)->DeleteGlobalRef(env, gref);
740	RESTOREENV;
741	}
742
743	void
744	DeleteLocalRef(obj)
745	JNIEnv * env = FETCHENV;
746	jobject obj
747	CODE:
748	{
749	(*env)->DeleteLocalRef(env, obj);
750	RESTOREENV;
751	}
752
753	jboolean
754	IsSameObject(obj1,obj2)
755	JNIEnv * env = FETCHENV;
756	jobject obj1
757	jobject obj2
758	CODE:
759	{
760	RETVAL = (*env)->IsSameObject(env, obj1,obj2);
761	RESTOREENV;
762	}
763	OUTPUT:
764	RETVAL
765
766	jobject
767	AllocObject(clazz)
768	JNIEnv * env = FETCHENV;
769	jclass clazz
770	CODE:
771	{
772	RETVAL = (*env)->AllocObject(env, clazz);
773	RESTOREENV;
774	}
775	OUTPUT:
776	RETVAL
777
778	jobject
779	NewObject(clazz,methodID,...)
780	JNIEnv * env = FETCHENV;
781	jclass clazz
782	jmethodID methodID
783	char * sig = 0;
784	int argoff = $min_args;
785	CODE:
786	{
787	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
788	RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
789	RESTOREENV;
790	}
791	OUTPUT:
792	RETVAL
793
794	jobject
795	NewObjectA(clazz,methodID,args)
796	JNIEnv * env = FETCHENV;
797	jclass clazz
798	jmethodID methodID
799	char * sig = 0;
800	jvalue * args
801	CODE:
802	{
803	RETVAL = (*env)->NewObjectA(env, clazz,methodID,args);
804	RESTOREENV;
805	}
806	OUTPUT:
807	RETVAL
808
809	jclass
810	GetObjectClass(obj)
811	JNIEnv * env = FETCHENV;
812	jobject obj
813	CODE:
814	{
815	RETVAL = (*env)->GetObjectClass(env, obj);
816	RESTOREENV;
817	}
818	OUTPUT:
819	RETVAL
820
821	jboolean
822	IsInstanceOf(obj,clazz)
823	JNIEnv * env = FETCHENV;
824	jobject obj
825	jclass clazz
826	CODE:
827	{
828	RETVAL = (*env)->IsInstanceOf(env, obj,clazz);
829	RESTOREENV;
830	}
831	OUTPUT:
832	RETVAL
833
834	jmethodID
835	GetMethodID(clazz,name,sig)
836	JNIEnv * env = FETCHENV;
837	jclass clazz
838	const char * name
839	const char * sig
840	CODE:
841	{
842	RETVAL = (*env)->GetMethodID(env, clazz,name,sig);
843	RESTOREENV;
844	}
845	OUTPUT:
846	RETVAL
847
848	jobject
849	CallObjectMethod(obj,methodID,...)
850	JNIEnv * env = FETCHENV;
851	jobject obj
852	jmethodID methodID
853	char * sig = 0;
854	int argoff = $min_args;
855	CODE:
856	{
857	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
858	RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
859	RESTOREENV;
860	}
861	OUTPUT:
862	RETVAL
863
864	jobject
865	CallObjectMethodA(obj,methodID,args)
866	JNIEnv * env = FETCHENV;
867	jobject obj
868	jmethodID methodID
869	char * sig = 0;
870	jvalue * args
871	CODE:
872	{
873	RETVAL = (*env)->CallObjectMethodA(env, obj,methodID,args);
874	RESTOREENV;
875	}
876	OUTPUT:
877	RETVAL
878
879	jboolean
880	CallBooleanMethod(obj,methodID,...)
881	JNIEnv * env = FETCHENV;
882	jobject obj
883	jmethodID methodID
884	char * sig = 0;
885	int argoff = $min_args;
886	CODE:
887	{
888	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
889	RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID,args);
890	RESTOREENV;
891	}
892	OUTPUT:
893	RETVAL
894
895	jboolean
896	CallBooleanMethodA(obj,methodID, args)
897	JNIEnv * env = FETCHENV;
898	jobject obj
899	jmethodID methodID
900	char * sig = 0;
901	jvalue * args
902	CODE:
903	{
904	RETVAL = (*env)->CallBooleanMethodA(env, obj,methodID, args);
905	RESTOREENV;
906	}
907	OUTPUT:
908	RETVAL
909
910	jbyte
911	CallByteMethod(obj,methodID,...)
912	JNIEnv * env = FETCHENV;
913	jobject obj
914	jmethodID methodID
915	char * sig = 0;
916	int argoff = $min_args;
917	CODE:
918	{
919	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
920	RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
921	RESTOREENV;
922	}
923	OUTPUT:
924	RETVAL
925
926	jbyte
927	CallByteMethodA(obj,methodID,args)
928	JNIEnv * env = FETCHENV;
929	jobject obj
930	jmethodID methodID
931	char * sig = 0;
932	jvalue * args
933	CODE:
934	{
935	RETVAL = (*env)->CallByteMethodA(env, obj,methodID,args);
936	RESTOREENV;
937	}
938	OUTPUT:
939	RETVAL
940
941	jchar
942	CallCharMethod(obj,methodID,...)
943	JNIEnv * env = FETCHENV;
944	jobject obj
945	jmethodID methodID
946	char * sig = 0;
947	int argoff = $min_args;
948	CODE:
949	{
950	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
951	RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
952	RESTOREENV;
953	}
954	OUTPUT:
955	RETVAL
956
957	jchar
958	CallCharMethodA(obj,methodID,args)
959	JNIEnv * env = FETCHENV;
960	jobject obj
961	jmethodID methodID
962	char * sig = 0;
963	jvalue * args
964	CODE:
965	{
966	RETVAL = (*env)->CallCharMethodA(env, obj,methodID,args);
967	RESTOREENV;
968	}
969	OUTPUT:
970	RETVAL
971
972	jshort
973	CallShortMethod(obj,methodID,...)
974	JNIEnv * env = FETCHENV;
975	jobject obj
976	jmethodID methodID
977	char * sig = 0;
978	int argoff = $min_args;
979	CODE:
980	{
981	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
982	RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
983	RESTOREENV;
984	}
985	OUTPUT:
986	RETVAL
987
988	jshort
989	CallShortMethodA(obj,methodID,args)
990	JNIEnv * env = FETCHENV;
991	jobject obj
992	jmethodID methodID
993	char * sig = 0;
994	jvalue * args
995	CODE:
996	{
997	RETVAL = (*env)->CallShortMethodA(env, obj,methodID,args);
998	RESTOREENV;
999	}
1000	OUTPUT:
1001	RETVAL
1002
1003	jint
1004	CallIntMethod(obj,methodID,...)
1005	JNIEnv * env = FETCHENV;
1006	jobject obj
1007	jmethodID methodID
1008	char * sig = 0;
1009	int argoff = $min_args;
1010	CODE:
1011	{
1012	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1013	RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
1014	RESTOREENV;
1015	}
1016	OUTPUT:
1017	RETVAL
1018
1019	jint
1020	CallIntMethodA(obj,methodID,args)
1021	JNIEnv * env = FETCHENV;
1022	jobject obj
1023	jmethodID methodID
1024	char * sig = 0;
1025	jvalue * args
1026	CODE:
1027	{
1028	RETVAL = (*env)->CallIntMethodA(env, obj,methodID,args);
1029	RESTOREENV;
1030	}
1031	OUTPUT:
1032	RETVAL
1033
1034	jlong
1035	CallLongMethod(obj,methodID,...)
1036	JNIEnv * env = FETCHENV;
1037	jobject obj
1038	jmethodID methodID
1039	char * sig = 0;
1040	int argoff = $min_args;
1041	CODE:
1042	{
1043	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1044	RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1045	RESTOREENV;
1046	}
1047	OUTPUT:
1048	RETVAL
1049
1050	jlong
1051	CallLongMethodA(obj,methodID,args)
1052	JNIEnv * env = FETCHENV;
1053	jobject obj
1054	jmethodID methodID
1055	char * sig = 0;
1056	jvalue * args
1057	CODE:
1058	{
1059	RETVAL = (*env)->CallLongMethodA(env, obj,methodID,args);
1060	RESTOREENV;
1061	}
1062	OUTPUT:
1063	RETVAL
1064
1065	jfloat
1066	CallFloatMethod(obj,methodID,...)
1067	JNIEnv * env = FETCHENV;
1068	jobject obj
1069	jmethodID methodID
1070	char * sig = 0;
1071	int argoff = $min_args;
1072	CODE:
1073	{
1074	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1075	RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1076	RESTOREENV;
1077	}
1078	OUTPUT:
1079	RETVAL
1080
1081	jfloat
1082	CallFloatMethodA(obj,methodID,args)
1083	JNIEnv * env = FETCHENV;
1084	jobject obj
1085	jmethodID methodID
1086	char * sig = 0;
1087	jvalue * args
1088	CODE:
1089	{
1090	RETVAL = (*env)->CallFloatMethodA(env, obj,methodID,args);
1091	RESTOREENV;
1092	}
1093	OUTPUT:
1094	RETVAL
1095
1096	jdouble
1097	CallDoubleMethod(obj,methodID,...)
1098	JNIEnv * env = FETCHENV;
1099	jobject obj
1100	jmethodID methodID
1101	char * sig = 0;
1102	int argoff = $min_args;
1103	CODE:
1104	{
1105	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1106	RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1107	RESTOREENV;
1108	}
1109	OUTPUT:
1110	RETVAL
1111
1112	jdouble
1113	CallDoubleMethodA(obj,methodID,args)
1114	JNIEnv * env = FETCHENV;
1115	jobject obj
1116	jmethodID methodID
1117	char * sig = 0;
1118	jvalue * args
1119	CODE:
1120	{
1121	RETVAL = (*env)->CallDoubleMethodA(env, obj,methodID,args);
1122	RESTOREENV;
1123	}
1124	OUTPUT:
1125	RETVAL
1126
1127	void
1128	CallVoidMethod(obj,methodID,...)
1129	JNIEnv * env = FETCHENV;
1130	jobject obj
1131	jmethodID methodID
1132	char * sig = 0;
1133	int argoff = $min_args;
1134	CODE:
1135	{
1136	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1137	(*env)->CallVoidMethodA(env, obj,methodID,args);
1138	RESTOREENV;
1139	}
1140
1141	void
1142	CallVoidMethodA(obj,methodID,args)
1143	JNIEnv * env = FETCHENV;
1144	jobject obj
1145	jmethodID methodID
1146	char * sig = 0;
1147	jvalue * args
1148	CODE:
1149	{
1150	(*env)->CallVoidMethodA(env, obj,methodID,args);
1151	RESTOREENV;
1152	}
1153
1154	jobject
1155	CallNonvirtualObjectMethod(obj,clazz,methodID,...)
1156	JNIEnv * env = FETCHENV;
1157	jobject obj
1158	jclass clazz
1159	jmethodID methodID
1160	char * sig = 0;
1161	int argoff = $min_args;
1162	CODE:
1163	{
1164	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1165	RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1166	RESTOREENV;
1167	}
1168	OUTPUT:
1169	RETVAL
1170
1171	jobject
1172	CallNonvirtualObjectMethodA(obj,clazz,methodID,args)
1173	JNIEnv * env = FETCHENV;
1174	jobject obj
1175	jclass clazz
1176	jmethodID methodID
1177	char * sig = 0;
1178	jvalue * args
1179	CODE:
1180	{
1181	RETVAL = (*env)->CallNonvirtualObjectMethodA(env, obj,clazz,methodID,args);
1182	RESTOREENV;
1183	}
1184	OUTPUT:
1185	RETVAL
1186
1187	jboolean
1188	CallNonvirtualBooleanMethod(obj,clazz,methodID,...)
1189	JNIEnv * env = FETCHENV;
1190	jobject obj
1191	jclass clazz
1192	jmethodID methodID
1193	char * sig = 0;
1194	int argoff = $min_args;
1195	CODE:
1196	{
1197	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1198	RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID,args);
1199	RESTOREENV;
1200	}
1201	OUTPUT:
1202	RETVAL
1203
1204	jboolean
1205	CallNonvirtualBooleanMethodA(obj,clazz,methodID, args)
1206	JNIEnv * env = FETCHENV;
1207	jobject obj
1208	jclass clazz
1209	jmethodID methodID
1210	char * sig = 0;
1211	jvalue * args
1212	CODE:
1213	{
1214	RETVAL = (*env)->CallNonvirtualBooleanMethodA(env, obj,clazz,methodID, args);
1215	RESTOREENV;
1216	}
1217	OUTPUT:
1218	RETVAL
1219
1220	jbyte
1221	CallNonvirtualByteMethod(obj,clazz,methodID,...)
1222	JNIEnv * env = FETCHENV;
1223	jobject obj
1224	jclass clazz
1225	jmethodID methodID
1226	char * sig = 0;
1227	int argoff = $min_args;
1228	CODE:
1229	{
1230	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1231	RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1232	RESTOREENV;
1233	}
1234	OUTPUT:
1235	RETVAL
1236
1237	jbyte
1238	CallNonvirtualByteMethodA(obj,clazz,methodID,args)
1239	JNIEnv * env = FETCHENV;
1240	jobject obj
1241	jclass clazz
1242	jmethodID methodID
1243	char * sig = 0;
1244	jvalue * args
1245	CODE:
1246	{
1247	RETVAL = (*env)->CallNonvirtualByteMethodA(env, obj,clazz,methodID,args);
1248	RESTOREENV;
1249	}
1250	OUTPUT:
1251	RETVAL
1252
1253	jchar
1254	CallNonvirtualCharMethod(obj,clazz,methodID,...)
1255	JNIEnv * env = FETCHENV;
1256	jobject obj
1257	jclass clazz
1258	jmethodID methodID
1259	char * sig = 0;
1260	int argoff = $min_args;
1261	CODE:
1262	{
1263	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1264	RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1265	RESTOREENV;
1266	}
1267	OUTPUT:
1268	RETVAL
1269
1270	jchar
1271	CallNonvirtualCharMethodA(obj,clazz,methodID,args)
1272	JNIEnv * env = FETCHENV;
1273	jobject obj
1274	jclass clazz
1275	jmethodID methodID
1276	char * sig = 0;
1277	jvalue * args
1278	CODE:
1279	{
1280	RETVAL = (*env)->CallNonvirtualCharMethodA(env, obj,clazz,methodID,args);
1281	RESTOREENV;
1282	}
1283	OUTPUT:
1284	RETVAL
1285
1286	jshort
1287	CallNonvirtualShortMethod(obj,clazz,methodID,...)
1288	JNIEnv * env = FETCHENV;
1289	jobject obj
1290	jclass clazz
1291	jmethodID methodID
1292	char * sig = 0;
1293	int argoff = $min_args;
1294	CODE:
1295	{
1296	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1297	RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1298	RESTOREENV;
1299	}
1300	OUTPUT:
1301	RETVAL
1302
1303	jshort
1304	CallNonvirtualShortMethodA(obj,clazz,methodID,args)
1305	JNIEnv * env = FETCHENV;
1306	jobject obj
1307	jclass clazz
1308	jmethodID methodID
1309	char * sig = 0;
1310	jvalue * args
1311	CODE:
1312	{
1313	RETVAL = (*env)->CallNonvirtualShortMethodA(env, obj,clazz,methodID,args);
1314	RESTOREENV;
1315	}
1316	OUTPUT:
1317	RETVAL
1318
1319	jint
1320	CallNonvirtualIntMethod(obj,clazz,methodID,...)
1321	JNIEnv * env = FETCHENV;
1322	jobject obj
1323	jclass clazz
1324	jmethodID methodID
1325	char * sig = 0;
1326	int argoff = $min_args;
1327	CODE:
1328	{
1329	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1330	RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1331	RESTOREENV;
1332	}
1333	OUTPUT:
1334	RETVAL
1335
1336	jint
1337	CallNonvirtualIntMethodA(obj,clazz,methodID,args)
1338	JNIEnv * env = FETCHENV;
1339	jobject obj
1340	jclass clazz
1341	jmethodID methodID
1342	char * sig = 0;
1343	jvalue * args
1344	CODE:
1345	{
1346	RETVAL = (*env)->CallNonvirtualIntMethodA(env, obj,clazz,methodID,args);
1347	RESTOREENV;
1348	}
1349	OUTPUT:
1350	RETVAL
1351
1352	jlong
1353	CallNonvirtualLongMethod(obj,clazz,methodID,...)
1354	JNIEnv * env = FETCHENV;
1355	jobject obj
1356	jclass clazz
1357	jmethodID methodID
1358	char * sig = 0;
1359	int argoff = $min_args;
1360	CODE:
1361	{
1362	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1363	RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1364	RESTOREENV;
1365	}
1366	OUTPUT:
1367	RETVAL
1368
1369	jlong
1370	CallNonvirtualLongMethodA(obj,clazz,methodID,args)
1371	JNIEnv * env = FETCHENV;
1372	jobject obj
1373	jclass clazz
1374	jmethodID methodID
1375	char * sig = 0;
1376	jvalue * args
1377	CODE:
1378	{
1379	RETVAL = (*env)->CallNonvirtualLongMethodA(env, obj,clazz,methodID,args);
1380	RESTOREENV;
1381	}
1382	OUTPUT:
1383	RETVAL
1384
1385	jfloat
1386	CallNonvirtualFloatMethod(obj,clazz,methodID,...)
1387	JNIEnv * env = FETCHENV;
1388	jobject obj
1389	jclass clazz
1390	jmethodID methodID
1391	char * sig = 0;
1392	int argoff = $min_args;
1393	CODE:
1394	{
1395	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1396	RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1397	RESTOREENV;
1398	}
1399	OUTPUT:
1400	RETVAL
1401
1402	jfloat
1403	CallNonvirtualFloatMethodA(obj,clazz,methodID,args)
1404	JNIEnv * env = FETCHENV;
1405	jobject obj
1406	jclass clazz
1407	jmethodID methodID
1408	char * sig = 0;
1409	jvalue * args
1410	CODE:
1411	{
1412	RETVAL = (*env)->CallNonvirtualFloatMethodA(env, obj,clazz,methodID,args);
1413	RESTOREENV;
1414	}
1415	OUTPUT:
1416	RETVAL
1417
1418	jdouble
1419	CallNonvirtualDoubleMethod(obj,clazz,methodID,...)
1420	JNIEnv * env = FETCHENV;
1421	jobject obj
1422	jclass clazz
1423	jmethodID methodID
1424	char * sig = 0;
1425	int argoff = $min_args;
1426	CODE:
1427	{
1428	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1429	RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1430	RESTOREENV;
1431	}
1432	OUTPUT:
1433	RETVAL
1434
1435	jdouble
1436	CallNonvirtualDoubleMethodA(obj,clazz,methodID,args)
1437	JNIEnv * env = FETCHENV;
1438	jobject obj
1439	jclass clazz
1440	jmethodID methodID
1441	char * sig = 0;
1442	jvalue * args
1443	CODE:
1444	{
1445	RETVAL = (*env)->CallNonvirtualDoubleMethodA(env, obj,clazz,methodID,args);
1446	RESTOREENV;
1447	}
1448	OUTPUT:
1449	RETVAL
1450
1451	void
1452	CallNonvirtualVoidMethod(obj,clazz,methodID,...)
1453	JNIEnv * env = FETCHENV;
1454	jobject obj
1455	jclass clazz
1456	jmethodID methodID
1457	char * sig = 0;
1458	int argoff = $min_args;
1459	CODE:
1460	{
1461	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1462	(*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1463	RESTOREENV;
1464	}
1465
1466	void
1467	CallNonvirtualVoidMethodA(obj,clazz,methodID,args)
1468	JNIEnv * env = FETCHENV;
1469	jobject obj
1470	jclass clazz
1471	jmethodID methodID
1472	char * sig = 0;
1473	jvalue * args
1474	CODE:
1475	{
1476	(*env)->CallNonvirtualVoidMethodA(env, obj,clazz,methodID,args);
1477	RESTOREENV;
1478	}
1479
1480	jfieldID
1481	GetFieldID(clazz,name,sig)
1482	JNIEnv * env = FETCHENV;
1483	jclass clazz
1484	const char * name
1485	const char * sig
1486	CODE:
1487	{
1488	RETVAL = (*env)->GetFieldID(env, clazz,name,sig);
1489	RESTOREENV;
1490	}
1491	OUTPUT:
1492	RETVAL
1493
1494	jobject
1495	GetObjectField(obj,fieldID)
1496	JNIEnv * env = FETCHENV;
1497	jobject obj
1498	jfieldID fieldID
1499	char * sig = 0;
1500	CODE:
1501	{
1502	RETVAL = (*env)->GetObjectField(env, obj,fieldID);
1503	RESTOREENV;
1504	}
1505	OUTPUT:
1506	RETVAL
1507
1508	jboolean
1509	GetBooleanField(obj,fieldID)
1510	JNIEnv * env = FETCHENV;
1511	jobject obj
1512	jfieldID fieldID
1513	char * sig = 0;
1514	CODE:
1515	{
1516	RETVAL = (*env)->GetBooleanField(env, obj,fieldID);
1517	RESTOREENV;
1518	}
1519	OUTPUT:
1520	RETVAL
1521
1522	jbyte
1523	GetByteField(obj,fieldID)
1524	JNIEnv * env = FETCHENV;
1525	jobject obj
1526	jfieldID fieldID
1527	char * sig = 0;
1528	CODE:
1529	{
1530	RETVAL = (*env)->GetByteField(env, obj,fieldID);
1531	RESTOREENV;
1532	}
1533	OUTPUT:
1534	RETVAL
1535
1536	jchar
1537	GetCharField(obj,fieldID)
1538	JNIEnv * env = FETCHENV;
1539	jobject obj
1540	jfieldID fieldID
1541	char * sig = 0;
1542	CODE:
1543	{
1544	RETVAL = (*env)->GetCharField(env, obj,fieldID);
1545	RESTOREENV;
1546	}
1547	OUTPUT:
1548	RETVAL
1549
1550	jshort
1551	GetShortField(obj,fieldID)
1552	JNIEnv * env = FETCHENV;
1553	jobject obj
1554	jfieldID fieldID
1555	char * sig = 0;
1556	CODE:
1557	{
1558	RETVAL = (*env)->GetShortField(env, obj,fieldID);
1559	RESTOREENV;
1560	}
1561	OUTPUT:
1562	RETVAL
1563
1564	jint
1565	GetIntField(obj,fieldID)
1566	JNIEnv * env = FETCHENV;
1567	jobject obj
1568	jfieldID fieldID
1569	char * sig = 0;
1570	CODE:
1571	{
1572	RETVAL = (*env)->GetIntField(env, obj,fieldID);
1573	RESTOREENV;
1574	}
1575	OUTPUT:
1576	RETVAL
1577
1578	jlong
1579	GetLongField(obj,fieldID)
1580	JNIEnv * env = FETCHENV;
1581	jobject obj
1582	jfieldID fieldID
1583	char * sig = 0;
1584	CODE:
1585	{
1586	RETVAL = (*env)->GetLongField(env, obj,fieldID);
1587	RESTOREENV;
1588	}
1589	OUTPUT:
1590	RETVAL
1591
1592	jfloat
1593	GetFloatField(obj,fieldID)
1594	JNIEnv * env = FETCHENV;
1595	jobject obj
1596	jfieldID fieldID
1597	char * sig = 0;
1598	CODE:
1599	{
1600	RETVAL = (*env)->GetFloatField(env, obj,fieldID);
1601	RESTOREENV;
1602	}
1603	OUTPUT:
1604	RETVAL
1605
1606	jdouble
1607	GetDoubleField(obj,fieldID)
1608	JNIEnv * env = FETCHENV;
1609	jobject obj
1610	jfieldID fieldID
1611	char * sig = 0;
1612	CODE:
1613	{
1614	RETVAL = (*env)->GetDoubleField(env, obj,fieldID);
1615	RESTOREENV;
1616	}
1617	OUTPUT:
1618	RETVAL
1619
1620	void
1621	SetObjectField(obj,fieldID,val)
1622	JNIEnv * env = FETCHENV;
1623	jobject obj
1624	jfieldID fieldID
1625	char * sig = 0;
1626	jobject val
1627	CODE:
1628	{
1629	(*env)->SetObjectField(env, obj,fieldID,val);
1630	RESTOREENV;
1631	}
1632
1633	void
1634	SetBooleanField(obj,fieldID,val)
1635	JNIEnv * env = FETCHENV;
1636	jobject obj
1637	jfieldID fieldID
1638	char * sig = 0;
1639	jboolean val
1640	CODE:
1641	{
1642	(*env)->SetBooleanField(env, obj,fieldID,val);
1643	RESTOREENV;
1644	}
1645
1646	void
1647	SetByteField(obj,fieldID,val)
1648	JNIEnv * env = FETCHENV;
1649	jobject obj
1650	jfieldID fieldID
1651	char * sig = 0;
1652	jbyte val
1653	CODE:
1654	{
1655	(*env)->SetByteField(env, obj,fieldID,val);
1656	RESTOREENV;
1657	}
1658
1659	void
1660	SetCharField(obj,fieldID,val)
1661	JNIEnv * env = FETCHENV;
1662	jobject obj
1663	jfieldID fieldID
1664	char * sig = 0;
1665	jchar val
1666	CODE:
1667	{
1668	(*env)->SetCharField(env, obj,fieldID,val);
1669	RESTOREENV;
1670	}
1671
1672	void
1673	SetShortField(obj,fieldID,val)
1674	JNIEnv * env = FETCHENV;
1675	jobject obj
1676	jfieldID fieldID
1677	char * sig = 0;
1678	jshort val
1679	CODE:
1680	{
1681	(*env)->SetShortField(env, obj,fieldID,val);
1682	RESTOREENV;
1683	}
1684
1685	void
1686	SetIntField(obj,fieldID,val)
1687	JNIEnv * env = FETCHENV;
1688	jobject obj
1689	jfieldID fieldID
1690	char * sig = 0;
1691	jint val
1692	CODE:
1693	{
1694	(*env)->SetIntField(env, obj,fieldID,val);
1695	RESTOREENV;
1696	}
1697
1698	void
1699	SetLongField(obj,fieldID,val)
1700	JNIEnv * env = FETCHENV;
1701	jobject obj
1702	jfieldID fieldID
1703	char * sig = 0;
1704	jlong val
1705	CODE:
1706	{
1707	(*env)->SetLongField(env, obj,fieldID,val);
1708	RESTOREENV;
1709	}
1710
1711	void
1712	SetFloatField(obj,fieldID,val)
1713	JNIEnv * env = FETCHENV;
1714	jobject obj
1715	jfieldID fieldID
1716	char * sig = 0;
1717	jfloat val
1718	CODE:
1719	{
1720	(*env)->SetFloatField(env, obj,fieldID,val);
1721	RESTOREENV;
1722	}
1723
1724	void
1725	SetDoubleField(obj,fieldID,val)
1726	JNIEnv * env = FETCHENV;
1727	jobject obj
1728	jfieldID fieldID
1729	char * sig = 0;
1730	jdouble val
1731	CODE:
1732	{
1733	(*env)->SetDoubleField(env, obj,fieldID,val);
1734	RESTOREENV;
1735	}
1736
1737	jmethodID
1738	GetStaticMethodID(clazz,name,sig)
1739	JNIEnv * env = FETCHENV;
1740	jclass clazz
1741	const char * name
1742	const char * sig
1743	CODE:
1744	{
1745	RETVAL = (*env)->GetStaticMethodID(env, clazz,name,sig);
1746	RESTOREENV;
1747	}
1748	OUTPUT:
1749	RETVAL
1750
1751	jobject
1752	CallStaticObjectMethod(clazz,methodID,...)
1753	JNIEnv * env = FETCHENV;
1754	jclass clazz
1755	jmethodID methodID
1756	char * sig = 0;
1757	int argoff = $min_args;
1758	CODE:
1759	{
1760	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1761	RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1762	RESTOREENV;
1763	}
1764	OUTPUT:
1765	RETVAL
1766
1767	jobject
1768	CallStaticObjectMethodA(clazz,methodID,args)
1769	JNIEnv * env = FETCHENV;
1770	jclass clazz
1771	jmethodID methodID
1772	char * sig = 0;
1773	jvalue * args
1774	CODE:
1775	{
1776	RETVAL = (*env)->CallStaticObjectMethodA(env, clazz,methodID,args);
1777	RESTOREENV;
1778	}
1779	OUTPUT:
1780	RETVAL
1781
1782	jboolean
1783	CallStaticBooleanMethod(clazz,methodID,...)
1784	JNIEnv * env = FETCHENV;
1785	jclass clazz
1786	jmethodID methodID
1787	char * sig = 0;
1788	int argoff = $min_args;
1789	CODE:
1790	{
1791	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1792	RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1793	RESTOREENV;
1794	}
1795	OUTPUT:
1796	RETVAL
1797
1798	jboolean
1799	CallStaticBooleanMethodA(clazz,methodID,args)
1800	JNIEnv * env = FETCHENV;
1801	jclass clazz
1802	jmethodID methodID
1803	char * sig = 0;
1804	jvalue * args
1805	CODE:
1806	{
1807	RETVAL = (*env)->CallStaticBooleanMethodA(env, clazz,methodID,args);
1808	RESTOREENV;
1809	}
1810	OUTPUT:
1811	RETVAL
1812
1813	jbyte
1814	CallStaticByteMethod(clazz,methodID,...)
1815	JNIEnv * env = FETCHENV;
1816	jclass clazz
1817	jmethodID methodID
1818	char * sig = 0;
1819	int argoff = $min_args;
1820	CODE:
1821	{
1822	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1823	RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1824	RESTOREENV;
1825	}
1826	OUTPUT:
1827	RETVAL
1828
1829	jbyte
1830	CallStaticByteMethodA(clazz,methodID,args)
1831	JNIEnv * env = FETCHENV;
1832	jclass clazz
1833	jmethodID methodID
1834	char * sig = 0;
1835	jvalue * args
1836	CODE:
1837	{
1838	RETVAL = (*env)->CallStaticByteMethodA(env, clazz,methodID,args);
1839	RESTOREENV;
1840	}
1841	OUTPUT:
1842	RETVAL
1843
1844	jchar
1845	CallStaticCharMethod(clazz,methodID,...)
1846	JNIEnv * env = FETCHENV;
1847	jclass clazz
1848	jmethodID methodID
1849	char * sig = 0;
1850	int argoff = $min_args;
1851	CODE:
1852	{
1853	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1854	RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1855	RESTOREENV;
1856	}
1857	OUTPUT:
1858	RETVAL
1859
1860	jchar
1861	CallStaticCharMethodA(clazz,methodID,args)
1862	JNIEnv * env = FETCHENV;
1863	jclass clazz
1864	jmethodID methodID
1865	char * sig = 0;
1866	jvalue * args
1867	CODE:
1868	{
1869	RETVAL = (*env)->CallStaticCharMethodA(env, clazz,methodID,args);
1870	RESTOREENV;
1871	}
1872	OUTPUT:
1873	RETVAL
1874
1875	jshort
1876	CallStaticShortMethod(clazz,methodID,...)
1877	JNIEnv * env = FETCHENV;
1878	jclass clazz
1879	jmethodID methodID
1880	char * sig = 0;
1881	int argoff = $min_args;
1882	CODE:
1883	{
1884	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1885	RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1886	RESTOREENV;
1887	}
1888	OUTPUT:
1889	RETVAL
1890
1891	jshort
1892	CallStaticShortMethodA(clazz,methodID,args)
1893	JNIEnv * env = FETCHENV;
1894	jclass clazz
1895	jmethodID methodID
1896	char * sig = 0;
1897	jvalue * args
1898	CODE:
1899	{
1900	RETVAL = (*env)->CallStaticShortMethodA(env, clazz,methodID,args);
1901	RESTOREENV;
1902	}
1903	OUTPUT:
1904	RETVAL
1905
1906	jint
1907	CallStaticIntMethod(clazz,methodID,...)
1908	JNIEnv * env = FETCHENV;
1909	jclass clazz
1910	jmethodID methodID
1911	char * sig = 0;
1912	int argoff = $min_args;
1913	CODE:
1914	{
1915	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1916	RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1917	RESTOREENV;
1918	}
1919	OUTPUT:
1920	RETVAL
1921
1922	jint
1923	CallStaticIntMethodA(clazz,methodID,args)
1924	JNIEnv * env = FETCHENV;
1925	jclass clazz
1926	jmethodID methodID
1927	char * sig = 0;
1928	jvalue * args
1929	CODE:
1930	{
1931	RETVAL = (*env)->CallStaticIntMethodA(env, clazz,methodID,args);
1932	RESTOREENV;
1933	}
1934	OUTPUT:
1935	RETVAL
1936
1937	jlong
1938	CallStaticLongMethod(clazz,methodID,...)
1939	JNIEnv * env = FETCHENV;
1940	jclass clazz
1941	jmethodID methodID
1942	char * sig = 0;
1943	int argoff = $min_args;
1944	CODE:
1945	{
1946	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1947	RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1948	RESTOREENV;
1949	}
1950	OUTPUT:
1951	RETVAL
1952
1953	jlong
1954	CallStaticLongMethodA(clazz,methodID,args)
1955	JNIEnv * env = FETCHENV;
1956	jclass clazz
1957	jmethodID methodID
1958	char * sig = 0;
1959	jvalue * args
1960	CODE:
1961	{
1962	RETVAL = (*env)->CallStaticLongMethodA(env, clazz,methodID,args);
1963	RESTOREENV;
1964	}
1965	OUTPUT:
1966	RETVAL
1967
1968	jfloat
1969	CallStaticFloatMethod(clazz,methodID,...)
1970	JNIEnv * env = FETCHENV;
1971	jclass clazz
1972	jmethodID methodID
1973	char * sig = 0;
1974	int argoff = $min_args;
1975	CODE:
1976	{
1977	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
1978	RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
1979	RESTOREENV;
1980	}
1981	OUTPUT:
1982	RETVAL
1983
1984	jfloat
1985	CallStaticFloatMethodA(clazz,methodID,args)
1986	JNIEnv * env = FETCHENV;
1987	jclass clazz
1988	jmethodID methodID
1989	char * sig = 0;
1990	jvalue * args
1991	CODE:
1992	{
1993	RETVAL = (*env)->CallStaticFloatMethodA(env, clazz,methodID,args);
1994	RESTOREENV;
1995	}
1996	OUTPUT:
1997	RETVAL
1998
1999	jdouble
2000	CallStaticDoubleMethod(clazz,methodID,...)
2001	JNIEnv * env = FETCHENV;
2002	jclass clazz
2003	jmethodID methodID
2004	char * sig = 0;
2005	int argoff = $min_args;
2006	CODE:
2007	{
2008	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2009	RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
2010	RESTOREENV;
2011	}
2012	OUTPUT:
2013	RETVAL
2014
2015	jdouble
2016	CallStaticDoubleMethodA(clazz,methodID,args)
2017	JNIEnv * env = FETCHENV;
2018	jclass clazz
2019	jmethodID methodID
2020	char * sig = 0;
2021	jvalue * args
2022	CODE:
2023	{
2024	RETVAL = (*env)->CallStaticDoubleMethodA(env, clazz,methodID,args);
2025	RESTOREENV;
2026	}
2027	OUTPUT:
2028	RETVAL
2029
2030	void
2031	CallStaticVoidMethod(cls,methodID,...)
2032	JNIEnv * env = FETCHENV;
2033	jclass cls
2034	jmethodID methodID
2035	char * sig = 0;
2036	int argoff = $min_args;
2037	CODE:
2038	{
2039	jvalue * args = makeargs(sig, &ST(argoff), items - argoff);
2040	(*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2041	RESTOREENV;
2042	}
2043
2044	void
2045	CallStaticVoidMethodA(cls,methodID,args)
2046	JNIEnv * env = FETCHENV;
2047	jclass cls
2048	jmethodID methodID
2049	char * sig = 0;
2050	jvalue * args
2051	CODE:
2052	{
2053	(*env)->CallStaticVoidMethodA(env, cls,methodID,args);
2054	RESTOREENV;
2055	}
2056
2057	jfieldID
2058	GetStaticFieldID(clazz,name,sig)
2059	JNIEnv * env = FETCHENV;
2060	jclass clazz
2061	const char * name
2062	const char * sig
2063	CODE:
2064	{
2065	RETVAL = (*env)->GetStaticFieldID(env, clazz,name,sig);
2066	RESTOREENV;
2067	}
2068	OUTPUT:
2069	RETVAL
2070
2071	jobject
2072	GetStaticObjectField(clazz,fieldID)
2073	JNIEnv * env = FETCHENV;
2074	jclass clazz
2075	jfieldID fieldID
2076	char * sig = 0;
2077	CODE:
2078	{
2079	RETVAL = (*env)->GetStaticObjectField(env, clazz,fieldID);
2080	RESTOREENV;
2081	}
2082	OUTPUT:
2083	RETVAL
2084
2085	jboolean
2086	GetStaticBooleanField(clazz,fieldID)
2087	JNIEnv * env = FETCHENV;
2088	jclass clazz
2089	jfieldID fieldID
2090	char * sig = 0;
2091	CODE:
2092	{
2093	RETVAL = (*env)->GetStaticBooleanField(env, clazz,fieldID);
2094	RESTOREENV;
2095	}
2096	OUTPUT:
2097	RETVAL
2098
2099	jbyte
2100	GetStaticByteField(clazz,fieldID)
2101	JNIEnv * env = FETCHENV;
2102	jclass clazz
2103	jfieldID fieldID
2104	char * sig = 0;
2105	CODE:
2106	{
2107	RETVAL = (*env)->GetStaticByteField(env, clazz,fieldID);
2108	RESTOREENV;
2109	}
2110	OUTPUT:
2111	RETVAL
2112
2113	jchar
2114	GetStaticCharField(clazz,fieldID)
2115	JNIEnv * env = FETCHENV;
2116	jclass clazz
2117	jfieldID fieldID
2118	char * sig = 0;
2119	CODE:
2120	{
2121	RETVAL = (*env)->GetStaticCharField(env, clazz,fieldID);
2122	RESTOREENV;
2123	}
2124	OUTPUT:
2125	RETVAL
2126
2127	jshort
2128	GetStaticShortField(clazz,fieldID)
2129	JNIEnv * env = FETCHENV;
2130	jclass clazz
2131	jfieldID fieldID
2132	char * sig = 0;
2133	CODE:
2134	{
2135	RETVAL = (*env)->GetStaticShortField(env, clazz,fieldID);
2136	RESTOREENV;
2137	}
2138	OUTPUT:
2139	RETVAL
2140
2141	jint
2142	GetStaticIntField(clazz,fieldID)
2143	JNIEnv * env = FETCHENV;
2144	jclass clazz
2145	jfieldID fieldID
2146	char * sig = 0;
2147	CODE:
2148	{
2149	RETVAL = (*env)->GetStaticIntField(env, clazz,fieldID);
2150	RESTOREENV;
2151	}
2152	OUTPUT:
2153	RETVAL
2154
2155	jlong
2156	GetStaticLongField(clazz,fieldID)
2157	JNIEnv * env = FETCHENV;
2158	jclass clazz
2159	jfieldID fieldID
2160	char * sig = 0;
2161	CODE:
2162	{
2163	RETVAL = (*env)->GetStaticLongField(env, clazz,fieldID);
2164	RESTOREENV;
2165	}
2166	OUTPUT:
2167	RETVAL
2168
2169	jfloat
2170	GetStaticFloatField(clazz,fieldID)
2171	JNIEnv * env = FETCHENV;
2172	jclass clazz
2173	jfieldID fieldID
2174	char * sig = 0;
2175	CODE:
2176	{
2177	RETVAL = (*env)->GetStaticFloatField(env, clazz,fieldID);
2178	RESTOREENV;
2179	}
2180	OUTPUT:
2181	RETVAL
2182
2183	jdouble
2184	GetStaticDoubleField(clazz,fieldID)
2185	JNIEnv * env = FETCHENV;
2186	jclass clazz
2187	jfieldID fieldID
2188	char * sig = 0;
2189	CODE:
2190	{
2191	RETVAL = (*env)->GetStaticDoubleField(env, clazz,fieldID);
2192	RESTOREENV;
2193	}
2194	OUTPUT:
2195	RETVAL
2196
2197	void
2198	SetStaticObjectField(clazz,fieldID,value)
2199	JNIEnv * env = FETCHENV;
2200	jclass clazz
2201	jfieldID fieldID
2202	char * sig = 0;
2203	jobject value
2204	CODE:
2205	{
2206	(*env)->SetStaticObjectField(env, clazz,fieldID,value);
2207	RESTOREENV;
2208	}
2209
2210	void
2211	SetStaticBooleanField(clazz,fieldID,value)
2212	JNIEnv * env = FETCHENV;
2213	jclass clazz
2214	jfieldID fieldID
2215	char * sig = 0;
2216	jboolean value
2217	CODE:
2218	{
2219	(*env)->SetStaticBooleanField(env, clazz,fieldID,value);
2220	RESTOREENV;
2221	}
2222
2223	void
2224	SetStaticByteField(clazz,fieldID,value)
2225	JNIEnv * env = FETCHENV;
2226	jclass clazz
2227	jfieldID fieldID
2228	char * sig = 0;
2229	jbyte value
2230	CODE:
2231	{
2232	(*env)->SetStaticByteField(env, clazz,fieldID,value);
2233	RESTOREENV;
2234	}
2235
2236	void
2237	SetStaticCharField(clazz,fieldID,value)
2238	JNIEnv * env = FETCHENV;
2239	jclass clazz
2240	jfieldID fieldID
2241	char * sig = 0;
2242	jchar value
2243	CODE:
2244	{
2245	(*env)->SetStaticCharField(env, clazz,fieldID,value);
2246	RESTOREENV;
2247	}
2248
2249	void
2250	SetStaticShortField(clazz,fieldID,value)
2251	JNIEnv * env = FETCHENV;
2252	jclass clazz
2253	jfieldID fieldID
2254	char * sig = 0;
2255	jshort value
2256	CODE:
2257	{
2258	(*env)->SetStaticShortField(env, clazz,fieldID,value);
2259	RESTOREENV;
2260	}
2261
2262	void
2263	SetStaticIntField(clazz,fieldID,value)
2264	JNIEnv * env = FETCHENV;
2265	jclass clazz
2266	jfieldID fieldID
2267	char * sig = 0;
2268	jint value
2269	CODE:
2270	{
2271	(*env)->SetStaticIntField(env, clazz,fieldID,value);
2272	RESTOREENV;
2273	}
2274
2275	void
2276	SetStaticLongField(clazz,fieldID,value)
2277	JNIEnv * env = FETCHENV;
2278	jclass clazz
2279	jfieldID fieldID
2280	char * sig = 0;
2281	jlong value
2282	CODE:
2283	{
2284	(*env)->SetStaticLongField(env, clazz,fieldID,value);
2285	RESTOREENV;
2286	}
2287
2288	void
2289	SetStaticFloatField(clazz,fieldID,value)
2290	JNIEnv * env = FETCHENV;
2291	jclass clazz
2292	jfieldID fieldID
2293	char * sig = 0;
2294	jfloat value
2295	CODE:
2296	{
2297	(*env)->SetStaticFloatField(env, clazz,fieldID,value);
2298	RESTOREENV;
2299	}
2300
2301	void
2302	SetStaticDoubleField(clazz,fieldID,value)
2303	JNIEnv * env = FETCHENV;
2304	jclass clazz
2305	jfieldID fieldID
2306	char * sig = 0;
2307	jdouble value
2308	CODE:
2309	{
2310	(*env)->SetStaticDoubleField(env, clazz,fieldID,value);
2311	RESTOREENV;
2312	}
2313
2314	jstring
2315	NewString(unicode)
2316	JNIEnv * env = FETCHENV;
2317	STRLEN tmplen = NO_INIT;
2318	jsize unicode_len_ = NO_INIT;
2319	const jchar * unicode
2320	CODE:
2321	{
2322	RETVAL = (*env)->NewString(env, unicode, unicode_len_);
2323	RESTOREENV;
2324	}
2325	OUTPUT:
2326	RETVAL
2327
2328	jsize
2329	GetStringLength(str)
2330	JNIEnv * env = FETCHENV;
2331	jstring str
2332	CODE:
2333	{
2334	RETVAL = (*env)->GetStringLength(env, str);
2335	RESTOREENV;
2336	}
2337	OUTPUT:
2338	RETVAL
2339
2340	const jchar *
2341	GetStringChars(str)
2342	JNIEnv * env = FETCHENV;
2343	jstring str
2344	jboolean isCopy = NO_INIT;
2345	jsize RETVAL_len_ = NO_INIT;
2346	CODE:
2347	{
2348	RETVAL = (*env)->GetStringChars(env, str,&isCopy);
2349	RETVAL_len_ = (*env)->GetStringLength(env, str);
2350	RESTOREENV;
2351	}
2352	OUTPUT:
2353	RETVAL
2354	CLEANUP:
2355	(*env)->ReleaseStringChars(env, str,RETVAL);
2356
2357	jstring
2358	NewStringUTF(utf)
2359	JNIEnv * env = FETCHENV;
2360	const char * utf
2361	CODE:
2362	{
2363	RETVAL = (*env)->NewStringUTF(env, utf);
2364	RESTOREENV;
2365	}
2366	OUTPUT:
2367	RETVAL
2368
2369	jsize
2370	GetStringUTFLength(str)
2371	JNIEnv * env = FETCHENV;
2372	jstring str
2373	CODE:
2374	{
2375	RETVAL = (*env)->GetStringUTFLength(env, str);
2376	RESTOREENV;
2377	}
2378	OUTPUT:
2379	RETVAL
2380
2381	const char *
2382	GetStringUTFChars(str)
2383	JNIEnv * env = FETCHENV;
2384	jstring str
2385	jboolean isCopy = NO_INIT;
2386	CODE:
2387	{
2388	RETVAL = (*env)->GetStringUTFChars(env, str,&isCopy);
2389	RESTOREENV;
2390	}
2391	OUTPUT:
2392	RETVAL
2393	CLEANUP:
2394	(*env)->ReleaseStringUTFChars(env, str, RETVAL);
2395
2396
2397	jsize
2398	GetArrayLength(array)
2399	JNIEnv * env = FETCHENV;
2400	jarray array
2401	CODE:
2402	{
2403	RETVAL = (*env)->GetArrayLength(env, array);
2404	RESTOREENV;
2405	}
2406	OUTPUT:
2407	RETVAL
2408
2409	jobjectArray
2410	NewObjectArray(len,clazz,init)
2411	JNIEnv * env = FETCHENV;
2412	jsize len
2413	jclass clazz
2414	jobject init
2415	CODE:
2416	{
2417	RETVAL = (*env)->NewObjectArray(env, len,clazz,init);
2418	RESTOREENV;
2419	}
2420	OUTPUT:
2421	RETVAL
2422
2423	jobject
2424	GetObjectArrayElement(array,index)
2425	JNIEnv * env = FETCHENV;
2426	jobjectArray array
2427	jsize index
2428	CODE:
2429	{
2430	RETVAL = (*env)->GetObjectArrayElement(env, array,index);
2431	RESTOREENV;
2432	}
2433	OUTPUT:
2434	RETVAL
2435
2436	void
2437	SetObjectArrayElement(array,index,val)
2438	JNIEnv * env = FETCHENV;
2439	jobjectArray array
2440	jsize index
2441	jobject val
2442	CODE:
2443	{
2444	(*env)->SetObjectArrayElement(env, array,index,val);
2445	RESTOREENV;
2446	}
2447
2448	jbooleanArray
2449	NewBooleanArray(len)
2450	JNIEnv * env = FETCHENV;
2451	jsize len
2452	CODE:
2453	{
2454	RETVAL = (*env)->NewBooleanArray(env, len);
2455	RESTOREENV;
2456	}
2457	OUTPUT:
2458	RETVAL
2459
2460	jbyteArray
2461	NewByteArray(len)
2462	JNIEnv * env = FETCHENV;
2463	jsize len
2464	CODE:
2465	{
2466	RETVAL = (*env)->NewByteArray(env, len);
2467	RESTOREENV;
2468	}
2469	OUTPUT:
2470	RETVAL
2471
2472	jcharArray
2473	NewCharArray(len)
2474	JNIEnv * env = FETCHENV;
2475	jsize len
2476	CODE:
2477	{
2478	RETVAL = (*env)->NewCharArray(env, len);
2479	RESTOREENV;
2480	}
2481	OUTPUT:
2482	RETVAL
2483
2484	jshortArray
2485	NewShortArray(len)
2486	JNIEnv * env = FETCHENV;
2487	jsize len
2488	CODE:
2489	{
2490	RETVAL = (*env)->NewShortArray(env, len);
2491	RESTOREENV;
2492	}
2493	OUTPUT:
2494	RETVAL
2495
2496	jintArray
2497	NewIntArray(len)
2498	JNIEnv * env = FETCHENV;
2499	jsize len
2500	CODE:
2501	{
2502	RETVAL = (*env)->NewIntArray(env, len);
2503	RESTOREENV;
2504	}
2505	OUTPUT:
2506	RETVAL
2507
2508	jlongArray
2509	NewLongArray(len)
2510	JNIEnv * env = FETCHENV;
2511	jsize len
2512	CODE:
2513	{
2514	RETVAL = (*env)->NewLongArray(env, len);
2515	RESTOREENV;
2516	}
2517	OUTPUT:
2518	RETVAL
2519
2520	jfloatArray
2521	NewFloatArray(len)
2522	JNIEnv * env = FETCHENV;
2523	jsize len
2524	CODE:
2525	{
2526	RETVAL = (*env)->NewFloatArray(env, len);
2527	RESTOREENV;
2528	}
2529	OUTPUT:
2530	RETVAL
2531
2532	jdoubleArray
2533	NewDoubleArray(len)
2534	JNIEnv * env = FETCHENV;
2535	jsize len
2536	CODE:
2537	{
2538	RETVAL = (*env)->NewDoubleArray(env, len);
2539	RESTOREENV;
2540	}
2541	OUTPUT:
2542	RETVAL
2543
2544	jboolean *
2545	GetBooleanArrayElements(array)
2546	JNIEnv * env = FETCHENV;
2547	jsize RETVAL_len_ = NO_INIT;
2548	jbooleanArray array
2549	jboolean isCopy = NO_INIT;
2550	PPCODE:
2551	{
2552	RETVAL = (*env)->GetBooleanArrayElements(env, array,&isCopy);
2553	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2554	if (GIMME == G_ARRAY) {
2555	int i;
2556	jboolean* r = RETVAL;
2557	EXTEND(sp, RETVAL_len_);
2558	for (i = RETVAL_len_; i; --i) {
2559	PUSHs(sv_2mortal(newSViv(*r++)));
2560	}
2561	}
2562	else {
2563	if (RETVAL_len_) {
2564	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2565	(STRLEN)RETVAL_len_ * sizeof(jboolean))));
2566	}
2567	else
2568	PUSHs(&PL_sv_no);
2569	}
2570	(*env)->ReleaseBooleanArrayElements(env, array,RETVAL,JNI_ABORT);
2571	RESTOREENV;
2572	}
2573
2574	jbyte *
2575	GetByteArrayElements(array)
2576	JNIEnv * env = FETCHENV;
2577	jsize RETVAL_len_ = NO_INIT;
2578	jbyteArray array
2579	jboolean isCopy = NO_INIT;
2580	PPCODE:
2581	{
2582	RETVAL = (*env)->GetByteArrayElements(env, array,&isCopy);
2583	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2584	if (GIMME == G_ARRAY) {
2585	int i;
2586	jbyte* r = RETVAL;
2587	EXTEND(sp, RETVAL_len_);
2588	for (i = RETVAL_len_; i; --i) {
2589	PUSHs(sv_2mortal(newSViv(*r++)));
2590	}
2591	}
2592	else {
2593	if (RETVAL_len_) {
2594	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2595	(STRLEN)RETVAL_len_ * sizeof(jbyte))));
2596	}
2597	else
2598	PUSHs(&PL_sv_no);
2599	}
2600	(*env)->ReleaseByteArrayElements(env, array,RETVAL,JNI_ABORT);
2601	RESTOREENV;
2602	}
2603
2604	jchar *
2605	GetCharArrayElements(array)
2606	JNIEnv * env = FETCHENV;
2607	jsize RETVAL_len_ = NO_INIT;
2608	jcharArray array
2609	jboolean isCopy = NO_INIT;
2610	PPCODE:
2611	{
2612	RETVAL = (*env)->GetCharArrayElements(env, array,&isCopy);
2613	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2614	if (GIMME == G_ARRAY) {
2615	int i;
2616	jchar* r = RETVAL;
2617	EXTEND(sp, RETVAL_len_);
2618	for (i = RETVAL_len_; i; --i) {
2619	PUSHs(sv_2mortal(newSViv(*r++)));
2620	}
2621	}
2622	else {
2623	if (RETVAL_len_) {
2624	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2625	(STRLEN)RETVAL_len_ * sizeof(jchar))));
2626	}
2627	else
2628	PUSHs(&PL_sv_no);
2629	}
2630	(*env)->ReleaseCharArrayElements(env, array,RETVAL,JNI_ABORT);
2631	RESTOREENV;
2632	}
2633
2634	jshort *
2635	GetShortArrayElements(array)
2636	JNIEnv * env = FETCHENV;
2637	jsize RETVAL_len_ = NO_INIT;
2638	jshortArray array
2639	jboolean isCopy = NO_INIT;
2640	PPCODE:
2641	{
2642	RETVAL = (*env)->GetShortArrayElements(env, array,&isCopy);
2643	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2644	if (GIMME == G_ARRAY) {
2645	int i;
2646	jshort* r = RETVAL;
2647	EXTEND(sp, RETVAL_len_);
2648	for (i = RETVAL_len_; i; --i) {
2649	PUSHs(sv_2mortal(newSViv(*r++)));
2650	}
2651	}
2652	else {
2653	if (RETVAL_len_) {
2654	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2655	(STRLEN)RETVAL_len_ * sizeof(jshort))));
2656	}
2657	else
2658	PUSHs(&PL_sv_no);
2659	}
2660	(*env)->ReleaseShortArrayElements(env, array,RETVAL,JNI_ABORT);
2661	RESTOREENV;
2662	}
2663
2664	jint *
2665	GetIntArrayElements(array)
2666	JNIEnv * env = FETCHENV;
2667	jsize RETVAL_len_ = NO_INIT;
2668	jintArray array
2669	jboolean isCopy = NO_INIT;
2670	PPCODE:
2671	{
2672	RETVAL = (*env)->GetIntArrayElements(env, array,&isCopy);
2673	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2674	if (GIMME == G_ARRAY) {
2675	int i;
2676	jint* r = RETVAL;
2677	EXTEND(sp, RETVAL_len_);
2678	for (i = RETVAL_len_; i; --i) {
2679	PUSHs(sv_2mortal(newSViv(*r++)));
2680	}
2681	}
2682	else {
2683	if (RETVAL_len_) {
2684	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2685	(STRLEN)RETVAL_len_ * sizeof(jint))));
2686	}
2687	else
2688	PUSHs(&PL_sv_no);
2689	}
2690	(*env)->ReleaseIntArrayElements(env, array,RETVAL,JNI_ABORT);
2691	RESTOREENV;
2692	}
2693
2694	jlong *
2695	GetLongArrayElements(array)
2696	JNIEnv * env = FETCHENV;
2697	jsize RETVAL_len_ = NO_INIT;
2698	jlongArray array
2699	jboolean isCopy = NO_INIT;
2700	PPCODE:
2701	{
2702	RETVAL = (*env)->GetLongArrayElements(env, array,&isCopy);
2703	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2704	if (GIMME == G_ARRAY) {
2705	int i;
2706	jlong* r = RETVAL;
2707	EXTEND(sp, RETVAL_len_);
2708	for (i = RETVAL_len_; i; --i) {
2709	PUSHs(sv_2mortal(newSViv(*r++)));
2710	}
2711	}
2712	else {
2713	if (RETVAL_len_) {
2714	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2715	(STRLEN)RETVAL_len_ * sizeof(jlong))));
2716	}
2717	else
2718	PUSHs(&PL_sv_no);
2719	}
2720	(*env)->ReleaseLongArrayElements(env, array,RETVAL,JNI_ABORT);
2721	RESTOREENV;
2722	}
2723
2724	jfloat *
2725	GetFloatArrayElements(array)
2726	JNIEnv * env = FETCHENV;
2727	jsize RETVAL_len_ = NO_INIT;
2728	jfloatArray array
2729	jboolean isCopy = NO_INIT;
2730	PPCODE:
2731	{
2732	RETVAL = (*env)->GetFloatArrayElements(env, array,&isCopy);
2733	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2734	if (GIMME == G_ARRAY) {
2735	int i;
2736	jfloat* r = RETVAL;
2737	EXTEND(sp, RETVAL_len_);
2738	for (i = RETVAL_len_; i; --i) {
2739	PUSHs(sv_2mortal(newSVnv(*r++)));
2740	}
2741	}
2742	else {
2743	if (RETVAL_len_) {
2744	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2745	(STRLEN)RETVAL_len_ * sizeof(jfloat))));
2746	}
2747	else
2748	PUSHs(&PL_sv_no);
2749	}
2750	(*env)->ReleaseFloatArrayElements(env, array,RETVAL,JNI_ABORT);
2751	RESTOREENV;
2752	}
2753
2754	jdouble *
2755	GetDoubleArrayElements(array)
2756	JNIEnv * env = FETCHENV;
2757	jsize RETVAL_len_ = NO_INIT;
2758	jdoubleArray array
2759	jboolean isCopy = NO_INIT;
2760	PPCODE:
2761	{
2762	RETVAL = (*env)->GetDoubleArrayElements(env, array,&isCopy);
2763	RETVAL_len_ = (*env)->GetArrayLength(env, array);
2764	if (GIMME == G_ARRAY) {
2765	int i;
2766	jdouble* r = RETVAL;
2767	EXTEND(sp, RETVAL_len_);
2768	for (i = RETVAL_len_; i; --i) {
2769	PUSHs(sv_2mortal(newSVnv(*r++)));
2770	}
2771	}
2772	else {
2773	if (RETVAL_len_) {
2774	PUSHs(sv_2mortal(newSVpvn((char*)RETVAL,
2775	(STRLEN)RETVAL_len_ * sizeof(jdouble))));
2776	}
2777	else
2778	PUSHs(&PL_sv_no);
2779	}
2780	(*env)->ReleaseDoubleArrayElements(env, array,RETVAL,JNI_ABORT);
2781	RESTOREENV;
2782	}
2783
2784	void
2785	GetBooleanArrayRegion(array,start,len,buf)
2786	JNIEnv * env = FETCHENV;
2787	jbooleanArray array
2788	jsize start
2789	jsize len
2790	STRLEN tmplen = len * sizeof(jboolean) + 1;
2791	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2792	jboolean * buf = (jboolean)sv_grow(ST(3),len sizeof(jboolean)+1);
2793	CODE:
2794	{
2795	(*env)->GetBooleanArrayRegion(env, array,start,len,buf);
2796	SvCUR_set(ST(3), len * sizeof(jboolean));
2797	*SvEND(ST(3)) = '\0';
2798	RESTOREENV;
2799	}
2800
2801	void
2802	GetByteArrayRegion(array,start,len,buf)
2803	JNIEnv * env = FETCHENV;
2804	jbyteArray array
2805	jsize start
2806	jsize len
2807	STRLEN tmplen = len * sizeof(jboolean) + 1;
2808	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2809	jbyte * buf = (jbyte)sv_grow(ST(3),len sizeof(jbyte)+1);
2810	CODE:
2811	{
2812	(*env)->GetByteArrayRegion(env, array,start,len,buf);
2813	SvCUR_set(ST(3), len * sizeof(jbyte));
2814	*SvEND(ST(3)) = '\0';
2815	RESTOREENV;
2816	}
2817
2818	void
2819	GetCharArrayRegion(array,start,len,buf)
2820	JNIEnv * env = FETCHENV;
2821	jcharArray array
2822	jsize start
2823	jsize len
2824	STRLEN tmplen = len * sizeof(jboolean) + 1;
2825	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2826	jchar * buf = (jchar)sv_grow(ST(3),len sizeof(jchar)+1);
2827	CODE:
2828	{
2829	(*env)->GetCharArrayRegion(env, array,start,len,buf);
2830	SvCUR_set(ST(3), len * sizeof(jchar));
2831	*SvEND(ST(3)) = '\0';
2832	RESTOREENV;
2833	}
2834
2835	void
2836	GetShortArrayRegion(array,start,len,buf)
2837	JNIEnv * env = FETCHENV;
2838	jshortArray array
2839	jsize start
2840	jsize len
2841	STRLEN tmplen = len * sizeof(jboolean) + 1;
2842	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2843	jshort * buf = (jshort)sv_grow(ST(3),len sizeof(jshort)+1);
2844	CODE:
2845	{
2846	(*env)->GetShortArrayRegion(env, array,start,len,buf);
2847	SvCUR_set(ST(3), len * sizeof(jshort));
2848	*SvEND(ST(3)) = '\0';
2849	RESTOREENV;
2850	}
2851
2852	void
2853	GetIntArrayRegion(array,start,len,buf)
2854	JNIEnv * env = FETCHENV;
2855	jintArray array
2856	jsize start
2857	jsize len
2858	STRLEN tmplen = len * sizeof(jboolean) + 1;
2859	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2860	jint * buf = (jint)sv_grow(ST(3),len sizeof(jint)+1);
2861	CODE:
2862	{
2863	(*env)->GetIntArrayRegion(env, array,start,len,buf);
2864	SvCUR_set(ST(3), len * sizeof(jint));
2865	*SvEND(ST(3)) = '\0';
2866	RESTOREENV;
2867	}
2868
2869	void
2870	GetLongArrayRegion(array,start,len,buf)
2871	JNIEnv * env = FETCHENV;
2872	jlongArray array
2873	jsize start
2874	jsize len
2875	STRLEN tmplen = len * sizeof(jboolean) + 1;
2876	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2877	jlong * buf = (jlong)sv_grow(ST(3),len sizeof(jlong)+1);
2878	CODE:
2879	{
2880	(*env)->GetLongArrayRegion(env, array,start,len,buf);
2881	SvCUR_set(ST(3), len * sizeof(jlong));
2882	*SvEND(ST(3)) = '\0';
2883	RESTOREENV;
2884	}
2885
2886	void
2887	GetFloatArrayRegion(array,start,len,buf)
2888	JNIEnv * env = FETCHENV;
2889	jfloatArray array
2890	jsize start
2891	jsize len
2892	STRLEN tmplen = len * sizeof(jboolean) + 1;
2893	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2894	jfloat * buf = (jfloat)sv_grow(ST(3),len sizeof(jfloat)+1);
2895	CODE:
2896	{
2897	(*env)->GetFloatArrayRegion(env, array,start,len,buf);
2898	SvCUR_set(ST(3), len * sizeof(jfloat));
2899	*SvEND(ST(3)) = '\0';
2900	RESTOREENV;
2901	}
2902
2903	void
2904	GetDoubleArrayRegion(array,start,len,buf)
2905	JNIEnv * env = FETCHENV;
2906	jdoubleArray array
2907	jsize start
2908	jsize len
2909	STRLEN tmplen = len * sizeof(jboolean) + 1;
2910	char * tmpbuf = (char*)sv_pvn_force(ST(3), &tmplen);
2911	jdouble * buf = (jdouble)sv_grow(ST(3),len sizeof(jdouble)+1);
2912	CODE:
2913	{
2914	(*env)->GetDoubleArrayRegion(env, array,start,len,buf);
2915	SvCUR_set(ST(3), len * sizeof(jdouble));
2916	*SvEND(ST(3)) = '\0';
2917	RESTOREENV;
2918	}
2919
2920	void
2921	SetBooleanArrayRegion(array,start,len,buf)
2922	JNIEnv * env = FETCHENV;
2923	STRLEN tmplen = NO_INIT;
2924	jbooleanArray array
2925	jsize start
2926	jsize len
2927	jsize buf_len_ = NO_INIT;
2928	jboolean * buf
2929	CODE:
2930	{
2931	if (buf_len_ < len)
2932	croak("string is too short");
2933	else if (buf_len_ > len && PL_dowarn)
2934	warn("string is too long");
2935	(*env)->SetBooleanArrayRegion(env, array,start,len,buf);
2936	RESTOREENV;
2937	}
2938
2939	void
2940	SetByteArrayRegion(array,start,len,buf)
2941	JNIEnv * env = FETCHENV;
2942	STRLEN tmplen = NO_INIT;
2943	jbyteArray array
2944	jsize start
2945	jsize len
2946	jsize buf_len_ = NO_INIT;
2947	jbyte * buf
2948	CODE:
2949	{
2950	if (buf_len_ < len)
2951	croak("string is too short");
2952	else if (buf_len_ > len && PL_dowarn)
2953	warn("string is too long");
2954	(*env)->SetByteArrayRegion(env, array,start,len,buf);
2955	RESTOREENV;
2956	}
2957
2958	void
2959	SetCharArrayRegion(array,start,len,buf)
2960	JNIEnv * env = FETCHENV;
2961	STRLEN tmplen = NO_INIT;
2962	jcharArray array
2963	jsize start
2964	jsize len
2965	jsize buf_len_ = NO_INIT;
2966	jchar * buf
2967	CODE:
2968	{
2969	if (buf_len_ < len)
2970	croak("string is too short");
2971	else if (buf_len_ > len && PL_dowarn)
2972	warn("string is too long");
2973	(*env)->SetCharArrayRegion(env, array,start,len,buf);
2974	RESTOREENV;
2975	}
2976
2977	void
2978	SetShortArrayRegion(array,start,len,buf)
2979	JNIEnv * env = FETCHENV;
2980	STRLEN tmplen = NO_INIT;
2981	jshortArray array
2982	jsize start
2983	jsize len
2984	jsize buf_len_ = NO_INIT;
2985	jshort * buf
2986	CODE:
2987	{
2988	if (buf_len_ < len)
2989	croak("string is too short");
2990	else if (buf_len_ > len && PL_dowarn)
2991	warn("string is too long");
2992	(*env)->SetShortArrayRegion(env, array,start,len,buf);
2993	RESTOREENV;
2994	}
2995
2996	void
2997	SetIntArrayRegion(array,start,len,buf)
2998	JNIEnv * env = FETCHENV;
2999	STRLEN tmplen = NO_INIT;
3000	jintArray array
3001	jsize start
3002	jsize len
3003	jsize buf_len_ = NO_INIT;
3004	jint * buf
3005	CODE:
3006	{
3007	if (buf_len_ < len)
3008	croak("string is too short");
3009	else if (buf_len_ > len && PL_dowarn)
3010	warn("string is too long");
3011	(*env)->SetIntArrayRegion(env, array,start,len,buf);
3012	RESTOREENV;
3013	}
3014
3015	void
3016	SetLongArrayRegion(array,start,len,buf)
3017	JNIEnv * env = FETCHENV;
3018	STRLEN tmplen = NO_INIT;
3019	jlongArray array
3020	jsize start
3021	jsize len
3022	jsize buf_len_ = NO_INIT;
3023	jlong * buf
3024	CODE:
3025	{
3026	if (buf_len_ < len)
3027	croak("string is too short");
3028	else if (buf_len_ > len && PL_dowarn)
3029	warn("string is too long");
3030	(*env)->SetLongArrayRegion(env, array,start,len,buf);
3031	RESTOREENV;
3032	}
3033
3034	void
3035	SetFloatArrayRegion(array,start,len,buf)
3036	JNIEnv * env = FETCHENV;
3037	STRLEN tmplen = NO_INIT;
3038	jfloatArray array
3039	jsize start
3040	jsize len
3041	jsize buf_len_ = NO_INIT;
3042	jfloat * buf
3043	CODE:
3044	{
3045	if (buf_len_ < len)
3046	croak("string is too short");
3047	else if (buf_len_ > len && PL_dowarn)
3048	warn("string is too long");
3049	(*env)->SetFloatArrayRegion(env, array,start,len,buf);
3050	RESTOREENV;
3051	}
3052
3053	void
3054	SetDoubleArrayRegion(array,start,len,buf)
3055	JNIEnv * env = FETCHENV;
3056	STRLEN tmplen = NO_INIT;
3057	jdoubleArray array
3058	jsize start
3059	jsize len
3060	jsize buf_len_ = NO_INIT;
3061	jdouble * buf
3062	CODE:
3063	{
3064	if (buf_len_ < len)
3065	croak("string is too short");
3066	else if (buf_len_ > len && PL_dowarn)
3067	warn("string is too long");
3068	(*env)->SetDoubleArrayRegion(env, array,start,len,buf);
3069	RESTOREENV;
3070	}
3071
3072	SysRet
3073	RegisterNatives(clazz,methods,nMethods)
3074	JNIEnv * env = FETCHENV;
3075	jclass clazz
3076	JNINativeMethod * methods
3077	jint nMethods
3078	CODE:
3079	{
3080	RETVAL = (*env)->RegisterNatives(env, clazz,methods,nMethods);
3081	}
3082
3083	SysRet
3084	UnregisterNatives(clazz)
3085	JNIEnv * env = FETCHENV;
3086	jclass clazz
3087	CODE:
3088	{
3089	RETVAL = (*env)->UnregisterNatives(env, clazz);
3090	}
3091	OUTPUT:
3092	RETVAL
3093
3094	SysRet
3095	MonitorEnter(obj)
3096	JNIEnv * env = FETCHENV;
3097	jobject obj
3098	CODE:
3099	{
3100	RETVAL = (*env)->MonitorEnter(env, obj);
3101	RESTOREENV;
3102	}
3103	OUTPUT:
3104	RETVAL
3105
3106	SysRet
3107	MonitorExit(obj)
3108	JNIEnv * env = FETCHENV;
3109	jobject obj
3110	CODE:
3111	{
3112	RETVAL = (*env)->MonitorExit(env, obj);
3113	RESTOREENV;
3114	}
3115	OUTPUT:
3116	RETVAL
3117
3118	JavaVM *
3119	GetJavaVM(...)
3120	JNIEnv * env = FETCHENV;
3121	CODE:
3122	{
3123	#ifdef JPL_DEBUG
3124	jpldebug = 1;
3125	#else
3126	jpldebug = 0;
3127	#endif
3128	if (env) { /* We're embedded. */
3129	if ((*env)->GetJavaVM(env, &RETVAL) < 0)
3130	RETVAL = 0;
3131	}
3132	else { /* We're embedding. */
3133	#ifdef KAFFE
3134	JavaVMInitArgs vm_args;
3135	#else
3136	JDK1_1InitArgs vm_args;
3137	#endif
3138	char *lib;
3139	if (jpldebug) {
3140	fprintf(stderr, "We're embedding Java in Perl.\n");
3141	}
3142
3143	if (items--) {
3144	++mark;
3145	lib = SvPV(*mark, PL_na);
3146	}
3147	else
3148	lib = 0;
3149	if (jpldebug) {
3150	fprintf(stderr, "lib is %s.\n", lib);
3151	}
3152	#ifdef WIN32
3153	if (LoadLibrary("jvm.dll")) {
3154	if (!LoadLibrary("javai.dll")) {
3155	warn("Can't load javai.dll");
3156	}
3157	} else {
3158	if (lib && !LoadLibrary(lib))
3159	croak("Can't load javai.dll");
3160	}
3161	#else
3162	if (jpldebug) {
3163	fprintf(stderr, "Opening Java shared library.\n");
3164	}
3165	#ifdef KAFFE
3166	if (!dlopen("libkaffevm.so", RTLD_LAZY\|RTLD_GLOBAL)) {
3167	#else
3168	if (!dlopen("libjava.so", RTLD_LAZY\|RTLD_GLOBAL)) {
3169	#endif
3170	if (lib && !dlopen(lib, RTLD_LAZY\|RTLD_GLOBAL))
3171	croak("Can't load Java shared library.");
3172	}
3173	#endif
3174	/* Kaffe seems to get very upset if vm_args.version isn't set */
3175	#ifdef KAFFE
3176	vm_args.version = JNI_VERSION_1_1;
3177	#endif
3178	JNI_GetDefaultJavaVMInitArgs(&vm_args);
3179	vm_args.exit = &call_my_exit;
3180	if (jpldebug) {
3181	fprintf(stderr, "items = %d\n", items);
3182	fprintf(stderr, "mark = %s\n", SvPV(*mark, PL_na));
3183	}
3184	while (items > 1) {
3185	char *s;
3186	++mark;
3187	s = SvPV(*mark,PL_na);
3188	++mark;
3189	if (jpldebug) {
3190	fprintf(stderr, "*s = %s\n", s);
3191	fprintf(stderr, "val = %s\n", SvPV(*mark, PL_na));
3192	}
3193	items -= 2;
3194	if (strEQ(s, "checkSource"))
3195	vm_args.checkSource = (jint)SvIV(*mark);
3196	else if (strEQ(s, "nativeStackSize"))
3197	vm_args.nativeStackSize = (jint)SvIV(*mark);
3198	else if (strEQ(s, "javaStackSize"))
3199	vm_args.javaStackSize = (jint)SvIV(*mark);
3200	else if (strEQ(s, "minHeapSize"))
3201	vm_args.minHeapSize = (jint)SvIV(*mark);
3202	else if (strEQ(s, "maxHeapSize"))
3203	vm_args.maxHeapSize = (jint)SvIV(*mark);
3204	else if (strEQ(s, "verifyMode"))
3205	vm_args.verifyMode = (jint)SvIV(*mark);
3206	else if (strEQ(s, "classpath"))
3207	vm_args.classpath = savepv(SvPV(*mark,PL_na));
3208	else if (strEQ(s, "enableClassGC"))
3209	vm_args.enableClassGC = (jint)SvIV(*mark);
3210	else if (strEQ(s, "enableVerboseGC"))
3211	vm_args.enableVerboseGC = (jint)SvIV(*mark);
3212	else if (strEQ(s, "disableAsyncGC"))
3213	vm_args.disableAsyncGC = (jint)SvIV(*mark);
3214	#ifdef KAFFE
3215	else if (strEQ(s, "libraryhome"))
3216	vm_args.libraryhome = savepv(SvPV(*mark,PL_na));
3217	else if (strEQ(s, "classhome"))
3218	vm_args.classhome = savepv(SvPV(*mark,PL_na));
3219	else if (strEQ(s, "enableVerboseJIT"))
3220	vm_args.enableVerboseJIT = (jint)SvIV(*mark);
3221	else if (strEQ(s, "enableVerboseClassloading"))
3222	vm_args.enableVerboseClassloading = (jint)SvIV(*mark);
3223	else if (strEQ(s, "enableVerboseCall"))
3224	vm_args.enableVerboseCall = (jint)SvIV(*mark);
3225	else if (strEQ(s, "allocHeapSize"))
3226	vm_args.allocHeapSize = (jint)SvIV(*mark);
3227	#else
3228	else if (strEQ(s, "verbose"))
3229	vm_args.verbose = (jint)SvIV(*mark);
3230	else if (strEQ(s, "debugging"))
3231	vm_args.debugging = (jboolean)SvIV(*mark);
3232	else if (strEQ(s, "debugPort"))
3233	vm_args.debugPort = (jint)SvIV(*mark);
3234	#endif
3235	else
3236	croak("unrecognized option: %s", s);
3237	}
3238
3239	if (jpldebug) {
3240	fprintf(stderr, "Creating Java VM...\n");
3241	fprintf(stderr, "Working CLASSPATH: %s\n",
3242	vm_args.classpath);
3243	}
3244	if (JNI_CreateJavaVM(&RETVAL, &jplcurenv, &vm_args) < 0) {
3245	croak("Unable to create instance of JVM");
3246	}
3247	if (jpldebug) {
3248	fprintf(stderr, "Created Java VM.\n");
3249	}
3250
3251	}
3252	}
3253

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/essentials/dev-lang/perl/jpl/JNI/JNI.xs

Download in other formats: