rice 2.1.1 → 4.0.0

data/rice/rubypp.rb

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

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

@@ -1,294 +0,0 @@
-#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::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::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()) == 1)
-    {
-      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)
-{
-  return Rice::String(x).str().data();
-}
-
-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 Rice::String(x).str();
-}
-
-template<>
-inline
-Rice::Object to_ruby<std::string>(std::string const & x)
-{
-  return Rice::protect(rb_str_new, x.data(), x.size());
-}
-
-template<>
-inline
-std::string* from_ruby<std::string* >(Rice::Object x)
-{
-  return new std::string(Rice::String(x).str());
-}

data/rice/to_from_ruby_defn.hpp

@@ -1,70 +0,0 @@
-#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));
- *
- *    Foo * p_foo = new Foo();
- *    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_
-