julia 0.2.0 → 0.3.0.dev

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 761658bd92a75b136265135887ffe7ca82a3c42d7e5d15ea5f6f9d8212d23ec1
-  data.tar.gz: 0052f5ad9249ff2063eceae0919573fea27039611824cad251b5aa63bdef57e1
+  metadata.gz: b6c14a8233ff0a3579610180d5696f5f7647a05a821103e90d2f29c38e5cc5c4
+  data.tar.gz: 2d8acdb2742ec06e627b2b0f1614aec7597a274380221dcc4973ed14c959a7c8
 SHA512:
-  metadata.gz: d6cf4724a9648c91ec03ed60fc1e9f3a337adc11ba1320ac74fedb7a0b6d12bde7fe1f050e9ca4e1d594caf45991977ee8f68ed6620d5beeb9fae79f6ca04c5b
-  data.tar.gz: 01d84c23f8c58efa7bd41a241389195e50a6842a6bd0ba0ae7fae77abb5b04bcb135d022b8cfe6a6372b5d4bcfbf18c8a3dd0b4f13f385057e898667c014b120
+  metadata.gz: 154d08d7ff8c9f75689034a0d0996a499daf1081d1d35e806d730faba824512e2fcbaee056d104676b1cbd3e590e2dd91dd34c2ef56164bef330928f9ea6fdb7
+  data.tar.gz: 010f472ce30703557beb5035d611c1a81b083d995680a8438c882c92beed3b9ea24bc1c58d3de7a67442c1d44df004cd4095b492bee262b32cffaf29dc172f67

data/.travis.yml

@@ -1,4 +1,13 @@
+dist: xenial
 language: ruby
 rvm:
-  - 2.2.2
-before_install: gem install bundler -v 1.10.3
+  - ruby-head
+  - 2.6
+  - 2.5
+  - 2.4
+  - 2.3
+before_install:
+  - wget -O /tmp/julia.tar.gz https://julialang-s3.julialang.org/bin/linux/x64/1.1/julia-1.1.0-linux-x86_64.tar.gz
+  - sudo mkdir /usr/local/julia
+  - sudo tar xf /tmp/julia.tar.gz -C /usr/local/julia --strip-components=1
+  - export PATH="/usr/local/julia/bin:$PATH"

data/README.md

@@ -12,9 +12,8 @@ Julia on Ruby.
 
 ### Julia
 
+- 1.1
 - 1.0
-- 0.7
-- 0.6
 
 ## Installation
 

data/RbCall.jl/src/RbCall.jl

