extpp 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a6f11af116da3bf20bffbb10008e43f8f03e41f
+  data.tar.gz: adf0040c8f4c3e15aa60093b96a774530f9a09d2
+SHA512:
+  metadata.gz: '0927493217502f10fc9f96a54ff1970a992ad4eec539c2ce8f5c03a35c22f917f20183c76ee3557ac245c9e033afc5289976a275267299abcb24983048473e94'
+  data.tar.gz: c1b5f0e6710d8abcc2a97a5912176b9536fcd7652870d636b443949f408bbf14dd58711feb174630a84337379868190a6f820efd0e37c2bec26ed481dce2e392

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 2017 Kouhei Sutou. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,29 @@
+# README
+
+## Name
+
+Ext++
+
+## Description
+
+Ext++ is a Ruby extension that provides C++ API for writing Ruby extension.
+
+You can write your Ruby extension easier than Ruby's C API. Because
+Ext++'s C++ API reduces duplicated code needed for Ruby's C API.
+
+You can use all Ruby's C API without any adapter layer. Because you
+can use C API directory from C++.
+
+## Install
+
+TODO
+
+## How to use
+
+TODO
+
+## License
+
+Copyright (C) 2017 Kouhei Sutou
+
+The 2-Clause BSD License. See [LICENSE.txt](LICENSE.txt) for details.

data/Rakefile

@@ -0,0 +1,48 @@
+# -*- ruby -*-
+
+require "rubygems"
+require "bundler/gem_helper"
+require "packnga"
+
+base_dir = File.join(File.dirname(__FILE__))
+
+helper = Bundler::GemHelper.new(base_dir)
+def helper.version_tag
+  version
+end
+
+helper.install
+spec = helper.gemspec
+
+Packnga::DocumentTask.new(spec) do |task|
+  task.original_language = "en"
+  task.translate_language = "ja"
+end
+
+Packnga::ReleaseTask.new(spec) do
+end
+
+def run_extconf(*arguments)
+  cd("ext/extpp") do
+    ruby("extconf.rb", *arguments)
+  end
+end
+
+desc "Configure"
+task :configure do
+  run_extconf
+end
+
+namespace :configure do
+  desc "Configure for debug"
+  task :debug do
+    run_extconf("--enable-debug-build")
+  end
+end
+
+desc "Run tests"
+task :test do
+  ruby("test/run-test.rb")
+end
+
+task default: ["configure:debug", :test]

data/doc/text/news.md

@@ -0,0 +1,5 @@
+# News
+
+## 0.0.1 - 2018-02-16
+
+The first release!!!

data/ext/extpp/class.cpp

@@ -0,0 +1,261 @@
+#include "function.hpp"
+
+#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::MethodFunc>(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, 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<MethodFunc>(method_missing),
+                       -1);
+      rb_define_method(class_,
+                       "respond_to_missing?",
+                       reinterpret_cast<MethodFunc>(respond_to_missing_p),
+                       -1);
+    }
+
+    void define_method(const char *name, VALUE (*body)(VALUE self)) {
+      rb_define_method(class_,
+                       name,
+                       reinterpret_cast<MethodFunc>(body),
+                       0);
+    }
+
+    void define_method(const char *name,
+                       VALUE (*body)(int argc, VALUE *argv, VALUE self)) {
+      rb_define_method(class_,
+                       name,
+                       reinterpret_cast<MethodFunc>(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<MethodFunc>(call_func),
+                         -1);
+      }
+    }
+
+  private:
+    VALUE class_;
+    MethodTable *method_table_;
+    bool lazy_define_method_;
+    MethodDefinitions *method_definitions_;
+  };
+
+  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

@@ -0,0 +1,75 @@
+require_relative "../../lib/extpp/compiler"
+
+cxxflags = RbConfig::CONFIG["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
+
+File.open("Makefile", "w") do |makefile|
+  makefile.puts(<<-MAKEFILE)
+LIBRARY = libruby-extpp.#{RbConfig::CONFIG["DLEXT"]}
+
+SOURCES = #{sources.collect(&:quote).join(" ")}
+OBJECTS = #{objects.collect(&:quote).join(" ")}
+HEADERS = #{headers.collect(&:quote).join(" ")}
+
+INCLUDE_DIR = #{include_dir.quote}
+
+CXX = #{RbConfig::CONFIG["CXX"].quote}
+
+RUBY = #{RbConfig.ruby.quote}
+RUBY_HEADER_DIR = #{RbConfig::CONFIG["rubyhdrdir"].quote}
+RUBY_ARCH_HEADER_DIR = #{RbConfig::CONFIG["rubyarchhdrdir"].quote}
+LDSHAREDXX = #{RbConfig::CONFIG["LDSHAREDXX"]}
+CCDLFLAGS = #{RbConfig::CONFIG["CCDLFLAGS"]}
+
+INCLUDEFLAGS = \
+	-I$(INCLUDE_DIR) \
+	-I$(RUBY_HEADER_DIR) \
+	-I$(RUBY_ARCH_HEADER_DIR)
+CPPFLAGS = #{RbConfig::CONFIG["CPPFLAGS"]}
+CXXFLAGS = $(CCDLFLAGS) #{cxxflags}
+
+all: $(LIBRARY)
+
+clean:
+	rm -rf $(OBJECTS) $(LIBRARY)
+
+dist-clean:
+	$(MAKE) clean
+	rm -rf Makefile
+
+install: $(LIBRARY)
+	"$(RUBY)" -run -e install -- $(LIBRARY) $(DESTDIR)/tmp/local/lib/
+
+$(LIBRARY): $(OBJECTS)
+	$(LDSHAREDXX) -o $@ $^
+
+.cpp.o:
+	$(CXX) $(INCLUDEFLAGS) $(CPPFLAGS) $(CXXFLAGS) -o $@ -c $<
+
+$(OBJECTS): $(HEADERS)
+  MAKEFILE
+end