wurlinc-rice 1.4.0.1

data/rice/Object.cpp

@@ -0,0 +1,160 @@
+#include "Object.hpp"
+#include "Class.hpp"
+#include "String.hpp"
+#include "Array.hpp"
+
+#include <algorithm>
+#include <iostream>
+
+namespace Rice
+{
+
+Object const Nil(Qnil);
+Object const True(Qtrue);
+Object const False(Qfalse);
+Object const Undef(Qundef);
+
+}
+
+Rice::Class Rice::Object::
+class_of() const {
+  return rb_class_of(value_);
+}
+
+int Rice::Object::
+compare(Object const & other) const
+{
+  Object result = call("<=>", other);
+  return from_ruby<int>(result);
+}
+
+void Rice::Object::
+freeze()
+{
+  protect(rb_obj_freeze, value());
+}
+
+bool Rice::Object::
+is_frozen() const
+{
+  return bool(OBJ_FROZEN(value()));
+}
+
+Rice::String Rice::Object::
+to_s() const {
+  return call("to_s");
+}
+
+Rice::String Rice::Object::
+inspect() const {
+  return call("inspect");
+}
+
+void Rice::Object::
+swap(Rice::Object & other)
+{
+  std::swap(value_, other.value_);
+}
+
+Rice::Object Rice::Object::
+instance_eval(String const & s)
+{
+  VALUE argv[] = { s.value() };
+  return protect(rb_obj_instance_eval, 1, &argv[0], *this);
+}
+
+int Rice::Object::
+rb_type() const
+{
+  return ::rb_type(*this);
+}
+
+bool Rice::Object::
+is_a(Object klass) const
+{
+  Object result = protect(rb_obj_is_kind_of, *this, klass);
+  return result.test();
+}
+
+bool Rice::Object::
+respond_to(Identifier id) const
+{
+  return bool(rb_respond_to(*this, id));
+}
+
+bool Rice::Object::
+is_instance_of(Object klass) const
+{
+  Object result = protect(rb_obj_is_instance_of, *this, klass);
+  return result.test();
+}
+
+Rice::Object Rice::Object::
+iv_get(
+    Identifier name) const
+{
+  return protect(rb_ivar_get, *this, name.id());
+}
+
+Rice::Object Rice::Object::
+attr_get(
+    Identifier name) const
+{
+  return protect(rb_attr_get, *this, name.id());
+}
+
+Rice::Object Rice::Object::
+vcall(
+    Identifier id,
+    Array args)
+{
+  return protect(rb_funcall3, *this, id, args.size(), args.to_c_array());
+}
+
+void Rice::Object::
+mark() const
+{
+  rb_gc_mark(*this);
+}
+
+void Rice::Object::
+set_value(VALUE v)
+{
+  value_ = v;
+}
+
+std::ostream & Rice::
+operator<<(std::ostream & out, Rice::Object const & obj)
+{
+  String s(obj.to_s());
+  out << s.c_str();
+  return out;
+}
+
+bool Rice::
+operator==(Rice::Object const & lhs, Rice::Object const & rhs)
+{
+  Object result = lhs.call("==", rhs);
+  return result.test();
+}
+
+bool Rice::
+operator!=(Rice::Object const & lhs, Rice::Object const & rhs)
+{
+  return !(lhs == rhs);
+}
+
+bool Rice::
+operator<(Rice::Object const & lhs, Rice::Object const & rhs)
+{
+  Object result = lhs.call("<", rhs);
+  return result.test();
+}
+
+bool Rice::
+operator>(Rice::Object const & lhs, Rice::Object const & rhs)
+{
+  Object result = lhs.call(">", rhs);
+  return result.test();
+}
+

data/rice/Object.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__Object__hpp_
+#define Rice__Object__hpp_
+
+#include "Object_defn.hpp"
+#include "Object.ipp"
+
+#endif // Rice__Object__hpp_
+

data/rice/Object.ipp

@@ -0,0 +1,19 @@
+#ifndef Rice__Object__ipp_
+#define Rice__Object__ipp_
+
+#include "protect.hpp"
+#include "detail/ruby.hpp"
+
+#include "detail/object_call.ipp"
+
+template<typename T>
+void Rice::Object::
+iv_set(
+    Identifier name,
+    T const & value)
+{
+  protect(rb_ivar_set, *this, name.id(), to_ruby(value));
+}
+
+#endif // Rice__Object__ipp_
+

data/rice/Object_defn.hpp

