extpp 0.0.1

data/ext/extpp/function.cpp

@@ -0,0 +1,28 @@
+#include "function.hpp"
+
+namespace rb {
+  FunctionWithoutArgument::FunctionWithoutArgument(const MethodWithoutArguments &function) :
+    function_(function) {
+  }
+
+  VALUE FunctionWithoutArgument::call(VALUE self, int argc, VALUE *argv) {
+    return function_(self);
+  };
+
+
+  FunctionWithArguments::FunctionWithArguments(const MethodWithArguments &function) :
+    function_(function) {
+  }
+
+  VALUE FunctionWithArguments::call(VALUE self, int argc, VALUE *argv) {
+    return function_(self, argc, argv);
+  };
+
+  FunctionWithArgumentsCompatible::FunctionWithArgumentsCompatible(const MethodWithArgumentsCompatible &function) :
+    function_(function) {
+  }
+
+  VALUE FunctionWithArgumentsCompatible::call(VALUE self, int argc, VALUE *argv) {
+    return function_(argc, argv, self);
+  };
+}

data/ext/extpp/object.cpp

@@ -0,0 +1,45 @@
+#include <ruby/object.hpp>
+
+namespace {
+  VALUE call_block(RB_BLOCK_CALL_FUNC_ARGLIST(rb_data, rb_block)) {
+    auto block = reinterpret_cast<rb::MethodWithoutArguments>(rb_block);
+    return block(rb_data);
+  }
+}
+
+namespace rb {
+  Object Object::send(ID name_id) {
+    VALUE rb_result = rb_funcall(rb_object_, name_id, 0);
+    return Object(rb_result);
+  }
+
+  Object Object::send(ID name_id,
+                      std::initializer_list<VALUE> args) {
+    size_t n = args.size();
+    VALUE rb_args[n];
+    int i = 0;
+    for (auto arg : args) {
+      rb_args[i++] = arg;
+    }
+    VALUE rb_result = rb_funcallv(rb_object_, name_id, n, rb_args);
+    return Object(rb_result);
+  }
+
+  Object Object::send(ID name_id,
+                      std::initializer_list<VALUE> args,
+                      MethodWithoutArguments block) {
+    size_t n = args.size();
+    VALUE rb_args[n];
+    int i = 0;
+    for (auto arg : args) {
+      rb_args[i++] = arg;
+    }
+    VALUE rb_result = rb_block_call(rb_object_,
+                                    name_id,
+                                    n,
+                                    rb_args,
+                                    reinterpret_cast<MethodFunc>(call_block),
+                                    reinterpret_cast<VALUE>(block));
+    return Object(rb_result);
+  }
+}

data/include/ruby.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <ruby.h>
+
+#define RB_BEGIN_DECLS extern "C" {
+#define RB_END_DECLS }
+
+#include <ruby/cast.hpp>
+#include <ruby/class.hpp>
+#include <ruby/object.hpp>

data/include/ruby/cast.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <ruby/object.hpp>
+
+namespace rb {
+  template <typename RETURN_TYPE, typename ARGUMENT_TYPE>
+  inline RETURN_TYPE cast(ARGUMENT_TYPE object);
+
+  template <typename RETURN_TYPE,
+            typename ARGUMENT_TYPE,
+            typename ADDTIONAL_DATA_TYPE1>
+  inline RETURN_TYPE cast(ARGUMENT_TYPE object,
+                          ADDTIONAL_DATA_TYPE1 data1);
+
+  template <>
+  inline int32_t cast<int32_t, Object>(Object rb_object) {
+    return NUM2INT(rb_object);
+  }
+
+  template <>
+  inline Object cast<Object, int32_t>(int32_t n) {
+    return Object(INT2NUM(n));
+  }
+
+
+  template <>
+  inline int64_t cast<int64_t, Object>(Object rb_object) {
+    return NUM2LONG(rb_object);
+  }
+
+  template <>
+  inline Object cast<Object, int64_t>(int64_t n) {
+    return Object(LONG2NUM(n));
+  }
+
+
+  template <>
+  inline uint32_t cast<uint32_t, Object>(Object rb_object) {
+    return NUM2UINT(rb_object);
+  }
+
+  template <>
+  inline Object cast<Object, uint32_t>(uint32_t n) {
+    return Object(UINT2NUM(n));
+  }
+
+
+  template <>
+  inline uint64_t cast<uint64_t, Object>(Object rb_object) {
+    return NUM2ULONG(rb_object);
+  }
+
+  template <>
+  inline Object cast<Object, uint64_t>(uint64_t n) {
+    return Object(ULONG2NUM(n));
+  }
+
+
+  template <>
+  inline const char *cast<const char *, Object>(Object rb_object) {
+    VALUE rb_object_raw = rb_object;
+    return StringValueCStr(rb_object_raw);
+  }
+
+  template <>
+  inline Object cast<Object, const char *>(const char *c_string) {
+    return Object(rb_str_new_cstr(c_string));
+  }
+
+  template <>
+  inline Object cast<Object, const char *, long>(const char *data, long size) {
+    return Object(rb_str_new(data, size));
+  }
+}

