rice 4.3.3 → 4.6.0

data/rice/detail/RubyType.ipp

@@ -0,0 +1,232 @@
+namespace Rice::detail
+{
+  template<>
+  class RubyType<bool>
+  {
+  public:
+    using FromRuby_T = bool(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = RB_TEST;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_TRUE, RUBY_T_FALSE };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_NIL };
+    static inline std::set<ruby_value_type> Narrowable = {  };
+    static inline std::string packTemplate = "not supported";
+  };
+
+  template<>
+  class RubyType<char>
+  {
+  public:
+    using FromRuby_T = char(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2char_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = CHAR_MIN < 0 ? "c*" : "C*";
+  };
+
+  template<>
+  class RubyType<signed char>
+  {
+  public:
+    // Hack - need to later typecast
+    using FromRuby_T = char(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2char_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "c*";
+  };
+
+  template<>
+  class RubyType<unsigned char>
+  {
+  public:
+    // Hack - need to later typecast, although char's in ruby are unsigned
+    using FromRuby_T = char(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2char_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_STRING };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "C*";
+  };
+
+  template<>
+  class RubyType<short>
+  {
+  public:
+    using FromRuby_T = short(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2short_inline;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "s*";
+  };
+
+  template<>
+  class RubyType<unsigned short>
+  {
+  public:
+    using FromRuby_T = unsigned short(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2ushort;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FIXNUM };
+    static inline std::string packTemplate = "S*";
+  };
+
+  template<>
+  class RubyType<int>
+  {
+  public:
+    using FromRuby_T = int(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2int_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    // We allow bignum to integer because Ruby switches to bignum at about 2 billion on 64 bit systems,
+    // while int can go up to 4 billion
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM };
+    static inline std::string packTemplate = "i*";
+  };
+
+  template<>
+  class RubyType<unsigned int>
+  {
+  public:
+    using FromRuby_T = unsigned int(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = RB_NUM2UINT;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    // We allow bignum to integer because Ruby switches to bignum at about 2 billion on 64 bit systems,
+    // while int can go up to 4 billion
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM };
+    static inline std::string packTemplate = "I*";
+  };
+
+  template<>
+  class RubyType<long>
+  {
+  public:
+    using FromRuby_T = long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2long_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM };
+    static inline std::string packTemplate = "l_*";
+  };
+
+  template<>
+  class RubyType<unsigned long>
+  {
+  public:
+    using FromRuby_T = unsigned long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2ulong_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM  };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_BIGNUM};
+    static inline std::string packTemplate = "L_*";
+  };
+
+  template<>
+  class RubyType<long long>
+  {
+  public:
+    using FromRuby_T = long long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2ll_inline;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "q_*";
+  };
+
+  template<>
+  class RubyType<unsigned long long>
+  {
+  public:
+    using FromRuby_T = unsigned long long(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = RB_NUM2ULL;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "Q_*";
+  };
+
+  template<>
+  class RubyType<float>
+  {
+  public:
+    using FromRuby_T = double(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2dbl;
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_FIXNUM };
+    static inline std::set<ruby_value_type> Narrowable = { RUBY_T_FLOAT };
+    static inline std::string packTemplate = "f*";
+  };
+
+  template<>
+  class RubyType<double>
+  {
+  public:
+    using FromRuby_T = double(*)(VALUE);
+
+    static inline FromRuby_T fromRuby = rb_num2dbl;
+    static inline std::set<ruby_value_type> Exact = { RUBY_T_FLOAT };
+    static inline std::set<ruby_value_type> Castable = { RUBY_T_FIXNUM, RUBY_T_BIGNUM };
+    static inline std::set<ruby_value_type> Narrowable = { };
+    static inline std::string packTemplate = "d*";
+  };
+
+  template<>
+  class RubyType<void>
+  {
+  public:
+    static inline std::set<ruby_value_type> Exact = { };
+    static inline std::set<ruby_value_type> Castable = { };
+    static inline std::set<ruby_value_type> Narrowable = { };
+  };
+}
+
+namespace Rice::detail
+{
+  template<typename T>
+  inline Data_Type<T> define_ruby_type()
+  {
+    std::string name = detail::typeName(typeid(T*));
+    std::string klassName = detail::rubyClassName(name);
+    Identifier id(klassName);
+
+    Module rb_mRice = define_module("Rice");
+    return define_class_under<T>(rb_mRice, id);
+  }
+
+  inline void define_ruby_types()
+  {
+    define_ruby_type<bool>();
+    define_ruby_type<char>();
+    define_ruby_type<signed char>();
+    define_ruby_type<unsigned char>();
+    define_ruby_type<short>();
+    define_ruby_type<unsigned short>();
+    define_ruby_type<int>();
+    define_ruby_type<unsigned int>();
+    define_ruby_type<long>();
+    define_ruby_type<unsigned long>();
+    define_ruby_type<long long>();
+    define_ruby_type<unsigned long long>();
+    define_ruby_type<float>();
+    define_ruby_type<double>();
+    define_ruby_type<void>();
+  }
+}

