rjb 1.4.7-x86-mswin32-100

data/ext/rjb.h

@@ -0,0 +1,164 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004,2005 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.h 180 2011-12-05 16:34:29Z arton $
+ * $Log: rjb.h,v $
+ * Revision 1.1  2005/01/16 17:36:10  arton
+ * Initial revision
+ *
+ *
+ */
+
+#ifndef RJB_H
+#define RJB_H
+
+#if RJB_RUBY_VERSION_CODE < 190
+#if !defined(RHASH_TBL)
+#define RHASH_TBL(x) RHASH((x))->tbl
+#endif
+#endif
+
+#if !defined(RSTRING_LEN)
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#if !defined(RSTRING_PTR)
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#if !defined(RARRAY_LEN)
+#define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+#if !defined(RARRAY_PTR)
+#define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+
+#if !defined(COUNTOF)
+#define COUNTOF(x) (sizeof(x)/sizeof(x[0]))
+#endif
+
+#if !defined(_I64_MIN)
+#define _I64_MIN    (-9223372036854775807i64 - 1)
+#endif
+#if !defined(_I64_MAX)
+#define _I64_MAX      9223372036854775807i64
+#endif
+
+#if !defined(HAVE_LONG_LONG) && defined(__LP64__)
+#define HAVE_LONG_LONG 1
+#endif
+
+/* in load.c */
+extern int rjb_create_jvm(JNIEnv** pjenv, JavaVMInitArgs*, char*, VALUE);
+
+/* in rjb.c */
+extern JavaVM* rjb_jvm;
+extern jclass rjb_rbridge;
+extern jmethodID rjb_register_bridge;
+extern VALUE rjb_loaded_classes;
+extern jmethodID rjb_class_getName;
+extern jclass rjb_j_throwable;
+extern jmethodID rjb_throwable_getMessage;
+extern JNIEnv* rjb_attach_current_thread(void);
+extern jclass rjb_find_class(JNIEnv* jenv, VALUE name);
+extern void rjb_release_string(JNIEnv *jenv, jstring str, const char* chrs);
+extern VALUE rjb_load_vm_default();
+extern void rjb_unload_vm();
+extern VALUE rjb_safe_funcall(VALUE args);
+extern VALUE jv2rv(JNIEnv* jenv, jvalue val);
+extern jobject get_systemloader(JNIEnv* jenv);
+extern jclass rjb_find_class_by_name(JNIEnv* jenv, const char* name);
+
+/* in rjbexception.c */
+extern VALUE rjb_get_exception_class(JNIEnv* jenv, jstring str);
+extern void rjb_check_exception(JNIEnv* jenv, int t);
+extern VALUE rjb_s_throw(int, VALUE*, VALUE);
+
+/* conversion functions */
+typedef void (*R2J)(JNIEnv*, VALUE, jvalue*, const char*, int);
+typedef VALUE (*J2R)(JNIEnv*, jvalue);
+typedef jarray (*R2JARRAY)(JNIEnv*, VALUE, const char*);
+typedef void (JNICALL *RELEASEARRAY)(JNIEnv*, jobject, void*, jint);
+typedef jlong (JNICALL *INVOKEAL)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jdouble (JNICALL *INVOKEAD)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jfloat (JNICALL *INVOKEAF)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jboolean (JNICALL *INVOKEAZ)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jshort (JNICALL *INVOKEAS)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef jobject (JNICALL *INVOKEA)(JNIEnv*, jobject, jmethodID, const jvalue*);
+typedef VALUE (*CONV)(JNIEnv*, void*);
+
+/*
+ * internal method class
+ */
+struct cls_constructor {
+    jmethodID id;
+    int arg_count;
+    R2J* arg_convert;
+    char* method_signature;
+    char  result_signature;
+    char  result_arraydepth;
+};
+
+struct cls_method {
+    struct cls_constructor basic;
+    ID name;
+    int static_method;
+    off_t method;
+    J2R result_convert;
+    /* overload only */
+    struct cls_method* next;
+};
+
+/*
+ * internal field class
+ */
+struct cls_field {
+    ID name;
+    jfieldID id;
+    char* field_signature;
+    char  result_signature;
+    char  result_arraydepth;
+    R2J arg_convert;
+    J2R value_convert;
+    int readonly;
+    int static_field;
+};
+
+/*
+ * Object instance
+ */
+struct jvi_data {
+    jclass klass; /* class */
+    jobject obj; /* instance */
+    st_table* methods;
+    st_table* fields;
+};
+
+/*
+ * Class instance
+ */
+struct jv_data {
+    struct jvi_data idata;
+    st_table* static_methods;
+    struct cls_constructor** constructors;
+};
+
+/*
+ * Bridge instance
+ */
+struct rj_bridge {
+    jobject bridge;
+    jobject proxy;
+    VALUE wrapped;
+};
+
+#endif