@@ -0,0 +1,191 @@
+#ifndef Rice__Object_defn__hpp_
+#define Rice__Object_defn__hpp_
+
+/*! \file Object.hpp
+ */
+
+#include "Identifier.hpp"
+#include "detail/ruby.hpp"
+
+#include <iosfwd>
+
+namespace Rice
+{
+
+class Class;
+class String;
+class Array;
+
+//! The base class for all Objects
+/*! Perhaps the name "Object" is a misnomer, because this class really
+ *  holds an object reference, not an object.
+ */
+class Object
+{
+public:
+  //! Encapsulate an existing ruby object.
+  Object(VALUE value = Qnil) : value_(value) { }
+
+  //! Copy constructor
+  Object(Object const & other) : value_(other.value()) { }
+
+  //! Destructor
+  virtual ~Object() { }
+
+  //! Returns false if the object is nil or false; returns true
+  //! otherwise.
+  // Having this conversion also prevents accidental conversion to
+  // undesired integral types (e.g. long or int) by making the
+  // conversion ambiguous.
+  bool test() const { return RTEST(value_); }
+
+  //! Returns false if the object is nil or false; returns true
+  //! otherwise.
+  operator bool() const { return test(); }
+
+  //! Returns true if the object is nil, false otherwise.
+  bool is_nil() const { return NIL_P(value_); }
+
+  //! Implicit conversion to VALUE.
+  operator VALUE() const { return value_; }
+
+  //! Explicitly get the encapsulated VALUE.
+  // Returns a const ref so that Address_Registration_Guard can access
+  // the address where the VALUE is stored
+  VALUE const volatile & value() const { return value_; }
+
+  //! Get the class of an object.
+  /*! \return the object's Class.
+   */
+  Class class_of() const;
+
+  //! Compare this object to another object.
+  /*! Gets the result of self <=> other and returns the result.  The
+   *  result will be less than zero if self < other, greater than zero
+   *  if self > other, and equal to zero if self == other.
+   */
+  int compare(Object const & other) const;
+
+  //! Return a string representation of an object.
+  /*! \return the result of calling to_s on the object.  A String is not
+   *  returned, because it is not possible to return an instance of a
+   *  derived class.
+   */
+  String to_s() const;
+
+  //! Inspect the object.
+  /*! \return the result of calling inspect on the object.  A String is
+   *  not returned, because it is not possible to return an instance of
+   *  a derived class.
+   */
+  String inspect() const;
+
+  //! Freeze the object.
+  void freeze();
+
+  //! Determine if the object is frozen.
+  /*! \return true if the object is frozen, false otherwise.
+   */
+  bool is_frozen() const;
+
+  //! Swap with another Object.
+  void swap(Object & other);
+
+  //! Evaluate the given string in the context of the object.
+  /*! This is equivalant to calling obj.instance_eval(s) from inside the
+   *  interpreter.
+   *  \return the result of the expression.
+   */
+  Object instance_eval(String const & s);
+
+  //! Return the type of the underlying C object.
+  /*! This is equivalent to calling rb_type(obj).
+   * \return the type of the underlying C object (e.g. T_DATA, T_ARRAY,
+   * etc.).
+   */
+  int rb_type() const;
+
+  //! Determine whether the object is an instance of a class/module.
+  /*! \param klass a class or module.
+   *  \return true if the object is an instance of the given
+   *  class/module or one of its descendants.
+   */
+  bool is_a(Object klass) const;
+
+  //! Determine if the objects responds to a method.
+  /*! \param id the name of the method
+   *  \return true if the objects responds to the method, false
+   *  otherwise.
+   */
+  bool respond_to(Identifier id) const;
+
+  //! Determine whether class is the object's class.
+  /*! \param klass a class.
+   *  \return true if the object is an instance of the given class.
+   */
+  bool is_instance_of(Object klass) const;
+
+  //! Set an instance variable.
+  /*! \param name the name of the instance variable to set (including
+   *  the leading @ sign)
+   *  \param value the value of the variable, which will be converted to
+   *  a Ruby type if necessary.
+   */
+  template<typename T>
+  void iv_set(
+      Identifier name,
+      T const & value);
+
+  //! Get the value of an instance variable.
+  /*! \param name the name of the instance variable to get
+   *  \return the value of the instance variable
+   */
+  Object iv_get(
+      Identifier name) const;
+
+  //! Get the value of an instance variable, but don't warn if it is
+  //unset.
+  /*! \param name the name of the instance variable to get
+   *  \return the value of the instance variable
+   */
+  Object attr_get(
+      Identifier name) const;
+
+#include "detail/object_call.hpp"
+
+  //! Vectorized call.
+  /*! Calls the method identified by id with the list of arguments
+   *  identified by args.
+   *  \param id the name of the method to call
+   *  \param args the arguments to the method
+   *  \return the return value of the method call
+   */
+  Object vcall(Identifier id, Array args);
+
+  //! Mark the object with the garbage collector.
+  void mark() const;
+
+protected:
+  //! Set the encapsulated value.
+  void set_value(VALUE v);
+
+private:
+  volatile VALUE value_;
+};
+
+std::ostream & operator<<(std::ostream & out, Object const & obj);
+
+bool operator==(Object const & lhs, Object const & rhs);
+bool operator!=(Object const & lhs, Object const & rhs);
+bool operator<(Object const & lhs, Object const & rhs);
+bool operator>(Object const & lhs, Object const & rhs);
+
+extern Object const Nil;
+extern Object const True;
+extern Object const False;
+extern Object const Undef;
+
+} // namespace Rice
+
+#endif // Rice__Object_defn__hpp_
+