data/rice/detail/Type.hpp

@@ -1,9 +1,7 @@
 #ifndef Rice__Type__hpp_
 #define Rice__Type__hpp_
 
-#include <string>
-#include <typeinfo>
-#include "../traits/rice_traits.hpp"
+#include <regex>
 
 namespace Rice::detail
 {
@@ -15,7 +13,12 @@ namespace Rice::detail
 
   // Return the name of a type
   std::string typeName(const std::type_info& typeInfo);
-  std::string makeClassName(const std::type_info& typeInfo);
+  std::string typeName(const std::type_index& typeIndex);
+  std::string cppClassName(const std::string& typeInfoName);
+  std::string rubyClassName(const std::string& typeInfoName);
+  std::string findGroup(std::string& string, size_t start = 0);
+  void replaceGroup(std::string& string, std::regex regex, std::string replacement);
+  void replaceAll(std::string& string, std::regex regex, std::string replacement);
 
   template<typename T>
   void verifyType();
@@ -24,6 +27,4 @@ namespace Rice::detail
   void verifyTypes();
 }
 
-#include "Type.ipp"
-
 #endif // Rice__Type__hpp_

data/rice/detail/Type.ipp

@@ -1,12 +1,3 @@
-#include "../traits/rice_traits.hpp"
-
-#include <iosfwd>
-#include <iterator>
-#include <numeric>
-#include <regex>
-#include <sstream>
-#include <tuple>
-
 #ifdef __GNUC__
 #include <cxxabi.h>
 #include <cstdlib>
@@ -15,14 +6,22 @@
 
 namespace Rice::detail
 {
-  template<>
-  struct Type<void>
+  template<typename T>
+  bool Type<T>::verify()
   {
-    static bool verify()
+    if constexpr (std::is_fundamental_v<T>)
     {
       return true;
     }
-  };
+    else if constexpr (std::is_array_v<T> && std::is_fundamental_v<std::remove_extent_t<T>>)
+    {
+      return true;
+    }
+    else
+    {
+      return Registries::instance.types.verify<T>();
+    }
+  }
 
   template<typename T>
   void verifyType()
@@ -31,7 +30,7 @@ namespace Rice::detail
   }
 
   template<typename Tuple_T, size_t...Is>
-  void verifyTypesImpl()
+  void verifyTypesImpl(std::index_sequence<Is...> indexes)
   {
     (verifyType<typename std::tuple_element<Is, Tuple_T>::type>(), ...);
   }
@@ -39,10 +38,8 @@ namespace Rice::detail
   template<typename Tuple_T>
   void verifyTypes()
   {
-    if constexpr (std::tuple_size<Tuple_T>::value > 0)
-    {
-      verifyTypesImpl<Tuple_T, std::tuple_size<Tuple_T>::value - 1>();
-    }
+    std::make_index_sequence<std::tuple_size_v<Tuple_T>> indexes;
+    verifyTypesImpl<Tuple_T>(indexes);
   }
 
   inline std::string demangle(char const* mangled_name)
@@ -89,13 +86,87 @@ namespace Rice::detail
     return demangle(typeInfo.name());
   }
 
