rjb 1.1.0-x86-mswin32-60

data/ext/riconv.c

@@ -0,0 +1,225 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004 Kuwashima
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * $Id: riconv.c 45 2007-12-26 20:03:21Z kuwa1 $
+ */
+
+#include "ruby.h"
+#include "extconf.h"
+
+#if defined _WIN32 || defined __CYGWIN__
+#include <windows.h>
+#endif
+
+#if defined HAVE_NL_LANGINFO
+#include <langinfo.h>
+static const char* const NL_EUC_TABLE[] = { "EUC-JISX0213", "EUC-JP", "EUC-JP-MS" };
+static const char* const NL_SJIS_TABLE[] = { "SHIFT_JIS", "SHIFT_JISX0213", "WINDOWS-31J" };
+#endif
+
+#if defined HAVE_SETLOCALE
+#include <locale.h>
+static const char* const LOCALE_EUC_TABLE[] = { "japanese", "ja_JP.eucJP", "japanese.euc", "ja_JP", "ja_JP.ujis" };
+static const char* const LOCALE_SJIS_TABLE[] = { "japanese.sjis", "ja_JP.SJIS" };
+static const char* const LOCALE_UTF8_TABLE[] = { "ja_JP.UTF-8", "ja_JP.utf8" };
+#endif
+
+#include "riconv.h"
+
+static const char* const CS_EUCJP = "EUC-JP";
+static const char* const CS_CP932 = "CP932";
+static const char* const CS_SJIS = "SHIFT_JIS";
+static const char* const CS_UTF8 = "UTF-8";
+
+
+static VALUE objIconvJ2R;
+static VALUE objIconvR2J;
+static const char* charcode; //is this necessary?
+static char Kcode = '\0';
+
+static int find_table(const char* const str, const char* const table[])
+{
+    int i;
+    int size = sizeof(table) / sizeof(table[0]);
+    for (i = 0; i < size; ++i)
+    {
+        if (strstr(str, table[i])) return 1;
+    }
+    return 0;
+}
+
+static const char* get_charcode_name_by_locale(const char* const name)
+{
+    if (find_table(name, LOCALE_UTF8_TABLE))
+        return NULL;
+    else if (find_table(name, LOCALE_EUC_TABLE))
+        return CS_EUCJP;
+    else if (find_table(name, LOCALE_SJIS_TABLE))
+        return CS_SJIS;
+    else
+        return NULL;
+}
+/*
+ * Get better charcode name.
+ */
+static const char* get_charcode_name()
+{
+    const char* result = NULL;
+    const char* lang = NULL;
+
+    switch(Kcode)
+    {
+    case 'E':
+        result = CS_EUCJP;
+        break;
+    case 'S':
+#if defined _WIN32 || defined __CYGWIN__
+        result = CS_CP932;
+#else
+        result = CS_SJIS;
+#endif
+        break;
+    case 'U':
+        //as is.
+        break;
+    case 'N':
+    default:
+#if defined _WIN32 || defined __CYGWIN__
+        if (932 == GetACP()) result = CS_CP932;
+#elif defined HAVE_NL_LANGINFO
+        setlocale(LC_ALL, ""); //initialize
+        lang = nl_langinfo(CODESET);
+        if (find_table(lang, NL_EUC_TABLE))
+                result =  CS_EUCJP;
+        else if (find_table(lang, NL_SJIS_TABLE))
+                result = CS_SJIS;
+#elif defined HAVE_SETLOCALE
+        setlocale(LC_ALL, ""); //initialize
+        result = get_charcode_name_by_locale(setlocale(LC_ALL, NULL));
+#elif defined HAVE_GETENV
+        printf("HAVE_GETENV\n");
+        if (result = get_charcode_name_by_locale(getenv("LC_ALL")))
+                ;
+        else if (result = get_charcode_name_by_locale(getenv("LC_CTYPE")))
+                ;
+        else if (result = get_charcode_name_by_locale(getenv("LANG")))
+                ;
+#endif
+        break;
+    }
+    return result;
+}
+
+
+static void reinit()
+{
+    charcode = get_charcode_name();
+    if (charcode)
+    {
+        VALUE rb_iconv_klass = rb_const_get(rb_cObject, rb_intern("Iconv"));
+        if (RTEST(rb_iconv_klass)) {
+            ID sym_new = rb_intern("new");
+	    rb_gc_unregister_address(&objIconvR2J);
+            objIconvR2J = rb_funcall(rb_iconv_klass, sym_new, 2, rb_str_new2(CS_UTF8), rb_str_new2(charcode));
+	    rb_gc_register_address(&objIconvR2J);
+	    rb_gc_unregister_address(&objIconvJ2R);
+            objIconvJ2R = rb_funcall(rb_iconv_klass, sym_new, 2, rb_str_new2(charcode), rb_str_new2(CS_UTF8));
+	    rb_gc_register_address(&objIconvJ2R);
+        }
+    }
+    else
+    {
+        objIconvR2J = objIconvJ2R = Qnil;
+    }
+}
+
+static void check_kcode()
+{
+    VALUE rb_iconv_klass = rb_const_get(rb_cObject, rb_intern("Iconv"));
+    VALUE kcode = rb_gv_get("$KCODE");
+    if (RTEST(rb_iconv_klass) && TYPE(kcode) == T_STRING) {
+        char* kcodep = StringValuePtr(kcode);
+        char upper_kcode = toupper(*kcodep);
+        if (Kcode != upper_kcode)
+        {
+            Kcode = upper_kcode;
+            reinit();
+        }
+    }
+    else
+    {
+        objIconvR2J = objIconvJ2R = Qnil;
+    }
+}
+
+VALUE exticonv_local_to_utf8(VALUE local_string)
+{
+#if RJB_RUBY_VERSION_CODE < 190
+    check_kcode();
+    if(RTEST(objIconvR2J))
+    {
+        return rb_funcall(objIconvR2J, rb_intern("iconv"), 1, local_string);
+    }
+    else
+    {
+        return local_string;
+    }
+#else
+    VALUE rb_cEncoding, default_external, encoding, ascii8bit;
+    rb_cEncoding = rb_const_get(rb_cObject, rb_intern("Encoding"));
+    default_external = rb_funcall(rb_cEncoding, rb_intern("default_external"), 0);
+    ascii8bit = rb_const_get(rb_cEncoding, rb_intern("ASCII_8BIT"));
+    encoding = rb_funcall(local_string, rb_intern("encoding"), 0);
+
+    if (ascii8bit == encoding && ascii8bit == default_external)
+    {
+	return local_string; //don't know default encoding
+    }
+    else if (encoding == ascii8bit)
+    {
+	local_string = rb_funcall(local_string, rb_intern("force_encoding"), 1, default_external);
+    }
+    return rb_funcall(local_string, rb_intern("encode"), 1, rb_str_new2("utf-8"));
+#endif
+}
+
+VALUE exticonv_utf8_to_local(VALUE utf8_string)
+{
+#if RJB_RUBY_VERSION_CODE < 190
+    check_kcode();
+    if(RTEST(objIconvR2J))
+    {
+        return rb_funcall(objIconvJ2R, rb_intern("iconv"), 1, utf8_string);
+    }
+    else
+    {
+        return utf8_string;
+    }
+#else
+    VALUE rb_cEncoding, encoding, ascii8bit;
+    rb_cEncoding = rb_const_get(rb_cObject, rb_intern("Encoding"));
+    encoding = rb_funcall(rb_cEncoding, rb_intern("default_external"), 0);
+    ascii8bit = rb_const_get(rb_cEncoding, rb_intern("ASCII_8BIT"));
+
+    utf8_string = rb_funcall(utf8_string, rb_intern("force_encoding"), 1, rb_str_new2("utf-8"));
+    if (ascii8bit == encoding)
+    {
+	return utf8_string; //don't know default encoding
+    }
+    else
+    {
+        return rb_funcall(utf8_string, rb_intern("encode"), 1, encoding);
+    }
+#endif
+}

data/ext/riconv.h

@@ -0,0 +1,24 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004 Kuwashima
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * $Id: riconv.h 43 2007-12-26 18:55:04Z kuwa1 $
+ */
+#ifndef _RICONV_H
+#define _RICONV_H
+
+
+VALUE exticonv_local_to_utf8(VALUE);
+VALUE exticonv_utf8_to_local(VALUE);
+
+#endif /* _RICONV_H */

data/ext/rjb.c

