rice 2.1.2 → 4.0.1

data/rice/detail/Caster.hpp

@@ -1,103 +0,0 @@
-#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/Not_Copyable.hpp

@@ -1,25 +0,0 @@
-#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

@@ -1,33 +0,0 @@
-#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

@@ -1,24 +0,0 @@
-#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

@@ -1,51 +0,0 @@
-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

@@ -1,27 +0,0 @@
-#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

@@ -1,23 +0,0 @@
-#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

@@ -1,37 +0,0 @@
-#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

@@ -1,36 +0,0 @@
-#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/define_method_and_auto_wrap.hpp

@@ -1,31 +0,0 @@
-#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_

data/rice/detail/define_method_and_auto_wrap.ipp

@@ -1,30 +0,0 @@
-#ifndef Rice__detail__define_method_and_auto_wrap__ipp_
-#define Rice__detail__define_method_and_auto_wrap__ipp_
-
-#include "wrap_function.hpp"
-#include "method_data.hpp"
-#include "Exception_Handler_defn.hpp"
-#include "../protect.hpp"
-
-template<typename Fun_T>
-void Rice::detail::
-define_method_and_auto_wrap(
-    VALUE klass,
-    Identifier name,
-    Fun_T function,
-    Data_Object<Exception_Handler> handler,
-    Arguments* arguments)
-{
-  Data_Object<Wrapped_Function> f(
-      wrap_function(function, handler, arguments),
-      rb_cObject);
-  Rice::protect(
-      define_method_with_data,
-      klass,
-      name.id(),
-      f->func(),
-      -1,
-      f);
-}
-
-#endif // Rice__detail__define_method_and_auto_wrap__ipp_

data/rice/detail/demangle.cpp

@@ -1,56 +0,0 @@
-#include "demangle.hpp"
-
-#ifdef __GNUC__
-#include <cxxabi.h>
-#include <cstdlib>
-#include <cstring>
-#endif
-
-std::string
-Rice::detail::
-demangle(char const * mangled_name)
-{
-#ifdef __GNUC__
-    struct Helper
-  {
-    Helper(
-        char const * mangled_name)
-      : name_(0)
-    {
-      int status = 0;
-      name_ = abi::__cxa_demangle(mangled_name, 0, 0, &status);
-    }
-
-    ~Helper()
-    {
-      std::free(name_);
-    }
-
-    char * name_;
-
-  private:
-    Helper(Helper const &);
-    void operator=(Helper const &);
-  };
-
-  Helper helper(mangled_name);
-  if(helper.name_)
-  {
-    return helper.name_;
-  }
-  else
-  {
-    return mangled_name;
-  }
-#else
-  return mangled_name;
-#endif
-}
-
-
-std::string
-Rice::detail::
-demangle(std::string const & mangled_name)
-{
-  return demangle(mangled_name.c_str());
-}