-  inline std::string makeClassName(const std::type_info& typeInfo)
+  inline std::string typeName(const std::type_index& typeIndex)
+  {
+    return demangle(typeIndex.name());
+  }
+
+  // Find text inside of < > taking into account nested groups.
+  // 
+  // Example:
+  //  
+  //   std::vector<std::vector<int>, std::allocator<std::vector, std::allocator<int>>>
+  inline std::string findGroup(std::string& string, size_t offset)
   {
-    std::string base = demangle(typeInfo.name());
+    int depth = 0;
+
+    auto begin = string.begin() + offset;
+    auto start = begin;
+    for (auto iter = begin; iter != string.end(); iter++)
+    {
+      if (*iter == '<')
+      {
+        if (depth == 0)
+        {
+          start = iter;
+        }
+        depth++;
+      }
+      else if (*iter == '>')
+      {
+        depth--;
+        if (depth == 0)
+        {
+          // Add + 1 to include current ">" character
+          return string.substr(offset + (start - begin), 1 + (iter - start));
+        }
+        else if (depth < 0)
+        {
+          throw std::runtime_error("Unbalanced Group");
+        }
+      }
+    }
+    throw std::runtime_error("Unbalanced Group");
+  }
+
+  inline void replaceAll(std::string& string, std::regex regex, std::string replacement)
+  {
+    std::smatch match;
+    while (std::regex_search(string, match, regex))
+    {
+      string = std::regex_replace(string, regex, replacement);
+    }
+  }
+
+  inline void removeGroup(std::string& string, std::regex regex)
+  {
+    std::smatch match;
+    while (std::regex_search(string, match, regex))
+    {
+      std::string group = findGroup(string, match.position());
+      group = match.str() + group;
+      string.erase(match.position(), group.length());
+    }
+  }
+
+  inline void replaceGroup(std::string& string, std::regex regex, std::string replacement)
+  {
+    std::smatch match;
+    while (std::regex_search(string, match, regex))
+    {
+      std::string group = findGroup(string, match.position());
+      group = match.str() + group;
+      string.replace(match.position(), group.length(), replacement);
+    }
+  }
+
+  inline std::string cppClassName(const std::string& typeInfoName)
+  {
+    std::string base = typeInfoName;
 
     // Remove class keyword
     auto classRegex = std::regex("class +");
-    base = std::regex_replace(base, classRegex, "");
+    base = std::regex_replace(typeInfoName, classRegex, "");
 
     // Remove struct keyword
     auto structRegex = std::regex("struct +");
@@ -103,37 +174,113 @@ namespace Rice::detail
 
     // Remove std::__[^:]*::
     auto stdClangRegex = std::regex("std::__[^:]+::");
-    base = std::regex_replace(base, stdClangRegex, "");
-      
-    // Remove std::
+    base = std::regex_replace(base, stdClangRegex, "std::");
+
+    // Remove allocators
+    std::regex allocatorRegex(R"(,\s*std::allocator)");
+    removeGroup(base, allocatorRegex);
+
+    // Remove char_traits
+    std::regex charTraitsRegex(R"(,\s*std::char_traits)");
+    removeGroup(base, charTraitsRegex);
+
+    // Remove less (std::map)
+    std::regex lessRegex(R"(,\s*std::less)");
+    removeGroup(base, lessRegex);
+
+    // Remove hash (std::unordered_map)
+    std::regex hashRegex(R"(,\s*std::hash)");
+    removeGroup(base, hashRegex);
+
+    // Remove equal_to (std::unordered_map)
+    std::regex equalRegex(R"(,\s*std::equal_to)");
+    removeGroup(base, equalRegex);
+
+    // Remove spaces before pointers
+    auto ptrRegex = std::regex(R"(\s+\*)");
+    base = std::regex_replace(base, ptrRegex, "*");
+
+    // Remove __ptr64
+    std::regex ptr64Regex(R"(\s*__ptr64\s*)");
+    base = std::regex_replace(base, ptr64Regex, "");
+
+    // Replace " >" with ">"
+    auto trailingAngleBracketSpaceRegex = std::regex(R"(\s+>)");
+    replaceAll(base, trailingAngleBracketSpaceRegex, ">");
+
+    // One space after a comma (MSVC has no spaces, GCC one space)
+    auto commaSpaceRegex = std::regex(R"(,(\S))");
+    replaceAll(base, commaSpaceRegex, ", $1");
+
+    // Fix strings
+    auto stringRegex = std::regex(R"(basic_string<char>)");
+    replaceAll(base, stringRegex, "string");
+
+    auto wstringRegex = std::regex(R"(basic_string<wchar_t>)");
+    replaceAll(base, wstringRegex, "wstring");
+
+    // Normalize Anonymous namespace
+    auto anonymousNamespaceGcc = std::regex(R"(\(anonymous namespace\))");
+    replaceAll(base, anonymousNamespaceGcc, "AnonymousNamespace");
+    auto anonymousNamespaceMsvc = std::regex(R"(`anonymous namespace')");
+    replaceAll(base, anonymousNamespaceMsvc, "AnonymousNamespace");
+
+    return base;
+  }
+
+
+  inline std::string rubyClassName(const std::string& typeInfoName)
+  {
+    std::string base = cppClassName(typeInfoName);
+
+    // Remove std:: these could be embedded in template types
     auto stdRegex = std::regex("std::");
     base = std::regex_replace(base, stdRegex, "");
 
-    // Replace > > 
-    auto trailingAngleBracketSpaceRegex = std::regex(" >");
-    base = std::regex_replace(base, trailingAngleBracketSpaceRegex, ">");
+    // Remove leading namespaces. This will not remove namespaces
+    // embedded in template types like std::vector<mynamespace::foo>
+    auto leadingNamespacesRegex = std::regex("^[^<]*::");
+    base = std::regex_replace(base, leadingNamespacesRegex, "");
 
-    // Replace < and >
-    auto angleBracketRegex = std::regex("<|>");
-    base = std::regex_replace(base, angleBracketRegex, "__");
+    // Capitalize first letter
+    base[0] = std::toupper(base[0]);
 
-    // Replace ,
-    auto commaRegex = std::regex(", *");
-    base = std::regex_replace(base, commaRegex, "_");
+    // Replace :: with unicode U+u02F8 (Modified Letter raised colon)
+    auto colonRegex = std::regex(R"(:)");
+    replaceAll(base, colonRegex, "\uA789");
 
-    // Now create a vector of strings split on whitespace
-    std::istringstream stream(base);
-    std::vector<std::string> words{ std::istream_iterator<std::string>{stream},
-                                    std::istream_iterator<std::string>{} };
+    // Replace _ and capitalize the next letter
+    std::regex namespaceRegex(R"(_(\w))");
+    std::smatch namespaceMatch;
+    while (std::regex_search(base, namespaceMatch, namespaceRegex))
+    {
+      std::string replacement = namespaceMatch[1];
+      std::transform(replacement.begin(), replacement.end(), replacement.begin(), ::toupper);
+      base.replace(namespaceMatch.position(), namespaceMatch.length(), replacement);
+    }
 
-    std::string result = std::accumulate(words.begin(), words.end(), std::string(),
-      [](const std::string& memo, const std::string& word) -> std::string
-      {
-        std::string capitalized = word;
-        capitalized[0] = toupper(capitalized[0]);
-        return memo + capitalized;
-      });
+    // Replace spaces with unicode U+u00A0 (Non breaking Space)
+    auto spaceRegex = std::regex(R"(\s+)");
+    replaceAll(base, spaceRegex, "\u00A0");
+
+    // Replace < with unicode U+227A (Precedes)
+    auto lessThanRegex = std::regex("<");
+    //replaceAll(base, lessThanRegex, "≺");
+    replaceAll(base, lessThanRegex, "\u227A");
+
+    // Replace > with unicode U+227B (Succeeds)
+    auto greaterThanRegex = std::regex(">");
+    //replaceAll(base, greaterThanRegex, "≻");
+    replaceAll(base, greaterThanRegex, "\u227B");
+
+    // Replace , with Unicode Character (U+066C) - Arabic Thousands Separator
+    auto commaRegex = std::regex(R"(,\s*)");
+    replaceAll(base, commaRegex, "\u201A");
+
+    // Replace * with Unicode Character (U+2217) -	Asterisk Operator
+    auto asteriskRegex = std::regex(R"(\*)");
+    replaceAll(base, asteriskRegex, "\u2217");
 
-    return result;
+    return base;
   }
 }