@@ -0,0 +1,191 @@
+__precompile__()
+
+module RbCall
+
+export _refcnt, _incref, _decref, gc_guard_references
+
+#########################################################################
+# prepare
+
+import Libdl
+
+struct Dl_info
+    dli_fname::Ptr{UInt8}
+    dli_fbase::Ptr{Cvoid}
+    dli_sname::Ptr{UInt8}
+    dli_saddr::Ptr{Cvoid}
+end
+
+hassym(lib, sym) = Libdl.dlsym_e(lib, sym) != C_NULL
+
+proc_handle = unsafe_load(cglobal(:jl_exe_handle, Ptr{Cvoid}))
+
+symbols_present = false
+@static if Sys.iswindows()
+  # TODO support windows
+else
+  global symbols_present = hassym(proc_handle, :rb_define_class)
+end
+
+if !symbols_present
+  # TODO load libruby dynamically
+else
+  @static if Sys.iswindows()
+    # TODO support windows
+  else
+    libruby_handle = proc_handle
+    # Now determine the name of the ruby library that these symbols are from
+    some_address_in_libruby = Libdl.dlsym(libruby_handle, :rb_define_class)
+    some_address_in_main_exe = Libdl.dlsym_e(proc_handle, Sys.isapple() ? :_mh_execute_header : :main)
+    if some_address_in_main_exe == nothing
+      # NOTE: we cannot get main symbol from ruby executable in travis-ci
+      some_address_in_main_exe = Libdl.dlsym_e(proc_handle, :_start)
+    end
+    dlinfo1 = Ref{Dl_info}()
+    dlinfo2 = Ref{Dl_info}()
+    ccall(:dladdr, Cint, (Ptr{Cvoid}, Ptr{Dl_info}), some_address_in_libruby, dlinfo1)
+    ccall(:dladdr, Cint, (Ptr{Cvoid}, Ptr{Dl_info}), some_address_in_main_exe, dlinfo2)
+    if dlinfo1[].dli_fbase == dlinfo2[].dli_fbase
+      const libruby = nothing
+    else
+      const libruby = unsafe_string(dlinfo1[].dli_fname)
+    end
+  end
+end
+
+#########################################################################
+# basic types
+
+@static if sizeof(Clong) == sizeof(Ptr{Cvoid})
+  const VALUE = Culong
+  const SVALUE = Clong
+  const ID = Culong
+  const Cintptr_t = Clong
+  const Cuintptr_t = Culong
+elseif sizeof(Clonglong) == sizeof(Ptr{Cvoid})
+  const VALUE = Culonglong
+  const SVALUE = Clonglong
+  const ID = Culonglong
+  const Cintptr_t = Clonglong
+  const Cuintptr_t = Culonglong
+else
+  error("ruby requires sizeof(Ptr{Cvoid}) == sizeof(Clong) or sizeof(Clonglong) to be compiled.")
+end
+
+struct RBasic_struct
+  flags::VALUE
+  klass::VALUE
+end
+
+struct RVALUE_struct
+  basic::RBasic_struct
+  v1::VALUE
+  v2::VALUE
+  v3::VALUE
+end
+
+const RbPtr = Ptr{RVALUE_struct}
+
+#########################################################################
+# basic constants
+
+const RUBY_FIXNUM_MAX = typemax(Clong) >> 1
+const RUBY_FIXNUM_MIN = typemin(Clong) >> 1
+
+@static if sizeof(VALUE) >= sizeof(Cdouble)
+  const RUBY_USE_FLONUM = true
+else
+  const RUBY_USE_FLONUM = false
+  error("currently RbCall.jl only supports Ruby with flonum.")
+end
+
+@static if RUBY_USE_FLONUM
+  const RUBY_Qfalse = 0x00
+  const RUBY_Qtrue  = 0x14
+  const RUBY_Qnil   = 0x08
+  const RUBY_Qundef = 0x34
+  const RUBY_IMMEDIATE_MASK = 0x07
+  const RUBY_FIXNUM_FLAG    = 0x01
+  const RUBY_FLONUM_MASK    = 0x03
+  const RUBY_FLONUM_FLAG    = 0x02
+  const RUBY_SYMBOL_FLAG    = 0x0c
+else
+  const RUBY_Qfalse = 0
+  const RUBY_Qtrue  = 2
+  const RUBY_Qnil   = 4
+  const RUBY_Qundef = 6
+  const RUBY_IMMEDIATE_MASK = 0x03
+  const RUBY_FIXNUM_FLAG    = 0x01
+  const RUBY_FLONUM_MASK    = 0x00
+  const RUBY_FLONUM_FLAG    = 0x02
+  const RUBY_SYMBOL_FLAG    = 0x0e
+end
+const RUBY_SPECIAL_SHIFT  = 8
+
+#########################################################################
+# basic utilities
+
+RB_FIXNUM_P(v::VALUE) = (x & RUBY_FIXNUM_FLAG) != 0
+RB_POSFIXABLE(x::Integer) = x <= RUBY_FIXNUM_MAX
+RB_NEGFIXABLE(x::Integer) = x >= RUBY_FIXNUM_MIN
+RB_FIXABLE(x::Integer) = RB_POSFIXABLE(x) && RB_NEGFIXABLE(x)
+
+RB_INT2FIX(i::Integer) = (VALUE(i) << 1) | RUBY_FIXNUM_FLAG
+RB_LONG2FIX(i::Clong) = RB_INT2FIX(i)
+
+function RB_LONG2NUM(i::Clong)
+  if RB_FIXABLE(i)
+    return RB_LONG2FIX(i)
+  else
+    return ccall(:rb_int2big, VALUE, (Cintptr_t,), Cintptr_t(i))
+  end
+end
+
+function RB_ULONG2NUM(i::Culong)
+  if RB_POSFIXABLE(i)
+    return RB_LONG2FIX(Clong(i))
+  else
+    return ccall(:rb_uint2big, VALUE, (Cuintptr_t,), Cuintptr_t(i))
+  end
+end
+
+RB_LL2NUM(i::Clonglong) = ccall(:rb_ll2inum, VALUE, (Clonglong,), i)
+RB_ULL2NUM(i::Culonglong) = ccall(:rb_ull2inum, VALUE, (Culonglong,), i)
+
+DBL2NUM(d::Cdouble) = ccall(:rb_float_new, VALUE, (Cdouble,), d)
+
+HAVE_RB_DBL_COMPLEX_NEW = hassym(libruby_handle, :rb_dbl_complex_new)
+
+#########################################################################
+# conversion
+
+include("conversion.jl")
+
+#########################################################################
+# gc
+
+const gc_guard_references = Dict{Any,Clong}()
+
+function _refcnt(value::Any)
+  return get(gc_guard_references, value , 0)
+end
+
+function _incref(value::Any)
+  gc_guard_references[value] = _refcnt(value) + 1
+  return value
+end
+
+function _decref(value::Any)
+  if haskey(gc_guard_references, value)
+    new_count = _refcnt(value) - 1
+    if new_count == 0
+      delete!(gc_guard_references, value)
+    else
+      gc_guard_references[value] = new_count
+    end
+  end
+end
+
+#########################################################################
+
+end # module RbCall

data/RbCall.jl/src/conversion.jl

