extpp 0.0.9 → 0.1.0

data/ext/extpp/class.cpp

@@ -1,277 +0,0 @@
-#include "function.hpp"
-
-#include <string>
-#include <unordered_map>
-#include <vector>
-
-namespace rb {
-  using MethodTable = std::unordered_map<ID, Function *>;
-
-  struct MethodDefinition {
-    MethodDefinition(std::string name_, Function *function_) :
-      name(name_),
-      function(function_) {
-    }
-
-    std::string name;
-    Function *function;
-  };
-  using MethodDefinitions = std::vector<MethodDefinition>;
-}
-
-namespace {
-  VALUE MethodTable = Qnil;
-
-  void free_method_table(void *data) {
-    auto method_table = static_cast<rb::MethodTable *>(data);
-    delete method_table;
-  }
-
-  const rb_data_type_t MethodTableType = {
-    "MethodTable",
-    {nullptr, free_method_table, nullptr,},
-    nullptr,
-    nullptr,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-  };
-
-  rb::MethodTable *method_table_from_ruby(VALUE rb_method_table) {
-    rb::MethodTable *method_table;
-    TypedData_Get_Struct(rb_method_table,
-                         rb::MethodTable,
-                         &MethodTableType,
-                         method_table);
-    return method_table;
-  }
-
-  VALUE method_table_to_ruby(rb::MethodTable *method_table) {
-    if (NIL_P(MethodTable)) {
-      MethodTable = rb_define_class("MethodTable", rb_cData);
-    }
-    return TypedData_Wrap_Struct(MethodTable, &MethodTableType, method_table);
-  }
-
-  VALUE MethodDefinitions = Qnil;
-
-  void free_method_definitions(void *data) {
-    auto method_definitions = static_cast<rb::MethodDefinitions *>(data);
-    delete method_definitions;
-  }
-
-  const rb_data_type_t MethodDefinitionsType = {
-    "MethodDefinitions",
-    {nullptr, free_method_definitions, nullptr,},
-    nullptr,
-    nullptr,
-    RUBY_TYPED_FREE_IMMEDIATELY,
-  };
-
-  rb::MethodDefinitions *method_definitions_from_ruby(VALUE rb_definitions) {
-    rb::MethodDefinitions *definitions;
-    TypedData_Get_Struct(rb_definitions,
-                         rb::MethodDefinitions,
-                         &MethodDefinitionsType,
-                         definitions);
-    return definitions;
-  }
-
-  VALUE method_definitions_to_ruby(rb::MethodDefinitions *definitions) {
-    if (NIL_P(MethodDefinitions)) {
-      MethodDefinitions = rb_define_class("MethodDefinitions", rb_cData);
-    }
-    return TypedData_Wrap_Struct(MethodDefinitions,
-                                 &MethodDefinitionsType,
-                                 definitions);
-  }
-
-  VALUE call_func(int argc, VALUE *argv, VALUE self) {
-    auto rb_method_table =
-      rb_ivar_get(rb_obj_class(self), rb_intern("__method_table__"));
-    auto method_table = method_table_from_ruby(rb_method_table);
-    auto method_name_symbol = rb_funcall(self, rb_intern("__method__"), 0);
-    auto function = (*method_table)[rb_sym2id(method_name_symbol)];
-    return function->call(self, argc, argv);
-  }
-
-  bool flush_method_definitions(VALUE klass) {
-    ID id_method_definitions = rb_intern("__method_definitions__");
-    auto rb_definitions = rb_ivar_get(klass, id_method_definitions);
-    if (NIL_P(rb_definitions)) {
-      return false;
-    }
-
-    auto definitions = method_definitions_from_ruby(rb_definitions);
-    auto rb_method_table = rb_ivar_get(klass, rb_intern("__method_table__"));
-    auto method_table = method_table_from_ruby(rb_method_table);
-    for (const auto &definition : *definitions) {
-      ID name_id = rb_intern(definition.name.c_str());
-      (*method_table)[name_id] = definition.function;
-      rb_define_method(klass,
-                       definition.name.c_str(),
-                       reinterpret_cast<rb::RawMethod>(call_func),
-                       -1);
-    }
-    rb_ivar_set(klass, id_method_definitions, Qnil);
-    return true;
-  }
-
-  VALUE method_missing(int argc, VALUE *argv, VALUE self) {
-    auto klass = rb_obj_class(self);
-
-    if (flush_method_definitions(klass)) {
-      auto rb_method_table = rb_ivar_get(klass, rb_intern("__method_table__"));
-      auto method_table = method_table_from_ruby(rb_method_table);
-
-      VALUE rb_name_symbol;
-      VALUE rb_args;
-      rb_scan_args(argc, argv, "1*", &rb_name_symbol, &rb_args);
-      auto function = (*method_table)[rb_sym2id(rb_name_symbol)];
-      if (function) {
-        return function->call(self,
-                              static_cast<int>(RARRAY_LEN(rb_args)),
-                              RARRAY_PTR(rb_args));
-      }
-    }
-
-    return rb_call_super(argc, argv);
-  }
-
-  VALUE respond_to_missing_p(VALUE self,
-                             VALUE rb_name_symbol,
-                             VALUE rb_include_private) {
-    auto klass = rb_obj_class(self);
-
-    if (flush_method_definitions(klass)) {
-      auto rb_method_table = rb_ivar_get(klass, rb_intern("__method_table__"));
-      auto method_table = method_table_from_ruby(rb_method_table);
-
-      auto function = (*method_table)[rb_sym2id(rb_name_symbol)];
-      if (function) {
-        return Qtrue;
-      }
-    }
-
-    VALUE rb_args[] = {rb_name_symbol, rb_include_private};
-    return rb_call_super(2, rb_args);
-  }
-}
-
-namespace rb {
-  class Class::ClassImpl {
-  public:
-    ClassImpl(VALUE klass) :
-      class_(klass),
-      method_table_(new MethodTable()),
-      lazy_define_method_(false),
-      method_definitions_(nullptr) {
-      rb_iv_set(class_, "__method_table__", method_table_to_ruby(method_table_));
-      rb_iv_set(class_, "__method_definitions__", Qnil);
-    }
-
-    void enable_lazy_define_method() {
-      if (lazy_define_method_) {
-        return;
-      }
-
-      lazy_define_method_ = true;
-      method_definitions_ = new MethodDefinitions();
-      rb_iv_set(class_, "__method_definitions__",
-                method_definitions_to_ruby(method_definitions_));
-      rb_define_method(class_,
-                       "method_missing",
-                       reinterpret_cast<RawMethod>(method_missing),
-                       -1);
-      rb_define_method(class_,
-                       "respond_to_missing?",
-                       reinterpret_cast<RawMethod>(respond_to_missing_p),
-                       -1);
-    }
-
-    void define_method(const char *name, VALUE (*body)(VALUE self)) {
-      rb_define_method(class_,
-                       name,
-                       reinterpret_cast<RawMethod>(body),
-                       0);
-    }
-
-    void define_method(const char *name,
-                       VALUE (*body)(int argc, VALUE *argv, VALUE self)) {
-      rb_define_method(class_,
-                       name,
-                       reinterpret_cast<RawMethod>(body),
-                       -1);
-    }
-
-    void define_method(const char *name, Function *function) {
-      if (lazy_define_method_) {
-        method_definitions_->emplace_back(name, function);
-      } else {
-        ID name_id = rb_intern(name);
-        (*method_table_)[name_id] = function;
-        rb_define_method(class_,
-                         name,
-                         reinterpret_cast<RawMethod>(call_func),
-                         -1);
-      }
-    }
-
-  private:
-    VALUE class_;
-    MethodTable *method_table_;
-    bool lazy_define_method_;
-    MethodDefinitions *method_definitions_;
-  };
-
-  Class::Class(const char *name) :
-    Object(RTEST(rb_funcall(rb_cObject,
-                            rb_intern("const_defined?"),
-                            1,
-                            rb_str_new_static(name, strlen(name)))) ?
-           rb_funcall(rb_cObject,
-                      rb_intern("const_get"),
-                      1,
-                      rb_str_new_static(name, strlen(name))) :
-           rb_define_class(name, rb_cObject)),
-    impl_(new ClassImpl(this->to_ruby())) {
-  }
-
-  Class::Class(const char *name, VALUE parent) :
-    Object(rb_define_class(name, parent)),
-    impl_(new ClassImpl(this->to_ruby())) {
-  }
-
-  Class::Class(VALUE klass) :
-    Object(klass),
-    impl_(new ClassImpl(this->to_ruby())) {
-  }
-
-  Class::~Class() {
-    delete impl_;
-  }
-
-  Class &Class::define_method(const char *name,
-                              MethodWithoutArguments body) {
-    auto function = new FunctionWithoutArgument(body);
-    impl_->define_method(name, function);
-    return (Class &)*this;
-  }
-
-  Class &Class::define_method(const char *name,
-                              MethodWithArguments body) {
-    auto function = new FunctionWithArguments(body);
-    impl_->define_method(name, function);
-    return (Class &)*this;
-  }
-
-  Class &Class::define_method(const char *name,
-                              MethodWithArgumentsCompatible body) {
-    auto function = new FunctionWithArgumentsCompatible(body);
-    impl_->define_method(name, function);
-    return (Class &)*this;
-  }
-
-  Class &Class::enable_lazy_define_method() {
-    impl_->enable_lazy_define_method();
-    return (Class &)*this;
-  }
-}

