keyme-rice 1.5.1.keyme

data/rice/detail/Caster.hpp

@@ -0,0 +1,103 @@
+#ifndef Rice__detail__Caster__hpp_
+#define Rice__detail__Caster__hpp_
+
+#include "../Module.hpp"
+#include <stdexcept>
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Abstract_Caster
+{
+public:
+  virtual void * cast_to_base(void * derived, Module type) const = 0;
+  virtual ~Abstract_Caster() { }
+};
+
+template<typename Derived_T, typename Base_T>
+class Caster
+  : public Abstract_Caster
+{
+public:
+  Caster(Abstract_Caster * base_caster, Module type)
+    : base_caster_(base_caster)
+    , type_(type)
+  {
+  }
+
+protected:
+  virtual void * cast_to_base(void * derived, Module type) const
+  {
+    if(type.value() == type_.value())
+    {
+      Derived_T * d(static_cast<Derived_T *>(derived));
+      return static_cast<Base_T *>(d);
+    }
+    else
+    {
+      if(base_caster_)
+      {
+        return base_caster_->cast_to_base(derived, type);
+      }
+      else
+      {
+        std::string s = "bad cast. No caster found for ";
+        s += type_.name().str();
+        throw std::runtime_error(s);
+      }
+    }
+  }
+
+private:
+  Abstract_Caster * base_caster_;
+  Module type_;
+};
+
+template<typename To_T, typename From_T>
+class Implicit_Caster
+  : public Abstract_Caster
+{
+public:
+  Implicit_Caster(Abstract_Caster * base_caster, Module type)
+    : base_caster_(base_caster)
+    , type_(type)
+  {
+  }
+
+protected:
+  virtual void * cast_to_base(void * derived, Module type) const
+  {
+    if(type.value() == type_.value())
+    {
+      return new To_T( *static_cast<From_T*>(derived) );
+    }
+    else
+    {
+      if(base_caster_)
+      {
+        return base_caster_->cast_to_base(derived, type);
+      }
+      else
+      {
+        std::string s = "bad cast. No implicit caster found for ";
+        s += type_.name().str();
+        throw std::runtime_error(s);
+      }
+    }
+  }
+
+private:
+  Abstract_Caster * base_caster_;
+  Module type_;
+};
+
+
+
+} // detail
+
+} // Rice
+
+#endif //Rice__detail__Caster__hpp_

data/rice/detail/Exception_Handler.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__detail__Exception_Handler__hpp_
+#define Rice__detail__Exception_Handler__hpp_
+
+#include "Exception_Handler_defn.hpp"
+#include "Exception_Handler.ipp"
+
+#endif // Rice__detail__Exception_Handler__hpp_
+

data/rice/detail/Exception_Handler.ipp

@@ -0,0 +1,68 @@
+#include "../Data_Type_defn.hpp"
+
+inline
+Rice::detail::Exception_Handler::
+Exception_Handler(
+    Data_Object<Exception_Handler> next_exception_handler)
+  : next_exception_handler_(next_exception_handler)
+  , next_exception_handler_guard_(&next_exception_handler_)
+{
+}
+
+inline
+Rice::detail::Exception_Handler::
+~Exception_Handler()
+{
+}
+
+inline
+VALUE
+Rice::detail::Exception_Handler::
+call_next_exception_handler() const
+{
+  return next_exception_handler_->handle_exception();
+}
+
+inline Rice::detail::Default_Exception_Handler::
+Default_Exception_Handler()
+  : Exception_Handler(
+      Data_Object<Exception_Handler>(0, rb_cObject))
+{
+}
+
+inline
+VALUE
+Rice::detail::Default_Exception_Handler::
+handle_exception() const
+{
+  throw;
+}
+
+template <typename Exception_T, typename Functor_T>
+inline
+Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
+Functor_Exception_Handler(
+    Functor_T handler,
+    Data_Object<Exception_Handler> next_exception_handler)
+  : Exception_Handler(next_exception_handler)
+  , handler_(handler)
+{
+}
+
+template <typename Exception_T, typename Functor_T>
+inline
+VALUE
+Rice::detail::Functor_Exception_Handler<Exception_T, Functor_T>::
+handle_exception() const
+{
+  try
+  {
+    return call_next_exception_handler();
+  }
+  catch(Exception_T const & ex)
+  {
+    handler_(ex);
+    throw;
+  }
+}
+