@@ -0,0 +1,56 @@
+convert(::Type{VALUE}, ::Nothing) = RUBY_Qnil
+
+convert(::Type{VALUE}, b::Bool) = b ? RUBY_Qtrue : RUBY_Qfalse
+
+convert(::Type{VALUE}, i::Int8) = RB_INT2FIX(Cint(i))
+convert(::Type{VALUE}, i::UInt8) = RB_INT2FIX(Cint(i))
+convert(::Type{VALUE}, i::Int16) = RB_INT2FIX(Cint(i))
+convert(::Type{VALUE}, i::UInt16) = RB_INT2FIX(Cint(i))
+convert(::Type{VALUE}, i::Int32) = RB_LONG2NUM(Clong(i))
+convert(::Type{VALUE}, i::UInt32) = RB_ULONG2NUM(Culong(i))
+
+if sizeof(Clong) == sizeof(Int64)
+  convert(::Type{VALUE}, i::Int64) = RB_LONG2NUM(Clong(i))
+  convert(::Type{VALUE}, i::UInt64) = RB_ULONG2NUM(Culong(i))
+else
+  convert(::Type{VALUE}, i::Int64) = RB_LL2NUM(Clonglong(i))
+  convert(::Type{VALUE}, i::UInt64) = RB_ULL2NUM(Culonglong(i))
+end
+
+if sizeof(Clonglong) == sizeof(Int128)
+  convert(::Type{VALUE}, i::Int128) = RB_LL2NUM(Clonglong(i))
+  convert(::Type{VALUE}, i::UInt128) = RB_ULL2NUM(Culonglong(i))
+end
+
+function convert(::Type{VALUE}, i::Integer)
+  # TODO convert to Bignum
+  return RUBY_Qnil
+end
+
+convert(::Type{VALUE}, d::Union{Float64,Float32}) = DBL2NUM(Cdouble(d))
+
+if HAVE_RB_DBL_COMPLEX_NEW
+  function convert(::Type{VALUE}, c::Union{ComplexF64,ComplexF32})
+    c64 = ComplexF64(c)
+    return ccall(:rb_dbl_complex_new, VALUE, (Cdouble, Cdouble), real(c64), imag(c64))
+  end
+else
+  function convert(::Type{VALUE}, c::Union{ComplexF64,ComplexF32})
+    c64 = ComplexF64(c)
+    return ccall(:rb_complex_new, VALUE, (VALUE, VALUE),
+                 convert(VALUE, real(c64)), convert(VALUE, imag(c64)))
+  end
+end
+
+function convert(::Type{VALUE}, s::AbstractString)
+  sb = String(s)
+  return ccall(:rb_utf8_str_new, VALUE, (Cstring, Clong), sb, sizeof(sb))
+end
+
+# TODO
+convert(::Type{VALUE}, ::Any) = RUBY_Qnil
+
+function convert_to_ruby(value::Any)
+  rbobj = convert(VALUE, value)
+  return rbobj
+end

data/ext/julia/julia.c

@@ -1,6 +1,27 @@
 #include "julia_internal.h"
 
-VALUE julia_mJulia;
+VALUE rbjl_mJulia;
+
+void
+rbjl_check_julia_exception(const char *message)
+{
+  jl_function_t *sprint;
+  jl_function_t *showerror;
+
+  jl_value_t *error = JULIA_API(jl_exception_occurred)();
+  if (!error) return;
+
+  JULIA_API(jl_exception_clear)();
+
+  sprint = (jl_function_t *)JULIA_API(jl_eval_string)("sprint");
+  showerror = (jl_function_t *)JULIA_API(jl_eval_string)("showerror");
+
+  jl_value_t *res = JULIA_API(jl_call2)(sprint, showerror, error);
+  if (res && jl_is_string(res)) {
+    const char * c_str = JULIA_API(jl_string_ptr)(res);
+    rb_raise(rb_eRuntimeError, "JuliaError: %s (%s)", c_str, message);
+  }
+}
 
 static void
 init_julia(void)
@@ -11,9 +32,12 @@ init_julia(void)
 void
 Init_julia(void)
 {
-  julia_mJulia = rb_define_module("Julia");
+  rbjl_mJulia = rb_define_module("Julia");
 
-  julia_init_libjulia();
+  rbjl_init_libjulia();
 
   init_julia();
+
+  rbjl_init_rbcall();
+  rbjl_init_value_ptr();
 }

data/ext/julia/julia_internal.h