data/include/ruby/class.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <ruby/object.hpp>
+
+namespace rb {
+  class Class: public Object {
+  public:
+    Class(const char *name, VALUE parent=rb_cObject);
+    Class(VALUE klass);
+    ~Class();
+
+    Class &define_method(const char *name,
+                         MethodWithoutArguments body);
+    Class &define_method(const char *name,
+                         MethodWithArguments body);
+    Class &define_method(const char *name,
+                         MethodWithArgumentsCompatible body);
+
+    Class &enable_lazy_define_method();
+
+  private:
+    class ClassImpl;
+    ClassImpl *impl_;
+  };
+}

data/include/ruby/object.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <ruby/type.hpp>
+
+#include <initializer_list>
+
+namespace rb {
+  class Object {
+  public:
+    explicit Object(VALUE rb_object=Qnil) :
+      rb_object_(rb_object),
+      is_gc_guarding_(false) {
+    }
+
+    explicit Object(const char *name) :
+      rb_object_(rb_const_get(rb_cObject, rb_intern(name))),
+      is_gc_guarding_(false) {
+    }
+
+    Object(Object const &object) :
+      rb_object_(object),
+      is_gc_guarding_(false) {
+    }
+
+    virtual ~Object() {
+      if (is_gc_guarding_) {
+        rb_gc_unregister_address(&rb_object_);
+      }
+    }
+
+    inline explicit operator bool() const {
+      return RTEST(rb_object_);
+    }
+
+    inline VALUE to_ruby() const {
+      return rb_object_;
+    }
+
+    inline operator VALUE() const {
+      return rb_object_;
+    }
+
+    inline bool is_nil() const {
+      return NIL_P(rb_object_);
+    }
+
+    inline void guard_from_gc() {
+      if (!is_gc_guarding_) {
+        return;
+      }
+
+      is_gc_guarding_ = true;
+      rb_gc_register_address(&rb_object_);
+    }
+
+    Object send(ID name_id);
+
+    inline Object send(const char *name) {
+      return send(rb_intern(name));
+    }
+
+    inline Object send(Object name) {
+      return send(rb_intern_str(name));
+    }
+
+    Object send(ID name_id, std::initializer_list<VALUE> args);
+
+    inline Object send(const char *name, std::initializer_list<VALUE> args) {
+      return send(rb_intern(name), args);
+    }
+
+    inline Object send(Object name, std::initializer_list<VALUE> args) {
+      return send(rb_intern_str(name), args);
+    }
+
+    Object send(ID name_id,
+                std::initializer_list<VALUE> args,
+                MethodWithoutArguments block);
+
+    inline Object send(const char *name,
+                       std::initializer_list<VALUE> args,
+                       MethodWithoutArguments block) {
+      return send(rb_intern(name), args, block);
+    }
+
+    inline Object send(Object name,
+                       std::initializer_list<VALUE> args,
+                       MethodWithoutArguments block) {
+      return send(rb_intern_str(name), args, block);
+    }
+
+  private:
+    VALUE rb_object_;
+    bool is_gc_guarding_;
+  };
+}

data/include/ruby/type.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <ruby.h>
+
+namespace rb {
+  using MethodFunc = VALUE (*)(ANYARGS);
+
+  using MethodWithoutArguments = VALUE (*)(VALUE self);
+  using MethodWithArguments = VALUE (*)(VALUE self, int argc, VALUE *argv);
+  using MethodWithArgumentsCompatible =
+    VALUE (*)(int argc, VALUE *argv, VALUE self);
+}

data/lib/extpp.rb

