wurlinc-rice 1.4.0.1

data/rice/ruby_mark.hpp

@@ -0,0 +1,13 @@
+#ifndef ruby_mark__hpp
+#define ruby_mark__hpp
+
+//! Default function to call to mark a data object.
+/*! This function can be specialized for a particular type to override
+ *  the default behavior (which is to not mark any additional objects).
+ */
+template<typename T>
+void ruby_mark(T * /* obj */)
+{
+}
+
+#endif // ruby_mark__hpp

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_defn.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/rubypp.rb

@@ -0,0 +1,97 @@
+class Preprocessor
+  def initialize(input, output, filename)
+    @input = input
+    @output = output
+    @filename = filename
+    @linenum = 1
+  end
+
+  def getline
+    line = @input.gets
+    @linenum += 1 if not line.nil?
+    return line
+  end
+
+  def preprocess
+    success = false
+    begin
+      loop do
+        line = getline
+        break if line.nil?
+        case line
+        when /(.*[^\\]|^)\#\{(.*?)\}(.*)/
+          puts "#{$1}#{evaluate($2, @linenum)}#{$3}"
+        when /^\#ruby\s+<<(.*)/
+          marker = $1
+          str = ''
+          evalstart = @linenum
+          loop do
+            line = getline
+            if line.nil? then
+              raise "End of input without #{marker}"
+            end
+            break if line.chomp == marker
+            str << line
+          end
+          result = evaluate(str, evalstart)
+          puts result if not result.nil?
+        when /^\#ruby\s+(.*)/
+          str = line = $1
+          while line[-1] == ?\\
+            str.chop!
+            line = getline
+            break if line.nil?
+            line.chomp!
+            str << line
+          end
+          result = evaluate(str, @linenum)
+          puts result if not result.nil?
+        else
+          puts line
+        end
+      end
+      success = true
+    ensure
+      if not success then
+        $stderr.puts "Error on line #{@linenum}:"
+      end
+    end
+  end
+
+  def evaluate(str, linenum)
+    result = eval(str, TOPLEVEL_BINDING, @filename, linenum)
+    success = true
+    return result
+  end
+
+  def puts(line='')
+    @output.puts(line)
+  end
+end
+
+def puts(line='')
+  $preprocessor.puts(line)
+end
+
+def rubypp(input_file, output_file)
+  input = input_file ? File.open(input_file) : $stdin
+  output = output_file ? File.open(output_file, 'w') : $stdout
+
+  success = false
+  begin
+    $preprocessor = Preprocessor.new(input, output, input_file || "(stdin)")
+    $preprocessor.preprocess()
+    success = true
+  ensure
+    if not success then
+      File.unlink(output_file) rescue Errno::ENOENT
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  input_file = ARGV[0]
+  output_file = ARGV[1]
+  rubypp(input_file, output_file)
+end
+

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,297 @@
+#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_LEN(x.value()) == 0)
+    {
+      return RSTRING_PTR(x.value())[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);
+}
+
+// ---------------------------------------------------------------------
+template<>
+inline
+char const * from_ruby<char const *>(Rice::Object x)
+{
+  // TODO: Maybe not the right way to do this conversion (what happens
+  // if the object gets GC'd?)
+  VALUE v(x.value());
+  return (char const *)Rice::protect<char const *>(rb_string_value_cstr, &v);
+}
+
+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());
+}
+
+template<>
+inline
+std::string* from_ruby<std::string* >(Rice::Object x)
+{
+  return new std::string(from_ruby<char const *>(x));
+}

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 an
+ *  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_
+

data/ruby/Makefile.am

@@ -0,0 +1 @@
+SUBDIRS = lib

data/ruby/lib/Makefile.am

@@ -0,0 +1,3 @@
+rubydir = @RUBY_SITELIBDIR@
+
+ruby_DATA = mkmf-rice.rb