rice 2.1.1 → 4.0.0

data/rice/Object.hpp

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

data/rice/Object.ipp

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

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

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

@@ -1,94 +0,0 @@
-#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<T_STRING>(protect(rb_str_new2, ""))
-{
-}
-
-Rice::String::
-String(VALUE v)
-  : Builtin_Object<T_STRING>(v)
-{
-}
-
-Rice::String::
-String(Object v)
-  : Builtin_Object<T_STRING>(v)
-{
-}
-
-Rice::String::
-String(char const * s)
-  : Builtin_Object<T_STRING>(protect(rb_str_new2, s))
-{
-}
-
-Rice::String::
-String(std::string const & s)
-  : Builtin_Object<T_STRING>(protect(rb_str_new, s.data(), s.length()))
-{
-}
-
-Rice::String::
-String(Identifier id)
-  : Builtin_Object<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 std::string(RSTRING_PTR(value()), length());
-}
-
-Rice::Identifier Rice::String::
-intern() const
-{
-  return rb_intern(c_str());
-}
-

data/rice/String.hpp

@@ -1,91 +0,0 @@
-#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<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;
-}
-
-#include "Builtin_Object.ipp"
-
-#endif // Rice__String__hpp_
-

data/rice/Struct.cpp

@@ -1,117 +0,0 @@
-#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<T_STRUCT>(type.new_instance(args))
-  , type_(type)
-{
-}
-
-Rice::Struct::Instance::
-Instance(
-    Struct const & type,
-    Object s)
-  : Builtin_Object<T_STRUCT>(s)
-  , type_(type)
-{
-}
-
-void Rice::Struct::Instance::
-swap(Instance & other)
-{
-  type_.swap(other.type_);
-  Builtin_Object<T_STRUCT>::swap(other);
-}
-
-Rice::Struct Rice::
-define_struct()
-{
-  return Struct();
-}
-