data/ext/extpp/extconf.rb

@@ -1,110 +0,0 @@
-require_relative "../../lib/extpp/compiler"
-require_relative "../../lib/extpp/platform"
-
-cxxflags = RbConfig.expand("$(CXXFLAGS)")
-compiler = ExtPP::Compiler.new(cxxflags)
-compiler.check
-cxxflags = compiler.cxx_flags
-
-sources = Dir.chdir(__dir__) do
-  Dir.glob("*.cpp").collect do |cpp_source|
-    File.join(__dir__, cpp_source)
-  end
-end
-objects = sources.collect do |source|
-  source.gsub(/\.cpp\z/, ".o")
-end
-
-def collect_headers(dir)
-  Dir.chdir(dir) do
-    Dir.glob("**/*.hpp").collect do |header|
-      File.join(dir, header)
-    end
-  end
-end
-
-include_dir = File.expand_path(File.join(__dir__, "..", "..", "include"))
-public_headers = collect_headers(include_dir)
-private_headers = collect_headers(__dir__)
-headers = public_headers + private_headers
-
-platform = ExtPP::Platform.new
-case RUBY_PLATFORM
-when /darwin/
-  ldsharedxx = RbConfig::CONFIG["LDSHAREDXX"]
-  ldsharedxx = ldsharedxx.gsub(/ (?:-dynamic|-bundle)/, "") + " -shared"
-  ldsharedxx += " -install_name #{Dir.pwd.quote}/$(LIBRARY)"
-else
-  ldsharedxx = RbConfig::CONFIG["LDSHAREDXX"]
-end
-
-librubyarg_shared = RbConfig::CONFIG["LIBRUBYARG_SHARED"]
-if compiler.gcc? and !librubyarg_shared.include?("-L")
-  librubyarg_shared += " -L$(libdir)"
-end
-
-File.open("Makefile", "w") do |makefile|
-  makefile.puts(<<-MAKEFILE)
-LIBRARY = libruby-extpp.#{platform.dynamic_library_extension}
-
-SOURCES = #{sources.collect(&:quote).join(" ")}
-OBJECTS = #{objects.collect(&:quote).join(" ")}
-HEADERS = #{headers.collect(&:quote).join(" ")}
-
-INCLUDE_DIR = #{include_dir.quote}
-
-CXX = #{RbConfig.expand("$(CXX)")}
-
-RUBY = #{RbConfig.ruby.quote}
-RUBY_HEADER_DIR = #{RbConfig::CONFIG["rubyhdrdir"].quote}
-RUBY_ARCH_HEADER_DIR = #{RbConfig::CONFIG["rubyarchhdrdir"].quote}
-
-libdir = #{RbConfig::CONFIG["libdir"].quote}
-sitearchdir = #{RbConfig::CONFIG["sitearchdir"].quote}
-sitelibdir = #{RbConfig::CONFIG["sitelibdir"].quote}
-
-LIBRUBYARG_SHARED = #{librubyarg_shared}
-ARCH_FLAG = #{RbConfig::CONFIG["ARCH_FLAG"]}
-LDFLAGS = #{RbConfig::CONFIG["LDFLAGS"]}
-DLDFLAGS = #{RbConfig::CONFIG["DLDFLAGS"]}
-EXTDLDFLAGS = #{RbConfig::CONFIG["EXTDLDFLAGS"]}
-LDSHAREDXX = #{ldsharedxx}
-CCDLFLAGS = #{RbConfig::CONFIG["CCDLFLAGS"]}
-
-INCLUDEFLAGS = \
-	-I$(INCLUDE_DIR) \
-	-I$(RUBY_HEADER_DIR) \
-	-I$(RUBY_ARCH_HEADER_DIR)
-CPPFLAGS = #{RbConfig::CONFIG["CPPFLAGS"]} -DRB_EXTPP_COMPILATION
-CXXFLAGS = $(CCDLFLAGS) #{cxxflags}
-
-all: $(LIBRARY)
-
-clean:
-	rm -rf $(OBJECTS) $(LIBRARY)
-
-dist-clean:
-	$(MAKE) clean
-	rm -rf Makefile
-
-install: install-so
-
-install-so: $(LIBRARY)
-	"$(RUBY)" -run -e install -- $(LIBRARY) $(sitearchdir)
-
-$(LIBRARY): $(OBJECTS) Makefile
-	$(LDSHAREDXX) \\
-	  -o $@ \\
-	  $(OBJECTS) \\
-	  $(LDFLAGS) \\
-	  $(DLDFLAGS) \\
-	  $(EXTDLDFLAGS) \\
-	  $(ARCH_FLAG) \\
-	  $(LIBRUBYARG_SHARED)
-
-.cpp.o:
-	$(CXX) $(INCLUDEFLAGS) $(CPPFLAGS) $(CXXFLAGS) -o $@ -c $<
-
-$(OBJECTS): $(HEADERS)
-  MAKEFILE
-end

