jameskilton-rice 1.2.0

data/rice/detail/node.hpp

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

@@ -0,0 +1,85 @@
+// This is a generated file.  DO NOT EDIT!!
+#ifdef DOXYGEN
+
+//! Call the Ruby method specified by 'id' on object 'obj'.
+/*! Pass in arguments (arg1, arg2, ...).  The arguments will be converted to
+ *  Ruby objects with to_ruby<>.  The return value will automatically be
+ *  converted to type Retval_T with from_ruby<>.
+ *
+ *  E.g.:
+ *  \code
+ *    float y = x.call<float>("foo", z, 42);
+ *  \endcode
+ */
+template<typename Retval_T>
+Retval_T call(Identifier id, T1 arg1, T2 arg2, ...) const;
+
+//! Version of call which defaults to Object return type.
+Object call(Identifier id, T1 arg1, T2 arg2, ...) const;
+#else
+
+
+Object call(Identifier id) const;
+
+
+template<typename T1>
+Object call(Identifier id, T1 arg1) const;
+
+
+template<typename T1, typename T2>
+Object call(Identifier id, T1 arg1, T2 arg2) const;
+
+
+template<typename T1, typename T2, typename T3>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14) const;
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+Object call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15) const;
+
+
+#endif // DOXYGEN

data/rice/detail/object_call.ipp

@@ -0,0 +1,147 @@
+// This is a generated file.  DO NOT EDIT!!
+#include "../protect.hpp"
+#include "../to_from_ruby.hpp"
+
+
+inline Rice::Object Rice::Object::
+call(Identifier id) const
+{
+  VALUE args[] = {  };
+  return protect(rb_funcall2, value(), id, 0, args);
+}
+
+
+template<typename T1>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1) const
+{
+  VALUE args[] = { to_ruby(arg1) };
+  return protect(rb_funcall2, value(), id, 1, args);
+}
+
+
+template<typename T1, typename T2>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2) };
+  return protect(rb_funcall2, value(), id, 2, args);
+}
+
+
+template<typename T1, typename T2, typename T3>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3) };
+  return protect(rb_funcall2, value(), id, 3, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4) };
+  return protect(rb_funcall2, value(), id, 4, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5) };
+  return protect(rb_funcall2, value(), id, 5, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6) };
+  return protect(rb_funcall2, value(), id, 6, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7) };
+  return protect(rb_funcall2, value(), id, 7, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8) };
+  return protect(rb_funcall2, value(), id, 8, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8), to_ruby(arg9) };
+  return protect(rb_funcall2, value(), id, 9, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8), to_ruby(arg9), to_ruby(arg10) };
+  return protect(rb_funcall2, value(), id, 10, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8), to_ruby(arg9), to_ruby(arg10), to_ruby(arg11) };
+  return protect(rb_funcall2, value(), id, 11, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8), to_ruby(arg9), to_ruby(arg10), to_ruby(arg11), to_ruby(arg12) };
+  return protect(rb_funcall2, value(), id, 12, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8), to_ruby(arg9), to_ruby(arg10), to_ruby(arg11), to_ruby(arg12), to_ruby(arg13) };
+  return protect(rb_funcall2, value(), id, 13, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8), to_ruby(arg9), to_ruby(arg10), to_ruby(arg11), to_ruby(arg12), to_ruby(arg13), to_ruby(arg14) };
+  return protect(rb_funcall2, value(), id, 14, args);
+}
+
+
+template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+inline Rice::Object Rice::Object::
+call(Identifier id, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15) const
+{
+  VALUE args[] = { to_ruby(arg1), to_ruby(arg2), to_ruby(arg3), to_ruby(arg4), to_ruby(arg5), to_ruby(arg6), to_ruby(arg7), to_ruby(arg8), to_ruby(arg9), to_ruby(arg10), to_ruby(arg11), to_ruby(arg12), to_ruby(arg13), to_ruby(arg14), to_ruby(arg15) };
+  return protect(rb_funcall2, value(), id, 15, args);
+}
+