data/rice/Require_Guard.hpp

@@ -0,0 +1,21 @@
+#ifndef Rice__Require_Guard__hpp_
+#define Rice__Require_Guard__hpp_
+
+/*! \def RICE_REQUIRE_GUARD
+ *  \brief Put this inside your Init_module function to keep it from
+ *         being required more than once with the same name (if you use
+ *         Rice, and your module is initialized more than once, an
+ *         exception will be thrown).
+ */
+#define RICE_REQUIRE_GUARD \
+  static bool Rice__module_initialized = false; \
+  if(Rice__module_initialized) \
+  { \
+    return; \
+  } \
+  /* TODO: If module initialization fails, it's not possible to */ \
+  /* retry */ \
+  Rice__module_initialized = true
+
+#endif // Rice__Require_Guard__hpp_
+

data/rice/String.cpp

@@ -0,0 +1,94 @@
+#include "String.hpp"
+#include "Builtin_Object.hpp"
+#include "protect.hpp"
+#include "detail/ruby.hpp"
+
+#ifdef HAVE_STDARG_PROTOTYPES
+#include <stdarg.h>
+#define va_init_list(a,b) va_start(a,b)
+#else
+#include <varargs.h>
+#define va_init_list(a,b) va_start(a)
+#endif
+
+Rice::String::
+String()
+  : Builtin_Object<RString, T_STRING>(protect(rb_str_new2, ""))
+{
+}
+
+Rice::String::
+String(VALUE v)
+  : Builtin_Object<RString, T_STRING>(v)
+{
+}
+
+Rice::String::
+String(Object v)
+  : Builtin_Object<RString, T_STRING>(v)
+{
+}
+
+Rice::String::
+String(char const * s)
+  : Builtin_Object<RString, T_STRING>(protect(rb_str_new2, s))
+{
+}
+
+Rice::String::
+String(std::string const & s)
+  : Builtin_Object<RString, T_STRING>(protect(rb_str_new, s.c_str(), s.length()))
+{
+}
+
+Rice::String::
+String(Identifier id)
+  : Builtin_Object<RString, T_STRING>(protect(rb_str_new2, id.c_str()))
+{
+}
+
+Rice::String Rice::String::
+format(char const * fmt, ...)
+{
+  va_list args;
+  char buf[BUFSIZ];
+  
+  va_init_list(args, fmt);
+  vsnprintf(buf, BUFSIZ, fmt, args);
+  buf[BUFSIZ - 1] = '\0';
+  va_end(args);
+
+  String s = String(buf);
+  return s;
+}
+
+size_t Rice::String::
+length() const
+{
+  return RSTRING_LEN(value());
+}
+
+char Rice::String::
+operator[](ptrdiff_t index) const
+{
+  return RSTRING_PTR(value())[index];
+}
+
+char const * Rice::String::
+c_str() const
+{
+  return RSTRING_PTR(value());
+}
+
+std::string Rice::String::
+str() const
+{
+  return RSTRING_PTR(value());
+}
+
+Rice::Identifier Rice::String::
+intern() const
+{
+  return rb_intern(c_str());
+}
+

data/rice/String.hpp