data/ext/rjbexception.c

@@ -0,0 +1,167 @@
+/*
+ * Rjb - Ruby <-> Java Bridge
+ * Copyright(c) 2004,2005,2006,2010 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: rjbexception.c 174 2011-11-09 13:47:43Z arton $
+ */
+
+#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 "riconv.h"
+#include "rjb.h"
+
+static VALUE missing_delegate(int argc, VALUE* argv, VALUE self)
+{
+    ID rmid = rb_to_id(argv[0]);
+    return rb_funcall(rb_ivar_get(self, rb_intern("@cause")), rmid, argc - 1, argv + 1);
+}
+
+static VALUE exception_to_s(VALUE self)
+{
+    return rb_funcall(rb_ivar_get(self, rb_intern("@cause")),
+                      rb_intern("toString"), 0);
+}
+
+/*
+ * handle Java exception
+ *  At this time, the Java exception is defined without the package name.
+ *  This design may change in future release.
+ */
+VALUE rjb_get_exception_class(JNIEnv* jenv, jstring str)
+{
+    VALUE rexp;
+    char* pcls;
+    VALUE cname;
+    const char* p = (*jenv)->GetStringUTFChars(jenv, str, JNI_FALSE);
+    char* clsname = ALLOCA_N(char, strlen(p) + 1);
+    strcpy(clsname, p);
+    rjb_release_string(jenv, str, p);
+    pcls = strrchr(clsname, '.');
+    if (pcls)
+    {
+	pcls++;
+    }
+    else
+    {
+	pcls = clsname;
+    }
+    cname = rb_str_new2(pcls);
+    rexp = rb_hash_aref(rjb_loaded_classes, cname);
+    if (rexp == Qnil)
+    {
+	rexp = rb_define_class(pcls, rb_eStandardError);
+        rb_define_method(rexp, "method_missing", missing_delegate, -1);
+        rb_define_method(rexp, "to_str", exception_to_s, 0);
+#if defined(HAVE_RB_HASH_ASET) || defined(RUBINIUS)
+	rb_hash_aset(rjb_loaded_classes, cname, rexp);
+#else
+#ifdef RHASH_TBL
+    st_insert(RHASH_TBL(rjb_loaded_classes), cname, rexp);
+#else
+    st_insert(RHASH(rjb_loaded_classes)->tbl, cname, rexp);
+#endif
+#endif
+	
+    }
+    return rexp;
+}
+
+/*
+ * throw newly created exception with supplied message.
+ */
+VALUE rjb_s_throw(int argc, VALUE* argv, VALUE self)
+{
+    VALUE klass;
+    VALUE message;
+    JNIEnv* jenv = NULL; 
+
+    rjb_load_vm_default();
+
+    jenv = rjb_attach_current_thread();
+    (*jenv)->ExceptionClear(jenv);
+
+    if (rb_scan_args(argc, argv, "11", &klass, &message) == 2)
+    {
+        jclass excep = rjb_find_class(jenv, klass);
+	if (excep == NULL)
+	{
+	    rb_raise(rb_eRuntimeError, "`%s' not found", StringValueCStr(klass));
+        }
+	(*jenv)->ThrowNew(jenv, excep, StringValueCStr(message));
+    }
+    else
+    {
+        struct jvi_data* ptr;
+	Data_Get_Struct(klass, struct jvi_data, ptr);
+	if (!(*jenv)->IsInstanceOf(jenv, ptr->obj, rjb_j_throwable))
+	{
+	    rb_raise(rb_eRuntimeError, "arg1 must be a throwable");
+	}
+	else
+	{
+  	    (*jenv)->Throw(jenv, ptr->obj);
+	}
+    }
+    return Qnil;
+}
+
+void rjb_check_exception(JNIEnv* jenv, int t)
+{
+    jthrowable exp = (*jenv)->ExceptionOccurred(jenv);
+    if (exp)
+    {
+	VALUE rexp = Qnil;
+        if (RTEST(ruby_verbose))
+	{
+	    (*jenv)->ExceptionDescribe(jenv);
+	}
+	(*jenv)->ExceptionClear(jenv);
+        if(1)
+	{
+ 	    char* msg = "unknown exception";
+	    jclass cls = (*jenv)->GetObjectClass(jenv, exp);
+ 	    jstring str = (*jenv)->CallObjectMethod(jenv, exp, rjb_throwable_getMessage);
+	    if (str)
+	    {
+	        const char* p = (*jenv)->GetStringUTFChars(jenv, str, JNI_FALSE);
+		msg = ALLOCA_N(char, strlen(p) + 1);
+		strcpy(msg, p);
+		rjb_release_string(jenv, str, p);
+	    }
+	    str = (*jenv)->CallObjectMethod(jenv, cls, rjb_class_getName);
+	    if (str)
+	    {
+		rexp = rjb_get_exception_class(jenv, str);
+	    }
+	    if (rexp == Qnil)
+	    {
+                (*jenv)->DeleteLocalRef(jenv, exp);
+		rb_raise(rb_eRuntimeError, "%s", msg);
+	    }
+	    else
+	    {
+                VALUE rexpi = rb_funcall(rexp, rb_intern("new"), 1, rb_str_new2(msg));
+                jvalue val;
+                val.l = exp;
+                rb_ivar_set(rexpi, rb_intern("@cause"), jv2rv(jenv, val));
+                rb_exc_raise(rexpi);
+	    }
+        }
+    }
+}