data/rice/detail/protect.cpp

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

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

@@ -0,0 +1,21 @@
+#ifndef Rice__detail__remove_const__hpp_
+#define Rice__detail__remove_const__hpp_
+
+namespace Rice
+{
+
+namespace detail
+{
+
+template<typename T>
+struct remove_const { typedef T Type; };
+
+template<typename T>
+struct remove_const<T const> { typedef T Type; };
+
+} // namespace detail
+
+} // namespace Rice
+
+#endif // Rice__detail__remove_const__hpp_
+

data/rice/detail/ruby.hpp

@@ -0,0 +1,89 @@
+#ifndef Rice__detail__ruby__hpp_
+#define Rice__detail__ruby__hpp_
+
+/*! \file
+ * \brief Hacks for addressing incompatibilities between various Ruby
+ * versions.
+ */
+
+#include <cmath>
+
+// missing.h that comes with the one-click installer doesn't properly
+// check for double-definition of isinf
+#ifdef isinf
+#define HAVE_ISINF
+#endif
+
+#include "ruby_version_code.hpp"
+
+// workaround for ruby 1.8.4, which defines eaccess and shouldn't
+#if RICE__RUBY_VERSION_CODE <= 184
+#define eaccess ruby_eaccess
+#endif
+
+#include <ruby.h>
+
+#if RICE__RUBY_VERSION_CODE <= 184
+#undef eaccess
+#endif
+
+#ifdef WIN32
+#include "win32.hpp"
+#endif
+
+// This causes problems with certain C++ libraries
+#undef TYPE
+
+//! A function that takes a VALUE as a parameter and returns a VALUE.
+// TODO: Casting from a C++ function to an extern "C" function won't
+// work on all platforms.  I'm not sure what to do about this.
+extern "C" typedef VALUE (*RUBY_VALUE_FUNC)(VALUE);
+
+// Fix Ruby RUBY_METHOD_FUNC from macro to typedef
+#if defined(RUBY_METHOD_FUNC)
+# undef RUBY_METHOD_FUNC
+  extern "C" typedef VALUE (*RUBY_METHOD_FUNC)(ANYARGS);
+#endif
+
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(str) RSTRING(str)->len
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(arr) RARRAY(arr)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(arr) RARRAY(arr)->ptr
+#endif
+
+#ifndef RHASH_TBL
+#define RHASH_TBL(hsh) RHASH(hsh)->tbl
+#endif
+
+// ruby.h has a few defines that conflict with Visual Studio's STL
+#if defined(_MSC_VER)
+  #undef write
+  #undef read
+  #undef bind
+#endif
+
+#if RICE__RUBY_VERSION_CODE < 190
+namespace Rice
+{
+  namespace detail
+  {
+    inline VALUE rb_errinfo() { return ruby_errinfo; }
+    inline void rb_set_errinfo(VALUE exc) { ruby_errinfo = exc; }
+  } // detail
+} // Rice
+#define rb_errinfo() ::Rice::detail::rb_errinfo()
+#define rb_set_errinfo(exc) ::Rice::detail::rb_set_errinfo(exc)
+#endif
+
+#endif // Rice__detail__ruby__hpp_
+

data/rice/detail/ruby_version_code.hpp

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

data/rice/detail/ruby_version_code.hpp.in

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

data/rice/detail/rubysig.hpp

@@ -0,0 +1,19 @@
+#ifndef Rice__detail__rubysig__hpp_
+#define Rice__detail__rubysig__hpp_
+
+#include "ruby_version_code.hpp"
+
+/**
+ * Helper header for the rubysig.h ruby include file, which does
+ * not have extern "C"
+ */
+
+#if RICE__RUBY_VERSION_CODE < 190
+
+extern "C" {
+  #include "rubysig.h"
+}
+
+#endif
+
+#endif