@@ -0,0 +1,89 @@
+#ifndef Rice__String__hpp_
+#define Rice__String__hpp_
+
+#include "Identifier.hpp"
+#include "Builtin_Object_defn.hpp"
+#include "to_from_ruby_defn.hpp"
+#include "detail/ruby.hpp"
+#include <string>
+
+namespace Rice
+{
+
+//! A Wraper for the ruby String class.
+/*! This class provides a C++-style interface to ruby's String class and
+ *  its associated rb_str_* functions.
+ *
+ *  Example:
+ *  \code
+ *    String s(String::format("%s: %d", "foo", 42));
+ *    std::cout << s.length() << std::endl;
+ *  \endcode
+ */
+class String
+  : public Builtin_Object<RString, T_STRING>
+{
+public:
+  //! Construct a new string.
+  String();
+
+  //! Wrap an existing string.
+  String(VALUE v);
+
+  //! Wrap an existing string.
+  String(Object v);
+
+  //! Construct a String from an Identifier.
+  String(Identifier id);
+
+  //! Construct a String from a null-terminated C string.
+  String(char const * s);
+
+  //! Construct a String from an std::string.
+  String(std::string const & s);
+
+  //! Format a string using printf-style formatting.
+  static String format(char const * s, ...);
+
+  //! Get the length of the String.
+  /*! \return the length of the string.
+   */
+  size_t length() const;
+
+  //! Get the character at the given index.
+  /*! \param index the desired index.
+   *  \return the character at the given index.
+   */
+  char operator[](ptrdiff_t index) const;
+
+  //! Return a pointer to the beginning of the underlying C string.
+  char const * c_str() const;
+
+  //! Return a copy of the string as an std::string.
+  std::string str() const;
+
+  //! Create an Identifier from the String.
+  /*! Calls rb_intern to create an ID.
+   *  \return an Identifier holding the ID returned from rb_intern.
+   */
+  Identifier intern() const;
+};
+
+} // namespace Rice
+
+template<>
+inline
+Rice::String from_ruby<Rice::String>(Rice::Object x)
+{
+  return Rice::String(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<Rice::String>(Rice::String const & x)
+{
+  return x;
+}
+
+#endif // Rice__String__hpp_
+

data/rice/Struct.cpp

@@ -0,0 +1,117 @@
+#include "Struct.hpp"
+#include "Symbol.hpp"
+
+#include <stdexcept>
+
+Rice::Struct::
+Struct()
+  : Module_impl<Class, Struct>(rb_cObject)
+  , members_()
+  , members_guard_(&members_)
+  , member_offset_()
+  , member_offset_guard_(&member_offset_)
+{
+}
+
+Rice::Struct::
+Struct(Rice::Struct const & s)
+  : Module_impl<Class, Struct>(s)
+  , members_(s.members_.value())
+  , members_guard_(&members_)
+  , member_offset_(s.member_offset_.value())
+  , member_offset_guard_(&member_offset_)
+{
+}
+
+Rice::Struct::
+~Struct()
+{
+}
+
+Rice::Struct & Rice::Struct::
+initialize(
+    Module module,
+    Identifier name)
+{
+  Class struct_class(rb_cStruct);
+  Object type = struct_class.vcall("new", members_);
+
+  set_value(type);
+  module.const_set(name, type);
+
+  return *this;
+}
+
+Rice::Struct & Rice::Struct::
+define_member(
+    Identifier name)
+{
+  if(value() != rb_cObject)
+  {
+    throw std::runtime_error("struct is already initialized");
+  }
+
+  // TODO: not exception-safe
+  Symbol ruby_name(name);
+  member_offset_[ruby_name] = members_.size();
+  members_.push(ruby_name);
+
+  return *this;
+}
+
+size_t Rice::Struct::
+offset_of(Identifier name) const
+{
+  Symbol ruby_name(name);
+  return from_ruby<size_t>(member_offset_[ruby_name]);
+}
+
+void Rice::Struct::
+swap(Rice::Struct & other)
+{
+  members_.swap(other.members_);
+  members_guard_.swap(other.members_guard_);
+  member_offset_.swap(other.member_offset_);
+  member_offset_guard_.swap(other.member_offset_guard_);
+  Class::swap(other);
+}
+
+Rice::Struct::Instance
+Rice::Struct::
+new_instance(Array args) const
+{
+  Object instance = const_cast<Struct *>(this)->vcall("new", args);
+  return Instance(*this, instance);
+}
+
+Rice::Struct::Instance::
+Instance(
+    Struct const & type,
+    Array args)
+  : Builtin_Object<RStruct, T_STRUCT>(type.new_instance(args))
+  , type_(type)
+{
+}
+
+Rice::Struct::Instance::
+Instance(
+    Struct const & type,
+    Object s)
+  : Builtin_Object<RStruct, T_STRUCT>(s)
+  , type_(type)
+{
+}
+
+void Rice::Struct::Instance::
+swap(Instance & other)
+{
+  type_.swap(other.type_);
+  Builtin_Object<RStruct, T_STRUCT>::swap(other);
+}
+
+Rice::Struct Rice::
+define_struct()
+{
+  return Struct();
+}
+