extpp 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ab73bb785e133a943037b1ceb34ca052b50cc6b6
-  data.tar.gz: 2d6eb1206d3e5d919d8cab0200515655b4cde36b
+SHA256:
+  metadata.gz: 1c37906ea8ea871e171e387ce61d68bc162cdc7d45aa94c85e9a080c1565b4a1
+  data.tar.gz: c1f54dea942fa0329b8e275bdb296e880d1b1731ec16eff59ef663509bad2fbc
 SHA512:
-  metadata.gz: 98487232c1998b95667dc561545f37f29684c6ba778470eeafd3be3e0ef3db29701111d8d843172814d7ab29d937d1c743ce234e239ca7f9c67d8ceee94b326d
-  data.tar.gz: 84bac288d828db338c208da99a4fe2c023409adfdb736518f8ed411a9605237d5efcb6804e68673dd814f770140f945bea0bf09d94cab68ac70db4221977e4bb
+  metadata.gz: 0dd33cc753814d03f1d2f1177a4ff74138a1c52808ee4bccfd3f4d8c52f8667e35f310d7d9afd3b64c3f0233d6549e2e0977b80a8d6947f3297f4188b4c5f089
+  data.tar.gz: 92f0058fb4af4f2da3702a0af37a4afb3095cb7fc3e5891b7500e29458a3fe21f4a7cf4c17c82553a916603643eb871fd921df3cf354336fb903d0ddf184756f

data/Rakefile

@@ -2,7 +2,7 @@
 
 require "rubygems"
 require "bundler/gem_helper"
-require "packnga"
+require "rake/clean"
 
 base_dir = File.join(File.dirname(__FILE__))
 
@@ -12,15 +12,6 @@ def helper.version_tag
 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
@@ -40,6 +31,15 @@ namespace :configure do
   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")

data/doc/text/news.md

@@ -1,5 +1,19 @@
 # News
 
+## 0.0.4 - 2019-02-16
+
+### Improvements
+
+  * `rb::Class(const char *name)`: Added.
+
+  * `rb::protect()`: Added.
+
+  * `rb::cast<std::string>(rb::Object)`: Added.
+
+  * `rb::cast<rb::Object(std::string)`: Added.
+
+  * Added support for auto needless C++ compiler warning flags remove.
+
 ## 0.0.3 - 2018-02-18
 
 ### Improvements

data/ext/extpp/class.cpp

@@ -108,7 +108,7 @@ namespace {
       (*method_table)[name_id] = definition.function;
       rb_define_method(klass,
                        definition.name.c_str(),
-                       reinterpret_cast<rb::MethodFunc>(call_func),
+                       reinterpret_cast<rb::RawMethod>(call_func),
                        -1);
     }
     rb_ivar_set(klass, id_method_definitions, Qnil);
@@ -179,18 +179,18 @@ namespace rb {
                 method_definitions_to_ruby(method_definitions_));
       rb_define_method(class_,
                        "method_missing",
-                       reinterpret_cast<MethodFunc>(method_missing),
+                       reinterpret_cast<RawMethod>(method_missing),
                        -1);
       rb_define_method(class_,
                        "respond_to_missing?",
-                       reinterpret_cast<MethodFunc>(respond_to_missing_p),
+                       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<MethodFunc>(body),
+                       reinterpret_cast<RawMethod>(body),
                        0);
     }
 
@@ -198,7 +198,7 @@ namespace rb {
                        VALUE (*body)(int argc, VALUE *argv, VALUE self)) {
       rb_define_method(class_,
                        name,
-                       reinterpret_cast<MethodFunc>(body),
+                       reinterpret_cast<RawMethod>(body),
                        -1);
     }
 
@@ -210,7 +210,7 @@ namespace rb {
         (*method_table_)[name_id] = function;
         rb_define_method(class_,
                          name,
-                         reinterpret_cast<MethodFunc>(call_func),
+                         reinterpret_cast<RawMethod>(call_func),
                          -1);
       }
     }
@@ -222,6 +222,19 @@ namespace rb {
     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())) {

data/ext/extpp/extconf.rb

@@ -1,7 +1,7 @@
 require_relative "../../lib/extpp/compiler"
 require_relative "../../lib/extpp/platform"
 
-cxxflags = RbConfig::CONFIG["CXXFLAGS"]
+cxxflags = RbConfig.expand("$(CXXFLAGS)")
 compiler = ExtPP::Compiler.new(cxxflags)
 compiler.check
 cxxflags = compiler.cxx_flags
@@ -38,6 +38,11 @@ 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}
@@ -54,10 +59,11 @@ 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 = #{RbConfig::CONFIG["LIBRUBYARG_SHARED"]}
+LIBRUBYARG_SHARED = #{librubyarg_shared}
 ARCH_FLAG = #{RbConfig::CONFIG["ARCH_FLAG"]}
 LDFLAGS = #{RbConfig::CONFIG["LDFLAGS"]}
 DLDFLAGS = #{RbConfig::CONFIG["DLDFLAGS"]}

