rice 1.0.0

data/rice/Object.cpp

@@ -0,0 +1,153 @@
+#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_iv_get, *this, name.c_str());
+}
+
+Rice::Object Rice::Object::
+vcall(
+    Identifier id,
+    Array args)
+{
+  return protect(rb_funcall3, *this, id, args.size(), args->ptr);
+}
+
+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_iv_set, *this, name.c_str(), to_ruby(value));
+}
+
+#endif // Rice__Object__ipp_
+

data/rice/Object_defn.hpp

@@ -0,0 +1,183 @@
+#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;
+
+#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,93 @@
+#include "String.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());
+}
+