@@ -0,0 +1,36 @@
+require "extpp/compiler"
+
+compiler = Extpp::Compiler.new($CXXFLAGS)
+compiler.check
+$CXXFLAGS = compiler.cxx_flags
+
+include_path = File.expand_path(File.join(__dir__, "..", "include"))
+$INCFLAGS += " -I#{include_path.quote}"
+
+header_files = Dir.chdir(include_path) do
+  Dir.glob("**/*.*").collect do |path|
+    File.join(include_path, path)
+  end
+end
+header_files_dependency_injector = Module.new do
+  define_method(:create_makefile) do |*args, &block|
+    super(*args, &block)
+    File.open("Makefile", "ab") do |makefile|
+      makefile.print <<-MAKEFILE
+
+extpp_headers = #{header_files.join(" ")}
+$(OBJS): $(extpp_headers)
+      MAKEFILE
+    end
+  end
+end
+extend(header_files_dependency_injector)
+
+[
+  File.join(__dir__, "..", "ext", "extpp"),
+  __dir__,
+].each do |candidate_dir|
+  so_name = "libruby-extpp.#{RbConfig::CONFIG["DLEXT"]}"
+  lib_path = File.expand_path(File.join(candidate_dir, so_name))
+  $LIBS += " #{lib_path.quote}" if File.exist?(lib_path)
+end

data/lib/extpp/compiler.rb

@@ -0,0 +1,69 @@
+require "mkmf"
+
+module Extpp
+  class Compiler
+    attr_reader :cxx_flags
+    def initialize(cxx_flags)
+      @cxx_flags = cxx_flags
+    end
+
+    def gcc?
+      RbConfig::CONFIG["GCC"] == "yes"
+    end
+
+    def check
+      check_debug_build
+      check_version
+    end
+
+    private
+    def check_debug_build
+      checking_for(checking_message("--enable-debug-build option")) do
+        enable_debug_build = enable_config("debug-build", false)
+        if enable_debug_build
+          @cxx_flags = disable_optimization_build_flag(@cxx_flags)
+          @cxx_flags = enable_debug_build_flag(@cxx_flags)
+        end
+        enable_debug_build
+      end
+    end
+
+    def check_version
+      return unless gcc?
+      checking_for(checking_message("g++ version"), "%g%s") do
+        version = nil
+        std = nil
+        if /\Ag\+\+ .+ (\d\.\d)\.\d/ =~ `#{RbConfig.expand("$(CXX) --version")}`
+          version = Float($1)
+          if version < 5.1
+            std = "gnu++11"
+          elsif version < 6.1
+            std = "gnu++14"
+          end
+        end
+        if std
+          @cxx_flags += " -std=#{std}"
+          [version, " (#{std})"]
+        else
+          [version, ""]
+        end
+      end
+    end
+
+    def disable_optimization_build_flag(flags)
+      if gcc?
+        flags.gsub(/(^|\s)-O\d(\s|$)/, '\\1-O0\\2')
+      else
+        flags
+      end
+    end
+
+    def enable_debug_build_flag(flags)
+      if gcc?
+        flags.gsub(/(^|\s)(?:-g|-g\d|-ggdb\d?)(\s|$)/, '\\1-g3\\2')
+      else
+        flags
+      end
+    end
+  end
+end

data/lib/extpp/version.rb

@@ -0,0 +1,3 @@
+module ExtPP
+  VERSION = "0.0.1"
+end

data/test/fixtures/cast/cast.cpp

@@ -0,0 +1,32 @@
+#include <ruby.hpp>
+
+extern "C" void
+Init_cast(void)
+{
+  rb::Class("Caster").
+    define_method("cast_int32", [](VALUE self, int argc, VALUE *argv) -> VALUE {
+        VALUE rb_n;
+        rb_scan_args(argc, argv, "1", &rb_n);
+        return rb::cast<rb::Object>(rb::cast<int32_t>(rb::Object(rb_n)));
+      }).
+    define_method("cast_int64", [](VALUE self, int argc, VALUE *argv) -> VALUE {
+        VALUE rb_n;
+        rb_scan_args(argc, argv, "1", &rb_n);
+        return rb::cast<rb::Object>(rb::cast<int64_t>(rb::Object(rb_n)));
+      }).
+    define_method("cast_uint32", [](VALUE self, int argc, VALUE *argv) -> VALUE {
+        VALUE rb_n;
+        rb_scan_args(argc, argv, "1", &rb_n);
+        return rb::cast<rb::Object>(rb::cast<uint32_t>(rb::Object(rb_n)));
+      }).
+    define_method("cast_uint64", [](VALUE self, int argc, VALUE *argv) -> VALUE {
+        VALUE rb_n;
+        rb_scan_args(argc, argv, "1", &rb_n);
+        return rb::cast<rb::Object>(rb::cast<uint64_t>(rb::Object(rb_n)));
+      }).
+    define_method("cast_string", [](VALUE self, int argc, VALUE *argv) -> VALUE {
+        VALUE rb_string;
+        rb_scan_args(argc, argv, "1", &rb_string);
+        return rb::cast<rb::Object>(rb::cast<const char *>(rb::Object(rb_string)));
+      });
+}

data/test/fixtures/cast/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+require "extpp"
+
+create_makefile("cast")