data/ext/extpp/function.cpp

@@ -1,28 +0,0 @@
-#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

@@ -1,48 +0,0 @@
-#include <ruby.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) {
-    auto 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,
-                                  static_cast<int>(n),
-                                  rb_args);
-    return Object(rb_result);
-  }
-
-  Object Object::send(ID name_id,
-                      std::initializer_list<VALUE> args,
-                      MethodWithoutArguments block) {
-    auto 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,
-                                    static_cast<int>(n),
-                                    rb_args,
-                                    reinterpret_cast<RawMethod>(call_block),
-                                    reinterpret_cast<VALUE>(block));
-    return Object(rb_result);
-  }
-}

data/ext/extpp/protect.cpp

@@ -1,12 +0,0 @@
-#include <ruby.hpp>
-
-namespace rb {
-  VALUE protect(RawCallback callback, VALUE callback_data) {
-    int state = 0;
-    auto result = rb_protect(callback, callback_data, &state);
-    if (state != 0) {
-      throw State(state);
-    }
-    return result;
-  }
-}

data/lib/extpp/platform.rb

@@ -1,8 +0,0 @@
-module ExtPP
-  class Platform
-    def dynamic_library_extension
-      RbConfig::CONFIG["SOEXT"]
-    end
-    alias_method :shared_library_extension, :dynamic_library_extension
-  end
-end