rice 1.0.0

data/rice/ruby_try_catch.hpp

@@ -0,0 +1,86 @@
+#ifndef Rice__ruby_try_catch__hpp_
+#define Rice__ruby_try_catch__hpp_
+
+#include "Exception_Base.hpp"
+#include "Jump_Tag.hpp"
+#include "detail/ruby.hpp"
+#include <stdexcept>
+
+/*! \def RUBY_TRY
+ *  \brief Start a block to catch Ruby exceptions and rethrow them.
+ */
+// Goto is used here to avoid having to use a second try/catch block (we
+// can't rb_exc_raise directly out of the catch blocks below, since the
+// exceptions will not get properly cleaned up).
+// The labels are located before the try and not after it so the function can't
+// "fall through" into the exception-handling code accidentally.
+#define RUBY_TRY \
+  VALUE Rice__ruby_exc = Qnil; \
+  int Rice__ruby_jump_tag = 0; \
+  \
+  goto start_of_RUBY_TRY; \
+  \
+  Rice__ruby_exception: \
+    rb_exc_raise(Rice__ruby_exc); \
+  Rice__ruby_jump_tag: \
+    rb_jump_tag(Rice__ruby_jump_tag); \
+  \
+  start_of_RUBY_TRY: \
+  try
+
+/*! \def RUBY_RETHROW(ex)
+ *  \brief Given a Ruby exception as a VALUE, safely raise the exception as a
+ *         Ruby exception.  This should be used inside a RUBY_TRY/RUBY_CATCH
+ *         block.
+ */
+#define RUBY_RETHROW(ex) \
+  Rice__ruby_exc = ex; \
+  goto Rice__ruby_exception;
+
+/*! \def RUBY_CATCH
+ *  \brief End a RUBY_TRY block.
+ */
+#define RUBY_CATCH \
+  catch(::Rice::Exception_Base const & ex) \
+  { \
+    RUBY_RETHROW(ex.value()); \
+  } \
+  catch(::Rice::Jump_Tag const & ex) \
+  { \
+    Rice__ruby_jump_tag = ex.tag; \
+    goto Rice__ruby_jump_tag; \
+  } \
+  catch(std::bad_alloc const & ex) \
+  { \
+    /* This won't work quite right if the rb_exc_new2 fails; not    */ \
+    /* much we can do about that, since Ruby doesn't give us access */ \
+    /* to a pre-allocated NoMemoryError object                      */ \
+    RUBY_RETHROW(rb_exc_new2(rb_eNoMemError, ex.what())); \
+  } \
+  catch(std::invalid_argument const & ex) \
+  { \
+    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
+    RUBY_RETHROW(rb_exc_new2(rb_eArgError, ex.what())); \
+  } \
+  catch(std::domain_error const & ex) \
+  { \
+    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
+    RUBY_RETHROW(rb_exc_new2(rb_eFloatDomainError, ex.what())); \
+  } \
+  catch(std::out_of_range const & ex) \
+  { \
+    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
+    RUBY_RETHROW(rb_exc_new2(rb_eRangeError, ex.what())); \
+  } \
+  catch(std::exception const & ex) \
+  { \
+    /* This can raise a NoMemoryError in VERY rare circumstances    */ \
+    RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, ex.what())); \
+  } \
+  catch(...) \
+  { \
+    RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, "unknown C++ exception thrown")); \
+  } \
+
+#endif // Rice__ruby_try_catch__hpp_
+

data/rice/to_from_ruby.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__to_from_ruby__hpp_
+#define Rice__to_from_ruby__hpp_
+
+#include "to_from_ruby_defn.hpp"
+#include "to_from_ruby.ipp"
+
+#endif // Rice__to_from_ruby__hpp_
+

data/rice/to_from_ruby.ipp