@@ -21,9 +21,34 @@ extern "C" {
 # error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
 #endif
 
+/* from src/support/htable.h */
+
+#define HT_N_INLINE 32
+
+typedef struct {
+    size_t size;
+    void **table;
+    void *_space[HT_N_INLINE];
+} htable_t;
+
+/* from src/support/arraylist.h */
+
+#define AL_N_INLINE 29
+
+typedef struct {
+    size_t len;
+    size_t max;
+    void **items;
+    void *_space[AL_N_INLINE];
+} arraylist_t;
+
+/* from src/julia.h */
+
 typedef struct _jl_value_t jl_value_t;
 typedef struct _jl_taggedvalue_t jl_taggedvalue_t;
 
+typedef jl_value_t jl_function_t;
+
 typedef struct _jl_sym_t {
     JL_DATA_TYPE
     struct _jl_sym_t *left;
@@ -80,25 +105,55 @@ typedef struct _jl_datatype_t {
     void *ditype;
 } jl_datatype_t;
 
-struct julia_api_table {
+typedef struct {
+    uint64_t hi;
+    uint64_t lo;
+} jl_uuid_t;
+
+typedef struct _jl_module_t {
+    JL_DATA_TYPE
+    jl_sym_t *name;
+    struct _jl_module_t *parent;
+    htable_t bindings;
+    arraylist_t usings;  // modules with all bindings potentially imported
+    uint64_t build_id;
+    jl_uuid_t uuid;
+    size_t primary_world;
+    uint32_t counter;
+    int32_t nospecialize;  // global bit flags: initialization for new methods
+    uint8_t istopmod;
+} jl_module_t;
+
+struct rbjl_api_table {
   int (* jl_is_initialized)(void);
   void (* jl_init)(void);
   char const * (* jl_ver_string)(void);
-  jl_datatype_t *jl_bool_type;
-  jl_datatype_t *jl_char_type;
-  jl_datatype_t *jl_string_type;
-  jl_datatype_t *jl_int8_type;
-  jl_datatype_t *jl_uint8_type;
-  jl_datatype_t *jl_int16_type;
-  jl_datatype_t *jl_uint16_type;
-  jl_datatype_t *jl_int32_type;
-  jl_datatype_t *jl_uint32_type;
-  jl_datatype_t *jl_int64_type;
-  jl_datatype_t *jl_uint64_type;
-  jl_datatype_t *jl_float16_type;
-  jl_datatype_t *jl_float32_type;
-  jl_datatype_t *jl_float64_type;
+  jl_datatype_t **jl_bool_type;
+  jl_datatype_t **jl_char_type;
+  jl_datatype_t **jl_string_type;
+  jl_datatype_t **jl_int8_type;
+  jl_datatype_t **jl_uint8_type;
+  jl_datatype_t **jl_int16_type;
+  jl_datatype_t **jl_uint16_type;
+  jl_datatype_t **jl_int32_type;
+  jl_datatype_t **jl_uint32_type;
+  jl_datatype_t **jl_int64_type;
+  jl_datatype_t **jl_uint64_type;
+  jl_datatype_t **jl_float16_type;
+  jl_datatype_t **jl_float32_type;
+  jl_datatype_t **jl_float64_type;
+  jl_datatype_t **jl_module_type;
+
+  jl_module_t **jl_main_module;
+  jl_module_t **jl_base_module;
+
+  jl_value_t * (* jl_call1)(jl_function_t *f, jl_value_t *a);
+  jl_value_t * (* jl_call2)(jl_function_t *f, jl_value_t *a, jl_value_t *b);
+  jl_value_t * (* jl_exception_occurred)(void);
+  void (* jl_exception_clear)(void);
   jl_value_t * (* jl_eval_string)(const char *str);
+  jl_value_t * (* jl_get_global)(jl_module_t *m, jl_sym_t *var);
+  jl_sym_t * (* jl_symbol)(const char *str);
   jl_value_t * (* jl_typeof)(jl_value_t *v);
   const char * (* jl_typeof_str)(jl_value_t *v);
   const char * (* jl_string_ptr)(jl_value_t *s);
@@ -113,13 +168,70 @@ struct julia_api_table {
   uint64_t (* jl_unbox_uint64)(jl_value_t *v);
   float (* jl_unbox_float32)(jl_value_t *v);
   double (* jl_unbox_float64)(jl_value_t *v);
+  void * (* jl_unbox_voidpointer)(jl_value_t *v);
 };
 
-struct julia_api_table *julia_get_api_table(void);
-#define JULIA_API(name) (julia_get_api_table()->name)
+struct rbjl_api_table *rbjl_get_api_table(void);
+#define JULIA_API(name) (rbjl_get_api_table()->name)
+
+#define jl_typeis(v,t) (JULIA_API(jl_typeof)(v)==(jl_value_t*)(t))
+
+// basic predicates -----------------------------------------------------------
+#define jl_is_nothing(v)     (((jl_value_t*)(v)) == ((jl_value_t*)jl_nothing))
+#define jl_is_tuple(v)       (((jl_datatype_t*)JULIA_API(jl_typeof)(v))->name == *JULIA_API(jl_tuple_typename))
+#define jl_is_svec(v)        jl_typeis(v,*JULIA_API(jl_simplevector_type))
+#define jl_is_simplevector(v) jl_is_svec(v)
+#define jl_is_datatype(v)    jl_typeis(v,*JULIA_API(jl_datatype_type))
+#define jl_is_mutable(t)     (((jl_datatype_t*)t)->mutabl)
+#define jl_is_mutable_datatype(t) (jl_is_datatype(t) && (((jl_datatype_t*)t)->mutabl))
+#define jl_is_immutable(t)   (!((jl_datatype_t*)t)->mutabl)
+#define jl_is_immutable_datatype(t) (jl_is_datatype(t) && (!((jl_datatype_t*)t)->mutabl))
+#define jl_is_uniontype(v)   jl_typeis(v,*JULIA_API(jl_uniontype_type))
+#define jl_is_typevar(v)     jl_typeis(v,*JULIA_API(jl_tvar_type))
+#define jl_is_unionall(v)    jl_typeis(v,*JULIA_API(jl_unionall_type))
+#define jl_is_typename(v)    jl_typeis(v,*JULIA_API(jl_typename_type))
+#define jl_is_int8(v)        jl_typeis(v,*JULIA_API(jl_int8_type))
+#define jl_is_int16(v)       jl_typeis(v,*JULIA_API(jl_int16_type))
+#define jl_is_int32(v)       jl_typeis(v,*JULIA_API(jl_int32_type))
+#define jl_is_int64(v)       jl_typeis(v,*JULIA_API(jl_int64_type))
+#define jl_is_uint8(v)       jl_typeis(v,*JULIA_API(jl_uint8_type))
+#define jl_is_uint16(v)      jl_typeis(v,*JULIA_API(jl_uint16_type))
+#define jl_is_uint32(v)      jl_typeis(v,*JULIA_API(jl_uint32_type))
+#define jl_is_uint64(v)      jl_typeis(v,*JULIA_API(jl_uint64_type))
+#define jl_is_float32(v)      jl_typeis(v,*JULIA_API(jl_float32_type))
+#define jl_is_float64(v)      jl_typeis(v,*JULIA_API(jl_float64_type))
+#define jl_is_bool(v)        jl_typeis(v,*JULIA_API(jl_bool_type))
+#define jl_is_symbol(v)      jl_typeis(v,*JULIA_API(jl_sym_type))
+#define jl_is_method_instance(v) jl_typeis(v,*JULIA_API(jl_method_instance_type))
+#define jl_is_method(v)      jl_typeis(v,*JULIA_API(jl_method_type))
+#define jl_is_module(v)      jl_typeis(v,*JULIA_API(jl_module_type))
+#define jl_is_string(v)      jl_typeis(v,*JULIA_API(jl_string_type))
+/*#define jl_is_cpointer(v)    jl_is_cpointer_type(jl_typeof(v))*/
+/*#define jl_is_pointer(v)     jl_is_cpointer_type(jl_typeof(v))*/
+
+static inline jl_function_t *
+jl_get_function(jl_module_t *m, const char *name)
+{
+  return (jl_function_t*)JULIA_API(jl_get_global)(m, JULIA_API(jl_symbol)(name));
+}
+
+void rbjl_check_julia_exception(const char *message);
+
+void rbjl_init_libjulia(void);
+void rbjl_init_rbcall(void);
+void rbjl_init_value_ptr(void);
+
+VALUE rbjl_rbcall_convert_to_ruby(jl_value_t *value);
+void rbjl_rbcall_incref(jl_value_t *value);
+void rbjl_rbcall_decref(jl_value_t *value);
+long rbjl_rbcall_refcnt(jl_value_t *jlobj);
+
+VALUE rbjl_value_ptr_new(jl_value_t *value);
+
+extern VALUE rbjl_mJulia;
+extern VALUE rbjl_mLibJulia;
+extern VALUE rbjl_cJuliaValuePtr;
 
-void julia_init_libjulia(void);
+extern jl_module_t *rbjl_rbcall_module;
 
-extern VALUE julia_mJulia;
-extern VALUE julia_mLibJulia;
 #endif /* JULIA_INTERNAL_H */

data/ext/julia/libjulia.c

@@ -1,13 +1,11 @@
 #include "julia_internal.h"
 
-VALUE julia_mLibJulia;
-VALUE julia_eAPINotFound;
-struct julia_api_table api_table;
-jl_value_t *ans;
-int8_t ans_bool;
-
-struct julia_api_table *
-julia_get_api_table(void)
+VALUE rbjl_mLibJulia;
+VALUE rbjl_eAPINotFound;
+struct rbjl_api_table api_table;
+
+struct rbjl_api_table *
+rbjl_get_api_table(void)
 {
   return &api_table;
 }
@@ -44,7 +42,7 @@ init_api_table(VALUE handle)
 #define INIT_API_TABLE_ENTRY2(member_name, api_name) do { \
     void *fptr = LOOKUP_API_ENTRY(api_name); \
     if (!fptr) { \
-      rb_raise(julia_eAPINotFound, "Unable to find the required symbol in libjulia: %s", #api_name); \
+      rb_raise(rbjl_eAPINotFound, "Unable to find the required symbol in libjulia: %s", #api_name); \
     } \
     ((api_table).member_name) = fptr; \
   } while (0)
@@ -74,6 +72,17 @@ init_api_table(VALUE handle)
   INIT_API_TABLE_ENTRY(jl_float16_type);
   INIT_API_TABLE_ENTRY(jl_float32_type);
   INIT_API_TABLE_ENTRY(jl_float64_type);
+  INIT_API_TABLE_ENTRY(jl_module_type);
+
+  INIT_API_TABLE_ENTRY(jl_main_module);
+  INIT_API_TABLE_ENTRY(jl_base_module);
+
+  INIT_API_TABLE_ENTRY(jl_call1);
+  INIT_API_TABLE_ENTRY(jl_call2);
+  INIT_API_TABLE_ENTRY(jl_exception_occurred);
+  INIT_API_TABLE_ENTRY(jl_exception_clear);
+  INIT_API_TABLE_ENTRY(jl_get_global);
+  INIT_API_TABLE_ENTRY(jl_symbol);
   INIT_API_TABLE_ENTRY(jl_eval_string);
   INIT_API_TABLE_ENTRY(jl_typeof);
   INIT_API_TABLE_ENTRY(jl_typeof_str);
@@ -89,160 +98,37 @@ init_api_table(VALUE handle)
   INIT_API_TABLE_ENTRY(jl_unbox_uint64);
   INIT_API_TABLE_ENTRY(jl_unbox_float32);
   INIT_API_TABLE_ENTRY(jl_unbox_float64);
-}
-
-int
-jl_typeis(jl_value_t *v, jl_datatype_t *t){
-  return ((jl_typename_t *)JULIA_API(jl_typeof)(v) == t->name);
-}
-
-int
-jl_is_bool(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_bool_type));
-}
-
-int
-jl_is_char(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_char_type));
-}
-
-int
-jl_is_string(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_string_type));
-}
-
-int
-jl_is_int8(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_int8_type));
-}
-
-int
-jl_is_uint8(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_uint8_type));
-}
-
-int
-jl_is_int16(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_int16_type));
-}
-
-int
-jl_is_uint16(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_uint16_type));
-}
-
-int
-jl_is_int32(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_int32_type));
-}
-
-int
-jl_is_uint32(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_uint32_type));
-}
-
-int
-jl_is_int64(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_int64_type));
-}
-
-int
-jl_is_uint64(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_uint64_type));
-}
-
-int
-jl_is_float16(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_float16_type));
-}
-
-int
-jl_is_float32(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_float32_type));
-}
-
-int
-jl_is_float64(jl_value_t *v)
-{
-  return jl_typeis(v, JULIA_API(jl_float64_type));
+  INIT_API_TABLE_ENTRY(jl_unbox_voidpointer);
 }
 
 static VALUE
