extpp 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f49c10b6867050e901d6a62c1603edf59a043a1bd00adaa0406ec617ad6433c1
-  data.tar.gz: 30b74d3f1d398329f5e46a8c26e37af6a136b894e7baacadc4a721d3a762fff5
+  metadata.gz: d99eab03d29814512bdae39c7be899d60794464e05b361f7cb6b612ba08d36b5
+  data.tar.gz: 73d755c8c3c52ddc2e2eb9474637735b1ed5f02a8b08fce1524522bcb3590bcc
 SHA512:
-  metadata.gz: 3a765bf63c05366b94f3002f3a29e03fd837db823af45205975f32d45ca0aaa1c536f5d278c22b4da61aa7b87e964966bcacb6d5c484dd52c14937af77553748
-  data.tar.gz: 4f36f5793d58b0e501f4b93ee5e35011d35c5cfb9d1abde899e746df1c959a2a4b6ca6872f79d85eccdd6a998c3c23ea36bfe258a64f65a4925643695587f0d7
+  metadata.gz: adbe4fc358aa20367f56703424366e5401c8c4c26af831b751e534fec5c853f64e0fb1a87fe68340a33ad1d50ce7808cf8d410e6cc5391f994403b57795a0702
+  data.tar.gz: 7fdc84981a093e94b5aeec3f1cbf58b9f986368e03f923f01ea9d6411f31d8c57f0e68dab1c054cc1a8315031a8596a586afd9064318b9ed406cb5e7b709a760

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (C) 2017 Kouhei Sutou. All rights reserved.
+Copyright (C) 2017-2021 Sutou Kouhei. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

data/README.md

@@ -96,6 +96,6 @@ Now, you can use this extension:
 
 ## License
 
-Copyright (C) 2017-2018 Kouhei Sutou
+Copyright (C) 2017-2021 Sutou Kouhei
 
 The 2-Clause BSD License. See [LICENSE.txt](LICENSE.txt) for details.

data/Rakefile

@@ -13,36 +13,9 @@ end
 
 helper.install
 
-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
-
-task :clean do
-  makefile = "ext/extpp/Makefile"
-  if File.exists?(makefile)
-    cd(File.dirname(makefile)) do
-      sh("make", "clean")
-    end
-  end
-end
-
 desc "Run tests"
 task :test do
   ruby("test/run-test.rb")
 end
 
-task default: ["configure:debug", :test]
+task default: :test

data/doc/text/news.md

@@ -1,5 +1,48 @@
 # News
 
+## 0.1.0 - 2021-10-03
+
+### Improvements
+
+  * Implemented as header only library.
+
+## 0.0.9 - 2020-11-03
+
+### Improvements
+
+  * Improved `clang++` version detection.
+    [GitHub#10][Patch by Alex Neill]
+
+  * Improved `g++` version detection.
+
+### Thanks
+
+  * Alex Neill
+
+## 0.0.8 - 2019-09-25
+
+### Improvements
+
+  * Changed to use `RbConfig::CONFIG["SOEXT"]`.
+    [Suggested by Nobuyoshi Nakada]
+
+  * Added `ExtpPP::Platform#shared_library_extension`.
+
+  * Added support for macOS Majave.
+    [GitHub#8][Patch by Josh Huckabee]
+
+### Thanks
+
+  * Nobuyoshi Nakada
+
+  * Josh Huckabee
+
+## 0.0.7 - 2019-03-21
+
+### Improvements
+
+  * Added support for Windows.
+
 ## 0.0.6 - 2019-02-25
 
 ### Improvements

data/include/ruby/cast.hpp

@@ -36,12 +36,12 @@ namespace rb {
 
   template <>
   inline int64_t cast<int64_t, Object>(const Object& rb_object) {
-    return NUM2LONG(rb_object);
+    return NUM2LL(rb_object);
   }
 
   template <>
   inline Object cast<Object, int64_t>(const int64_t& n) {
-    return Object(LONG2NUM(n));
+    return Object(LL2NUM(n));
   }
 
 
@@ -58,12 +58,12 @@ namespace rb {
 
   template <>
   inline uint64_t cast<uint64_t, Object>(const Object& rb_object) {
-    return NUM2ULONG(rb_object);
+    return NUM2ULL(rb_object);
   }
 
   template <>
   inline Object cast<Object, uint64_t>(const uint64_t& n) {
-    return Object(ULONG2NUM(n));
+    return Object(ULL2NUM(n));
   }
 
 

data/include/ruby/class.hpp

@@ -1,26 +1,203 @@
 #pragma once
 
+#include <ruby/function.hpp>
 #include <ruby/object.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 {
+    inline MethodTable *method_table_from_ruby(VALUE rb_method_table) {
+      return reinterpret_cast<MethodTable *>(NUM2ULL(rb_method_table));
+    }
+
+    inline VALUE method_table_to_ruby(MethodTable *method_table) {
+      return ULL2NUM(reinterpret_cast<uintptr_t>(method_table));
+    }
+
+    inline MethodDefinitions *
+    method_definitions_from_ruby(VALUE rb_definitions) {
+      return reinterpret_cast<MethodDefinitions *>(NUM2ULL(rb_definitions));
+    }
+
+    inline VALUE method_definitions_to_ruby(MethodDefinitions *definitions) {
+      return ULL2NUM(reinterpret_cast<uintptr_t>(definitions));
+    }
+
+    inline 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);
+    }
+
+    inline 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;
+    }
+
+    inline 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);
+    }
+
+    inline 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);
+    }
+  }
+
   class Class: public Object {
   public:
-    Class(const char *name);
-    Class(const char *name, VALUE parent);
-    Class(VALUE klass);
-    ~Class();
+    Class(const char *name) :
+      Class(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)) {
+    }
+
+    Class(const char *name, VALUE parent) :
+      Class(rb_define_class(name, parent)) {
+    }
+
+    Class(VALUE klass) :
+      Object(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);
+    }
+
+    inline Class &define_method(const char *name,
+                                MethodWithoutArguments body) {
+      auto function = new FunctionWithoutArgument(body);
+      return define_method(name, function);
+    }
+
+    inline Class &define_method(const char *name,
+                                MethodWithArguments body) {
+      auto function = new FunctionWithArguments(body);
+      return define_method(name, function);
+    }
+
+    inline Class &define_method(const char *name,
+                                MethodWithArgumentsCompatible body) {
+      auto function = new FunctionWithArgumentsCompatible(body);
+      return define_method(name, function);
+    }
+
+    inline Class &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);
+      }
+      return (Class &)*this;
+    }
 
