rice 1.0.2 → 1.1.0

data/rice/Module.cpp

@@ -27,7 +27,16 @@ Module(VALUE v)
 Rice::String Rice::Module::
 name() const
 {
-  return rb_mod_name(*this);
+  Object name = rb_mod_name(*this);
+  if(name.is_nil())
+  {
+    // 1.9
+    return String("");
+  }
+  else
+  {
+    return name;
+  }
 }
 
 Rice::Module Rice::
@@ -56,8 +65,7 @@ anonymous_module()
 void Rice::Module::
 swap(Rice::Module & other)
 {
-  std::swap(handler_, other.handler_);
-  Object::swap(other);
+  Module_base::swap(other);
 }
 
 Rice::Array

data/rice/Module_impl.hpp

@@ -1,9 +1,10 @@
 #ifndef Rice__Module_impl__hpp_
 #define Rice__Module_impl__hpp_
 
-#include "detail/Exception_Handler.hpp"
+#include "detail/Exception_Handler_defn.hpp"
 #include "detail/ruby.hpp"
 #include "Object_defn.hpp"
+#include "Address_Registration_Guard_defn.hpp"
 
 namespace Rice
 {
@@ -20,11 +21,21 @@ class Module_base
 {
 public:
   Module_base(VALUE v = rb_cObject);
+  Module_base(Module_base const & other);
 
-protected: // TODO
-  // TODO: For now, we always leak the handler, but in the future, we
-  // should register it with the garbage collector.
-  detail::Exception_Handler const * handler_;
+  Module_base & operator=(Module_base const & other);
+
+  void swap(Module_base & other);
+
+protected:
+  template<typename Exception_T, typename Functor_T>
+  void add_handler(Functor_T functor);
+
+  Object handler() const;
+
+private:
+  Object mutable handler_;
+  Address_Registration_Guard handler_guard_;
 };
 
 /*! An intermediate base class so we can always return the most-derived
@@ -90,7 +101,7 @@ public:
    */
   template<typename Func_T>
   Derived_T & define_method(
-      char const * name,
+      Identifier name,
       Func_T func);
 
   //! Define a singleton method.
@@ -106,7 +117,7 @@ public:
    */
   template<typename Func_T>
   Derived_T & define_singleton_method(
-      char const * name,
+      Identifier name,
       Func_T func);
 
   //! Define a module function.
@@ -124,7 +135,7 @@ public:
    */
   template<typename Func_T>
   Derived_T & define_module_function(
-      char const * name,
+      Identifier name,
       Func_T func);
 
   //! Define an iterator.
@@ -141,7 +152,7 @@ public:
   Derived_T & define_iterator(
       Iterator_T (T::*begin)(),
       Iterator_T (T::*end)(),
-      char const * name = "each");
+      Identifier name = "each");
 
   //! Include a module.
   /*! \param inc the module to be included.

data/rice/Module_impl.ipp

@@ -1,8 +1,10 @@
 #include "detail/define_method_and_auto_wrap.hpp"
 #include "Object.hpp"
+#include "Address_Registration_Guard.hpp"
 #include "Data_Object.hpp"
 #include "Data_Type.hpp"
 #include "Symbol.hpp"
+#include "Exception.hpp"
 #include "protect.hpp"
 
 #include "Module.hpp"
@@ -11,16 +13,77 @@
 
 #include "detail/ruby.hpp"
 #include "detail/method_data.hpp"
+#include "detail/Iterator.hpp"
 
 
 inline
 Rice::Module_base::
 Module_base(VALUE v)
   : Object(v)
-  , handler_(new Rice::detail::Default_Exception_Handler)
+  , handler_(Qnil)
+  , handler_guard_(&handler_)
 {
 }
 
+inline
+Rice::Module_base::
+Module_base(Module_base const & other)
+  : Object(other)
+  , handler_(other.handler_)
+  , handler_guard_(&handler_)
+{
+}
+
+inline
+Rice::Module_base &
+Rice::Module_base::
+operator=(Module_base const & other)
+{
+  Module_base tmp(other);
+  swap(tmp);
+  return *this;
+}
+
+inline
+void
+Rice::Module_base::
+swap(Module_base & other)
+{
+  std::swap(handler_, other.handler_);
+  Object::swap(other);
+}
+
+template<typename Exception_T, typename Functor_T>
+inline
+void
+Rice::Module_base::
+add_handler(Functor_T functor)
+{
+  Data_Object<detail::Exception_Handler> handler(
+      new detail::
+      Functor_Exception_Handler<Exception_T, Functor_T>(
+          functor,
+          this->handler()),
+      rb_cObject);
+  this->handler_.swap(handler);
+}
+
+inline
+Rice::Object
+Rice::Module_base::
+handler() const
+{
+  if(!handler_.test())
+  {
+    Data_Object<Rice::detail::Default_Exception_Handler> handler(
+        new Rice::detail::Default_Exception_Handler,
+        rb_cObject);
+    handler_.swap(handler);
+  }
+
+  return handler_;
+}
+
 template<typename Base_T, typename Derived_T>
 inline
 Rice::Module_impl<Base_T, Derived_T>::
@@ -46,11 +109,7 @@ Rice::Module_impl<Base_T, Derived_T>::
 add_handler(
     Functor_T functor)
 {
-  this->handler_ =
-      new Rice::detail::
-      Functor_Exception_Handler<Exception_T, Functor_T>(
-          functor,
-          this->handler_);
+  Module_base::add_handler<Exception_T>(functor);
   return (Derived_T &)*this;
 }
 
@@ -60,99 +119,48 @@ inline
 Derived_T &
 Rice::Module_impl<Base_T, Derived_T>::
 define_method(
-    char const * name,
+    Identifier name,
     Func_T func)
 {
   detail::define_method_and_auto_wrap(
-      *this, name, func, this->handler_);
+      *this, name, func, this->handler());
   return (Derived_T &)*this;
 }
 
 template<typename Base_T, typename Derived_T>
-template<typename T>
+template<typename Func_T>
 inline
 Derived_T &
 Rice::Module_impl<Base_T, Derived_T>::
 define_singleton_method(
-    char const * name,
-    T func)
+    Identifier name,
+    Func_T func)
 {
   detail::define_method_and_auto_wrap(
-      rb_class_of(*this), name, func, this->handler_);
+      rb_class_of(*this), name, func, this->handler());
   return (Derived_T &)*this;
 }
 
 template<typename Base_T, typename Derived_T>
-template<typename T>
+template<typename Func_T>
 inline
 Derived_T &
 Rice::Module_impl<Base_T, Derived_T>::
 define_module_function(
-    char const * name,
-    T func)
-{
-  detail::define_method_and_auto_wrap(*this, name, func);
-  this->call("module_function", Symbol(name));
-  return (Derived_T &)*this;
-}
-
-namespace Rice
-{
-
-namespace detail
-{
-
-class Iterator
-{
-public:
-  virtual ~Iterator() { }
-
-  virtual VALUE call_impl(VALUE self) = 0;
-
-  static VALUE call(VALUE self)
-  {
-    void * data = Rice::detail::method_data();
-    Iterator * iterator = static_cast<Iterator *>(data);
-    return iterator->call_impl(self);
-  }
-};
-
-template<typename T, typename Iterator_T>
-class Iterator_Impl
-  : public Iterator
+    Identifier name,
+    Func_T func)
 {
-public:
-  Iterator_Impl(
-      Iterator_T (T::*begin)(),
-      Iterator_T (T::*end)(),
-      Rice::Data_Type<T> data_type)
-    : begin_(begin)
-    , end_(end)
-    , data_type_(data_type)
-  {
-  }
-
-  virtual VALUE call_impl(VALUE self)
+  if(this->rb_type() != T_MODULE)
   {
-    Rice::Data_Object<T> obj(self, data_type_);
-    Iterator_T it = obj->begin();
-    Iterator_T end = obj->end();
-    for(; it != end; ++it)
-    {
-      protect(rb_yield, to_ruby(*it));
-    }
-    return self;
+    throw Rice::Exception(
+        rb_eTypeError,
+        "can only define module functions for modules");
   }
 
-private:
-  Iterator_T (T::*begin_)();
-  Iterator_T (T::*end_)();
-  Rice::Data_Type<T> data_type_;
-};
-
-} // namespace detail
-
-} // namespace Rice
+  define_method(name, func);
+  define_singleton_method(name, func);
+  return (Derived_T &)*this;
+}
 
 template<typename Base_T, typename Derived_T>
 template<typename T, typename Iterator_T>
@@ -162,20 +170,9 @@ Rice::Module_impl<Base_T, Derived_T>::
 define_iterator(
     Iterator_T (T::*begin)(),
     Iterator_T (T::*end)(),
-    char const * name)
+    Identifier name)
 {
-  // TODO: memory leak!!!!!!!
-  detail::Iterator * iterator =
-    new detail::Iterator_Impl<T, Iterator_T>(
-        begin,
-        end,
-        Data_Type<T>());
-  detail::define_method_with_data(
-      static_cast<VALUE>(*this),
-      name,
-      (RUBY_METHOD_FUNC)iterator->call,
-      0,
-      iterator);
+  detail::define_iterator(*this, name, begin, end);
   return (Derived_T &)*this;
 }
 

data/rice/Object.cpp

@@ -101,7 +101,7 @@ vcall(
     Identifier id,
     Array args)
 {
-  return protect(rb_funcall3, *this, id, args.size(), args->ptr);
+  return protect(rb_funcall3, *this, id, args.size(), args.to_c_array());
 }
 
 void Rice::Object::

data/rice/VM.cpp

@@ -1,6 +1,7 @@
 #include "VM.hpp"
 #include "detail/ruby.hpp"
 #include "detail/env.hpp" 
+#include "detail/ruby_version_code.hpp"
 
 #include <stdexcept>
 
@@ -19,7 +20,7 @@ VM(int argc, char * argv[])
 }
 
 Rice::VM::
-VM(std::vector<char *> const & args)
+VM(std::vector<const char *> const & args)
 {
   check_not_initialized();
   init_stack();
@@ -51,29 +52,41 @@ init_stack()
 void Rice::VM::
 run()
 {
+#if RICE__RUBY_VERSION_CODE >= 190
+  ruby_run_node(node_);
+#else
   ruby_run();
+#endif
 }
 
 extern "C"
 {
 
+#if RICE__RUBY_VERSION_CODE < 190
 RUBY_EXTERN VALUE * rb_gc_stack_start;
+#endif
 
 }
 
 void Rice::VM::
 check_not_initialized() const
 {
+#if RICE__RUBY_VERSION_CODE < 190
   if(rb_gc_stack_start)
   {
     throw std::runtime_error("Only one VM allowed per application");
   }
+#endif
+  // TODO: how to do this check on 1.9?
 }
 
 void Rice::VM::
 init(int argc, char * argv[])
 {
   ruby_init();
+#if RICE__RUBY_VERSION_CODE >= 190
+  node_ =
+#endif
   ruby_options(argc, argv);
 }
 

data/rice/VM.hpp

@@ -2,6 +2,7 @@
 #define VM__hpp
 
 #include <vector>
+#include "detail/ruby_version_code.hpp"
 
 namespace Rice
 {
@@ -11,7 +12,7 @@ class VM
 public:
   VM(char * app_name);
   VM(int argc, char * argv[]);
-  VM(std::vector<char *> const & args);
+  VM(std::vector<const char *> const & args);
   ~VM();
 
   void init_stack();
@@ -20,6 +21,10 @@ public:
 private:
   void check_not_initialized() const;
   void init(int argc, char * argv[]);
+
+#if RICE__RUBY_VERSION_CODE >= 190
+  void * node_;
+#endif
 };
 
 }

data/rice/config.hpp

@@ -1,6 +1,24 @@
 /* rice/config.hpp.  Generated from config.hpp.in by configure.  */
 /* rice/config.hpp.in.  Generated from configure.ac by autoheader.  */
 