data/rice/detail/Exception_Handler_defn.hpp

@@ -0,0 +1,96 @@
+#ifndef Rice__detail__Exception_Handler_defn__hpp_
+#define Rice__detail__Exception_Handler_defn__hpp_
+
+#include "ruby.h"
+#undef TYPE
+
+#include "Not_Copyable.hpp"
+#include "../Address_Registration_Guard_defn.hpp"
+#include "../Data_Object_defn.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// A class for converting C++ exceptions to ruby exceptions.  It's used
+// like this:
+//
+//   try
+//   {
+//   }
+//   catch(...)
+//   {
+//     handler->handle_exception();
+//   }
+//
+// If an exception is thrown the handler will pass the exception up the
+// chain, then the last handler in the chain will throw the exception
+// down the chain until a lower handler can handle it, e.g.:
+//
+//   try
+//   {
+//     return call_next_exception_handler();
+//   }
+//   catch(MyException const & ex)
+//   {
+//     throw Rice::Exception(rb_cMyException, "%s", ex.what());
+//   }
+//
+class Exception_Handler
+  : public Rice::detail::Not_Copyable
+{
+public:
+  Exception_Handler(
+      Data_Object<Exception_Handler> next_exception_handler);
+
+  virtual ~Exception_Handler();
+
+  virtual VALUE handle_exception() const = 0;
+
+  VALUE call_next_exception_handler() const;
+
+private:
+  Data_Object<Exception_Handler> next_exception_handler_;
+  Address_Registration_Guard next_exception_handler_guard_;
+};
+
+// The default exception handler just rethrows the exception.  If there
+// are other handlers in the chain, they will try to handle the rethrown
+// exception.
+class Default_Exception_Handler
+  : public Exception_Handler
+{
+public:
+  Default_Exception_Handler();
+
+  virtual VALUE handle_exception() const;
+};
+
+// An exception handler that takes a functor as an argument.  The
+// functor should throw a Rice::Exception to handle the exception.  If
+// the functor does not handle the exception, the exception will be
+// re-thrown.
+template <typename Exception_T, typename Functor_T>
+class Functor_Exception_Handler
+  : public Exception_Handler
+{
+public:
+  Functor_Exception_Handler(
+      Functor_T handler,
+      Data_Object<Exception_Handler> next_exception_handler);
+
+private:
+  virtual VALUE handle_exception() const;
+
+private:
+  Functor_T handler_;
+};
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__Exception_Handler_defn__hpp_
+

data/rice/detail/Iterator.hpp

