rice 3.0.0 → 4.0.3

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());
-}

data/rice/detail/demangle.hpp

@@ -1,19 +0,0 @@
-#ifndef Rice__detail__demangle__hpp_
-#define Rice__detail__demangle__hpp_
-
-#include <string>
-
-namespace Rice
-{
-
-namespace detail
-{
-
-std::string demangle(char const * mangled_name);
-std::string demangle(std::string const & mangled_name);
-
-} // detail
-
-} // Rice
-
-#endif // Rice__detail__demangle__hpp_

data/rice/detail/env.hpp

@@ -1,11 +0,0 @@
-#ifndef Rice__detail__env__hpp_
-#define Rice__detail__env__hpp_
-
-/**
- * Helper header for the env.h ruby include file, which does
- * not have extern "C"
- */
-
-#include "ruby_version_code.hpp"
-
-#endif

data/rice/detail/method_data.cpp

@@ -1,92 +0,0 @@
-#include "method_data.hpp"
-#include "ruby.hpp"
-
-// TODO: This is silly, autoconf...
-#undef PACKAGE_NAME
-#undef PACKAGE_STRING
-#undef PACKAGE_TARNAME
-#undef PACKAGE_VERSION
-#include "../config.hpp"
-
-#define RICE_ID rb_intern("__rice__")
-
-VALUE
-Rice::detail::
-method_data()
-{
-  ID id;
-  VALUE klass;
-  if (!rb_frame_method_id_and_class(&id, &klass))
-  {
-    rb_raise(
-        rb_eRuntimeError,
-        "Cannot get method id and class for function");
-  }
-
-  if (rb_type(klass) == T_ICLASS) {
-    klass = rb_class_of(klass);
-  }
-
-  VALUE store = rb_ivar_get(klass, RICE_ID);
-  return (store == Qnil) ? Qnil : rb_ivar_get(store, id);
-}
-
-// Ruby 2.7 now includes a similarly named macro that uses templates to
-// pick the right overload for the underlying function. That doesn't work
-// for our cases because we are using this method dynamically and get a
-// compilation error otherwise. This removes the macro and lets us fall
-// back to the C-API underneath again.
-#undef rb_define_method_id
-
-// Define a method and attach data to it.
-// The method looks to ruby like a normal aliased CFUNC, with a modified
-// origin class.
-//
-// How this works:
-//
-// To store method data and have it registered with the GC, we need a
-// "slot" to put it in.  This "slot" must be recognized and marked by
-// the garbage collector.  There happens to be such a place we can put
-// data, and it has to do with aliased methods.  When Ruby creates an
-// alias for a method, it stores a reference to the original class in
-// the method entry.  The form of the method entry differs from ruby
-// version to ruby version, but the concept is the same across all of
-// them.
-// 
-// In Rice, we make use of this by attach the data to a dummy object 
-// (store) in the class variables table.
-// 
-// When Ruby makes a method call, it stores the class Object and method
-// ID in the current stack frame.  When Ruby calls into Rice, we grab
-// the class and method ID from the stack frame, then pull the data out
-// of the class. The data item is then used to determine how to convert
-// arguments and return type, how to handle exceptions, etc.
-//
-VALUE
-Rice::detail::
-define_method_with_data(
-    VALUE klass, ID id, VALUE (*cfunc)(ANYARGS), int arity, VALUE data)
-{
-  VALUE store = rb_attr_get(klass, RICE_ID);
-
-  if (store == Qnil) {
-    store = rb_obj_alloc(rb_cObject);
-    // store is stored in the instance variables table with
-    // name "__rice__".
-    // since "__rice__" does not have the @ prefix,
-    // so it can never be read at the Ruby level.
-    rb_ivar_set(klass, RICE_ID, store);
-  }
-
-  rb_ivar_set(store, id, data);
-
-  // Create the aliased method on the origin class
-  rb_define_method_id(
-      klass,
-      id,
-      cfunc,
-      arity);
-
-  return Qnil;
-}
-

data/rice/detail/node.hpp

@@ -1,13 +0,0 @@
-#ifndef Rice__detail__node__hpp_
-#define Rice__detail__node__hpp_
-
-/**
- * Helper header for the node.h ruby include file, which does
- * not have extern "C"
- */
-
-extern "C" {
-  #include "node.h"
-}
-
-#endif

data/rice/detail/protect.cpp

@@ -1,29 +0,0 @@
-#include "protect.hpp"
-#include "../Exception.hpp"
-#include "../Jump_Tag.hpp"
-
-#ifndef TAG_RAISE
-#define TAG_RAISE 0x6
-#endif
-
-VALUE Rice::detail::
-protect(
-    RUBY_VALUE_FUNC f,
-    VALUE arg)
-{
-  int state = 0;
-  VALUE retval = rb_protect(f, arg, &state);
-  if(state != 0)
-  {
-    VALUE err = rb_errinfo();
-    if(state == TAG_RAISE && RTEST(err))
-    {
-      // TODO: convert NoMemoryError into bad_alloc?
-      rb_set_errinfo(Rice::Nil);
-      throw Rice::Exception(err);
-    }
-    throw Jump_Tag(state);
-  }
-  return retval;
-}
-

data/rice/detail/protect.hpp

@@ -1,34 +0,0 @@
-#ifndef Rice__detail__protect__hpp_
-#define Rice__detail__protect__hpp_
-
-#include "ruby.hpp"
-
-/*! \file
- *  \brief Functions for making exception-safe calls into Ruby code.
- *  These are the building blocks for building other exception-safe
- *  helper functions.
- */
-
-namespace Rice
-{
-
-namespace detail
-{
-
-//! Call the given function, converting Ruby exceptions to C++
-//! exceptions.
-/*! Call the function f with the parameter arg  If f raises a Ruby
- * exception, then the exception is re-thrown as an Exception.  If f
- * exits with any other non-zero tag (e.g. a Symbol is thrown), then the
- * tag is re-thrown as a Jump_Tag.
- */
-VALUE protect(
-    RUBY_VALUE_FUNC f,
-    VALUE arg);
-
-} // namespace detail
-
-} // namespace Rice
-
-#endif // Rice__detail__protect__hpp_
-

data/rice/detail/ruby_version_code.hpp

@@ -1,6 +0,0 @@
-#ifndef Rice__detail__ruby_version_code__hpp
-#define Rice__detail__ruby_version_code__hpp
-
-#define RICE__RUBY_VERSION_CODE 300
-
-#endif // Rice__detail__ruby_version_code__hpp