-jl_eval_string(VALUE handle, VALUE arg)
+jl_eval_string(VALUE handle, VALUE arg, VALUE raw_p)
 {
   Check_Type(arg, T_STRING);
-  ans = JULIA_API(jl_eval_string)(StringValuePtr(arg));
-  if (jl_is_string(ans)) {
-    return rb_str_new2(JULIA_API(jl_string_ptr)(ans));
-  }
-  if (jl_is_bool(ans)) {
-    ans_bool = JULIA_API(jl_unbox_bool)(ans);
-    if (ans_bool == 1){
-      return Qtrue;
-    }else{
-      return Qfalse;
-    }
-  }
-  if (jl_is_int8(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_int8)(ans));
- }
-  if (jl_is_uint8(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_uint8)(ans));
-  }
-  if (jl_is_int16(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_int16)(ans));
-  }
-  if (jl_is_uint16(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_uint16)(ans));
-  }
-  if (jl_is_int32(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_int32)(ans));
-  }
-  if (jl_is_uint32(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_uint32)(ans));
-  }
-  if (jl_is_int64(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_int64)(ans));
-  }
-  if (jl_is_uint64(ans)) {
-    return INT2NUM(JULIA_API(jl_unbox_uint64)(ans));
-  }
-  if (jl_is_float32(ans)) {
-    return DBL2NUM(JULIA_API(jl_unbox_float32)(ans));
-  }
-  if (jl_is_float64(ans)) {
-    return DBL2NUM(JULIA_API(jl_unbox_float64)(ans));
+  jl_value_t *ans = JULIA_API(jl_eval_string)(StringValuePtr(arg));
+  rbjl_check_julia_exception("LibJulia.eval_string");
+
+  if (RTEST(raw_p)) {
+    return rbjl_value_ptr_new(ans);
   }
-  return rb_str_new2(JULIA_API(jl_typeof_str)(ans));
+
+  return rbjl_rbcall_convert_to_ruby(ans);
 }
 
 static void
 define_JULIA_VERSION(void)
 {
   char const *version = JULIA_API(jl_ver_string)();
-  rb_define_const(julia_mLibJulia, "JULIA_VERSION", rb_usascii_str_new_static(version, strlen(version)));
+  rb_define_const(rbjl_mLibJulia, "JULIA_VERSION", rb_usascii_str_new_static(version, strlen(version)));
 }
 
 void