@@ -0,0 +1,93 @@
+#ifndef Rice__detail__Iterator__hpp_
+#define Rice__detail__Iterator__hpp_
+
+#include "method_data.hpp"
+#include "ruby.hpp"
+#include "../protect.hpp"
+#include "../Data_Object.hpp"
+#include "../Identifier.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Iterator
+{
+public:
+  virtual ~Iterator() { }
+
+  virtual VALUE call_impl(VALUE self) = 0;
+
+  static VALUE call(VALUE self)
+  {
+    VALUE data = (VALUE)method_data();
+    Data_Object<Iterator> iterator(
+        data,
+        Data_Type<Iterator>());
+    return iterator->call_impl(self);
+  }
+};
+
+template<typename T, typename Iterator_T>
+class Iterator_Impl
+  : public Iterator
+{
+public:
+  Iterator_Impl(
+      Iterator_T (T::*begin)(),
+      Iterator_T (T::*end)(),
+      Data_Type<T> data_type)
+    : begin_(begin)
+    , end_(end)
+    , data_type_(data_type)
+  {
+  }
+
+  virtual VALUE call_impl(VALUE self)
+  {
+    Data_Object<T> obj(self, data_type_);
+    Iterator_T it = obj->begin();
+    Iterator_T end = obj->end();
+    for(; it != end; ++it)
+    {
+      Rice::protect(rb_yield, to_ruby(*it));
+    }
+    return self;
+  }
+
+private:
+  Iterator_T (T::*begin_)();
+  Iterator_T (T::*end_)();
+  Data_Type<T> data_type_;
+};
+
+template<typename T, typename Iterator_T>
+void define_iterator(
+    Module klass,
+    Identifier name,
+    Iterator_T (T::*begin)(),
+    Iterator_T (T::*end)())
+{
+  Data_Type<Iterator> iterator_klass;
+  Data_Object<Iterator> iterator(
+      new Iterator_Impl<T, Iterator_T>(
+          begin,
+          end,
+          Data_Type<T>(klass)),
+      iterator_klass);
+  define_method_with_data(
+      klass,
+      name,
+      (RUBY_METHOD_FUNC)iterator->call,
+      0,
+      iterator);
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__Iterator__hpp_
+

data/rice/detail/Not_Copyable.hpp

@@ -0,0 +1,25 @@
+#ifndef Rice__Not_Copyable__hpp_
+#define Rice__Not_Copyable__hpp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// Inherit from Not_Copyable to prevent copying instances of a class.
+class Not_Copyable
+{
+public:
+  Not_Copyable() { }
+
+private:
+  Not_Copyable(Not_Copyable const &);
+  Not_Copyable & operator=(Not_Copyable const &);
+};
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__Not_Copyable__hpp_

data/rice/detail/Wrapped_Function.hpp

@@ -0,0 +1,33 @@
+#ifndef Rice__detail__Wrapped_Function__hpp_
+#define Rice__detail__Wrapped_Function__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Wrapped_Function
+{
+public:
+  Wrapped_Function(RUBY_METHOD_FUNC func, int arity)
+    : func_(func)
+    , arity_(arity)
+  {
+  }
+
+  RUBY_METHOD_FUNC func() const { return func_; }
+  int arity() const { return arity_; }
+
+private:
+  RUBY_METHOD_FUNC func_;
+  int arity_;
+};
+
+} // detail
+
+} // Rice
+
+#endif // Rice__detail__Wrapped_Function__hpp_

data/rice/detail/cfp.hpp

@@ -0,0 +1,24 @@
+#ifndef Rice__detail__cfp__hpp_
+#define Rice__detail__cfp__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+VALUE * cfp();
+
+VALUE & cfp_data_memo_node_and_pc(VALUE * cfp);
+VALUE & cfp_self(VALUE * cfp);
+VALUE & cfp_method_class(VALUE * cfp);
+
+} // detail
+
+} // Rice
+
+#include "cfp.ipp"
+
+#endif // Rice__detail__cfp__hpp_

data/rice/detail/cfp.ipp

@@ -0,0 +1,51 @@
+namespace detail
+{
+
+struct rb_thread_struct
+{
+    VALUE self;
+    void *vm;
+    VALUE *stack;
+    unsigned long stack_size;
+    VALUE *cfp;
+    /* ... */
+};
+
+typedef struct rb_thread_struct rb_thread_t;
+
+} // namespace detail
+
+extern "C" detail::rb_thread_t * ruby_current_thread;
+
+inline
+VALUE *
+Rice::detail::
+cfp()
+{
+  return ruby_current_thread->cfp;
+}
+
+inline
+VALUE &
+Rice::detail::
+cfp_data_memo_node_and_pc(VALUE * cfp)
+{
+  return cfp[0];
+}
+
+inline
+VALUE &
+Rice::detail::
+cfp_self(VALUE * cfp)
+{
+  return cfp[5];
+}
+
+inline
+VALUE &
+Rice::detail::
+cfp_method_class(VALUE * cfp)
+{
+  return cfp[11];
+}
+

data/rice/detail/check_ruby_type.cpp

@@ -0,0 +1,27 @@
+#include "check_ruby_type.hpp"
+#include "../Exception.hpp"
+
+void Rice::detail::
+check_ruby_type(
+    VALUE value,
+    VALUE klass,
+    bool include_super
+    )
+{ 
+  if( !rb_obj_is_kind_of(value, klass) ||
+     (!include_super && rb_obj_class(value) != klass))
+  {
+    // Not sure why this stuff can't be chained
+    VALUE gotV = protect(rb_mod_name, rb_obj_class(value));
+    char* got = StringValuePtr(gotV);
+    VALUE exptV = protect(rb_mod_name, klass);
+    char* expected = StringValuePtr(exptV);
+
+    throw Exception(
+        rb_eTypeError,
+        "wrong argument type %s (expected %s)",
+        got, expected
+      );
+  }                                 
+}
+