+/* Define to 1 if you have the <env.h> header file. */
+#define HAVE_ENV_H 1
+
+/* Define to 1 if you have the <node.h> header file. */
+#define HAVE_NODE_H 1
+
+/* Define this macro if rb_class_boot is defined */
+#define HAVE_RB_CLASS_BOOT 
+
+/* Define to 1 if you have the <ruby.h> header file. */
+#define HAVE_RUBY_H 1
+
+/* Define to 1 if you have the <ruby/node.h> header file. */
+/* #undef HAVE_RUBY_NODE_H */
+
+/* Define to 1 if you have the <version.h> header file. */
+#define HAVE_VERSION_H 1
+
 /* Name of package */
 #define PACKAGE "rice"
 
@@ -11,13 +29,16 @@
 #define PACKAGE_NAME "rice"
 
 /* Define to the full name and version of this package. */
-#define PACKAGE_STRING "rice 1.0"
+#define PACKAGE_STRING "rice 1.1"
 
 /* Define to the one symbol short name of this package. */
 #define PACKAGE_TARNAME "rice"
 
 /* Define to the version of this package. */
-#define PACKAGE_VERSION "1.0"
+#define PACKAGE_VERSION "1.1"
+
+/* Define this macro to use ruby/node.h */
+/* #undef REALLY_HAVE_RUBY_NODE_H */
 
 /* Version number of package */
-#define VERSION "1.0"
+#define VERSION "1.1"