data/lib/rjb.rb

@@ -0,0 +1,122 @@
+=begin
+  Copyright(c) 2006-2010,2012 arton
+=end
+
+require 'rbconfig'
+
+module RjbConf
+  if /darwin/ =~ RUBY_PLATFORM
+    if ENV['JVM_LIB'].nil? || ENV['JVM_LIB'] == ''
+      if ENV['JAVA_HOME'].nil? || ENV['JAVA_HOME'] == ''
+        jvms = Dir.glob("#{`/usr/libexec/java_home`.strip}/**/libjvm.dylib")
+      else
+        jvms = Dir.glob("#{ENV['JAVA_HOME']}/**/libjvm.dylib")
+      end
+      if jvms.size > 0
+        ENV['JVM_LIB'] = jvms[0]
+      end
+    end
+  end
+
+  dir = File.join(File.dirname(File.dirname(__FILE__)), 'data')
+  if File.exist?(dir)
+    datadir = dir
+  else
+    datadir = RbConfig::CONFIG['datadir']
+  end
+  BRIDGE_FILE = File.join(datadir, 'rjb', 'jp', 'co', 'infoseek', 'hp',
+                          'arton', 'rjb', 'RBridge.class')
+  unless File.exist?(BRIDGE_FILE)
+    raise 'bridge file not found'
+  end
+end
+
+require 'rjbcore'
+
+module Rjb
+  module MODIFIER
+    def self.STATIC
+      8
+    end
+    def self.PUBLIC
+      1
+    end
+  end
+
+  module JMethod
+    def instance_method?(m)
+      m.modifiers & MODIFIER.STATIC == 0
+    end
+    def public_method?(m)
+      (m.modifiers & MODIFIER.PUBLIC) == MODIFIER.PUBLIC
+    end
+    def jmethods(org, klass, &blk)
+      (org + klass.getMethods.select do |m|
+         blk.call(m)
+      end.map do |m|
+        m.name
+      end).uniq
+    end
+    def format_sigs(s)
+      if s.size < 0
+        ''
+      elsif s.size == 1
+        s[0]
+      else
+        "[#{s.map{|m|m.nil? ? 'void' : m}.join(', ')}]"
+      end
+    end
+  end
+
+  class Rjb_JavaClass
+    include JMethod
+    def public_methods(inh = true)
+      jmethods(super(inh), self) do |m|
+        !instance_method?(m) && public_method?(m)
+      end
+    end
+    def methods(inh = true)
+      jmethods(super(inh), self) do |m|
+        !instance_method?(m) && public_method?(m)
+      end
+    end
+    def java_methods
+      jmethods([], self) do |m|
+        !instance_method?(m) && public_method?(m)
+      end.map do |m|
+        "#{m}(#{format_sigs(self.static_sigs(m))})"
+      end
+    end
+  end
+  class Rjb_JavaProxy
+    include JMethod
+    def initialize_proxy
+    end
+    def public_methods(inh = true)
+      jmethods(super(inh), getClass) do |m|
+        instance_method?(m) && public_method?(m)
+      end
+    end
+    def methods(inh = true)
+      jmethods(super(inh), getClass) do |m|
+        instance_method?(m) && public_method?(m)
+      end
+    end
+    def java_methods
+      jmethods([], getClass) do |m|
+        instance_method?(m) && public_method?(m)
+      end.map do |m|
+        "#{m}(#{format_sigs(getClass.sigs(m))})"
+      end
+    end
+  end
+  class Rjb_JavaBridge
+    def method_missing(name, *args)
+      @wrapped.__send__(name, *args)
+    end
+    def respond_to?(name, inc_private = false)
+      @wrapped.respond_to?(name, inc_private)
+    end
+    attr_reader :wrapped
+  end
+end