Project: RJB

Revision: 80

Author: arton

Date: 25 Aug 2008 08:56:50

• /1.1.5/ext/rjb.c

  ......	@@ -0,0 +1,2839 @@
  	1	/*
  	2	* Rjb - Ruby <-> Java Bridge
  	3	* Copyright(c) 2004,2005,2006,2007,2008 arton
  	4	*
  	5	* This library is free software; you can redistribute it and/or
  	6	* modify it under the terms of the GNU Lesser General Public
  	7	* License as published by the Free Software Foundation; either
  	8	* version 2.1 of the License, or (at your option) any later version.
  	9	*
  	10	* This library is distributed in the hope that it will be useful,
  	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
  	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  	13	* Lesser General Public License for more details.
  	14	*
  	15	* $Id$
  	16	*/
  	17
  	18	#define RJB_VERSION "1.1.5"
  	19
  	20	#include "ruby.h"
  	21	#include "extconf.h"
  	22	#if RJB_RUBY_VERSION_CODE < 190
  	23	#include "st.h"
  	24	#else
  	25	#include "ruby/st.h"
  	26	#endif
  	27	#include "jniwrap.h"
  	28	#include "jp_co_infoseek_hp_arton_rjb_RBridge.h"
  	29	#include "riconv.h"
  	30	#include "rjb.h"
  	31	#include "ctype.h"
  	32
  	33	/*
  	34	* Method Modifier Flag defined in
  	35	* http://java.sun.com/docs/books/vmspec/2nd-edition/html/ClassFile.doc.html#88358
  	36	*/
  	37	#define ACC_PUBLIC 0x0001
  	38	#define ACC_PRIVATE 0x0002
  	39	#define ACC_PROTECTED 0x0004
  	40	#define ACC_STATIC 0x0008
  	41	#define ACC_FINAL 0x0010
  	42	#define ACC_VOLATILE 0x0040
  	43	#define ACC_TRANSIENT 0x0080
  	44
  	45	#define RJB_FIND_CLASS(var, name) \
  	46	var = (*jenv)->FindClass(jenv, name); \
  	47	rjb_check_exception(jenv, 1)
  	48	#define RJB_HOLD_CLASS(var, name) \
  	49	var = (*jenv)->FindClass(jenv, name); \
  	50	rjb_check_exception(jenv, 1); \
  	51	var = (*jenv)->NewGlobalRef(jenv, var)
  	52	#define RJB_LOAD_METHOD(var, obj, name, sig) \
  	53	var = (*jenv)->GetMethodID(jenv, obj, name, sig); \
  	54	rjb_check_exception(jenv, 1)
  	55	#define RJB_LOAD_STATIC_METHOD(var, obj, name, sig) \
  	56	var = (*jenv)->GetStaticMethodID(jenv, obj, name, sig); \
  	57	rjb_check_exception(jenv, 1)
  	58
  	59	static void register_class(VALUE, VALUE);
  	60	static VALUE import_class(JNIEnv* jenv, jclass, VALUE);
  	61	static VALUE register_instance(JNIEnv* jenv, struct jvi_data*, jobject);
  	62	static VALUE rjb_s_free(struct jv_data*);
  	63	static VALUE rjb_class_forname(int argc, VALUE* argv, VALUE self);
  	64	static void setup_metadata(JNIEnv* jenv, VALUE self, struct jv_data*, VALUE classname);
  	65	static VALUE jarray2rv(JNIEnv* jenv, jvalue val);
  	66	static jarray r2objarray(JNIEnv* jenv, VALUE v, const char* cls);
  	67	static VALUE jv2rv_withprim(JNIEnv* jenv, jobject o);
  	68	static J2R get_arrayconv(const char* cname, char* depth);
  	69
  	70	static VALUE rjb;
  	71	static VALUE jklass;
  	72	static VALUE rjbc;
  	73	static VALUE rjbi;
  	74	static VALUE rjbb;
  	75
  	76	VALUE rjb_loaded_classes;
  	77	static VALUE proxies;
  	78	JavaVM* rjb_jvm;
  	79	jclass rjb_rbridge;
  	80	jmethodID rjb_register_bridge;
  	81	static JNIEnv* main_jenv;
  	82	static VALUE primitive_conversion = Qfalse;
  	83
  	84	/*
  	85	* Object cache, never destroyed
  	86	*/
  	87	/* method */
  	88	static jmethodID method_getModifiers;
  	89	static jmethodID method_getName;
  	90	static jmethodID getParameterTypes;
  	91	static jmethodID getReturnType;
  	92	/* field */
  	93	static jmethodID field_getModifiers;
  	94	static jmethodID field_getName;
  	95	static jmethodID field_getType;
  	96	/* constructor */
  	97	static jmethodID ctrGetParameterTypes;
  	98	/* class */
  	99	static jclass j_class;
  	100	jmethodID rjb_class_getName;
  	101	/* throwable */
  	102	jclass rjb_j_throwable;
  	103	jmethodID rjb_throwable_getMessage;
  	104	/* String global reference */
  	105	static jclass j_string;
  	106	static jmethodID str_tostring;
  	107	/* Object global reference */
  	108	static jclass j_object;
  	109
  	110	enum PrimitiveType {
  	111	PRM_INT = 0,
  	112	PRM_LONG,
  	113	PRM_DOUBLE,
  	114	PRM_BOOLEAN,
  	115	PRM_CHARACTER,
  	116	PRM_SHORT,
  	117	PRM_BYTE,
  	118	PRM_FLOAT,
  	119	/* */
  	120	PRM_LAST
  	121	};
  	122
  	123	/*
  	124	* Native type conversion table
  	125	*/
  	126	typedef struct jobject_ruby_table {
  	127	const char* classname;
  	128	const char* to_prim_method;
  	129	const char* prmsig;
  	130	const char* ctrsig;
  	131	jclass klass; /* primitive class */
  	132	jmethodID to_prim_id;
  	133	jmethodID ctr_id;
  	134	J2R func;
  	135	} jprimitive_table;
  	136
  	137	JNIEnv* rjb_attach_current_thread(void)
  	138	{
  	139	JNIEnv* env;
  	140	(*rjb_jvm)->AttachCurrentThread(rjb_jvm, (void**)&env, '\0');
  	141	return env;
  	142	}
  	143
  	144	void rjb_release_string(JNIEnv *jenv, jstring str, const char* chrs)
  	145	{
  	146	(*jenv)->ReleaseStringUTFChars(jenv, str, chrs);
  	147	(*jenv)->DeleteLocalRef(jenv, str);
  	148	}
  	149
  	150	static char* java2jniname(char* jnicls)
  	151	{
  	152	char* p;
  	153	for (p = jnicls; *p; p++)
  	154	{
  	155	if (*p == '.')
  	156	{
  	157	*p = '/';
  	158	}
  	159	}
  	160	return jnicls;
  	161	}
  	162
  	163	#if 0
  	164	static char* jni2javaname(char* jnicls)
  	165	{
  	166	char* p;
  	167	for (p = jnicls; *p; p++)
  	168	{
  	169	if (*p == '/')
  	170	{
  	171	*p = '.';
  	172	}
  	173	}
  	174	return jnicls;
  	175	}
  	176	#endif
  	177
  	178	static char* next_sig(char* p)
  	179	{
  	180	if (!*p)
  	181	{
  	182	return p;
  	183	}
  	184	if (*p == '[')
  	185	{
  	186	p++;
  	187	}
  	188	if (*p == 'L')
  	189	{
  	190	while (*p && *p != ';')
  	191	{
  	192	p++;
  	193	}
  	194	}
  	195	return (*p) ? ++p : p;
  	196	}
  	197
  	198	static VALUE jstring2val(JNIEnv* jenv, jstring s)
  	199	{
  	200	const char* p;
  	201	VALUE v;
  	202
  	203	if (s == NULL)
  	204	{
  	205	return Qnil;
  	206	}
  	207	p = (*jenv)->GetStringUTFChars(jenv, s, NULL);
  	208	v = rb_str_new2(p);
  	209	v = exticonv_utf8_to_local(v);
  	210	rjb_release_string(jenv, s, p);
  	211	return v;
  	212	}
  	213
  	214	/*
  	215	* Type conversion tables
  	216	*/
  	217	typedef struct type_conversion_table {
  	218	const char* jtype;
  	219	const char* jntype;
  	220	R2J r2j;
  	221	J2R j2r;
  	222	J2R ja2r;
  	223	R2JARRAY r2ja;
  	224	off_t jcall; /* for instance method */
  	225	off_t jscall; /* for static method */
  	226	} jconv_table;
  	227
  	228	/*
  	229	* conversion methods
  	230	* val will be released in this function.
  	231	*/
  	232	static VALUE jv2rclass(JNIEnv* jenv, jclass jc)
  	233	{
  	234	const char* cname;
  	235	VALUE clsname;
  	236	VALUE v;
  	237	jstring nm = (*jenv)->CallObjectMethod(jenv, jc, rjb_class_getName);
  	238	rjb_check_exception(jenv, 0);
  	239	cname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
  	240	clsname = rb_str_new2(cname);
  	241	rjb_release_string(jenv, nm, cname);
  	242	v = rb_hash_aref(rjb_loaded_classes, clsname);
  	243	if (v == Qnil)
  	244	{
  	245	v = import_class(jenv, jc, clsname);
  	246	}
  	247	(*jenv)->DeleteLocalRef(jenv, jc);
  	248	return v;
  	249	}
  	250
  	251	static VALUE jv2rv_r(JNIEnv* jenv, jvalue val)
  	252	{
  	253	const char* cname;
  	254	jstring nm;
  	255	jclass klass;
  	256	VALUE clsname;
  	257	VALUE v;
  	258	struct jv_data* ptr;
  	259	/* object to ruby */
  	260	if (!val.l) return Qnil;
  	261	klass = (*jenv)->GetObjectClass(jenv, val.l);
  	262
  	263	if ((*jenv)->IsSameObject(jenv, klass, j_class))
  	264	{
  	265	(*jenv)->DeleteLocalRef(jenv, klass);
  	266	return jv2rclass(jenv, val.l);
  	267	}
  	268	nm = (*jenv)->CallObjectMethod(jenv, klass, rjb_class_getName);
  	269	rjb_check_exception(jenv, 0);
  	270	cname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
  	271	if (*cname == '[')
  	272	{
  	273	char depth = 0;
  	274	J2R j2r = get_arrayconv(cname, &depth);
  	275	rjb_release_string(jenv, nm, cname);
  	276	v = j2r(jenv, val);
  	277	(*jenv)->DeleteLocalRef(jenv, klass);
  	278	(*jenv)->DeleteLocalRef(jenv, val.l);
  	279	return v;
  	280	}
  	281	clsname = rb_str_new2(cname);
  	282	rjb_release_string(jenv, nm, cname);
  	283	v = rb_hash_aref(rjb_loaded_classes, clsname);
  	284	if (v == Qnil)
  	285	{
  	286	v = import_class(jenv, klass, clsname);
  	287	}
  	288	Data_Get_Struct(v, struct jv_data, ptr);
  	289	v = register_instance(jenv, (struct jvi_data*)ptr, val.l);
  	290	(*jenv)->DeleteLocalRef(jenv, klass);
  	291	(*jenv)->DeleteLocalRef(jenv, val.l);
  	292	return v;
  	293	}
  	294
  	295	static VALUE jv2rv(JNIEnv* jenv, jvalue val)
  	296	{
  	297	if (RTEST(primitive_conversion))
  	298	{
  	299	return jv2rv_withprim(jenv, val.l);
  	300	}
  	301	return jv2rv_r(jenv, val);
  	302	}
  	303
  	304	static VALUE jvoid2rv(JNIEnv* jenv, jvalue val)
  	305	{
  	306	return Qnil;
  	307	}
  	308
  	309	static VALUE jbyte2rv(JNIEnv* jenv, jvalue val)
  	310	{
  	311	return INT2NUM(val.b);
  	312	}
  	313
  	314	static VALUE jchar2rv(JNIEnv* jenv, jvalue val)
  	315	{
  	316	return INT2NUM(val.c);
  	317	}
  	318
  	319	static VALUE jdouble2rv(JNIEnv* jenv, jvalue val)
  	320	{
  	321	return rb_float_new(val.d);
  	322	}
  	323
  	324	static VALUE jfloat2rv(JNIEnv* jenv, jvalue val)
  	325	{
  	326	return rb_float_new((double)val.f);
  	327	}
  	328
  	329	static VALUE jint2rv(JNIEnv* jenv, jvalue val)
  	330	{
  	331	return INT2NUM(val.i);
  	332	}
  	333
  	334	static VALUE jlong2rv(JNIEnv* jenv, jvalue val)
  	335	{
  	336	#if HAVE_LONG_LONG
  	337	return LL2NUM(val.j);
  	338	#else
  	339	char bignum[64];
  	340	sprintf(bignum, "%ld * 0x100000000 + 0x%lx",
  	341	(long)(val.j >> 32), (unsigned long)val.j);
  	342	return rb_eval_string(bignum);
  	343	#endif
  	344	}
  	345
  	346	static VALUE jshort2rv(JNIEnv* jenv, jvalue val)
  	347	{
  	348	return INT2NUM(val.s);
  	349	}
  	350
  	351	static VALUE jboolean2rv(JNIEnv* jenv, jvalue val)
  	352	{
  	353	return (val.z) ? Qtrue : Qfalse;
  	354	}
  	355
  	356	static VALUE jstring2rv(JNIEnv* jenv, jvalue val)
  	357	{
  	358	return jstring2val(jenv, (jstring)val.l);
  	359	}
  	360
  	361	static VALUE ja2r(J2R conv, JNIEnv* jenv, jvalue val, int depth)
  	362	{
  	363	jsize len;
  	364	VALUE v;
  	365	int i;
  	366	if (!val.l) return Qnil;
  	367	if (depth == 1)
  	368	{
  	369	return conv(jenv, val);
  	370	}
  	371	len = (*jenv)->GetArrayLength(jenv, val.l);
  	372	v = rb_ary_new2(len);
  	373	for (i = 0; i < len; i++)
  	374	{
  	375	jvalue wrap;
  	376	wrap.l = (*jenv)->GetObjectArrayElement(jenv, val.l, i);
  	377	rb_ary_push(v, ja2r(conv, jenv, wrap, depth - 1));
  	378	}
  	379	(*jenv)->DeleteLocalRef(jenv, val.l);
  	380	return v;
  	381	}
  	382
  	383	static VALUE jarray2rv(JNIEnv* jenv, jvalue val)
  	384	{
  	385	jsize len;
  	386	VALUE v;
  	387	int i;
  	388	if (!val.l) return Qnil;
  	389	len = (*jenv)->GetArrayLength(jenv, val.l);
  	390	v = rb_ary_new2(len);
  	391	for (i = 0; i < len; i++)
  	392	{
  	393	jvalue wrap;
  	394	wrap.l = (*jenv)->GetObjectArrayElement(jenv, val.l, i);
  	395	/* wrap.l will be release in jv2rv */
  	396	rb_ary_push(v, jv2rv(jenv, wrap));
  	397	}
  	398	(*jenv)->DeleteLocalRef(jenv, val.l);
  	399	return v;
  	400	}
  	401
  	402	static VALUE ca2rv(JNIEnv* jenv, void* p)
  	403	{
  	404	return INT2FIX(*(jchar*)p);
  	405	}
  	406
  	407	static VALUE da2rv(JNIEnv* jenv, void* p)
  	408	{
  	409	return rb_float_new(*(jdouble*)p);
  	410	}
  	411
  	412	static VALUE fa2rv(JNIEnv* jenv, void* p)
  	413	{
  	414	return rb_float_new(*(jfloat*)p);
  	415	}
  	416
  	417	static VALUE ia2rv(JNIEnv* jenv, void* p)
  	418	{
  	419	return INT2NUM(*(jint*)p);
  	420	}
  	421
  	422	static VALUE la2rv(JNIEnv* jenv, void* p)
  	423	{
  	424	#if HAVE_LONG_LONG
  	425	return LL2NUM(*(jlong*)p);
  	426	#else
  	427	return LONG2NUM(*(jlong*)p);
  	428	#endif
  	429	}
  	430
  	431	static VALUE sa2rv(JNIEnv* jenv, void* p)
  	432	{
  	433	return INT2FIX(*(jshort*)p);
  	434	}
  	435
  	436	static VALUE ba2rv(JNIEnv* jenv, void* p)
  	437	{
  	438	return (*(jboolean*)p) ? Qtrue : Qfalse;
  	439	}
  	440
  	441	/*
  	442	* val : released in this function.
  	443	*/
  	444	static VALUE call_conv(JNIEnv* jenv, jvalue val, size_t sz, void* p, CONV conv, size_t fnc)
  	445	{
  	446	int i;
  	447	char* cp = (char*)p;
  	448	jsize len = (*jenv)->GetArrayLength(jenv, val.l);
  	449	VALUE v = rb_ary_new2(len);
  	450	VALUE* pv = RARRAY_PTR(v);
  	451	RARRAY_LEN(v) = len;
  	452	for (i = 0; i < len; i++)
  	453	{
  	454	*pv++ =conv(jenv, cp);
  	455	cp += sz;
  	456	}
  	457	(*(RELEASEARRAY*)(((char*)*jenv) + fnc))(jenv, val.l, p, JNI_ABORT);
  	458	(*jenv)->DeleteLocalRef(jenv, val.l);
  	459	return v;
  	460	}
  	461
  	462	static VALUE jbytearray2rv(JNIEnv* jenv, jvalue val)
  	463	{
  	464	jsize len = (*jenv)->GetArrayLength(jenv, val.l);
  	465	jbyte* p = (*jenv)->GetByteArrayElements(jenv, val.l, NULL);
  	466	VALUE v = rb_str_new((char*)p, len);
  	467	(*jenv)->ReleaseByteArrayElements(jenv, val.l, p, JNI_ABORT);
  	468	(*jenv)->DeleteLocalRef(jenv, val.l);
  	469	return v;
  	470	}
  	471	static VALUE jchararray2rv(JNIEnv* jenv, jvalue val)
  	472	{
  	473	jchar* p = (*jenv)->GetCharArrayElements(jenv, val.l, NULL);
  	474	return call_conv(jenv, val, sizeof(jchar), p, ca2rv,
  	475	offsetof(struct JNINativeInterface_, ReleaseCharArrayElements));
  	476	}
  	477	static VALUE jdoublearray2rv(JNIEnv* jenv, jvalue val)
  	478	{
  	479	jdouble* p = (*jenv)->GetDoubleArrayElements(jenv, val.l, NULL);
  	480	return call_conv(jenv, val, sizeof(jdouble), p, da2rv,
  	481	offsetof(struct JNINativeInterface_, ReleaseDoubleArrayElements));
  	482	}
  	483	static VALUE jfloatarray2rv(JNIEnv* jenv, jvalue val)
  	484	{
  	485	jfloat* p = (*jenv)->GetFloatArrayElements(jenv, val.l, NULL);
  	486	return call_conv(jenv, val, sizeof(jfloat), p, fa2rv,
  	487	offsetof(struct JNINativeInterface_, ReleaseFloatArrayElements));
  	488	}
  	489	static VALUE jintarray2rv(JNIEnv* jenv, jvalue val)
  	490	{
  	491	jint* p = (*jenv)->GetIntArrayElements(jenv, val.l, NULL);
  	492	return call_conv(jenv, val, sizeof(jint), p, ia2rv,
  	493	offsetof(struct JNINativeInterface_, ReleaseIntArrayElements));
  	494	}
  	495	static VALUE jlongarray2rv(JNIEnv* jenv, jvalue val)
  	496	{
  	497	jlong* p = (*jenv)->GetLongArrayElements(jenv, val.l, NULL);
  	498	return call_conv(jenv, val, sizeof(jlong), p, la2rv,
  	499	offsetof(struct JNINativeInterface_, ReleaseLongArrayElements));
  	500	}
  	501	static VALUE jshortarray2rv(JNIEnv* jenv, jvalue val)
  	502	{
  	503	jshort* p = (*jenv)->GetShortArrayElements(jenv, val.l, NULL);
  	504	return call_conv(jenv, val, sizeof(jshort), p, sa2rv,
  	505	offsetof(struct JNINativeInterface_, ReleaseShortArrayElements));
  	506	}
  	507	static VALUE jstringarray2rv(JNIEnv* jenv, jvalue val)
  	508	{
  	509	int i;
  	510	jsize len = (*jenv)->GetArrayLength(jenv, val.l);
  	511	VALUE v = rb_ary_new2(len);
  	512	for (i = 0; i < len; i++)
  	513	{
  	514	jobject p = (*jenv)->GetObjectArrayElement(jenv, val.l, i);
  	515	rb_ary_push(v, jstring2val(jenv, (jstring)p));
  	516	}
  	517	(*jenv)->DeleteLocalRef(jenv, val.l);
  	518	return v;
  	519	}
  	520	static VALUE jbooleanarray2rv(JNIEnv* jenv, jvalue val)
  	521	{
  	522	jboolean* p = (*jenv)->GetBooleanArrayElements(jenv, val.l, NULL);
  	523	return call_conv(jenv, val, sizeof(jboolean), p, ba2rv,
  	524	offsetof(struct JNINativeInterface_, ReleaseBooleanArrayElements));
  	525	}
  	526
  	527	/*
  	528	* table that handles java primitive type.
  	529	* index: according to enum PrimitiveType.
  	530	*/
  	531	static jprimitive_table jpcvt[] = {
  	532	{ "java/lang/Integer", "intValue", "()I", "(I)V", NULL, 0, 0, jint2rv, },
  	533	{ "java/lang/Long", "longValue", "()J", "(J)V", NULL, 0, 0, jlong2rv, },
  	534	{ "java/lang/Double", "doubleValue", "()D", "(D)V", NULL, 0, 0, jdouble2rv, },
  	535	{ "java/lang/Boolean", "booleanValue", "()Z", "(Z)Ljava/lang/Boolean;",
  	536	NULL, 0, 0, jboolean2rv, },
  	537	{ "java/lang/Character", "charValue", "()C", NULL, NULL, 0, 0, jchar2rv, },
  	538	{ "java/lang/Short", "intValue", "()I", NULL, NULL, 0, 0, jint2rv, },
  	539	{ "java/lang/Byte", "intValue", "()I", NULL, NULL, 0, 0, jint2rv, },
  	540	{ "java/lang/Float", "doubleValue", "()D", NULL, NULL, 0, 0, jdouble2rv, },
  	541	};
  	542
  	543	/*
  	544	* o will be released in this function.
  	545	*/
  	546	static VALUE jv2rv_withprim(JNIEnv* jenv, jobject o)
  	547	{
  	548	jvalue jv;
  	549	int i;
  	550	jclass klass;
  	551	jv.j = 0;
  	552	if (!o)
  	553	rb_raise(rb_eRuntimeError, "Object is NULL");
  	554	klass = (*jenv)->GetObjectClass(jenv, o);
  	555	for (i = PRM_INT; i < PRM_LAST; i++)
  	556	{
  	557	if ((*jenv)->IsSameObject(jenv, jpcvt[i].klass, klass))
  	558	{
  	559	switch (*(jpcvt[i].to_prim_method))
  	560	{
  	561	case 'i':
  	562	jv.i = (*jenv)->CallIntMethod(jenv, o, jpcvt[i].to_prim_id);
  	563	break;
  	564	case 'b':
  	565	jv.z = (*jenv)->CallBooleanMethod(jenv, o, jpcvt[i].to_prim_id);
  	566	break;
  	567	case 'd':
  	568	jv.d = (*jenv)->CallDoubleMethod(jenv, o, jpcvt[i].to_prim_id);
  	569	break;
  	570	case 'c':
  	571	jv.c = (*jenv)->CallCharMethod(jenv, o, jpcvt[i].to_prim_id);
  	572	break;
  	573	case 'l':
  	574	jv.j = (*jenv)->CallLongMethod(jenv, o, jpcvt[i].to_prim_id);
  	575	break;
  	576	default:
  	577	rb_raise(rb_eRuntimeError, "no convertor defined(%d)", i);
  	578	break;
  	579	}
  	580	(*jenv)->DeleteLocalRef(jenv, o);
  	581	return jpcvt[i].func(jenv, jv);
  	582	}
  	583	}
  	584	if ((*jenv)->IsSameObject(jenv, j_string, klass))
  	585	{
  	586	return jstring2val(jenv, o);
  	587	}
  	588	jv.l = o;
  	589	return jv2rv_r(jenv, jv);
  	590	}
  	591
  	592	/*
  	593	* functions convert VALUE to jvalue
  	594	*/
  	595	static void rv2jv(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	596	{
  	597	jv->l = NULL;
  	598	}
  	599
  	600	static void rv2jbyte(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	601	{
  	602	if (!release)
  	603	jv->b = (jbyte)NUM2INT(val);
  	604	}
  	605	static void rv2jchar(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	606	{
  	607	if (!release)
  	608	jv->c = (jchar)NUM2INT(val);
  	609	}
  	610	static void rv2jdouble(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	611	{
  	612	if (release) return;
  	613	switch (TYPE(val))
  	614	{
  	615	case T_FIXNUM:
  	616	jv->d = NUM2INT(val);
  	617	break;
  	618	case T_FLOAT:
  	619	jv->d = NUM2DBL(val);
  	620	break;
  	621	default:
  	622	rb_raise(rb_eRuntimeError, "can't change to double");
  	623	break;
  	624	}
  	625	}
  	626	static void rv2jfloat(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	627	{
  	628	if (release) return;
  	629	switch (TYPE(val))
  	630	{
  	631	case T_FIXNUM:
  	632	jv->f = (float)NUM2INT(val);
  	633	break;
  	634	case T_FLOAT:
  	635	jv->f = (float)NUM2DBL(val);
  	636	break;
  	637	default:
  	638	rb_raise(rb_eRuntimeError, "can't change to float");
  	639	break;
  	640	}
  	641	}
  	642	static void rv2jint(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	643	{
  	644	if (!release)
  	645	jv->i = NUM2INT(val);
  	646	}
  	647	static void rv2jlong(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	648	{
  	649	if (release) return;
  	650	switch (TYPE(val))
  	651	{
  	652	case T_FIXNUM:
  	653	jv->j = NUM2INT(val);
  	654	break;
  	655	default:
  	656	#if HAVE_LONG_LONG
  	657	jv->j = NUM2LL(val);
  	658	#else
  	659	rb_raise(rb_eRuntimeError, "can't change to long");
  	660	#endif
  	661	break;
  	662	}
  	663	}
  	664	static void rv2jshort(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	665	{
  	666	if (!release)
  	667	jv->s = (short)NUM2INT(val);
  	668	}
  	669	static void rv2jboolean(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	670	{
  	671	if (!release)
  	672	jv->z = (RTEST(val)) ? JNI_TRUE : JNI_FALSE;
  	673	}
  	674	static void rv2jstring(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	675	{
  	676	if (!release)
  	677	{
  	678	if (TYPE(val) == T_DATA
  	679	&& (RBASIC(val)->klass == rjbi || RBASIC(val)->klass == rjb))
  	680	{
  	681	struct jvi_data* ptr;
  	682	Data_Get_Struct(val, struct jvi_data, ptr);
  	683	if ((*jenv)->IsInstanceOf(jenv, ptr->obj, j_string))
  	684	{
  	685	jv->l = ptr->obj;
  	686	}
  	687	else
  	688	{
  	689	jmethodID tostr;
  	690	jstring js;
  	691	tostr = (*jenv)->GetMethodID(jenv, ptr->klass, "toString", "()Ljava/lang/String;");
  	692	rjb_check_exception(jenv, 0);
  	693	js = (*jenv)->CallObjectMethod(jenv, ptr->obj, tostr);
  	694	rjb_check_exception(jenv, 0);
  	695	jv->l = js;
  	696	}
  	697	}
  	698	else
  	699	{
  	700	if (NIL_P(val))
  	701	{
  	702	jv->l = NULL;
  	703	}
  	704	else
  	705	{
  	706	val = exticonv_local_to_utf8(val);
  	707	jv->l = (*jenv)->NewStringUTF(jenv, StringValuePtr(val));
  	708	}
  	709	}
  	710	}
  	711	else
  	712	{
  	713	if (TYPE(val) == T_DATA)
  	714	{
  	715	if (RBASIC(val)->klass == rjbi || RBASIC(val)->klass == rjb)
  	716	{
  	717	struct jvi_data* ptr;
  	718	Data_Get_Struct(val, struct jvi_data, ptr);
  	719	if ((*jenv)->IsInstanceOf(jenv, ptr->obj, j_string))
  	720	{
  	721	return; /* never delete at this time */
  	722	}
  	723	}
  	724	}
  	725	(*jenv)->DeleteLocalRef(jenv, jv->l);
  	726	}
  	727	}
  	728
  	729	/*
  	730	* psig may be NULL (from proxy/array call)
  	731	*/
  	732	static void rv2jobject(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
  	733	{
  	734	if (!release)
  	735	{
  	736	jv->l = NULL;
  	737	if (val == Qtrue || val == Qfalse)
  	738	{
  	739	jv->l = (*jenv)->CallStaticObjectMethod(jenv,
  	740	jpcvt[PRM_BOOLEAN].klass, jpcvt[PRM_BOOLEAN].ctr_id,
  	741	(val == Qtrue) ? JNI_TRUE : JNI_FALSE);
  	742	}
  	743	else if (NIL_P(val))
  	744	{
  	745	/* no-op */
  	746	}
  	747	else if (FIXNUM_P(val))
  	748	{
  	749	jvalue arg;
  	750	int idx = PRM_INT;
  	751	#if HAVE_LONG_LONG
  	752	arg.j = FIX2LONG(val);
  	753	if (arg.j < INT_MIN || arg.j > INT_MAX)
  	754	{
  	755	idx = PRM_LONG;
  	756	}
  	757	#else
  	758	arg.i = FIX2LONG(val);
  	759	#endif
  	760	jv->l = (*jenv)->NewObject(jenv, jpcvt[idx].klass,
  	761	jpcvt[idx].ctr_id, arg);
  	762	}
  	763	else
  	764	{
  	765	jvalue arg;
  	766	switch (TYPE(val))
  	767	{
  	768	case T_DATA:
  	769	if (RBASIC(val)->klass == rjbi || RBASIC(val)->klass == rjb)
  	770	{
  	771	/* TODO: check instanceof (class (in psig) ) */
  	772	struct jvi_data* ptr;
  	773	Data_Get_Struct(val, struct jvi_data, ptr);
  	774	jv->l = ptr->obj;
  	775	}
  	776	else if (RBASIC(val)->klass == rjbb)
  	777	{
  	778	struct rj_bridge* ptr;
  	779	Data_Get_Struct(val, struct rj_bridge, ptr);
  	780	jv->l = ptr->proxy;
  	781	}
  	782	else if (rb_class_inherited(rjbc, RBASIC(val)->klass))
  	783	{
  	784	struct jv_data* ptr;
  	785	Data_Get_Struct(val, struct jv_data, ptr);
  	786	jv->l = ptr->idata.obj;
  	787	}
  	788	break;
  	789	case T_STRING:
  	790	rv2jstring(jenv, val, jv, NULL, 0);
  	791	break;
  	792	case T_FLOAT:
  	793	arg.d = NUM2DBL(val);
  	794	jv->l = (*jenv)->NewObject(jenv, jpcvt[PRM_DOUBLE].klass,
  	795	jpcvt[PRM_DOUBLE].ctr_id, arg.d);
  	796	break;
  	797	case T_ARRAY:
  	798	jv->l = r2objarray(jenv, val, "Ljava/lang/Object;");
  	799	break;
  	800	#if HAVE_LONG_LONG
  	801	case T_BIGNUM:
  	802	arg.j = rb_big2ll(val);
  	803	jv->l = (*jenv)->NewObject(jenv, jpcvt[PRM_LONG].klass,
  	804	jpcvt[PRM_LONG].ctr_id, arg);
  	805	break;
  	806	#endif
  	807	default:
  	808	rb_raise(rb_eRuntimeError, "can't convert to java type");
  	809	break;
  	810	}
  	811	}
  	812	}
  	813	else
  	814	{
  	815	switch (TYPE(val))
  	816	{
  	817	case T_STRING:
  	818	case T_FLOAT:
  	819	case T_ARRAY:
  	820	case T_BIGNUM:
  	821	if (jv->l) (*jenv)->DeleteLocalRef(jenv, jv->l);
  	822	break;
  	823	}
  	824	}
  	825	}
  	826
  	827	static void check_fixnumarray(VALUE v)
  	828	{
  	829	int i;
  	830	int len = RARRAY_LEN(v);
  	831	VALUE* p = RARRAY_PTR(v);
  	832	/* check all fixnum (overflow is permit) */
  	833	for (i = 0; i < len; i++)
  	834	{
  	835	if (!FIXNUM_P(*p++))
  	836	{
  	837	rb_raise(rb_eRuntimeError, "array element must be a fixnum");
  	838	}
  	839	}
  	840	}
  	841
  	842	static jarray r2barray(JNIEnv* jenv, VALUE v, const char* cls)
  	843	{
  	844	jarray ary = NULL;
  	845	if (TYPE(v) == T_STRING)
  	846	{
  	847	ary = (*jenv)->NewByteArray(jenv, RSTRING_LEN(v));
  	848	(*jenv)->SetByteArrayRegion(jenv, ary, 0, RSTRING_LEN(v),
  	849	(const jbyte*)RSTRING_PTR(v));
  	850	}
  	851	else if (TYPE(v) == T_ARRAY)
  	852	{
  	853	int i;
  	854	jbyte* pb;
  	855	check_fixnumarray(v);
  	856	ary = (*jenv)->NewByteArray(jenv, RARRAY_LEN(v));
  	857	pb = (*jenv)->GetByteArrayElements(jenv, ary, NULL);
  	858	for (i = 0; i < RARRAY_LEN(v); i++)
  	859	{
  	860	*(pb + i) = (jbyte)FIX2ULONG(RARRAY_PTR(v)[i]);
  	861	}
  	862	(*jenv)->ReleaseByteArrayElements(jenv, ary, pb, 0);
  	863	}
  	864	if (!ary)
  	865	{
  	866	rb_raise(rb_eRuntimeError, "can't coerce to byte array");
  	867	}
  	868	return ary;
  	869	}
  	870
  	871	static jarray r2carray(JNIEnv* jenv, VALUE v, const char* cls)
  	872	{
  	873	jarray ary = NULL;
  	874	if (TYPE(v) == T_ARRAY)
  	875	{
  	876	int i;
  	877	jchar* pb;
  	878	check_fixnumarray(v);
  	879	ary = (*jenv)->NewCharArray(jenv, RARRAY_LEN(v));
  	880	pb = (*jenv)->GetCharArrayElements(jenv, ary, NULL);
  	881	for (i = 0; i < RARRAY_LEN(v); i++)
  	882	{
  	883	*(pb + i) = (jchar)FIX2ULONG(RARRAY_PTR(v)[i]);
  	884	}
  	885	(*jenv)->ReleaseCharArrayElements(jenv, ary, pb, 0);
  	886	return ary;
  	887	}
  	888	rb_raise(rb_eRuntimeError, "can't coerce to char array");
  	889	}
  	890
  	891	static jarray r2darray(JNIEnv* jenv, VALUE v, const char* cls)
  	892	{
  	893	jarray ary = NULL;
  	894	if (TYPE(v) == T_ARRAY)
  	895	{
  	896	int i;
  	897	jdouble* pb;
  	898	ary = (*jenv)->NewDoubleArray(jenv, RARRAY_LEN(v));
  	899	pb = (*jenv)->GetDoubleArrayElements(jenv, ary, NULL);
  	900	for (i = 0; i < RARRAY_LEN(v); i++)
  	901	{
  	902	*(pb + i) = (jdouble)rb_num2dbl(RARRAY_PTR(v)[i]);
  	903	}
  	904	(*jenv)->ReleaseDoubleArrayElements(jenv, ary, pb, 0);
  	905	return ary;
  	906	}
  	907	rb_raise(rb_eRuntimeError, "can't coerce to double array");
  	908	}
  	909
  	910	static jarray r2farray(JNIEnv* jenv, VALUE v, const char* cls)
  	911	{
  	912	jarray ary = NULL;
  	913	if (TYPE(v) == T_ARRAY)
  	914	{
  	915	int i;
  	916	jfloat* pb;
  	917	ary = (*jenv)->NewFloatArray(jenv, RARRAY_LEN(v));
  	918	pb = (*jenv)->GetFloatArrayElements(jenv, ary, NULL);
  	919	for (i = 0; i < RARRAY_LEN(v); i++)
  	920	{
  	921	*(pb + i) = (jfloat)rb_num2dbl(RARRAY_PTR(v)[i]);
  	922	}
  	923	(*jenv)->ReleaseFloatArrayElements(jenv, ary, pb, 0);
  	924	return ary;
  	925	}
  	926	rb_raise(rb_eRuntimeError, "can't coerce to float array");
  	927	}
  	928
  	929	static jarray r2iarray(JNIEnv* jenv, VALUE v, const char* cls)
  	930	{
  	931	jarray ary = NULL;
  	932	if (TYPE(v) == T_ARRAY)
  	933	{
  	934	int i;
  	935	jint* pb;
  	936	check_fixnumarray(v);
  	937	ary = (*jenv)->NewIntArray(jenv, RARRAY_LEN(v));
  	938	pb = (*jenv)->GetIntArrayElements(jenv, ary, NULL);
  	939	for (i = 0; i < RARRAY_LEN(v); i++)
  	940	{
  	941	*(pb + i) = (jint)FIX2LONG(RARRAY_PTR(v)[i]);
  	942	}