data/rice/detail/TypeRegistry.hpp

@@ -2,12 +2,10 @@
 #define Rice__TypeRegistry__hpp_
 
 #include <optional>
-#include <string>
-#include <typeindex>
-#include <typeinfo>
 #include <unordered_map>
+#include <set>
+#include <regex>
 
-#include "ruby.hpp"
 
 /* The type registry keeps track of all C++ types wrapped by Rice. When a native function returns 
    an instance of a class/struct we look up its type to verity that it has been registered. 
@@ -31,17 +29,27 @@ namespace Rice::detail
     bool isDefined();
 
     template <typename T>
-    bool verifyDefined();
+    std::pair<VALUE, rb_data_type_t*> getType();
+
+    template <typename T>
+    bool verify();
       
     template <typename T>
     std::pair<VALUE, rb_data_type_t*> figureType(const T& object);
 
+    // Validate types and throw if any types are unverified
+    void validateTypes();
+
+    // Clear unverified types. This is mostly for unit tests
+    void clearUnverifiedTypes();
+
   private:
     std::optional<std::pair<VALUE, rb_data_type_t*>> lookup(const std::type_info& typeInfo);
+    void raiseUnverifiedType(const std::string& typeName);
+
     std::unordered_map<std::type_index, std::pair<VALUE, rb_data_type_t*>> registry_{};
+    std::set<std::type_index> unverified_{};
   };
 }
 
-#include "TypeRegistry.ipp"
-
 #endif // Rice__TypeRegistry__hpp_