-    Class &define_method(const char *name,
-                         MethodWithoutArguments body);
-    Class &define_method(const char *name,
-                         MethodWithArguments body);
-    Class &define_method(const char *name,
-                         MethodWithArgumentsCompatible body);
+    inline Class &enable_lazy_define_method() {
+      if (lazy_define_method_) {
+        return (Class &)*this;
+      }
 
-    Class &enable_lazy_define_method();
+      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);
+      return (Class &)*this;
+    }
 
   private:
-    class ClassImpl;
-    ClassImpl *impl_;
+    VALUE class_;
+    MethodTable *method_table_;
+    bool lazy_define_method_;
+    MethodDefinitions *method_definitions_;
   };
 }

data/{ext/extpp → include/ruby}/function.hpp

@@ -13,9 +13,13 @@ namespace rb {
 
   class FunctionWithoutArgument : public Function {
   public:
-    FunctionWithoutArgument(const MethodWithoutArguments &function);
+    FunctionWithoutArgument(const MethodWithoutArguments &function) :
+      function_(function) {
+    }
 
-    VALUE call(VALUE self, int argc, VALUE *argv) override;
+    inline VALUE call(VALUE self, int argc, VALUE *argv) override {
+      return function_(self);
+    }
 
   private:
     MethodWithoutArguments function_;
@@ -23,9 +27,13 @@ namespace rb {
 
   class FunctionWithArguments : public Function {
   public:
-    FunctionWithArguments(const MethodWithArguments &function);
+    FunctionWithArguments(const MethodWithArguments &function) :
+      function_(function) {
+    }
 
-    VALUE call(VALUE self, int argc, VALUE *argv) override;
+    inline VALUE call(VALUE self, int argc, VALUE *argv) override {
+      return function_(self, argc, argv);
+    }
 
   private:
     MethodWithArguments function_;
@@ -33,9 +41,14 @@ namespace rb {
 
   class FunctionWithArgumentsCompatible : public Function {
   public:
-    FunctionWithArgumentsCompatible(const MethodWithArgumentsCompatible &function);
-
-    VALUE call(VALUE self, int argc, VALUE *argv) override;
+    FunctionWithArgumentsCompatible(
+      const MethodWithArgumentsCompatible &function) :
+      function_(function) {
+    }
+
+    inline VALUE call(VALUE self, int argc, VALUE *argv) override {
+      return function_(argc, argv, self);
+    }
 
   private:
     MethodWithArgumentsCompatible function_;

data/include/ruby/object.hpp

@@ -56,7 +56,10 @@ namespace rb {
       rb_gc_register_address(&rb_object_);
     }
 
-    Object send(ID name_id);
+    inline Object send(ID name_id) {
+      VALUE rb_result = rb_funcall(rb_object_, name_id, 0);
+      return Object(rb_result);
+    }
 
     inline Object send(const char *name) {
       return send(rb_intern(name));
@@ -66,7 +69,19 @@ namespace rb {
       return send(rb_intern_str(name));
     }
 
-    Object send(ID name_id, std::initializer_list<VALUE> args);
+    inline 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);
+    }
 
     inline Object send(const char *name, std::initializer_list<VALUE> args) {
       return send(rb_intern(name), args);
@@ -76,9 +91,33 @@ namespace rb {
       return send(rb_intern_str(name), args);
     }
 
-    Object send(ID name_id,
-                std::initializer_list<VALUE> args,
-                MethodWithoutArguments block);
+    inline 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;
+      }
+      auto call_block = [](RB_BLOCK_CALL_FUNC_ARGLIST(rb_data, rb_block)) {
+        auto block = reinterpret_cast<rb::MethodWithoutArguments>(rb_block);
+        return block(rb_data);
+      };
+#ifdef RUBY_BACKWARD_CXXANYARGS_HPP
+#  define CAST_CALLER(caller) caller
+#else
+#  define CAST_CALLER(caller) reinterpret_cast<RawMethod>(+caller)
+#endif
+      auto rb_result = rb_block_call(rb_object_,
+                                     name_id,
+                                     static_cast<int>(n),
+                                     rb_args,
+                                     CAST_CALLER(call_block),
+                                     reinterpret_cast<VALUE>(block));
+#undef CAST_CALLER
+      return Object(rb_result);
+    }
 
     inline Object send(const char *name,
                        std::initializer_list<VALUE> args,

data/include/ruby/protect.hpp

@@ -17,15 +17,22 @@ namespace rb {
     int state_;
   };
 
-  VALUE protect(RawCallback callback, VALUE callback_data);
+  inline 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;
+  }
 
-  template <typename CALLBACK>
-  VALUE protect(const CALLBACK& callback) {
+  template <typename NoArgumentCallback>
+  VALUE protect(const NoArgumentCallback& callback) {
     struct Data {
-      Data(const CALLBACK& callback) :
+      Data(const NoArgumentCallback& callback) :
         callback_(callback) {
       }
-      const CALLBACK& callback_;
+      const NoArgumentCallback& callback_;
     } data(callback);
     auto callback_data = reinterpret_cast<VALUE>(&data);
     return protect([](VALUE callback_data) -> VALUE {

data/lib/extpp/compiler.rb

@@ -60,23 +60,16 @@ module ExtPP
         std = nil
 
         case `#{RbConfig.expand("$(CXX) --version")}`
-        when /\Ag\+\+ .+ (\d\.\d)\.\d/
+        when /g\+\+.+ (\d+\.\d+)\.\d/
           version = Float($1)
           if version < 5.1
             std = "gnu++11"
           elsif version < 6.1
             std = "gnu++14"
-          end
-        when /\A.+ clang version (\d\.\d)\.\d/
-          version = Float($1)
-          if version < 3.5
-            std = "gnu++11"
-          elsif version < 5
-            std = "gnu++14"
           else
             std = "gnu++17"
           end
-        when /\AApple LLVM version (\d+\.\d+)\.\d/
+        when /\AApple (?:LLVM|clang) version (\d+\.\d+)\.\d/
           version = Float($1)
           # TODO: Is it right?
           if version < 9.0
@@ -87,6 +80,15 @@ module ExtPP
             std = "gnu++17"
           end
           cxx_flags = "-Wno-deprecated-register"
+        when /clang version (\d+\.\d+)\.\d/
+          version = Float($1)
+          if version < 3.5
+            std = "gnu++11"
+          elsif version < 5
+            std = "gnu++14"
+          else
+            std = "gnu++17"
+          end
         end
 
         if std
@@ -135,7 +137,12 @@ module ExtPP
           flags << warning_flag
         end
       end
-      @cxx_flags = Shellwords.join(flags)
+      case RUBY_PLATFORM
+      when /windows/, /mingw/
+        @cxx_flags = flags.join(" ")
+      else
+        @cxx_flags = Shellwords.join(flags)
+      end
     end
   end
 end

data/lib/extpp/version.rb

@@ -1,3 +1,3 @@
 module ExtPP
-  VERSION = "0.0.6"
+  VERSION = "0.1.0"
 end

data/lib/extpp.rb

@@ -1,5 +1,4 @@
 require "extpp/compiler"
-require "extpp/platform"
 
 compiler = ExtPP::Compiler.new(RbConfig.expand($CXXFLAGS))
 compiler.check
@@ -26,14 +25,3 @@ $(OBJS): $(extpp_headers)
   end
 end
 extend(header_files_dependency_injector)
-
-platform = ExtPP::Platform.new
-
-[
-  File.join(__dir__, "..", "ext", "extpp"),
-  __dir__,
-].each do |candidate_dir|
-  so_name = "libruby-extpp.#{platform.dynamic_library_extension}"
-  lib_path = File.expand_path(File.join(candidate_dir, so_name))
-  $LIBS += " #{lib_path.quote}" if File.exist?(lib_path)
-end

data/sample/hello/Rakefile

@@ -1,4 +1,9 @@
-task :default => :build
+task :default => :run
+
+desc "Run"
+task :run => :build do
+  ruby("hello.rb")
+end
 
 desc "Build"
 task :build => "hello.so"