@@ -0,0 +1,2807 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004,2005,2006,2007 arton
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * $Id: rjb.c 50 2007-12-28 07:31:33Z arton $
+ */
+
+#define RJB_VERSION "1.1.0"
+
+#include "ruby.h"
+#include "extconf.h"
+#if RJB_RUBY_VERSION_CODE < 190
+#include "st.h"
+#else
+#include "ruby/st.h"
+#endif
+#include "jniwrap.h"
+#include "jp_co_infoseek_hp_arton_rjb_RBridge.h"
+#include "riconv.h"
+#include "rjb.h"
+
+/*
+ * Method Modifier Flag defined in
+ * http://java.sun.com/docs/books/vmspec/2nd-edition/html/ClassFile.doc.html#88358
+ */
+#define ACC_PUBLIC  0x0001
+#define ACC_PRIVATE  0x0002
+#define ACC_PROTECTED  0x0004
+#define ACC_STATIC  0x0008
+#define ACC_FINAL  0x0010
+#define ACC_VOLATILE  0x0040
+#define ACC_TRANSIENT  0x0080
+
+static void register_class(VALUE, VALUE);
+static VALUE import_class(JNIEnv* jenv, jclass, VALUE);
+static VALUE register_instance(JNIEnv* jenv, struct jvi_data*, jobject);
+static VALUE rjb_s_free(struct jv_data*);
+static VALUE rjb_class_forname(int argc, VALUE* argv, VALUE self);
+static void setup_metadata(JNIEnv* jenv, VALUE self, struct jv_data*, VALUE classname);
+static VALUE jarray2rv(JNIEnv* jenv, jvalue val);
+static jarray r2objarray(JNIEnv* jenv, VALUE v, const char* cls);
+static VALUE jv2rv_withprim(JNIEnv* jenv, jobject o);
+static J2R get_arrayconv(const char* cname, char* depth);
+
+static VALUE rjb;
+static VALUE jklass;
+static VALUE rjbc;
+static VALUE rjbi;
+static VALUE rjbb;
+
+VALUE rjb_loaded_classes;
+static VALUE proxies;
+JavaVM* rjb_jvm;
+jclass rjb_rbridge;
+jmethodID rjb_register_bridge;
+static JNIEnv* main_jenv;
+static VALUE primitive_conversion = Qfalse;
+
+/*
+ * Object cache, never destroyed
+ */
+/* method */ 
+static jmethodID method_getModifiers;
+static jmethodID method_getName;
+static jmethodID getParameterTypes;
+static jmethodID getReturnType;
+/* field */
+static jmethodID field_getModifiers;
+static jmethodID field_getName;
+static jmethodID field_getType;
+/* constructor */
+static jmethodID ctrGetParameterTypes;
+/* class */
+static jclass j_class;
+jmethodID rjb_class_getName;
+/* throwable */
+jclass rjb_j_throwable;
+jmethodID rjb_throwable_getMessage;
+/* String global reference */
+static jclass j_string;
+static jmethodID str_tostring;
+/* Object global reference */
+static jclass j_object;
+
+enum PrimitiveType {
+    PRM_INT = 0,
+    PRM_LONG,
+    PRM_DOUBLE,
+    PRM_BOOLEAN,
+    PRM_CHARACTER,
+    PRM_SHORT,
+    PRM_BYTE,
+    PRM_FLOAT,
+    //
+    PRM_LAST
+};
+
+/*
+ * Native type conversion table
+ */
+typedef struct jobject_ruby_table {
+    const char* classname;
+    const char* to_prim_method;
+    const char* prmsig;
+    const char* ctrsig;
+    jclass klass; /* primitive class */
+    jmethodID to_prim_id;
+    jmethodID ctr_id;
+    J2R func;
+} jprimitive_table;
+
+JNIEnv* rjb_attach_current_thread(void)
+{
+  JNIEnv* env;
+  (*rjb_jvm)->AttachCurrentThread(rjb_jvm, (void**)&env, '\0');
+  return env;
+}
+
+
+void rjb_release_string(JNIEnv *jenv, jstring str, const char* chrs)
+{
+    (*jenv)->ReleaseStringUTFChars(jenv, str, chrs);
+    (*jenv)->DeleteLocalRef(jenv, str);
+}
+
+static char* java2jniname(char* jnicls)
+{
+    char* p;
+    for (p = jnicls; *p; p++)
+    {
+	if (*p == '.')
+	{
+	    *p = '/';
+	}
+    }
+    return jnicls;
+}
+
+static char* jni2javaname(char* jnicls)
+{
+    char* p;
+    for (p = jnicls; *p; p++)
+    {
+	if (*p == '/')
+	{
+	    *p = '.';
+	}
+    }
+    return jnicls;
+}
+
+static char* next_sig(char* p)
+{
+    if (!*p)
+    {
+	return p;
+    }
+    if (*p == '[')
+    {
+	p++;
+    }
+    if (*p == 'L')
+    {
+	while (*p && *p != ';')
+	{
+	    p++;
+	}
+    }
+    return (*p) ? ++p : p;
+}
+
+static VALUE jstring2val(JNIEnv* jenv, jstring s)
+{
+    const char* p;
+    VALUE v;
+
+    if (s == NULL) 
+    {
+        return Qnil;
+    }
+    p = (*jenv)->GetStringUTFChars(jenv, s, NULL);
+    v = rb_str_new2(p);
+    v = exticonv_utf8_to_local(v);
+    rjb_release_string(jenv, s, p);
+    return v;
+}
+
+/*
+ * Type conversion tables
+ */
+typedef struct type_conversion_table {
+    const char* jtype;
+    const char* jntype;
+    R2J r2j;
+    J2R j2r;
+    J2R ja2r;
+    R2JARRAY r2ja;
+    off_t jcall;	/* for instance method */
+    off_t jscall;	/* for static method */
+} jconv_table;
+
+/*
+ * conversion methods
+ * val will be released in this function.
+ */
+static VALUE jv2rclass(JNIEnv* jenv, jclass jc)
+{
+    const char* cname;
+    VALUE clsname;
+    VALUE v;
+    jstring nm = (*jenv)->CallObjectMethod(jenv, jc, rjb_class_getName);
+    rjb_check_exception(jenv, 0);
+    cname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
+    clsname = rb_str_new2(cname);
+    rjb_release_string(jenv, nm, cname);
+    v = rb_hash_aref(rjb_loaded_classes, clsname);
+    if (v == Qnil)
+    {
+        v = import_class(jenv, jc, clsname);
+    }
+    (*jenv)->DeleteLocalRef(jenv, jc);
+    return v;
+}
+
+static VALUE jv2rv_r(JNIEnv* jenv, jvalue val)
+{
+    const char* cname;
+    jstring nm;
+    jclass klass;
+    VALUE clsname;
+    VALUE v;
+    struct jv_data* ptr;
+    // object to ruby
+    if (!val.l) return Qnil;
+    klass = (*jenv)->GetObjectClass(jenv, val.l);
+
+    if ((*jenv)->IsSameObject(jenv, klass, j_class))
+    {
+        (*jenv)->DeleteLocalRef(jenv, klass);
+        return jv2rclass(jenv, val.l);
+    }
+    nm = (*jenv)->CallObjectMethod(jenv, klass, rjb_class_getName);
+    rjb_check_exception(jenv, 0);
+    cname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
+    if (*cname == '[')
+    {
+        char depth = 0;
+        J2R j2r = get_arrayconv(cname, &depth);
+        rjb_release_string(jenv, nm, cname);
+        v = j2r(jenv, val);
+        (*jenv)->DeleteLocalRef(jenv, klass);
+        (*jenv)->DeleteLocalRef(jenv, val.l);
+        return v;
+    }
+    clsname = rb_str_new2(cname);
+    rjb_release_string(jenv, nm, cname);
+    v = rb_hash_aref(rjb_loaded_classes, clsname);
+    if (v == Qnil)
+    {
+        v = import_class(jenv, klass, clsname);
+    }
+    Data_Get_Struct(v, struct jv_data, ptr);
+    v = register_instance(jenv, (struct jvi_data*)ptr, val.l);
+    (*jenv)->DeleteLocalRef(jenv, klass);
+    (*jenv)->DeleteLocalRef(jenv, val.l);    
+    return v;
+}
+
+static VALUE jv2rv(JNIEnv* jenv, jvalue val)
+{
+    if (RTEST(primitive_conversion))
+    {
+        return jv2rv_withprim(jenv, val.l);
+    }
+    return jv2rv_r(jenv, val);
+}
+
+static VALUE jvoid2rv(JNIEnv* jenv, jvalue val)
+{
+    return Qnil;
+}
+
+static VALUE jbyte2rv(JNIEnv* jenv, jvalue val)
+{
+    return INT2NUM(val.b);
+}
+
+static VALUE jchar2rv(JNIEnv* jenv, jvalue val)
+{
+    return INT2NUM(val.c);
+}
+
+static VALUE jdouble2rv(JNIEnv* jenv, jvalue val)
+{
+    return rb_float_new(val.d);
+}
+
+static VALUE jfloat2rv(JNIEnv* jenv, jvalue val)
+{
+    return rb_float_new((double)val.f);
+}
+
+static VALUE jint2rv(JNIEnv* jenv, jvalue val)
+{
+    return INT2NUM(val.i);    
+}
+
+static VALUE jlong2rv(JNIEnv* jenv, jvalue val)
+{
+#if HAVE_LONG_LONG
+    return LL2NUM(val.j);
+#else
+    char bignum[64];
+    sprintf(bignum, "%ld * 0x100000000 + 0x%lx",
+	    (long)(val.j >> 32), (unsigned long)val.j);
+    return rb_eval_string(bignum);
+#endif
+}
+
+static VALUE jshort2rv(JNIEnv* jenv, jvalue val)
+{
+    return INT2NUM(val.s);
+}
+
+static VALUE jboolean2rv(JNIEnv* jenv, jvalue val)
+{
+    return (val.z) ? Qtrue : Qfalse;
+}
+
+static VALUE jstring2rv(JNIEnv* jenv, jvalue val)
+{
+    return jstring2val(jenv, (jstring)val.l);
+}
+
+static VALUE ja2r(J2R conv, JNIEnv* jenv, jvalue val, int depth)
+{
+    jsize len;
+    VALUE v;
+    int i;
+    if (!val.l) return Qnil;
+    if (depth == 1) 
+    {
+        return conv(jenv, val);
+    }
+    len = (*jenv)->GetArrayLength(jenv, val.l);
+    v = rb_ary_new2(len);
+    for (i = 0; i < len; i++) 
+    {
+	jvalue wrap;
+	wrap.l = (*jenv)->GetObjectArrayElement(jenv, val.l, i);
+	rb_ary_push(v, ja2r(conv, jenv, wrap, depth - 1));
+    }
+    (*jenv)->DeleteLocalRef(jenv, val.l);
+    return v;
+}
+
+static VALUE jarray2rv(JNIEnv* jenv, jvalue val)
+{
+    jsize len;
+    VALUE v;
+    int i;
+    if (!val.l) return Qnil;
+    len = (*jenv)->GetArrayLength(jenv, val.l);
+    v = rb_ary_new2(len);
+    for (i = 0; i < len; i++)
+    {
+	jvalue wrap;
+	wrap.l = (*jenv)->GetObjectArrayElement(jenv, val.l, i);
+	/* wrap.l will be release in jv2rv */
+	rb_ary_push(v, jv2rv(jenv, wrap));
+    }
+    (*jenv)->DeleteLocalRef(jenv, val.l);
+    return v;
+}
+
+static VALUE ca2rv(JNIEnv* jenv, void* p)
+{
+    return INT2FIX(*(jchar*)p);
+}
+
+static VALUE da2rv(JNIEnv* jenv, void* p)
+{
+    return rb_float_new(*(jdouble*)p);
+}
+
+static VALUE fa2rv(JNIEnv* jenv, void* p)
+{
+    return rb_float_new(*(jfloat*)p);
+}
+
+static VALUE ia2rv(JNIEnv* jenv, void* p)
+{
+    return INT2NUM(*(jint*)p);
+}
+
+static VALUE la2rv(JNIEnv* jenv, void* p)
+{
+#if HAVE_LONG_LONG
+    return LL2NUM(*(jlong*)p);
+#else
+    return LONG2NUM(*(jlong*)p);
+#endif	
+}
+
+static VALUE sa2rv(JNIEnv* jenv, void* p)
+{
+    return INT2FIX(*(jshort*)p);
+}
+
+static VALUE ba2rv(JNIEnv* jenv, void* p)
+{
+    return (*(jboolean*)p) ? Qtrue : Qfalse;
+}
+
+/*
+ * val : released in this function.
+ */
+static VALUE call_conv(JNIEnv* jenv, jvalue val, size_t sz, void* p, CONV conv, size_t fnc)
+{
+    int i;
+    char* cp = (char*)p;
+    jsize len = (*jenv)->GetArrayLength(jenv, val.l);
+    VALUE v = rb_ary_new2(len);
+    VALUE* pv = RARRAY_PTR(v);
+    RARRAY_LEN(v) = len;
+    for (i = 0; i < len; i++)
+    {
+        *pv++ =conv(jenv, cp);
+	cp += sz;
+    }
+    (*(RELEASEARRAY*)(((char*)*jenv) + fnc))(jenv, val.l, p, JNI_ABORT);
+    (*jenv)->DeleteLocalRef(jenv, val.l);
+    return v;
+}
+
+static VALUE jbytearray2rv(JNIEnv* jenv, jvalue val)
+{
+    jsize len = (*jenv)->GetArrayLength(jenv, val.l);
+    jbyte* p = (*jenv)->GetByteArrayElements(jenv, val.l, NULL);
+    VALUE v = rb_str_new((char*)p, len);
+    (*jenv)->ReleaseByteArrayElements(jenv, val.l, p, JNI_ABORT);
+    (*jenv)->DeleteLocalRef(jenv, val.l);
+    return v;
+}
+static VALUE jchararray2rv(JNIEnv* jenv, jvalue val)
+{
+    jchar* p = (*jenv)->GetCharArrayElements(jenv, val.l, NULL);
+    return call_conv(jenv, val, sizeof(jchar), p, ca2rv, 
+			offsetof(struct JNINativeInterface_, ReleaseCharArrayElements));
+}
+static VALUE jdoublearray2rv(JNIEnv* jenv, jvalue val)
+{
+    jdouble* p = (*jenv)->GetDoubleArrayElements(jenv, val.l, NULL);
+    return call_conv(jenv, val, sizeof(jdouble), p, da2rv,
+			offsetof(struct JNINativeInterface_, ReleaseDoubleArrayElements));
+}
+static VALUE jfloatarray2rv(JNIEnv* jenv, jvalue val)
+{
+    jfloat* p = (*jenv)->GetFloatArrayElements(jenv, val.l, NULL);
+    return call_conv(jenv, val, sizeof(jfloat), p, fa2rv,
+			offsetof(struct JNINativeInterface_, ReleaseFloatArrayElements));
+}
+static VALUE jintarray2rv(JNIEnv* jenv, jvalue val)
+{
+    jint* p = (*jenv)->GetIntArrayElements(jenv, val.l, NULL);
+    return call_conv(jenv, val, sizeof(jint), p, ia2rv,
+			offsetof(struct JNINativeInterface_, ReleaseIntArrayElements));
+}
+static VALUE jlongarray2rv(JNIEnv* jenv, jvalue val)
+{
+    jlong* p = (*jenv)->GetLongArrayElements(jenv, val.l, NULL);
+    return call_conv(jenv, val, sizeof(jlong), p, la2rv,
+			offsetof(struct JNINativeInterface_, ReleaseLongArrayElements));
+}
+static VALUE jshortarray2rv(JNIEnv* jenv, jvalue val)
+{
+    jshort* p = (*jenv)->GetShortArrayElements(jenv, val.l, NULL);
+    return call_conv(jenv, val, sizeof(jshort), p, sa2rv,
+			offsetof(struct JNINativeInterface_, ReleaseShortArrayElements));
+}
+static VALUE jstringarray2rv(JNIEnv* jenv, jvalue val)
+{
+    int i;
+    jsize len = (*jenv)->GetArrayLength(jenv, val.l);
+    VALUE v = rb_ary_new2(len);
+    for (i = 0; i < len; i++)
+    {
+	jobject p = (*jenv)->GetObjectArrayElement(jenv, val.l, i);
+	rb_ary_push(v, jstring2val(jenv, (jstring)p));
+    }
+    (*jenv)->DeleteLocalRef(jenv, val.l);
+    return v;
+}
+static VALUE jbooleanarray2rv(JNIEnv* jenv, jvalue val)
+{
+    jboolean* p = (*jenv)->GetBooleanArrayElements(jenv, val.l, NULL);
+    return call_conv(jenv, val, sizeof(jboolean), p, ba2rv,
+			offsetof(struct JNINativeInterface_, ReleaseBooleanArrayElements));
+}
+
+/*
+ * table that handles java primitive type.
+ * index: according to enum PrimitiveType.
+ */
+static jprimitive_table jpcvt[] = {
+    { "java/lang/Integer", "intValue", "()I", "(I)V", NULL, 0, 0, jint2rv, },
+    { "java/lang/Long", "longValue", "()J", "(J)V", NULL, 0, 0, jlong2rv, },    
+    { "java/lang/Double", "doubleValue", "()D", "(D)V", NULL, 0, 0, jdouble2rv, },
+    { "java/lang/Boolean", "booleanValue", "()Z", "(Z)Ljava/lang/Boolean;",
+      NULL, 0, 0, jboolean2rv, },
+    { "java/lang/Character", "charValue", "()C", NULL, NULL, 0, 0, jint2rv, },
+    { "java/lang/Short", "intValue", "()I", NULL, NULL, 0, 0, jint2rv, },
+    { "java/lang/Byte", "intValue", "()I", NULL, NULL, 0, 0, jint2rv, },
+    { "java/lang/Float", "doubleValue", "()D", NULL, NULL, 0, 0, jdouble2rv, },        
+};
+
+/*
+ * o will be released in this function.
+ */
+static VALUE jv2rv_withprim(JNIEnv* jenv, jobject o)
+{
+    jvalue jv;
+    int i;
+    jclass klass;
+    jv.j = 0;
+    if (!o)
+	rb_raise(rb_eRuntimeError, "Object is NULL");
+    klass = (*jenv)->GetObjectClass(jenv, o);
+    for (i = PRM_INT; i < PRM_LAST; i++)
+    {
+        if ((*jenv)->IsSameObject(jenv, jpcvt[i].klass, klass))
+	{
+	    switch (*(jpcvt[i].to_prim_method))
+	    {
+	    case 'i':
+		jv.i = (*jenv)->CallIntMethod(jenv, o, jpcvt[i].to_prim_id);
+		break;
+	    case 'b':
+		jv.z = (*jenv)->CallBooleanMethod(jenv, o, jpcvt[i].to_prim_id);
+		break;
+	    case 'd':
+		jv.d = (*jenv)->CallDoubleMethod(jenv, o, jpcvt[i].to_prim_id);
+		break;
+	    case 'c':
+		jv.c = (*jenv)->CallCharMethod(jenv, o, jpcvt[i].to_prim_id);
+		break;
+            case 'l':
+                jv.j = (*jenv)->CallLongMethod(jenv, o, jpcvt[i].to_prim_id);
+                break;
+	    default:
+		rb_raise(rb_eRuntimeError, "no convertor defined(%d)", i);
+		break;
+	    }
+            (*jenv)->DeleteLocalRef(jenv, o);
+	    return jpcvt[i].func(jenv, jv);
+	}
+    }
+    if ((*jenv)->IsSameObject(jenv, j_string, klass))
+    {
+        return jstring2val(jenv, o);
+    }
+    jv.l = o;
+    return jv2rv_r(jenv, jv);
+}
+
+/*
+ * functions convert VALUE to jvalue
+ */
+static void rv2jv(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    jv->l = NULL;
+}
+
+static void rv2jbyte(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (!release)
+	jv->b = (jbyte)NUM2INT(val);
+}
+static void rv2jchar(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (!release)
+	jv->c = (jchar)NUM2INT(val);
+}
+static void rv2jdouble(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (release) return;
+    switch (TYPE(val))
+    {
+    case T_FIXNUM:
+	jv->d = NUM2INT(val);
+	break;
+    case T_FLOAT:
+	jv->d = NUM2DBL(val);
+	break;
+    default:
+	rb_raise(rb_eRuntimeError, "can't change to double");
+	break;
+    }
+}
+static void rv2jfloat(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (release) return;
+    switch (TYPE(val))
+    {
+    case T_FIXNUM:
+	jv->f = (float)NUM2INT(val);
+	break;
+    case T_FLOAT:
+	jv->f = (float)NUM2DBL(val);
+	break;
+    default:
+	rb_raise(rb_eRuntimeError, "can't change to float");
+	break;
+    }
+}
+static void rv2jint(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (!release)
+	jv->i = NUM2INT(val);    
+}
+static void rv2jlong(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (release) return;
+    switch (TYPE(val))
+    {
+    case T_FIXNUM:
+	jv->j = NUM2INT(val);
+	break;
+    default:
+#if HAVE_LONG_LONG
+	jv->j = NUM2LL(val);
+#else
+	rb_raise(rb_eRuntimeError, "can't change to long");
+#endif
+	break;
+    }
+}
+static void rv2jshort(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (!release)
+	jv->s = (short)NUM2INT(val);    
+}
+static void rv2jboolean(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (!release)
+	jv->z = (RTEST(val)) ? JNI_TRUE : JNI_FALSE;
+}
+static void rv2jstring(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (!release)
+    {
+	if (TYPE(val) == T_DATA
+	    && (RBASIC(val)->klass == rjbi || RBASIC(val)->klass == rjb))
+	{
+	    struct jvi_data* ptr;
+	    Data_Get_Struct(val, struct jvi_data, ptr);
+	    if ((*jenv)->IsInstanceOf(jenv, ptr->obj, j_string))
+	    {
+		jv->l = ptr->obj;
+	    }
+	    else
+	    {
+		jmethodID tostr;
+		jstring js;
+		tostr = (*jenv)->GetMethodID(jenv, ptr->klass, "toString", "()Ljava/lang/String;");
+		rjb_check_exception(jenv, 0);
+		js = (*jenv)->CallObjectMethod(jenv, ptr->obj, tostr);
+		rjb_check_exception(jenv, 0);
+		jv->l = js;
+	    }
+	}
+	else
+        {
+            if (NIL_P(val))
+            {
+	        jv->l = NULL;
+	    }
+	    else
+	    {
+                val = exticonv_local_to_utf8(val);
+                jv->l = (*jenv)->NewStringUTF(jenv, StringValuePtr(val));
+	    }
+	}
+    }
+    else
+    {
+	if (TYPE(val) == T_DATA)
+	{
+	    if (RBASIC(val)->klass == rjbi || RBASIC(val)->klass == rjb)
+	    {
+		struct jvi_data* ptr;
+		Data_Get_Struct(val, struct jvi_data, ptr);
+		if ((*jenv)->IsInstanceOf(jenv, ptr->obj, j_string))
+		{
+		    return; // never delete at this time
+		}
+	    }
+	}
+	(*jenv)->DeleteLocalRef(jenv, jv->l);
+    }
+}
+
+/*
+ * psig may be NULL (from proxy/array call)
+ */
+static void rv2jobject(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (!release)
+    {
+	jv->l = NULL;
+	if (val == Qtrue || val == Qfalse)
+	{
+	    jv->l = (*jenv)->CallStaticObjectMethod(jenv,
+		    jpcvt[PRM_BOOLEAN].klass, jpcvt[PRM_BOOLEAN].ctr_id,
+				    (val == Qtrue) ? JNI_TRUE : JNI_FALSE);
+	}
+	else if (NIL_P(val))
+	{
+	    // no-op
+	}
+	else if (FIXNUM_P(val))
+	{
+	    jvalue arg;
+	    int idx = PRM_INT;
+#if HAVE_LONG_LONG
+	    arg.j = FIX2LONG(val);
+	    if (arg.j < INT_MIN || arg.j > INT_MAX)
+	    {
+		idx = PRM_LONG;
+	    }
+#else
+	    arg.i = FIX2LONG(val);
+#endif
+	    jv->l = (*jenv)->NewObject(jenv, jpcvt[idx].klass,
+				       jpcvt[idx].ctr_id, arg);
+	}
+	else
+	{
+	    jvalue arg;
+	    switch (TYPE(val))
+	    {
+	    case T_DATA:
+	        if (RBASIC(val)->klass == rjbi || RBASIC(val)->klass == rjb)
+		{
+		    // TODO: check instanceof (class (in psig) )
+		    struct jvi_data* ptr;
+		    Data_Get_Struct(val, struct jvi_data, ptr);
+		    jv->l = ptr->obj;
+		}
+		else if (RBASIC(val)->klass == rjbb)
+		{
+		    struct rj_bridge* ptr;
+		    Data_Get_Struct(val, struct rj_bridge, ptr);
+		    jv->l = ptr->proxy;
+		}
+		else if (rb_class_inherited(rjbc, RBASIC(val)->klass)) 
+		{
+		    struct jv_data* ptr;
+		    Data_Get_Struct(val, struct jv_data, ptr);
+		    jv->l = ptr->idata.obj;
+		}
+		break;
+	    case T_STRING:
+		rv2jstring(jenv, val, jv, NULL, 0);
+		break;
+	    case T_FLOAT:
+		arg.d = NUM2DBL(val);
+		jv->l = (*jenv)->NewObject(jenv, jpcvt[PRM_DOUBLE].klass,
+				       jpcvt[PRM_DOUBLE].ctr_id, arg.d);
+		break;
+	    case T_ARRAY:
+		jv->l = r2objarray(jenv, val, "Ljava/lang/Object;");
+		break;
+#if HAVE_LONG_LONG                
+            case T_BIGNUM:
+                arg.j = rb_big2ll(val);
+                jv->l = (*jenv)->NewObject(jenv, jpcvt[PRM_LONG].klass,
+				       jpcvt[PRM_LONG].ctr_id, arg);
+                break;
+#endif                
+            default:
+                rb_raise(rb_eRuntimeError, "can't convert to java type");
+                break;
+	    }
+	}
+    }
+    else
+    {
+        switch (TYPE(val)) 
+	{
+        case T_STRING:
+        case T_FLOAT:
+        case T_ARRAY:
+        case T_BIGNUM:
+            if (jv->l) (*jenv)->DeleteLocalRef(jenv, jv->l);
+            break;
+        }
+    }
+}
+
+static void check_fixnumarray(VALUE v)
+{
+    int i;
+    int len = RARRAY_LEN(v);
+    VALUE* p = RARRAY_PTR(v);
+    // check all fixnum (overflow is permit)
+    for (i = 0; i < len; i++)
+    {
+	if (!FIXNUM_P(*p++))
+	{
+	    rb_raise(rb_eRuntimeError, "array element must be a fixnum");
+	}
+    }
+}
+
+static jarray r2barray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_STRING)
+    {
+	ary = (*jenv)->NewByteArray(jenv, RSTRING_LEN(v));
+	(*jenv)->SetByteArrayRegion(jenv, ary, 0, RSTRING_LEN(v),
+				    RSTRING_PTR(v));
+    }
+    else if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jbyte* pb;
+	check_fixnumarray(v);
+	ary = (*jenv)->NewByteArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetByteArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    *(pb + i) = (jbyte)FIX2ULONG(RARRAY_PTR(v)[i]);
+	}
+	(*jenv)->ReleaseByteArrayElements(jenv, ary, pb, 0);
+    }
+    if (!ary)
+    {
+	rb_raise(rb_eRuntimeError, "can't coerce to byte array");
+    }
+    return ary;
+}
+
+static jarray r2carray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jchar* pb;
+	check_fixnumarray(v);
+	ary = (*jenv)->NewCharArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetCharArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    *(pb + i) = (jchar)FIX2ULONG(RARRAY_PTR(v)[i]);
+	}
+	(*jenv)->ReleaseCharArrayElements(jenv, ary, pb, 0);
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to char array");
+}
+
+static jarray r2darray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jdouble* pb;
+	ary = (*jenv)->NewDoubleArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetDoubleArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    *(pb + i) = (jdouble)rb_num2dbl(RARRAY_PTR(v)[i]);
+	}
+	(*jenv)->ReleaseDoubleArrayElements(jenv, ary, pb, 0);
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to double array");
+}
+
+static jarray r2farray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jfloat* pb;
+	ary = (*jenv)->NewFloatArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetFloatArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    *(pb + i) = (jfloat)rb_num2dbl(RARRAY_PTR(v)[i]);
+	}
+	(*jenv)->ReleaseFloatArrayElements(jenv, ary, pb, 0);
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to float array");
+}
+
+static jarray r2iarray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jint* pb;
+	check_fixnumarray(v);
+	ary = (*jenv)->NewIntArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetIntArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    *(pb + i) = (jint)FIX2LONG(RARRAY_PTR(v)[i]);
+	}
+	(*jenv)->ReleaseIntArrayElements(jenv, ary, pb, 0);
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to int array");
+}
+
+static jarray r2larray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jlong* pb;
+	ary = (*jenv)->NewLongArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetLongArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+#if HAVE_LONG_LONG
+	    *(pb + i) = (jlong)rb_num2ll(RARRAY_PTR(v)[i]);
+#else
+	    *(pb + i) = (jlong)FIX2LONG(RARRAY_PTR(v)[i]);
+#endif
+	}
+	(*jenv)->ReleaseLongArrayElements(jenv, ary, pb, 0);
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to long array");
+}
+
+static jarray r2sarray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jshort* pb;
+	check_fixnumarray(v);
+	ary = (*jenv)->NewShortArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetShortArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    *(pb + i) = (jshort)FIX2LONG(RARRAY_PTR(v)[i]);
+	}
+	(*jenv)->ReleaseShortArrayElements(jenv, ary, pb, 0);
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to short array");
+}
+
+static jarray r2boolarray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	jboolean* pb;
+	ary = (*jenv)->NewBooleanArray(jenv, RARRAY_LEN(v));
+	pb = (*jenv)->GetBooleanArrayElements(jenv, ary, NULL);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    *(pb + i)
+		= (!RTEST(RARRAY_PTR(v)[i]))
+			? JNI_FALSE : JNI_TRUE;
+	}
+	(*jenv)->ReleaseBooleanArrayElements(jenv, ary, pb, 0);
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to boolean array");
+}
+
+static jarray r2voidarray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    rb_raise(rb_eRuntimeError, "void never arrayed");
+}
+
+static jarray r2objarray(JNIEnv* jenv, VALUE v, const char* cls)
+{
+    jarray ary = NULL;
+    if (TYPE(v) == T_ARRAY)
+    {
+	int i;
+	ary = (*jenv)->NewObjectArray(jenv, RARRAY_LEN(v), j_object, NULL);
+	rjb_check_exception(jenv, 0);
+	for (i = 0; i < RARRAY_LEN(v); i++)
+	{
+	    jvalue jv;
+	    rv2jobject(jenv, RARRAY_PTR(v)[i], &jv, NULL, 0);
+	    (*jenv)->SetObjectArrayElement(jenv, ary, i, jv.l);
+	}
+	return ary;
+    }
+    rb_raise(rb_eRuntimeError, "can't coerce to object array");
+}
+
+/*
+ * Type convertion tables
+ */
+static const jconv_table jcvt[] = {
+    { "byte", "B", rv2jbyte, jbyte2rv,
+      jbytearray2rv, r2barray,
+      offsetof(struct JNINativeInterface_, CallByteMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticByteMethodA), },
+    { "char", "C", rv2jchar, jchar2rv,
+      jchararray2rv, r2carray,
+      offsetof(struct JNINativeInterface_, CallCharMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticCharMethodA), },
+    { "double", "D", rv2jdouble, jdouble2rv,
+      jdoublearray2rv, r2darray,
+      offsetof(struct JNINativeInterface_, CallDoubleMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticDoubleMethodA), },
+    { "float", "F", rv2jfloat, jfloat2rv,
+      jfloatarray2rv, r2farray,
+      offsetof(struct JNINativeInterface_, CallFloatMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticFloatMethodA), },
+    { "int", "I", rv2jint, jint2rv,
+      jintarray2rv, r2iarray,
+      offsetof(struct JNINativeInterface_, CallIntMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticIntMethodA), },
+    { "long", "J", rv2jlong, jlong2rv,
+      jlongarray2rv, r2larray,
+      offsetof(struct JNINativeInterface_, CallLongMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticLongMethodA), },
+    { "short", "S", rv2jshort, jshort2rv,
+      jshortarray2rv, r2sarray,
+      offsetof(struct JNINativeInterface_, CallShortMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticShortMethodA), },
+    { "boolean", "Z", rv2jboolean, jboolean2rv,
+      jbooleanarray2rv, r2boolarray,
+      offsetof(struct JNINativeInterface_, CallBooleanMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticBooleanMethodA), },
+    { "void", "V", rv2jv, jvoid2rv,
+      NULL, r2voidarray,
+      offsetof(struct JNINativeInterface_, CallVoidMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticVoidMethodA), },
+    { "java.lang.String", "Ljava.lang.String;", rv2jstring, jstring2rv,
+      jstringarray2rv, r2objarray,
+      offsetof(struct JNINativeInterface_, CallObjectMethodA),
+      offsetof(struct JNINativeInterface_, CallStaticObjectMethodA), },
+};
+
+static void rv2jarray(JNIEnv* jenv, VALUE val, jvalue* jv, const char* psig, int release)
+{
+    if (*psig != '[')
+    {
+	rb_raise(rb_eRuntimeError, "argument signature not array");
+    }
+    if (release)
+    {
+	(*jenv)->DeleteLocalRef(jenv, jv->l);
+    }
+    else
+    {
+        int i;
+        jarray ja = NULL;
+	if (NIL_P(val))
+	{
+	    // no-op, null for an array
+	}
+        else if (*(psig + 1) == '[')
+        {
+            if (TYPE(val) != T_ARRAY) {
+                rb_raise(rb_eRuntimeError, "array's rank unmatch");
+            }
+            ja = (*jenv)->NewObjectArray(jenv, RARRAY_LEN(val), j_object, NULL);
+            rjb_check_exception(jenv, 0);
+            for (i = 0; i < RARRAY_LEN(val); i++)
+            {
+                jvalue jv;
+                rv2jarray(jenv, RARRAY_PTR(val)[i], &jv, psig + 1, 0);
+                (*jenv)->SetObjectArrayElement(jenv, ja, i, jv.l);
+            }
+        }
+        else
+        {
+            R2JARRAY r2a = r2objarray;
+            for (i = 0; i < COUNTOF(jcvt); i++)
+            {
+                if (*(psig + 1) == jcvt[i].jntype[0])
+                {
+                    r2a = jcvt[i].r2ja;
+                    break;
+                }
+            }
+            ja = r2a(jenv, val, psig + 1);
+	}
+	jv->l = ja;
+    }
+}
+
+/*
+ */
+static R2J get_r2j(JNIEnv* jenv, jobject o, int* siglen,  char* sigp)
+{
+    int len, i;
+    const char* cname;
+    R2J result = NULL;
+    jstring nm = (*jenv)->CallObjectMethod(jenv, o, rjb_class_getName);
+    rjb_check_exception(jenv, 0);
+    cname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
+    if (*cname == '[')
+    {
+        if (siglen)
+        {
+            len = strlen(cname);
+	    *siglen += len;
+	    strcpy(sigp, cname);
+        }
+	result = rv2jarray;
+    }
+    else
+    {
+        for (i = 0; i < COUNTOF(jcvt); i++)
+        {
+	    if (!strcmp(cname, jcvt[i].jtype))
+	    {
+                if (siglen)
+                {
+		    *siglen += strlen(jcvt[i].jntype);
+		    strcpy(sigp, jcvt[i].jntype);
+                }
+	        result = jcvt[i].r2j;
+		break;
+	    }
+        }
+        if (!result)
+        {
+            if (siglen)
+	    {
+	        *siglen += sprintf(sigp, "L%s;", cname);
+	    }
+            result = rv2jobject;
+	}
+    }
+    rjb_release_string(jenv, nm, cname);
+    return result;
+}
+
+static J2R get_arrayconv(const char* cname, char* pdepth)
+{
+    int i;
+    int start;
+    for (start = 1; *(cname + start) == '['; start++);
+    *pdepth = (char)start;
+    for (i = 0; i < COUNTOF(jcvt); i++)
+    {
+        if (*(cname + start) == jcvt[i].jntype[0])
+        {
+            if (jcvt[i].jntype[0] == 'L'
+                && strncmp(cname + start, jcvt[i].jntype, strlen(jcvt[i].jntype)))
+            {
+                break;
+            }
+            return jcvt[i].ja2r;
+        }
+    }
+    return jarray2rv;
+}
+
+static J2R get_j2r(JNIEnv* jenv, jobject cls, char* psig, char* pdepth, char* ppsig, off_t* piv, int static_method)
+{
+    int i;
+    J2R result = NULL;
+    const char* cname;
+    const char* jname = NULL;
+    jstring nm = (*jenv)->CallObjectMethod(jenv, cls, rjb_class_getName);
+    rjb_check_exception(jenv, 0);	    
+    cname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
+
+    if (*cname == '[')
+    {
+        result = get_arrayconv(cname, pdepth);
+	jname = cname;
+    }
+    else
+    {
+	for (i = 0; i < COUNTOF(jcvt); i++)
+	{
+	    if (!strcmp(cname, jcvt[i].jtype))
+	    {
+		result = jcvt[i].j2r;
+		*piv = (static_method) ? jcvt[i].jscall : jcvt[i].jcall;
+		if (jcvt[i].jntype[0] != 'L')
+		{
+		    *psig = jcvt[i].jntype[0];
+		}
+		jname = jcvt[i].jntype;
+		break;
+	    }
+	}
+    }
+    if (ppsig)
+    {
+	if (!jname)
+	{
+	    sprintf(ppsig, "L%s;", cname);
+	}
+	else
+	{
+	    strcpy(ppsig, jname);
+	}
+	java2jniname(ppsig);
+    }
+    rjb_release_string(jenv, nm, cname);
+    return result;
+}
+
+static void setup_j2r(JNIEnv* jenv, jobject cls, struct cls_method* pm, int static_method)
+{
+    off_t iv = 0;
+    J2R result = get_j2r(jenv, cls, &pm->basic.result_signature, &pm->basic.result_arraydepth, NULL, &iv, static_method);
+    pm->result_convert = (result) ? result : jv2rv;
+    if (iv)
+    {
+	pm->method = iv;
+    }
+    else
+    {
+	pm->method = (static_method)
+	    ? offsetof(struct JNINativeInterface_, CallStaticObjectMethodA)
+	    : offsetof(struct JNINativeInterface_, CallObjectMethodA);
+    }
+}
+
+static void fill_convert(JNIEnv* jenv, struct cls_constructor* cls, jobjectArray tp, int count)
+{
+    int i, siglen;
+    R2J* tbl = ALLOC_N(R2J, count);
+    char** sig = (char**)ALLOCA_N(char*, count);
+    char siga[256];
+    cls->arg_convert = tbl;
+    memset(tbl, 0, sizeof(R2J) * count);
+    siglen = 0;
+    for (i = 0; i < count; i++)
+    {
+	jobject o = (*jenv)->GetObjectArrayElement(jenv, tp, i);
+	*(tbl + i) = get_r2j(jenv, o, &siglen, siga);
+	*(sig + i) = ALLOCA_N(char, strlen(siga) + 1);
+	strcpy(*(sig + i), siga);
+    }
+    cls->method_signature = ALLOC_N(char, siglen + 1);
+    *(cls->method_signature) = 0;
+    for (i = 0; i < count; i++)
+    {
+	strcat(cls->method_signature, *(sig + i));
+    }
+}
+
+/*
+ * create method info structure
+ * m = instance of Method class
+ * c = instance of the class
+ */
+static void setup_methodbase(JNIEnv* jenv, struct cls_constructor* pm,
+			     jobjectArray parama, jsize pcount)
+{
+    pm->arg_count = pcount;
+    pm->method_signature = NULL;
+    pm->result_signature = 'O';
+    pm->result_arraydepth = 0;
+    pm->arg_convert = NULL;
+    if (pcount)
+    {
+	fill_convert(jenv, pm, parama, pcount);
+    }
+}
+
+static void register_methodinfo(struct cls_method* newpm, st_table* tbl)
+{
+    struct cls_method* pm;
+    
+    if (st_lookup(tbl, newpm->name, (st_data_t*)&pm))
+    {
+	newpm->next = pm->next;
+	pm->next = newpm;
+    }
+    else
+    {
+	newpm->next = NULL;
+	st_insert(tbl, newpm->name, (VALUE)newpm);
+    }
+}
+
+static struct cls_method* clone_methodinfo(struct cls_method* pm)
+{
+    struct cls_method* result = ALLOC(struct cls_method);
+    memcpy(result, pm, sizeof(struct cls_method));
+    return result;
+}
+
+static void make_alias(const char* jname, char* rname)
+{
+    while (*jname)
+    {
+        if (isupper(*jname))
+        {
+            *rname++ = '_';
+            *rname++ = tolower(*jname++);
+        }
+        else
+        {
+            *rname++ = *jname++;
+        }
+    }
+    *rname = '\0';
+}
+
+static void create_methodinfo(JNIEnv* jenv, st_table* tbl, jobject m, int static_method)
+{
+    struct cls_method* result;
+    struct cls_method* pm;    
+    char* param = NULL;
+    const char* jname;
+    jstring nm;
+    jobjectArray parama;
+    jobject cls;
+    jsize param_count;
+    char* rname;
+
+    result = ALLOC(struct cls_method);
+    parama = (*jenv)->CallObjectMethod(jenv, m, getParameterTypes);
+    rjb_check_exception(jenv, 0);
+    param_count = (*jenv)->GetArrayLength(jenv, parama);
+    rjb_check_exception(jenv, 0);
+    setup_methodbase(jenv, &result->basic, parama, param_count);
+    nm = (*jenv)->CallObjectMethod(jenv, m, method_getName);
+    rjb_check_exception(jenv, 0);	    
+    jname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
+    rname = ALLOCA_N(char, strlen(jname) * 2 + 8);
+    make_alias(jname, rname);
+    result->name = rb_intern(jname);
+    rjb_release_string(jenv, nm, jname);    
+    result->basic.id = (*jenv)->FromReflectedMethod(jenv, m);
+    rjb_check_exception(jenv, 0);
+    cls = (*jenv)->CallObjectMethod(jenv, m, getReturnType);
+    rjb_check_exception(jenv, 0);
+    setup_j2r(jenv, cls, result, static_method);
+    (*jenv)->DeleteLocalRef(jenv, cls);
+    result->static_method = static_method;
+    register_methodinfo(result, tbl);
+    // create method alias
+    pm = NULL;
+    if (strlen(rname) > 3
+        && (*rname == 'g' || *rname == 's') && *(rname + 1) == 'e' && *(rname + 2) == 't')
+    {
+        pm = clone_methodinfo(result);
+        if (*rname == 's') 
+        {
+            if (result->basic.arg_count == 1)
+            {
+                rname += 3;
+                strcat(rname, "=");
+            }
+        }
+        else
+        {
+            rname += 3;
+        }
+        if (*rname == '_') rname++;
+    }
+    else if (strlen(rname) > 2 && result->basic.result_signature == 'Z'
+             && *rname == 'i' && *(rname + 1) == 's')
+    {
+        pm = clone_methodinfo(result);
+        rname += 2;
+        if (*rname == '_') rname++;
+        strcat(rname, "?");
+    }
+    else
+    {
+        pm = clone_methodinfo(result);
+    }
+    if (pm)
+    {
+        pm->name = rb_intern(rname);
+        register_methodinfo(pm, tbl);
+    }
+}
+
+static void create_fieldinfo(JNIEnv* jenv, st_table* tbl, jobject f, int readonly, int static_field)
+{
+    struct cls_field* result;
+    const char* jname;
+    jstring nm;
+    jobject cls;
+    char sigs[256];
+    off_t iv = 0;
+    char sig = 0;
+
+    result = ALLOC(struct cls_field);
+    memset(result, 0, sizeof(struct cls_field));
+    nm = (*jenv)->CallObjectMethod(jenv, f, field_getName);
+    rjb_check_exception(jenv, 0);	    
+    jname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
+    result->name = rb_intern(jname);
+    rjb_release_string(jenv, nm, jname);
+    result->id = (*jenv)->FromReflectedField(jenv, f);
+    rjb_check_exception(jenv, 0);
+    cls = (*jenv)->CallObjectMethod(jenv, f, field_getType);
+    rjb_check_exception(jenv, 0);
+    result->value_convert = get_j2r(jenv, cls, &result->result_signature, &result->result_arraydepth, sigs, &iv, 0);
+    result->arg_convert = get_r2j(jenv, cls, NULL, NULL);
+    (*jenv)->DeleteLocalRef(jenv, cls);
+    result->field_signature = ALLOC_N(char, strlen(sigs) + 1);
+    strcpy(result->field_signature, sigs);
+    if (!result->value_convert) result->value_convert = jv2rv;
+    result->readonly = readonly;
+    result->static_field = static_field;
+    st_insert(tbl, result->name, (VALUE)result);
+}
+
+static void setup_constructors(JNIEnv* jenv, struct cls_constructor*** pptr, jobjectArray methods)
+{
+    int i;
+    struct cls_constructor* pc;    
+    jsize mcount = (*jenv)->GetArrayLength(jenv, methods);
+    struct cls_constructor** tbl = ALLOC_N(struct cls_constructor*, mcount + 1);
+    *pptr = tbl;
+    for (i = 0; i < mcount; i++)
+    {
+	jobjectArray parama;
+	jsize pcount;
+	jobject c = (*jenv)->GetObjectArrayElement(jenv, methods, i);
+	rjb_check_exception(jenv, 0);
+	pc = ALLOC(struct cls_constructor);
+	tbl[i] = pc;
+	parama = (*jenv)->CallObjectMethod(jenv, c, ctrGetParameterTypes);
+	rjb_check_exception(jenv, 0);
+	pcount = (*jenv)->GetArrayLength(jenv, parama);
+	rjb_check_exception(jenv, 0);
+	setup_methodbase(jenv, pc, parama, pcount);
+	pc->id = (*jenv)->FromReflectedMethod(jenv, c);
+	(*jenv)->DeleteLocalRef(jenv, c);
+    }
+    tbl[mcount] = NULL;    
+}
+			       
+static void setup_methods(JNIEnv* jenv, st_table** tbl, st_table** static_tbl,
+			  jobjectArray methods)
+{
+    int i;
+    jint modifier;    
+    jsize mcount = (*jenv)->GetArrayLength(jenv, methods);
+    *tbl = st_init_numtable_with_size(mcount);
+    *static_tbl = st_init_numtable();
+    for (i = 0; i < mcount; i++)
+    {
+	jobject m = (*jenv)->GetObjectArrayElement(jenv, methods, i);
+	rjb_check_exception(jenv, 0);	
+	modifier = (*jenv)->CallIntMethod(jenv, m, method_getModifiers);
+	if (!(modifier & ACC_STATIC))
+	{
+	    create_methodinfo(jenv, *tbl, m, 0);
+	}
+	else
+	{
+	    create_methodinfo(jenv, *static_tbl, m, 1);
+	}
+	(*jenv)->DeleteLocalRef(jenv, m);
+    }
+}
+
+static void setup_fields(JNIEnv* jenv, st_table** tbl, jobjectArray flds)
+{
+    int i;
+    jint modifier;    
+    jsize fcount = (*jenv)->GetArrayLength(jenv, flds);
+    *tbl = st_init_numtable_with_size(fcount);
+    for (i = 0; i < fcount; i++)
+    {
+	jobject f = (*jenv)->GetObjectArrayElement(jenv, flds, i);
+	rjb_check_exception(jenv, 0);	
+	modifier = (*jenv)->CallIntMethod(jenv, f, field_getModifiers);
+	create_fieldinfo(jenv, *tbl, f, modifier & ACC_FINAL, modifier & ACC_STATIC);
+	(*jenv)->DeleteLocalRef(jenv, f);
+    }
+}
+
+static void load_constants(JNIEnv* jenv, jclass klass, VALUE self, jobjectArray flds)
+{
+    int i;
+    jint modifier;
+    jsize fcount = (*jenv)->GetArrayLength(jenv, flds);
+    for (i = 0; i < fcount; i++)
+    {
+	jobject f = (*jenv)->GetObjectArrayElement(jenv, flds, i);
+	rjb_check_exception(jenv, 0);
+	modifier = (*jenv)->CallIntMethod(jenv, f, field_getModifiers);
+	rjb_check_exception(jenv, 0);
+	if ((modifier & (ACC_PUBLIC | ACC_STATIC | ACC_FINAL)) == (ACC_PUBLIC | ACC_STATIC | ACC_FINAL))
+	{
+	    jstring nm;
+	    const char* cname;
+	    jobject cls;
+	    char sig;
+	    char depth;
+	    off_t iv;
+	    J2R j2r;
+	    jvalue jv;
+	    jfieldID jfid;
+	    char sigs[256];
+            char* pname;
+
+	    // constants make define directly in the ruby object
+	    cls = (*jenv)->CallObjectMethod(jenv, f, field_getType);
+	    rjb_check_exception(jenv, 0);
+	    iv = 0;
+	    sig = depth = 0;
+	    j2r = get_j2r(jenv, cls, &sig, &depth, sigs, &iv, 1);
+	    if (!j2r) j2r = jv2rv;
+	    (*jenv)->DeleteLocalRef(jenv, cls);
+	    nm = (*jenv)->CallObjectMethod(jenv, f, field_getName);
+	    rjb_check_exception(jenv, 0);
+	    cname = (*jenv)->GetStringUTFChars(jenv, nm, NULL);
+	    rjb_check_exception(jenv, 0);
+	    jfid = (*jenv)->GetStaticFieldID(jenv, klass, cname, sigs);
+	    rjb_check_exception(jenv, 0);
+	    switch (sig) 
+	    {
+	    case 'D':
+		jv.d = (*jenv)->GetStaticDoubleField(jenv, klass, jfid);
+		break;
+	    case 'Z':
+		jv.z = (*jenv)->GetStaticBooleanField(jenv, klass, jfid);
+		break;
+	    case 'B':
+		jv.b = (*jenv)->GetStaticByteField(jenv, klass, jfid);
+		break;
+	    case 'F':
+		jv.f = (*jenv)->GetStaticFloatField(jenv, klass, jfid);
+		break;
+	    case 'C':
+		jv.c = (*jenv)->GetStaticCharField(jenv, klass, jfid);
+		break;
+	    case 'S':
+		jv.s = (*jenv)->GetStaticShortField(jenv, klass, jfid);
+		break;
+	    case 'J':
+		jv.j = (*jenv)->GetStaticLongField(jenv, klass, jfid);
+		break;
+	    case 'I':
+		jv.i = (*jenv)->GetStaticIntField(jenv, klass, jfid);
+		break;
+	    default:
+		jv.l = (*jenv)->GetStaticObjectField(jenv, klass, jfid);
+		break;
+	    }
+            pname = (char*)cname; 
+	    if (!isupper(*cname))
+	    {
+ 	        pname = ALLOCA_N(char, strlen(cname) + 1);
+		strcpy(pname, cname);
+		*pname = toupper(*pname);
+		if (!isupper(*pname) 
+                    || rb_const_defined(RBASIC(self)->klass, rb_intern(pname))) 
+		{
+	            pname = NULL;
+		}
+	    }
+	    if (pname)
+	    {
+	        rb_define_const(RBASIC(self)->klass, pname, j2r(jenv, jv));
+	    }
+	    rjb_release_string(jenv, nm, cname);
+	}
+	(*jenv)->DeleteLocalRef(jenv, f);
+    }
+}
+
+static void setup_metadata(JNIEnv* jenv, VALUE self, struct jv_data* ptr, VALUE classname)
+{
+    jmethodID mid;
+    jobjectArray methods;
+    jobjectArray flds;
+    
+    jclass klass = (*jenv)->GetObjectClass(jenv, ptr->idata.obj);
+    ptr->idata.klass = (*jenv)->NewGlobalRef(jenv, klass);
+    rjb_check_exception(jenv, 0);
+    mid = (*jenv)->GetMethodID(jenv, klass, "getMethods", "()[Ljava/lang/reflect/Method;");
+    rjb_check_exception(jenv, 0);
+    methods = (*jenv)->CallNonvirtualObjectMethod(jenv, ptr->idata.obj, klass, mid);
+    rjb_check_exception(jenv, 0);
+    setup_methods(jenv, &ptr->idata.methods, &ptr->static_methods, methods);
+    mid = (*jenv)->GetMethodID(jenv, klass, "getConstructors", "()[Ljava/lang/reflect/Constructor;");
+    rjb_check_exception(jenv, 0);
+    methods = (*jenv)->CallNonvirtualObjectMethod(jenv, ptr->idata.obj, klass, mid);
+    rjb_check_exception(jenv, 0);
+    setup_constructors(jenv, &ptr->constructors, methods);
+    mid = (*jenv)->GetMethodID(jenv, klass, "getFields", "()[Ljava/lang/reflect/Field;");
+    rjb_check_exception(jenv, 0);
+    flds = (*jenv)->CallNonvirtualObjectMethod(jenv, ptr->idata.obj, klass, mid);
+    rjb_check_exception(jenv, 0);
+    setup_fields(jenv, &ptr->idata.fields, flds);
+
+    register_class(self, classname);
+    load_constants(jenv, ptr->idata.obj, self, flds);
+}
+
+/*
+ * load Java Virtual Machine
+ * def load(class_path = '', vmargs = [])
+ * class_path: passes for the class dir and jar name
+ * vmargs: strng array of vmarg (such as -Xrs)
+ * 
+ * change in rjb 0.1.7, omit first argument for JNI version.
+ *  because I misunderstood the number means (JVM but JNI).
+ */
+static VALUE rjb_s_load(int argc, VALUE* argv, VALUE self)
+{
+    JNIEnv* jenv;
+    JavaVMInitArgs vm_args;
+    jint res;
+    VALUE user_path;
+    VALUE vm_argv;
+    char* userpath;
+    int i;
+    jclass jmethod;
+    jclass jfield;
+    jclass jconstructor;
+
+    if (rjb_jvm)
+    {
+	return Qnil;
+    }
+
+    memset(&vm_args, 0, sizeof(vm_args));
+    vm_args.version = JNI_VERSION_1_4;
+    rb_scan_args(argc, argv, "02", &user_path, &vm_argv);
+    if (!NIL_P(user_path))
+    {
+        Check_Type(user_path, T_STRING);
+	userpath = StringValueCStr(user_path);
+    }
+    else
+    {
+	userpath = ".";
+    }
+    if (!NIL_P(vm_argv))
+    {
+        Check_Type(vm_argv, T_ARRAY);
+    }
+    jenv = NULL;
+    res = rjb_create_jvm(&jenv, &vm_args, userpath, vm_argv);
+    if (res < 0)
+    {
+	rjb_jvm = NULL;
+	rb_raise(rb_eRuntimeError, "can't create Java VM");
+    } else {
+        main_jenv = jenv;
+    }
+
+    jconstructor = (*jenv)->FindClass(jenv, "java/lang/reflect/Constructor");
+    rjb_check_exception(jenv, 1);
+    ctrGetParameterTypes = (*jenv)->GetMethodID(jenv, jconstructor, "getParameterTypes", "()[Ljava/lang/Class;");
+    rjb_check_exception(jenv, 1);
+    jmethod = (*jenv)->FindClass(jenv, "java/lang/reflect/Method");
+    method_getModifiers = (*jenv)->GetMethodID(jenv, jmethod, "getModifiers", "()I");
+    rjb_check_exception(jenv, 1);
+    method_getName = (*jenv)->GetMethodID(jenv, jmethod, "getName", "()Ljava/lang/String;");
+    rjb_check_exception(jenv, 1);	
+    getParameterTypes = (*jenv)->GetMethodID(jenv, jmethod, "getParameterTypes", "()[Ljava/lang/Class;");
+    rjb_check_exception(jenv, 1);	
+    getReturnType = (*jenv)->GetMethodID(jenv, jmethod, "getReturnType", "()Ljava/lang/Class;");
+    rjb_check_exception(jenv, 1);
+
+    jfield = (*jenv)->FindClass(jenv, "java/lang/reflect/Field");
+    field_getModifiers = (*jenv)->GetMethodID(jenv, jfield, "getModifiers", "()I");
+    rjb_check_exception(jenv, 1);
+    field_getName = (*jenv)->GetMethodID(jenv, jfield, "getName", "()Ljava/lang/String;");
+    rjb_check_exception(jenv, 1);	
+    field_getType = (*jenv)->GetMethodID(jenv, jfield, "getType", "()Ljava/lang/Class;");
+    rjb_check_exception(jenv, 1);	
+
+    j_class = (*jenv)->FindClass(jenv, "java/lang/Class");
+    rjb_check_exception(jenv, 1);
+    rjb_class_getName = (*jenv)->GetMethodID(jenv, j_class, "getName", "()Ljava/lang/String;");
+    rjb_check_exception(jenv, 1);
+    j_class = (*jenv)->NewGlobalRef(jenv, j_class);
+
+    rjb_j_throwable = (*jenv)->FindClass(jenv, "java/lang/Throwable");
+    rjb_check_exception(jenv, 1);
+    rjb_throwable_getMessage = (*jenv)->GetMethodID(jenv, rjb_j_throwable, "getMessage", "()Ljava/lang/String;");
+    rjb_check_exception(jenv, 1);
+
+    j_string = (*jenv)->FindClass(jenv, "java/lang/String");
+    rjb_check_exception(jenv, 1);
+    str_tostring = (*jenv)->GetMethodID(jenv, j_string, "toString", "()Ljava/lang/String;");
+    rjb_check_exception(jenv, 1);
+    j_string = (*jenv)->NewGlobalRef(jenv, j_string);
+
+    j_object = (*jenv)->FindClass(jenv, "java/lang/Object");
+    rjb_check_exception(jenv, 1);
+    j_object = (*jenv)->NewGlobalRef(jenv, j_object);
+
+    for (i = PRM_INT; i < PRM_LAST; i++)
+    {
+	jclass klass = (*jenv)->FindClass(jenv, jpcvt[i].classname);
+	if (i == PRM_BOOLEAN)
+	{
+	    jpcvt[i].ctr_id = (*jenv)->GetStaticMethodID(jenv,
+			 klass, "valueOf", jpcvt[i].ctrsig);
+	    rjb_check_exception(jenv, 1);
+	}
+	else if (jpcvt[i].ctrsig)
+	{
+	    jpcvt[i].ctr_id = (*jenv)->GetMethodID(jenv, klass,
+						   "<init>", jpcvt[i].ctrsig);
+	    rjb_check_exception(jenv, 1);
+	}
+	jpcvt[i].to_prim_id = (*jenv)->GetMethodID(jenv, klass,
+				   jpcvt[i].to_prim_method, jpcvt[i].prmsig);
+	rjb_check_exception(jenv, 1);
+        jpcvt[i].klass = (*jenv)->NewGlobalRef(jenv, klass);
+    }
+
+    jklass = import_class(jenv, j_class, rb_str_new2("java.lang.Class"));
+    rb_define_method(RBASIC(jklass)->klass, "forName", rjb_class_forname, -1);
+    rb_gc_register_address(&jklass);
+    
+    return Qnil;
+}
+
+/*
+ * unload Java Virtual Machine
+ *
+ * def unload()
+ *   classes.clear
+ *   unload(jvm)
+ * end
+ */
+static int clear_classes(VALUE key, VALUE val, VALUE dummy)
+{
+    return ST_DELETE;
+}
+static VALUE rjb_s_unload(int argc, VALUE* argv, VALUE self)
+{
+    st_foreach(RHASH_TBL(rjb_loaded_classes), clear_classes, 0);
+    if (rjb_jvm)
+    {
+	(*rjb_jvm)->DestroyJavaVM(rjb_jvm);
+	rjb_jvm = NULL;
+    }
+    return Qnil;
+}
+
+/*
+ * return all classes that were already loaded.
+ * this method simply returns the global hash,
+ * but it's safe because the hash was frozen.
+ */
+static VALUE rjb_s_classes(VALUE self)
+{
+    return rjb_loaded_classes;
+}
+
+/**
+ * For JRuby conpatible optsion
+ */
+static VALUE rjb_s_set_pconversion(VALUE self, VALUE val)
+{
+    primitive_conversion = (RTEST(val)) ? Qtrue : Qfalse;
+    return val;
+}
+
+/**
+ * For JRuby conpatible optsion
+ */
+static VALUE rjb_s_get_pconversion(VALUE self)
+{
+    return primitive_conversion;
+}
+
+
+/*
+ * free java class
+ */
+static void free_constructor(struct cls_constructor* p)
+{
+    free(p->arg_convert);
+    free(p->method_signature);
+}
+static int free_method_item(ID key, struct cls_method* pm, int dummy)
+{
+    for (; pm; pm = pm->next)
+    {
+	free_constructor(&pm->basic);
+    }
+    return ST_CONTINUE;
+}
+
+/*
+ * finalize Object instance
+ */
+static VALUE rjb_delete_ref(struct jvi_data* ptr)
+{
+    JNIEnv* jenv = rjb_attach_current_thread();
+    if (jenv)
+    {
+	(*jenv)->DeleteGlobalRef(jenv, ptr->obj);
+    }
+    return Qnil;
+}
+
+/*
+ * finalize Bridge instance
+ */
+static VALUE rj_bridge_free(struct rj_bridge* ptr)
+{
+    JNIEnv* jenv = rjb_attach_current_thread();    
+    (*jenv)->DeleteLocalRef(jenv, ptr->proxy);    
+    (*jenv)->DeleteLocalRef(jenv, ptr->bridge);
+    return Qnil;
+}
+
+/*
+ * mark wrapped object in the Bridge
+ */
+static void rj_bridge_mark(struct rj_bridge* ptr)
+{
+    rb_gc_mark(ptr->wrapped);
+}
+
+/*
+ * finalize Class instance
+ */
+static VALUE rjb_s_free(struct jv_data* ptr)
+{
+    /* class never delete
+    JNIEnv* jenv = rjb_attach_current_thread();
+    struct cls_constructor** c;
+    
+    rjb_delete_ref(&ptr->idata);
+    if (ptr->constructors)
+    {
+	for (c = ptr->constructors; *c; c++)
+	{
+	    free_constructor(*c);
+	}
+    }
+    free(ptr->constructors);
+    if (ptr->idata.methods)
+    {
+	st_foreach(ptr->idata.methods, (int(*)())free_method_item, 0);
+	st_free_table(ptr->idata.methods);
+    }
+    (*jenv)->DeleteGlobalRef(jenv, ptr->idata.klass);	
+    st_delete(RHASH(rjb_loaded_classes)->tbl, clsname, NULL);
+    */
+    return Qnil;
+}
+
+/*
+ * create new instance of this class
+ */
+static VALUE createinstance(JNIEnv* jenv, int argc, VALUE* argv,
+	    struct jvi_data* org, struct cls_constructor* pc)
+{
+    int i;
+    char* psig = pc->method_signature;
+    jobject obj = NULL;
+    VALUE result;
+
+    jvalue* args = (argc) ? ALLOCA_N(jvalue, argc) : NULL;
+    for (i = 0; i < argc; i++)
+    {
+	R2J pr2j = *(pc->arg_convert + i);
+	pr2j(jenv, argv[i], args + i, psig, 0);
+	psig = next_sig(psig);
+	rjb_check_exception(jenv, 1);
+    }
+    obj = (*jenv)->NewObjectA(jenv, org->obj, pc->id, args);
+    if (!obj)
+    {
+	rjb_check_exception(jenv, 1);
+    }
+    psig = pc->method_signature;
+    for (i = 0; i < argc; i++)
+    {
+	R2J pr2j = *(pc->arg_convert + i);
+	pr2j(jenv, argv[i], args + i, psig, 1);
+	psig = next_sig(psig);
+    }
+
+    result = register_instance(jenv, org, obj);
+    (*jenv)->DeleteLocalRef(jenv, obj);
+    return result;
+}
+
+static VALUE import_class(JNIEnv* jenv, jclass jcls, VALUE clsname)
+{
+    VALUE v;
+    VALUE rexp;
+    struct jv_data* ptr;
+    char* pclsname = StringValueCStr(clsname);
+    char* nm = ALLOCA_N(char, strlen(pclsname) + 1);
+    strcpy(nm, pclsname);
+    *nm = toupper(*nm);
+    for (pclsname = nm; *pclsname; pclsname++) 
+    {
+        if (*pclsname == '.')
+	{
+	    *pclsname = '_';
+	}
+    }
+    rexp = rb_define_class_under(rjb, nm, rjbc);
+    ptr = ALLOC(struct jv_data);
+    memset(ptr, 0, sizeof(struct jv_data));
+    v = Data_Wrap_Struct(rexp, NULL, rjb_s_free, ptr);
+    ptr->idata.obj = (*jenv)->NewGlobalRef(jenv, jcls);
+    setup_metadata(jenv, v, ptr, clsname);
+    return v;
+}
+
+static VALUE register_instance(JNIEnv* jenv, struct jvi_data* org, jobject obj)
+{
+    VALUE v;
+    struct jvi_data* ptr = ALLOC(struct jvi_data);
+    memset(ptr, 0, sizeof(struct jvi_data));
+    v = Data_Wrap_Struct(rjbi, NULL, rjb_delete_ref, ptr);
+    ptr->klass = org->obj;
+    ptr->obj = (*jenv)->NewGlobalRef(jenv, obj);
+    ptr->methods = org->methods;
+    ptr->fields = org->fields;
+    return v;
+}
+
+/*
+ * temporary signature check
+ * return !0 if found
+ */
+static int check_rtype(JNIEnv* jenv, VALUE v, char* p)
+{
+    char* pcls = NULL;
+    if (*p == 'L')
+    {
+        char* pt = strchr(p, ';');
+	if (pt)
+	{
+	    int len = pt - p - 1;
+	    pcls = ALLOCA_N(char, len + 1);
+            strncpy(pcls, p + 1, len);
+	    *(pcls + len) = '\0';
+	}
+    }
+    if (pcls && !strcmp("java.lang.Object", pcls))
+    {
+        return 1;
+    }
+    switch (TYPE(v))
+    {
+    case T_FIXNUM:
+        return strchr("BCDFIJS", *p) != NULL;
+    case T_FLOAT:
+	return strchr("DF", *p) != NULL;
+    case T_STRING:
+      return pcls && !strcmp("java.lang.String", pcls);
+    case T_TRUE:
+    case T_FALSE:
+        return *p == 'Z';
+    case T_ARRAY:
+        return *p == '[';
+    case T_DATA:
+        if (RBASIC(v)->klass == rjbi && pcls)
+	{
+	    // imported object
+	    jclass cls;
+            struct jvi_data* ptr;
+	    int result = 0;
+            if (!strcmp("java.lang.String", pcls)) return 1;
+	    Data_Get_Struct(v, struct jvi_data, ptr);
+	    cls = (*jenv)->FindClass(jenv, java2jniname(pcls));
+	    if (cls)
+	    {
+	        result = (cls && (*jenv)->IsInstanceOf(jenv, ptr->obj, cls));
+	        (*jenv)->DeleteLocalRef(jenv, cls);
+	    }
+	    return result;
+	}
+	// fall down to the next case 
+    case T_OBJECT:
+	// fall down to the next case
+    default:
+        if (pcls || *p == '[')
+        {
+            return 1;
+        }
+	return 0;
+    }
+}
+
+/*
+ * new instance with signature
+ */
+static VALUE rjb_newinstance_s(int argc, VALUE* argv, VALUE self)
+{
+    VALUE vsig, rest;
+    char* sig;
+    VALUE ret = Qnil;
+    struct jv_data* ptr;
+    JNIEnv* jenv = rjb_attach_current_thread();
+    int found = 0;
+
+    rb_scan_args(argc, argv, "1*", &vsig, &rest);
+    sig = StringValueCStr(vsig);
+    Data_Get_Struct(self, struct jv_data, ptr);
+    if (ptr->constructors)
+    {
+	struct cls_constructor** pc = ptr->constructors;
+	for (pc = ptr->constructors; *pc; pc++)
+	{
+	    if ((*pc)->arg_count == argc - 1
+		&& !strcmp(sig, (*pc)->method_signature))
+	    {
+	        found = 1;
+		ret = createinstance(jenv, argc - 1, argv + 1, &ptr->idata, *pc);
+		break;
+	    }
+	}
+    }
+    if (!found) {
+	rb_raise(rb_eRuntimeError, "Constructor not found");
+    }
+    return ret;
+}
+
+static VALUE rjb_newinstance(int argc, VALUE* argv, VALUE self)
+{
+    VALUE ret = Qnil;
+    struct jv_data* ptr;
+    struct cls_constructor** pc;
+    JNIEnv* jenv = rjb_attach_current_thread();
+    int found = 0;
+
+    Data_Get_Struct(self, struct jv_data, ptr);
+
+    if (ptr->constructors)
+    {
+        int i;
+	char* psig;
+	for (pc = ptr->constructors; *pc; pc++)
+	{
+	    if ((*pc)->arg_count == argc)
+	    {
+	        found = 1;
+		psig = (*pc)->method_signature;
+		for (i = 0; i < argc; i++)
+		{
+		    if (!check_rtype(jenv, *(argv + i), psig))
+                    {
+		        found = 0;
+			break;
+		    }
+		    psig = next_sig(psig);
+		}
+		if (found)
+		{
+		    ret = createinstance(jenv, argc, argv, &ptr->idata, *pc);
+		    break;
+		}
+	    }
+	}
+    }
+    if (!found) {
+	rb_raise(rb_eRuntimeError, "Constructor not found");
+    }
+    return ret;
+}
+
+/*
+ * find java class from classname
+ */
+jclass rjb_find_class(JNIEnv* jenv, VALUE name)
+{
+    char* cname;
+    char* jnicls;
+    
+    cname = StringValueCStr(name);
+    jnicls = ALLOCA_N(char, strlen(cname) + 1);
+    strcpy(jnicls, cname);
+    return (*jenv)->FindClass(jenv, java2jniname(jnicls));
+}
+
+/*
+ * jclass Rjb::bind(rbobj, interface_name)
+ */
+static VALUE rjb_s_bind(VALUE self, VALUE rbobj, VALUE itfname)
+{
+    VALUE result = Qnil;
+    JNIEnv* jenv = rjb_attach_current_thread();
+    
+    jclass itf = rjb_find_class(jenv, itfname); 
+    rjb_check_exception(jenv, 1);
+    if (itf)
+    {
+	struct rj_bridge* ptr = ALLOC(struct rj_bridge);
+	memset(ptr, 0, sizeof(struct rj_bridge));
+	ptr->bridge = (*jenv)->NewGlobalRef(jenv,
+                                   (*jenv)->AllocObject(jenv, rjb_rbridge));
+	if (!ptr->bridge)
+	{
+	    free(ptr);
+	    rjb_check_exception(jenv, 1);
+	    return Qnil;
+	}
+	ptr->proxy = (*jenv)->CallObjectMethod(jenv, ptr->bridge,
+					       rjb_register_bridge, itf);
+        ptr->proxy = (*jenv)->NewGlobalRef(jenv, ptr->proxy);
+	ptr->wrapped = rbobj;
+	result = Data_Wrap_Struct(rjbb, rj_bridge_mark, rj_bridge_free, ptr);
+	rb_ary_push(proxies, result);
+    }
+    return result;
+}
+
+/*
+ * Jclass Rjb::import(classname)
+ */
+static VALUE rjb_s_import(VALUE self, VALUE clsname)
+{
+    JNIEnv* jenv;
+    jclass jcls;
+    VALUE v = rb_hash_aref(rjb_loaded_classes, clsname);
+    if (v != Qnil)
+    {
+	return v;
+    }
+
+    if (!rjb_jvm) 
+    {
+        /* auto-load with default setting */
+        rjb_s_load(0, NULL, 0);
+    }
+    jenv = rjb_attach_current_thread();
+    jcls = rjb_find_class(jenv, clsname);
+    if (!jcls)
+    {
+	rjb_check_exception(jenv, 0);
+	rb_raise(rb_eRuntimeError, "`%s' not found", StringValueCStr(clsname));
+    }
+    v = import_class(jenv, jcls, clsname);
+    return v;
+}
+
+static void register_class(VALUE self, VALUE clsname)
+{
+    rb_define_singleton_method(self, "new", rjb_newinstance, -1);
+    rb_define_singleton_method(self, "new_with_sig", rjb_newinstance_s, -1);
+    /*
+     * the hash was frozen, so it need to call st_ func directly.
+     */
+    st_insert(RHASH_TBL(rjb_loaded_classes), clsname, self);
+}
+
+/*
+ * return class name
+ */
+static VALUE rjb_i_class(VALUE self)
+{
+    JNIEnv* jenv = rjb_attach_current_thread();
+    struct jvi_data* ptr;
+    jstring nm;
+    Data_Get_Struct(self, struct jvi_data, ptr);
+    nm = (*jenv)->CallObjectMethod(jenv, ptr->klass, rjb_class_getName);
+    rjb_check_exception(jenv, 0);
+    return jstring2val(jenv, nm);
+}
+
+/*
+ * invoker
+ */
+static VALUE getter(JNIEnv* jenv, struct cls_field* pf,  struct jvi_data* ptr)
+{
+    jvalue jv;
+    switch (pf->result_signature) 
+    {
+    case 'D':
+        if (pf->static_field)
+        {
+            jv.d = (*jenv)->GetStaticDoubleField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+            jv.d = (*jenv)->GetDoubleField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    case 'Z':
+        if (pf->static_field)
+        {
+            jv.z = (*jenv)->GetStaticBooleanField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+            jv.z = (*jenv)->GetBooleanField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    case 'B':
+        if (pf->static_field)
+        {
+            jv.b = (*jenv)->GetStaticByteField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+            jv.b = (*jenv)->GetByteField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    case 'F':
+        if (pf->static_field)
+        {
+            jv.f = (*jenv)->GetStaticFloatField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+            jv.f = (*jenv)->GetFloatField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    case 'C':
+        if (pf->static_field)
+        {
+            jv.c = (*jenv)->GetStaticCharField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+            jv.c = (*jenv)->GetCharField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    case 'S':
+        if (pf->static_field)
+        {
+	    jv.s = (*jenv)->GetStaticShortField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+	    jv.s = (*jenv)->GetShortField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    case 'J':
+        if (pf->static_field)
+        {
+	    jv.j = (*jenv)->GetStaticLongField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+	    jv.j = (*jenv)->GetLongField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    case 'I':
+        if (pf->static_field)
+        {
+	    jv.i = (*jenv)->GetStaticIntField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+	    jv.i = (*jenv)->GetIntField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    default:
+        if (pf->static_field)
+        {
+	    jv.l = (*jenv)->GetStaticObjectField(jenv, ptr->klass, pf->id);
+        }
+        else
+        {
+	    jv.l = (*jenv)->GetObjectField(jenv, ptr->obj, pf->id);
+        }
+	break;
+    }
+    if (pf->result_arraydepth)
+    {
+        return ja2r(pf->value_convert, jenv, jv, pf->result_arraydepth);
+    }
+    else
+    {
+        return pf->value_convert(jenv, jv);
+    }
+}
+
+static void setter(JNIEnv* jenv, struct cls_field* pf,  struct jvi_data* ptr, VALUE val)
+{
+    jvalue jv;
+    pf->arg_convert(jenv, val, &jv, pf->field_signature, 0);
+    switch (*pf->field_signature) 
+    {
+    case 'D':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticDoubleField(jenv, ptr->klass, pf->id, jv.d);
+        }
+        else
+        {
+            (*jenv)->SetDoubleField(jenv, ptr->obj, pf->id, jv.d);
+        }
+	break;
+    case 'Z':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticBooleanField(jenv, ptr->klass, pf->id, jv.z);
+        }
+        else
+        {
+            (*jenv)->SetBooleanField(jenv, ptr->obj, pf->id, jv.z);
+        }
+	break;
+    case 'B':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticByteField(jenv, ptr->klass, pf->id, jv.b);
+        }
+        else
+        {
+            (*jenv)->SetByteField(jenv, ptr->obj, pf->id, jv.b);
+        }
+	break;
+    case 'F':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticFloatField(jenv, ptr->klass, pf->id, jv.f);
+        }
+        else
+        {
+            (*jenv)->SetFloatField(jenv, ptr->obj, pf->id, jv.f);
+        }
+	break;
+    case 'C':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticCharField(jenv, ptr->klass, pf->id, jv.c);
+        }
+        else
+        {
+            (*jenv)->SetCharField(jenv, ptr->obj, pf->id, jv.c);
+        }
+	break;
+    case 'S':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticShortField(jenv, ptr->klass, pf->id, jv.s);
+        }
+        else
+        {
+            (*jenv)->SetShortField(jenv, ptr->obj, pf->id, jv.s);
+        }
+	break;
+    case 'J':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticLongField(jenv, ptr->klass, pf->id, jv.j);
+        }
+        else
+        {
+            (*jenv)->SetLongField(jenv, ptr->obj, pf->id, jv.j);
+        }
+	break;
+    case 'I':
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticIntField(jenv, ptr->klass, pf->id, jv.i);
+        }
+        else
+        {
+            (*jenv)->SetIntField(jenv, ptr->obj, pf->id, jv.i);
+        }
+	break;
+    default:
+        if (pf->static_field)
+        {
+            (*jenv)->SetStaticObjectField(jenv, ptr->klass, pf->id, jv.l);
+        }
+        else
+        {
+            (*jenv)->SetObjectField(jenv, ptr->obj, pf->id, jv.l);
+        }
+	break;
+    }
+    pf->arg_convert(jenv, val, &jv, pf->field_signature, 1);
+}
+
+static VALUE invoke(JNIEnv* jenv, struct cls_method* pm, struct jvi_data* ptr,
+		    int argc, VALUE* argv, const char* sig)
+{
+    int i, found;
+    jvalue jv;
+    jvalue* args;
+    char* psig;
+    struct cls_method* orgpm = pm;
+
+    for (found = 0; pm; pm = pm->next)
+    {
+        if (argc == pm->basic.arg_count)
+        {
+            if (sig) 
+            {
+                if (!strcmp(sig, pm->basic.method_signature))
+                {
+	            found = 1;
+                    break;
+		}
+	    }
+            else
+            {
+	        psig = pm->basic.method_signature;
+                found = 1;
+                for (i = 0; i < argc; i++)
+                {
+		    if (!check_rtype(jenv, *(argv + i), psig))
+                    {
+                        found = 0;
+                        break;
+                    }
+		    psig = next_sig(psig);
+                }
+                if (found) break;
+	    }
+	}
+    }
+    if (!found)
+    {
+	char* tname = rb_id2name(orgpm->name);
+	if (sig) 
+	{
+	    rb_raise(rb_eRuntimeError, "Fail: unknown method name `%s(\'%s\')'", tname, sig);
+	}
+	else
+	{
+	    rb_raise(rb_eRuntimeError, "Fail: unknown method name `%s'", tname);
+	}
+    }
+    args = (argc) ? ALLOCA_N(jvalue, argc) : NULL;
+    psig = pm->basic.method_signature;
+    for (i = 0; i < argc; i++)
+    {
+	R2J pr2j = *(pm->basic.arg_convert + i);
+	pr2j(jenv, argv[i], args + i, psig, 0);
+	psig = next_sig(psig);
+    }
+    switch (pm->basic.result_signature)
+    {
+    case 'D':
+      {
+        INVOKEAD voked = *(INVOKEAD*)(((char*)*jenv) + pm->method);
+	jv.d = voked(jenv, ptr->obj, pm->basic.id, args);
+      }
+      break;
+    case 'Z':
+    case 'B':
+      {
+        INVOKEAZ vokez = *(INVOKEAZ*)(((char*)*jenv) + pm->method);
+	jv.z = vokez(jenv, ptr->obj, pm->basic.id, args);
+      }
+      break;
+    case 'F':
+      {
+        INVOKEAF vokef = *(INVOKEAF*)(((char*)*jenv) + pm->method);
+	jv.f = vokef(jenv, ptr->obj, pm->basic.id, args);
+      }
+      break;
+    case 'C':
+    case 'S':
+      {
+        INVOKEAS vokes = *(INVOKEAS*)(((char*)*jenv) + pm->method);
+	jv.s = vokes(jenv, ptr->obj, pm->basic.id, args);
+      }
+      break;
+#if HAVE_LONG_LONG
+    case 'J':
+      {
+        INVOKEAL vokel = *(INVOKEAL*)(((char*)*jenv) + pm->method);
+	jv.j = vokel(jenv, ptr->obj, pm->basic.id, args);
+      }
+      break;
+#endif
+    default:
+      {
+        INVOKEA voke = *(INVOKEA*)(((char*)*jenv) + pm->method);
+        jv.l = voke(jenv, ptr->obj, pm->basic.id, args);
+      }
+      break;
+    }
+    rjb_check_exception(jenv, 1);
+    psig = pm->basic.method_signature;
+    for (i = 0; i < argc; i++)
+    {
+	R2J pr2j = *(pm->basic.arg_convert + i);
+	pr2j(jenv, argv[i], args + i, psig, 1);
+	psig = next_sig(psig);
+    }
+    if (pm->basic.result_arraydepth)
+    {
+        return ja2r(pm->result_convert, jenv, jv, pm->basic.result_arraydepth);
+    }
+    else
+    {
+        return pm->result_convert(jenv, jv);
+    }
+}
+
+/*
+ * Object invocation
+ */
+static VALUE invoke_by_instance(ID rmid, int argc, VALUE* argv,
+				struct jvi_data* ptr, char* sig)
+{
+    VALUE ret = Qnil;
+    JNIEnv* jenv = rjb_attach_current_thread();
+    struct cls_field* pf;
+    struct cls_method* pm;
+    char* tname = rb_id2name(rmid);
+    
+    if (argc == 0 && st_lookup(ptr->fields, rmid, (st_data_t*)&pf))
+    {
+        ret = getter(jenv, pf, ptr);
+    }
+    else if (argc == 1 && *(tname + strlen(tname) - 1) == '=')
+    {
+        char* fname = ALLOCA_N(char, strlen(tname) + 1);
+	strcpy(fname, tname);
+	fname[strlen(tname) - 1] = '\0';
+	if (st_lookup(ptr->fields, rb_intern(fname), (st_data_t*)&pf))
+	{
+	    setter(jenv, pf, ptr, *argv);
+            return ret;
+        }
+        // fall through for the setter alias name
+    }
+    if (st_lookup(ptr->methods, rmid, (st_data_t*)&pm))
+    {
+	ret = invoke(jenv, pm, ptr, argc, argv, sig);
+    }
+    else
+    {
+	rb_raise(rb_eRuntimeError, "Fail: unknown method name `%s'", tname);
+    }
+    return ret;
+}
+
+static VALUE rjb_i_invoke(int argc, VALUE* argv, VALUE self)
+{
+    VALUE vsig, rmid, rest;
+    char* sig;
+    struct jvi_data* ptr;
+
+    rb_scan_args(argc, argv, "2*", &rmid, &vsig, &rest);
+    rmid = rb_to_id(rmid);
+    sig = StringValueCStr(vsig);
+    Data_Get_Struct(self, struct jvi_data, ptr);
+
+    return invoke_by_instance(rmid, argc -2, argv + 2, ptr, sig);
+}
+
+static VALUE rjb_i_missing(int argc, VALUE* argv, VALUE self)
+{
+    struct jvi_data* ptr;
+    ID rmid = rb_to_id(argv[0]);
+    
+    Data_Get_Struct(self, struct jvi_data, ptr);
+    
+    return invoke_by_instance(rmid, argc -1, argv + 1, ptr, NULL);
+}
+
+/*
+ * Class invocation (first static method, then instance method)
+ */
+static VALUE invoke_by_class(ID rmid, int argc, VALUE* argv,
+			     struct jv_data* ptr, char* sig)
+{
+    VALUE ret = Qnil;
+    struct jv_data* clsptr;
+    struct cls_field* pf;
+    struct cls_method* pm;
+    char* tname = rb_id2name(rmid);
+    JNIEnv* jenv = rjb_attach_current_thread();
+
+    Data_Get_Struct(jklass, struct jv_data, clsptr);
+    if (argc == 0 && st_lookup(ptr->idata.fields, rmid, (st_data_t*)&pf))
+    {
+        if (!pf->static_field)
+	{
+            rb_raise(rb_eRuntimeError, "instance field `%s' for class", tname);
+	}
+        ret = getter(jenv, pf, &ptr->idata);
+    }
+    else if (argc == 1 && *(tname + strlen(tname) - 1) == '=')
+    {
+        char* fname = ALLOCA_N(char, strlen(tname) + 1);
+	strcpy(fname, tname);
+	fname[strlen(tname) - 1] = '\0';
+	if (st_lookup(ptr->idata.fields, rb_intern(fname), (st_data_t*)&pf))
+	{
+            if (!pf->static_field)
+	    {
+                rb_raise(rb_eRuntimeError, "instance field `%s' for class", fname);
+            }
+	    setter(jenv, pf, &ptr->idata, *argv);
+        }
+	else
+	{
+	    rb_raise(rb_eRuntimeError, "Fail: unknown field name `%s'", fname);
+	}
+    }
+    else if (st_lookup(ptr->static_methods, rmid, (st_data_t*)&pm))
+    {
+	ret = invoke(jenv, pm, &ptr->idata, argc, argv, sig);
+    }
+    else if (st_lookup(clsptr->idata.methods, rmid, (st_data_t*)&pm))
+    {
+	ret = invoke(jenv, pm, &ptr->idata, argc, argv, sig);
+    }
+    else
+    {
+        if (st_lookup(ptr->idata.methods, rmid, (st_data_t*)&pm))
+	{
+	    rb_raise(rb_eRuntimeError, "instance method `%s' for class", tname);
+	}
+	else
+        {
+	    rb_raise(rb_eRuntimeError, "Fail: unknown method name `%s'", tname);
+	}
+    }
+    
+    return ret;
+}
+
+static VALUE rjb_invoke(int argc, VALUE* argv, VALUE self)
+{
+    VALUE vsig, rmid, rest;
+    char* sig;
+    struct jv_data* ptr;
+    
+    rb_scan_args(argc, argv, "2*", &rmid, &vsig, &rest);
+    rmid = rb_to_id(rmid);
+    sig = StringValueCStr(vsig);
+    Data_Get_Struct(self, struct jv_data, ptr);
+
+    return invoke_by_class(rmid, argc - 2, argv + 2, ptr, sig);
+}
+
+static VALUE find_const(VALUE pv)
+{
+    VALUE* p = (VALUE*)pv;
+    return rb_const_get(*p, (ID)*(p + 1));
+}
+
+static VALUE rjb_missing(int argc, VALUE* argv, VALUE self)
+{
+    struct jv_data* ptr;
+    ID rmid = rb_to_id(argv[0]);
+    char* rmname = rb_id2name(rmid);
+    if (isupper(*rmname))
+    {
+        VALUE r, args[2];
+        int state = 0;
+	args[0] = RBASIC(self)->klass;
+	args[1] = rmid;
+        r = rb_protect(find_const, (VALUE)args, &state);
+	if (!state)
+        {
+	    return r;
+	}
+    }
+    
+    Data_Get_Struct(self, struct jv_data, ptr);
+    return invoke_by_class(rmid, argc - 1, argv + 1, ptr, NULL);
+}
+
+/*
+ * Class#forName entry.
+ */
+static VALUE rjb_class_forname(int argc, VALUE* argv, VALUE self)
+{
+    if (argc == 1)
+    {
+        return rjb_s_import(self, *argv);
+    }
+    else
+    {
+        struct jv_data* ptr;
+	ID rmid = rb_intern("forName");
+	Data_Get_Struct(self, struct jv_data, ptr);
+	return invoke_by_class(rmid, argc, argv, ptr, NULL);
+    }
+}
+
+/*
+ * Class initializer called by Ruby while requiring this library
+ */
+void Init_rjbcore()
+{
+    rb_protect((VALUE(*)(VALUE))rb_require, (VALUE)"iconv", NULL);
+
+    rjb_loaded_classes = rb_hash_new();
+    OBJ_FREEZE(rjb_loaded_classes);
+    rb_global_variable(&rjb_loaded_classes);
+    proxies = rb_ary_new();
+    rb_global_variable(&proxies);
+    
+    rjb = rb_define_module("Rjb");
+    rb_define_module_function(rjb, "load", rjb_s_load, -1);
+    rb_define_module_function(rjb, "unload", rjb_s_unload, -1);
+    rb_define_module_function(rjb, "import", rjb_s_import, 1);
+    rb_define_module_function(rjb, "bind", rjb_s_bind, 2);
+    rb_define_module_function(rjb, "classes", rjb_s_classes, 0);
+    rb_define_module_function(rjb, "throw", rjb_s_throw, -1);
+    rb_define_module_function(rjb, "primitive_conversion=", rjb_s_set_pconversion, 1);
+    rb_define_module_function(rjb, "primitive_conversion", rjb_s_get_pconversion, 0);
+    rb_define_const(rjb, "VERSION", rb_str_new2(RJB_VERSION));
+
+    /* Java class object */    
+    rjbc = rb_class_new(rb_cObject);
+    rb_gc_register_address(&rjbc);
+    rb_define_method(rjbc, "method_missing", rjb_missing, -1);
+    rb_define_method(rjbc, "_invoke", rjb_invoke, -1);
+    rb_define_method(rjbc, "_classname", rjb_i_class, 0);    
+
+    /* Java instance object */
+    rjbi = rb_class_new(rb_cObject);
+    rb_gc_register_address(&rjbi);
+    rb_define_method(rjbi, "method_missing", rjb_i_missing, -1);    
+    rb_define_method(rjbi, "_invoke", rjb_i_invoke, -1);
+    rb_define_method(rjbi, "_classname", rjb_i_class, 0);
+
+    /* Ruby-Java Bridge object */
+    rjbb = rb_class_new(rb_cObject);
+    rb_gc_register_address(&rjbb);
+}
+
+static VALUE safe_funcall(VALUE args)
+{
+    VALUE* argp = (VALUE*)args;
+    return rb_funcall2(*argp, *(argp + 1), *(argp + 2), argp + 3);
+}
+
+/**
+  Entry point from JavaVM through java.reflect.Proxy
+  */
+JNIEXPORT jobject JNICALL Java_jp_co_infoseek_hp_arton_rjb_RBridge_call
+  (JNIEnv * jenv, jobject bridge, jstring name, jobject proxy, jobjectArray args)
+{
+    int i;
+    jvalue j;
+    memset(&j, 0, sizeof(j));
+
+    for (i = 0; i < RARRAY_LEN(proxies); i++)
+    {
+	struct rj_bridge* ptr;
+	VALUE val = RARRAY_PTR(proxies)[i];
+	Data_Get_Struct(val, struct rj_bridge, ptr);
+	if ((*jenv)->IsSameObject(jenv, proxy, ptr->proxy))
+	{
+            int sstat;
+	    VALUE result;
+	    VALUE* argv = NULL;
+	    int argc = 3;
+            ID id = rb_to_id(jstring2val(jenv, name));
+	    if (args)
+	    {
+		int i;
+		jsize js = (*jenv)->GetArrayLength(jenv, args);
+		argc += (int)js;
+		argv = ALLOCA_N(VALUE, argc);
+		memset(argv, 0, sizeof(VALUE*) * argc);
+		for (i = 3; i < argc; i++)
+		{
+		    jobject f = (*jenv)->GetObjectArrayElement(jenv, args, i - 3);
+		    /* f will be release in jv2rv_withprim */
+		    *(argv + i) = jv2rv_withprim(jenv, f);
+		}
+	    }
+	    else
+	    {
+		argv = ALLOCA_N(VALUE, argc + 1);
+		memset(argv, 0, sizeof(VALUE*) * (argc + 1));
+	    }
+            *argv = ptr->wrapped;
+            *(argv + 1) = id;
+            *(argv + 2) = argc - 3;
+            result = rb_protect(safe_funcall, (VALUE)argv, &sstat);
+	    rv2jobject(jenv, result, &j, NULL, 0);
+	    // I can't delete this object...
+            break;
+	}
+    }
+    return j.l;
+}