data/rice/detail/check_ruby_type.hpp

@@ -0,0 +1,23 @@
+#ifndef Rice__detail__check_ruby_type__hpp_
+#define Rice__detail__check_ruby_type__hpp_
+
+#include "ruby.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+// Throws an exception if the given object is not of type klass.
+void check_ruby_type(
+    VALUE value,
+    VALUE klass,
+    bool include_super);
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__check_ruby_type__hpp_
+

data/rice/detail/creation_funcs.hpp

@@ -0,0 +1,37 @@
+#ifndef Rice__detail__creation_funcs__hpp_
+#define Rice__detail__creation_funcs__hpp_
+
+namespace Rice
+{
+
+class Class;
+
+namespace detail
+{
+
+//! Like define_alloc_func, but allows the user to define an
+//! "initialize" method too.
+template<typename Initialize_Func_T>
+void define_creation_funcs(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func,
+    Initialize_Func_T initialize_func);
+
+//! This is just the opposite of define_alloc_func.  It can be
+//! used to create a class that cannot be instantiated by the user.
+void undef_alloc_func(
+    Class const & klass);
+
+//! This is just the opposite of define_creation_func.  It can be
+//! used to create a class that cannot be instantiated by the user.
+void undef_creation_funcs(
+    Class const & klass);
+
+} // namespace detail
+
+} // namespace Rice
+
+#include "creation_funcs.ipp"
+
+#endif // Rice__detail__creation_funcs__hpp_
+

data/rice/detail/creation_funcs.ipp

@@ -0,0 +1,36 @@
+#ifndef Rice__detail__creation_funcs__ipp_
+#define Rice__detail__creation_funcs__ipp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+template<typename Initialize_Func_T>
+inline void define_creation_funcs(
+    Class const & klass,
+    RUBY_VALUE_FUNC allocate_func,
+    Initialize_Func_T initialize_func)
+{
+  rb_define_alloc_func(klass, allocate_func);
+  klass.define_method("initialize", initialize_func);
+}
+
+inline void undef_alloc_func(Class const & klass)
+{
+  rb_undef_alloc_func(klass);
+}
+
+inline void undef_creation_funcs(Class const & klass)
+{
+  undef_alloc_func(klass);
+  rb_undef_method(klass, "initialize");
+}
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__creation_funcs__ipp_
+

data/rice/detail/default_allocation_func.hpp

@@ -0,0 +1,23 @@
+#ifndef Rice__detail__default_allocation_func__hpp_
+#define Rice__detail__default_allocation_func__hpp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+//! A default implementation of an allocate_func.  This function does no
+//! actual allocation; the initialize_func can later do the real
+//! allocation with: DATA_PTR(self) = new Type(arg1, arg2, ...)
+template<typename T>
+VALUE default_allocation_func(VALUE klass);
+
+} // detail
+
+} // Rice
+
+#include "default_allocation_func.ipp"
+
+#endif // Rice__detail__default_allocation_func__hpp_
+

data/rice/detail/default_allocation_func.ipp

@@ -0,0 +1,11 @@
+#include "../Data_Object.hpp"
+
+template<typename T>
+VALUE Rice::detail::
+default_allocation_func(VALUE klass)
+{
+  Data_Object<T> m(static_cast<T*>(0), klass);
+  return m.value();
+} 
+
+

data/rice/detail/define_method_and_auto_wrap.hpp

@@ -0,0 +1,31 @@
+#ifndef Rice__detail__define_method_and_auto_wrap__hpp_
+#define Rice__detail__define_method_and_auto_wrap__hpp_
+
+#include "ruby.hpp"
+#include "../Data_Object.hpp"
+#include "../Identifier.hpp"
+#include "Arguments.hpp"
+
+namespace Rice
+{
+
+namespace detail
+{
+
+class Exception_Handler;
+
+template<typename Fun_T>
+void define_method_and_auto_wrap(
+    VALUE klass,
+    Identifier name,
+    Fun_T function,
+    Data_Object<Exception_Handler> handler,
+    Arguments* arguments = 0);
+
+} // detail
+
+} // Rice
+
+#include "define_method_and_auto_wrap.ipp"
+
+#endif // Rice__detail__define_method_and_auto_wrap__hpp_