-julia_init_libjulia(void)
+rbjl_init_libjulia(void)
 {
   VALUE handle;
-  julia_mLibJulia = rb_const_get_at(julia_mJulia, rb_intern("LibJulia"));
-  handle = rb_funcall(julia_mLibJulia, rb_intern("handle"), 0);
-  rb_define_module_function(julia_mLibJulia, "jl_eval_string", jl_eval_string, 1);
+  rbjl_mLibJulia = rb_const_get_at(rbjl_mJulia, rb_intern("LibJulia"));
+  handle = rb_funcall(rbjl_mLibJulia, rb_intern("handle"), 0);
+  rb_define_module_function(rbjl_mLibJulia, "jl_eval_string", jl_eval_string, 2);
   init_api_table(handle);
 
   if (JULIA_API(jl_is_initialized)() == 0) {

data/ext/julia/rbcall.c

@@ -0,0 +1,66 @@
+#include "julia_internal.h"
+
+jl_module_t *rbjl_rbcall_module;
+
+static jl_function_t *convert_to_ruby_function;
+static jl_function_t *incref_function;
+static jl_function_t *decref_function;
+static jl_function_t *refcnt_function;
+
+VALUE
+rbjl_rbcall_convert_to_ruby(jl_value_t *jlobj)
+{
+  jl_value_t *ans = JULIA_API(jl_call1)(convert_to_ruby_function, jlobj);
+  rbjl_check_julia_exception("rbjl_rbcall_convert_to_ruby");
+  return (VALUE)JULIA_API(jl_unbox_voidpointer)(ans);
+}
+
+void
+rbjl_rbcall_incref(jl_value_t *jlobj)
+{
+  (void)JULIA_API(jl_call1)(incref_function, jlobj);
+}
+
+void
+rbjl_rbcall_decref(jl_value_t *jlobj)
+{
+  (void)JULIA_API(jl_call1)(decref_function, jlobj);
+}
+
+long
+rbjl_rbcall_refcnt(jl_value_t *jlobj)
+{
+  jl_value_t *res = JULIA_API(jl_call1)(refcnt_function, jlobj);
+  /* TODO: exception handling */
+  if (jl_is_int32(res)) {
+    return JULIA_API(jl_unbox_int32)(res);
+  }
+  else if (jl_is_int64(res)) {
+    return JULIA_API(jl_unbox_int64)(res);
+  }
+
+  return -1;
+}
+
+void
+rbjl_init_rbcall(void)
+{
+  VALUE rbcall_dir = rb_ivar_get(rbjl_mJulia, rb_intern("@rbcall_dir"));
+  StringValue(rbcall_dir);
+
+  VALUE include_rbcall = rb_sprintf("Base.include(Main, \"%"PRIsVALUE"/src/RbCall.jl\")", rbcall_dir);
+  const char *include_rbcall_cstr = StringValueCStr(include_rbcall);
+  (void)JULIA_API(jl_eval_string)(include_rbcall_cstr);
+  rbjl_check_julia_exception("include RbCall.jl");
+
+  jl_module_t *main_module = *JULIA_API(jl_main_module);
+  jl_value_t *rbcall_module = JULIA_API(jl_get_global)(main_module, JULIA_API(jl_symbol)("RbCall"));
+  if (!rbcall_module || !jl_is_module(rbcall_module)) {
+    rb_raise(rb_eRuntimeError, "RbCall is not a module");
+  }
+  rbjl_rbcall_module = (jl_module_t *)rbcall_module;
+  convert_to_ruby_function = jl_get_function(rbjl_rbcall_module, "convert_to_ruby");
+  incref_function = jl_get_function(rbjl_rbcall_module, "_incref");
+  decref_function = jl_get_function(rbjl_rbcall_module, "_decref");
+  refcnt_function = jl_get_function(rbjl_rbcall_module, "_refcnt");
+}

data/ext/julia/value_ptr.c

@@ -0,0 +1,49 @@
+#include "julia_internal.h"
+
+VALUE rbjl_cJuliaValuePtr;
+
+static void
+rbjl_value_ptr_free(void *ptr)
+{
+  jl_value_t *jlobj = ptr;
+  rbjl_rbcall_decref(jlobj);
+}
+
+static size_t
+rbjl_value_ptr_memsize(void const *ptr)
+{
+  /* FIXME */
+  return 0;
+}
+
+const rb_data_type_t rbjl_value_ptr_data_type = {
+  "Julia::ValuePtr",
+  { 0, rbjl_value_ptr_free, rbjl_value_ptr_memsize, },
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+  0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+#endif
+};
+
+VALUE
+rbjl_value_ptr_new(jl_value_t *jlobj)
+{
+  VALUE rbobj = TypedData_Wrap_Struct(rbjl_cJuliaValuePtr, &rbjl_value_ptr_data_type, jlobj);
+  rbjl_rbcall_incref(jlobj);
+  return rbobj;
+}
+
+static VALUE
+value_ptr_refcnt(VALUE self)
+{
+  jl_value_t *value;
+  TypedData_Get_Struct(self, jl_value_t, &rbjl_value_ptr_data_type, value);
+  long refcnt = rbjl_rbcall_refcnt(value);
+  return LONG2NUM(refcnt);
+}
+
+void
+rbjl_init_value_ptr(void)
+{
+  rbjl_cJuliaValuePtr = rb_define_class_under(rbjl_mJulia, "ValuePtr", rb_cData);
+  rb_define_method(rbjl_cJuliaValuePtr, "__refcnt__", value_ptr_refcnt, 0);
+}

data/julia.gemspec

@@ -5,9 +5,15 @@ require 'julia/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "julia"
-  spec.version       = Julia::VERSION
+  version_components = [
+    Julia::Version::MAJOR.to_s,
+    Julia::Version::MINOR.to_s,
+    Julia::Version::MICRO.to_s,
+    Julia::Version::TAG,
+  ]
+  spec.version       = version_components.compact.join(".")
   spec.authors       = ["Kenta Murata"]
-  spec.email         = ["mrkn@cookpad.com"]
+  spec.email         = ["mrkn@mrkn.jp"]
 
   spec.summary       = 'Julia on Ruby'
   spec.description   = 'Julia on Ruby'
@@ -21,11 +27,12 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/julia/extconf.rb"]
 
-  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "bundler", ">= 1.17.2"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "pry-byebug"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rake-compiler"
   spec.add_development_dependency "rspec"
 end

data/lib/julia.rb

@@ -5,8 +5,8 @@ module Julia
 
   module_function
 
-  def eval(str)
-    Julia.init unless LibJulia.respond_to? :jl_eval_string
-    LibJulia.jl_eval_string(str)
+  def eval(str, raw: false)
+    Julia.init unless defined? Julia::JULIA_VERSION
+    LibJulia.jl_eval_string(str, raw)
   end
 end

data/lib/julia/init.rb

@@ -1,34 +1,43 @@
 module Julia
   def self.const_missing(name)
     case name
-    when :JULIA_VERSION
-      Julia.init
-      const_get(name)
-    else
-      super
+    when :JULIA_VERSION, :ValuePtr
+      return const_get(name) if Julia.init
     end
+    super
+  end
+
+  def self.method_missing(*args)
+    return send(*args) if Julia.init
+    super
   end
 
   module LibJulia
     def self.const_missing(name)
       case name
       when :JULIA_VERSION
-        Julia.init
-        const_get(name)
-      else
-        super
+        return const_get(name) if Julia.init
       end
+      super
+    end
+
+    def self.method_missing(*args)
+      return send(*args) if Julia.init
+      super
     end
   end
 
+  def self.initialized?
+    @initialized
+  end
+
   def self.init(julia = ENV['JULIA'])
-    return false if LibJulia.instance_variable_defined? :@handle
-    class << Julia
-      remove_method :const_missing
-    end
-    class << Julia::LibJulia
-      remove_method :const_missing
-    end
+    return false if initialized?
+
+    require 'pathname'
+    top_dir = Pathname(__dir__).parent.parent
+    rbcall_dir = top_dir / "RbCall.jl"
+    Julia.instance_variable_set :@rbcall_dir, rbcall_dir.to_s
 
     LibJulia.instance_variable_set :@handle, LibJulia::Finder.find_libjulia(julia)
     class << LibJulia
@@ -44,6 +53,17 @@ module Julia
     end
 
     const_set(:JULIA_VERSION, LibJulia::JULIA_VERSION)
-    true
+
+    class << Julia
+      remove_method :const_missing
+      remove_method :method_missing
+    end
+
+    class << Julia::LibJulia
+      remove_method :const_missing
+      remove_method :method_missing
+    end
+
+    @initialized = true
   end
 end

data/lib/julia/version.rb

@@ -1,3 +1,9 @@
 module Julia
-  VERSION = "0.2.0"
+  VERSION = "0.3.0-dev"
+
+  module Version
+    numbers, TAG = VERSION.split("-")
+    MAJOR, MINOR, MICRO = numbers.split(".").map(&:to_i)
+    STRING = VERSION
+  end
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: julia
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0.dev
 platform: ruby
 authors:
 - Kenta Murata
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-29 00:00:00.000000000 Z
+date: 2019-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: 1.17.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.10'
+        version: 1.17.2
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -96,9 +96,10 @@ dependencies:
         version: '0'
 description: Julia on Ruby
 email:
-- mrkn@cookpad.com
+- mrkn@mrkn.jp
 executables: []
-extensions: []
+extensions:
+- ext/julia/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -108,6 +109,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- RbCall.jl/src/RbCall.jl
+- RbCall.jl/src/conversion.jl
 - bin/console
 - bin/setup
 - examples/pkg_status.rb
@@ -115,6 +118,8 @@ files:
 - ext/julia/julia.c
 - ext/julia/julia_internal.h
 - ext/julia/libjulia.c
+- ext/julia/rbcall.c
+- ext/julia/value_ptr.c
 - julia.gemspec
 - lib/julia.rb
 - lib/julia/error.rb
@@ -140,12 +145,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Julia on Ruby