@@ -0,0 +1,299 @@
+#include "protect.hpp"
+#include "Object.hpp"
+#include "detail/from_ruby.ipp"
+#include "detail/to_ruby.ipp"
+
+// ---------------------------------------------------------------------
+template<>
+inline
+Rice::Object from_ruby<Rice::Object>(Rice::Object x)
+{
+  return x;
+}
+
+template<>
+inline
+Rice::Object to_ruby<Rice::Object>(Rice::Object const & x)
+{
+  return x;
+}
+
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline int num2int(VALUE x)
+    {
+      return NUM2INT(x);
+    }
+
+    inline VALUE int2num(int x)
+    {
+      return INT2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+int from_ruby<int>(Rice::Object x)
+{
+  return Rice::protect(Rice::detail::num2int, x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<int>(int const & x)
+{
+  return Rice::protect(Rice::detail::int2num, x);
+}
+
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline long num2long(VALUE x)
+    {
+      return NUM2LONG(x);
+    }
+
+    inline VALUE long2num(long x)
+    {
+      return LONG2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+long from_ruby<long>(Rice::Object x)
+{
+  return Rice::protect(Rice::detail::num2long, x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<long>(long const & x)
+{
+  return Rice::protect(Rice::detail::long2num, x);
+}
+
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline unsigned int num2uint(VALUE x)
+    {
+      return NUM2UINT(x);
+    }
+
+    inline VALUE uint2num(unsigned int x)
+    {
+      return UINT2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+unsigned int from_ruby<unsigned int>(Rice::Object x)
+{
+  return Rice::protect(Rice::detail::num2uint, x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<unsigned int>(unsigned int const & x)
+{
+  return Rice::protect(Rice::detail::uint2num, x);
+}
+
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline unsigned long num2ulong(VALUE x)
+    {
+      return NUM2ULONG(x);
+    }
+
+    inline VALUE ulong2num(unsigned long x)
+    {
+      return ULONG2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+unsigned long from_ruby<unsigned long>(Rice::Object x)
+{
+  return Rice::protect(Rice::detail::num2ulong, x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<unsigned long>(unsigned long const & x)
+{
+  return Rice::protect(Rice::detail::ulong2num, x);
+}
+
+// ---------------------------------------------------------------------
+template<>
+inline
+bool from_ruby<bool>(Rice::Object x)
+{
+  return RTEST(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<bool>(bool const & x)
+{
+  return x ? Qtrue : Qfalse;
+}
+
+// ---------------------------------------------------------------------
+template<>
+inline
+char from_ruby<char>(Rice::Object x)
+{
+  if(x.rb_type() == T_STRING)
+  {
+    if(RSTRING(x.value())->len == 0)
+    {
+      return RSTRING(x.value())->ptr[0];
+    }
+    else
+    {
+      throw std::invalid_argument("from_ruby<char>: string must have length 1");
+    }
+  }
+  else
+  {
+    return from_ruby<int>(x) & 0xff;
+  }
+}
+
+template<>
+inline
+Rice::Object to_ruby<char>(char const & x)
+{
+  return to_ruby<int>(x);
+}
+
+// ---------------------------------------------------------------------
+
+template<>
+inline
+unsigned char from_ruby<unsigned char>(Rice::Object x)
+{
+  // TODO: I'm not sure if this is the right behavior yet
+  return from_ruby<char>(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<unsigned char>(unsigned char const & x)
+{
+  return to_ruby<unsigned int>(x);
+}
+
+// ---------------------------------------------------------------------
+
+namespace Rice
+{
+  namespace detail
+  {
+    inline VALUE num2dbl(VALUE x, double * d)
+    {
+      *d = NUM2DBL(x);
+      return Qnil;
+    }
+
+    inline VALUE dbl2num(double x)
+    {
+      return rb_float_new(x);
+    }
+  }
+}
+
+template<>
+inline
+float from_ruby<float>(Rice::Object x)
+{
+  double d;
+  Rice::protect(Rice::detail::num2dbl, x, &d);
+  return float(d);
+}
+
+template<>
+inline
+Rice::Object to_ruby<float>(float const & x)
+{
+  return Rice::protect(Rice::detail::dbl2num, x);
+}
+
+// ---------------------------------------------------------------------
+
+template<>
+inline
+double from_ruby<double>(Rice::Object x)
+{
+  double d;
+  Rice::protect(Rice::detail::num2dbl, x, &d);
+  return d;
+}
+
+template<>
+inline
+Rice::Object to_ruby<double>(double const & x)
+{
+  return Rice::protect(Rice::detail::dbl2num, x);
+}
+
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline VALUE str2ccstr(VALUE x)
+    {
+      return (VALUE)(STR2CSTR(x));
+    }
+  }
+}
+
+template<>
+inline
+char const * from_ruby<char const *>(Rice::Object x)
+{
+  return (char const *)Rice::protect(Rice::detail::str2ccstr, x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<char const *>(char const * const & x)
+{
+  return Rice::protect(rb_str_new2, x);
+}
+
+// ---------------------------------------------------------------------
+template<>
+inline
+std::string from_ruby<std::string>(Rice::Object x)
+{
+  return std::string(from_ruby<char const *>(x));
+}
+
+template<>
+inline
+Rice::Object to_ruby<std::string>(std::string const & x)
+{
+  return to_ruby(x.c_str());
+}
+

data/rice/to_from_ruby_defn.hpp

@@ -0,0 +1,71 @@
+#ifndef Rice__to_from_ruby_defn__hpp_
+#define Rice__to_from_ruby_defn__hpp_
+
+#include "Object_defn.hpp"
+#include "detail/from_ruby.hpp"
+#include "detail/to_ruby.hpp"
+
+#include <typeinfo>
+#include <string>
+#include <stdexcept>
+
+// ---------------------------------------------------------------------
+
+//! Convert a Ruby object to C++.
+/*! If the Ruby object can be converted to an immediate value, returns a
+ *  copy of the Ruby object.  If the Ruby object is holding a C++
+ *  object and the type specified is a pointer to that type, returns a
+ *  pointer to that object.
+ *
+ *  Conversions from ruby to a pointer type are automatically generated
+ *  when a type is bound using Data_Type.  If no conversion exists, and
+ *  exception is thrown.
+ *
+ *  \param T the C++ type to which to convert.
+ *  \param x the Ruby object to convert.
+ *  \return a C++ representation of the Ruby object.
+ *
+ *  Example:
+ *  \code
+ *    Object x = INT2NUM(42);
+ *    std::cout << from_ruby<int>(x);
+ *
+ *    Data_Object<Foo> foo(new Foo);
+ *    Object obj(foo);
+ *    std::cout << *from_ruby<Foo *>(obj) << std::endl;
+ *  \endcode
+ */
+template<typename T>
+inline
+typename Rice::detail::from_ruby_<T>::Retval_T from_ruby(Rice::Object x)
+{
+  return Rice::detail::from_ruby_<T>::convert(x);
+}
+
+//! Convert a C++ object to Ruby.
+/*! If x is a pointer, wraps the pointee as a Ruby object.  If x is an
+ *  Object, returns x.
+ *
+ *  If no conversion exists, a compile-time error is generated.
+ *
+ *  \param x the object to convert.
+ *  \return a Ruby representation of the C++ object.
+ *
+ *  Example:
+ *  \code
+ *    rb_p(to_ruby(42));
+ *
+ *    Data_Object<Foo> foo(new Foo);
+ *    Foo * p_foo = foo.get();
+ *    rb_p(to_ruby(p_foo));
+ *  \endcode
+ */
+template<typename T>
+inline
+Rice::Object to_ruby(T const & x)
+{
+  return Rice::detail::to_ruby_<T>::convert(x);
+}
+
+#endif // Rice__to_from_ruby_defn__hpp_
+