data/ext/extpp/object.cpp

@@ -41,7 +41,7 @@ namespace rb {
                                     name_id,
                                     static_cast<int>(n),
                                     rb_args,
-                                    reinterpret_cast<MethodFunc>(call_block),
+                                    reinterpret_cast<RawMethod>(call_block),
                                     reinterpret_cast<VALUE>(block));
     return Object(rb_result);
   }

data/ext/extpp/protect.cpp

@@ -0,0 +1,12 @@
+#include <ruby/protect.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/include/ruby.hpp

@@ -8,3 +8,4 @@
 #include <ruby/cast.hpp>
 #include <ruby/class.hpp>
 #include <ruby/object.hpp>
+#include <ruby/protect.hpp>

data/include/ruby/cast.hpp

@@ -1,74 +1,98 @@
 #pragma once
 
+#include <string>
+
 #include <ruby/object.hpp>
 
 namespace rb {
   template <typename RETURN_TYPE, typename ARGUMENT_TYPE>
-  inline RETURN_TYPE cast(ARGUMENT_TYPE object);
+  inline RETURN_TYPE cast(const ARGUMENT_TYPE& object);
+
+  template <typename RETURN_TYPE, typename ARGUMENT_TYPE>
+  inline RETURN_TYPE cast(const ARGUMENT_TYPE *object);
+
+  template <typename RETURN_TYPE,
+            typename ARGUMENT_TYPE,
+            typename ADDTIONAL_DATA_TYPE1>
+  inline RETURN_TYPE cast(const ARGUMENT_TYPE& object,
+                          ADDTIONAL_DATA_TYPE1 data1);
 
   template <typename RETURN_TYPE,
             typename ARGUMENT_TYPE,
             typename ADDTIONAL_DATA_TYPE1>
-  inline RETURN_TYPE cast(ARGUMENT_TYPE object,
+  inline RETURN_TYPE cast(const ARGUMENT_TYPE *object,
                           ADDTIONAL_DATA_TYPE1 data1);
 
   template <>
-  inline int32_t cast<int32_t, Object>(Object rb_object) {
+  inline int32_t cast<int32_t, Object>(const Object& rb_object) {
     return NUM2INT(rb_object);
   }
 
   template <>
-  inline Object cast<Object, int32_t>(int32_t n) {
+  inline Object cast<Object, int32_t>(const int32_t& n) {
     return Object(INT2NUM(n));
   }
 
 
   template <>
-  inline int64_t cast<int64_t, Object>(Object rb_object) {
+  inline int64_t cast<int64_t, Object>(const Object& rb_object) {
     return NUM2LONG(rb_object);
   }
 
   template <>
-  inline Object cast<Object, int64_t>(int64_t n) {
+  inline Object cast<Object, int64_t>(const int64_t& n) {
     return Object(LONG2NUM(n));
   }
 
 
   template <>
-  inline uint32_t cast<uint32_t, Object>(Object rb_object) {
+  inline uint32_t cast<uint32_t, Object>(const Object& rb_object) {
     return NUM2UINT(rb_object);
   }
 
   template <>
-  inline Object cast<Object, uint32_t>(uint32_t n) {
+  inline Object cast<Object, uint32_t>(const uint32_t& n) {
     return Object(UINT2NUM(n));
   }
 
 
   template <>
-  inline uint64_t cast<uint64_t, Object>(Object rb_object) {
+  inline uint64_t cast<uint64_t, Object>(const Object& rb_object) {
     return NUM2ULONG(rb_object);
   }
 
   template <>
-  inline Object cast<Object, uint64_t>(uint64_t n) {
+  inline Object cast<Object, uint64_t>(const uint64_t& n) {
     return Object(ULONG2NUM(n));
   }
 
 
   template <>
-  inline const char *cast<const char *, Object>(Object rb_object) {
+  inline const char *cast<const char *, Object>(const 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) {
+  inline Object cast<Object, 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) {
+  inline Object cast<Object, char, long>(const char *data, long size) {
     return Object(rb_str_new(data, size));
   }
+
+
+  template <>
+  inline std::string cast<std::string, Object>(const Object& rb_object) {
+    VALUE rb_object_raw = rb_object;
+    return std::string(RSTRING_PTR(rb_object_raw),
+                       RSTRING_LEN(rb_object_raw));
+  }
+
+  template <>
+  inline Object cast<Object, std::string>(const std::string& string) {
+    return Object(rb_str_new(string.data(), string.size()));
+  }
 }

data/include/ruby/class.hpp

@@ -5,7 +5,8 @@
 namespace rb {
   class Class: public Object {
   public:
-    Class(const char *name, VALUE parent=rb_cObject);
+    Class(const char *name);
+    Class(const char *name, VALUE parent);
     Class(VALUE klass);
     ~Class();
 

data/include/ruby/object.hpp

@@ -13,7 +13,10 @@ namespace rb {
     }
 
     explicit Object(const char *name) :
-      rb_object_(rb_const_get(rb_cObject, rb_intern(name))),
+      rb_object_(rb_funcall(rb_cObject,
+                            rb_intern("const_get"),
+                            1,
+                            rb_str_new_static(name, strlen(name)))),
       is_gc_guarding_(false) {
     }
 

data/include/ruby/protect.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <ruby/type.hpp>
+
+namespace rb {
+  class State {
+  public:
+    explicit State(int state) :
+      state_(state) {
+    }
+
+    inline void jump() {
+      rb_jump_tag(state_);
+    }
+
+  private:
+    int state_;
+  };
+
+  VALUE protect(RawCallback callback, VALUE callback_data);
+
+  template <typename CALLBACK>
+  VALUE protect(const CALLBACK& callback) {
+    struct Data {
+      Data(const CALLBACK& callback) :
+        callback_(callback) {
+      }
+      const CALLBACK& callback_;
+    } data(callback);
+    auto callback_data = reinterpret_cast<VALUE>(&data);
+    return protect([](VALUE callback_data) -> VALUE {
+                     auto data = reinterpret_cast<Data *>(callback_data);
+                     return data->callback_();
+                   },
+                   callback_data);
+  };
+}

data/include/ruby/type.hpp

@@ -3,10 +3,12 @@
 #include <ruby.h>
 
 namespace rb {
-  using MethodFunc = VALUE (*)(ANYARGS);
+  using RawMethod = 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);
+
+  using RawCallback = VALUE (*)(VALUE user_data);
 }

data/lib/extpp.rb

@@ -1,7 +1,7 @@
 require "extpp/compiler"
 require "extpp/platform"
 
-compiler = ExtPP::Compiler.new($CXXFLAGS)
+compiler = ExtPP::Compiler.new(RbConfig.expand($CXXFLAGS))
 compiler.check
 $CXXFLAGS = compiler.cxx_flags
 

data/lib/extpp/compiler.rb

@@ -14,6 +14,7 @@ module ExtPP
     def check
       check_debug_build
       check_version
+      check_warning_flags
     end
 
     private
@@ -28,6 +29,22 @@ module ExtPP
       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
+
     def check_version
       return unless gcc?
 
@@ -73,20 +90,37 @@ module ExtPP
       end
     end
 
-    def disable_optimization_build_flag(flags)
-      if gcc?
-        flags.gsub(/(^|\s)-O\d(\s|$)/, '\\1-O0\\2')
-      else
-        flags
+    def try_cxx_warning_flag(warning_flag)
+      conftest_cxx = "#{CONFTEST}.cpp"
+      begin
+        source = "int main(void) {return 0;}"
+        open(conftest_cxx, "wb") do |cxx_file|
+          cxx_file.print(source)
+        end
+        flags = "-Werror #{warning_flag}"
+        xsystem(RbConfig.expand("$(CXX) #{flags} -c #{conftest_cxx}"))
+      ensure
+        log_src(source)
+        MakeMakefile.rm_f(conftest_cxx)
       end
     end
 
-    def enable_debug_build_flag(flags)
-      if gcc?
-        flags.gsub(/(^|\s)(?:-g|-g\d|-ggdb\d?)(\s|$)/, '\\1-g3\\2')
-      else
-        flags
+    def check_warning_flags
+      flags = []
+      warning_flags = []
+      Shellwords.split(@cxx_flags).each do |flag|
+        if flag.start_with?("-W")
+          warning_flags << flag
+        else
+          flags << flag
+        end
+      end
+      warning_flags.each do |warning_flag|
+        if try_cxx_warning_flag(warning_flag.gsub(/\A-Wno-/, "-W"))
+          flags << warning_flag
+        end
       end
+      @cxx_flags = Shellwords.join(flags)
     end
   end
 end