rice 3.0.0 → 4.0.3

data/rice/Object_defn.hpp

@@ -1,214 +0,0 @@
-#ifndef Rice__Object_defn__hpp_
-#define Rice__Object_defn__hpp_
-
-/*! \file Object.hpp
- */
-
-#include "Identifier.hpp"
-#include "detail/ruby.hpp"
-
-#include <iosfwd>
-#include <vector>
-
-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;
-
-  //! Call the Ruby method specified by 'id' on object 'obj'.
-  /*! Pass in arguments (arg1, arg2, ...).  The arguments will be converted to
-  *  Ruby objects with to_ruby<>.
-  *
-  *  E.g.:
-  *  \code
-  *    Rice::Object obj = x.call("foo", "one", 2);
-  *  \endcode
-  *
-  *  If a return type is specified, the return value will automatically be
-  *  converted to that type as long as 'from_ruby' exists for that type.
-  *
-  *  E.g.:
-  *  \code
-  *    float ret = x.call<float>("foo", z, 42);
-  *  \endcode
-  */
-  template<typename ...ArgT>
-  Object call(Identifier id, ArgT... args) const;
-
-  //! 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);
-
-  //! Unpack the provided arguments and convert them all to Ruby types.
-  template<typename ...ArgT>
-  std::vector<VALUE> convert_args(ArgT&... args) const;
-
-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,89 +0,0 @@
-#include "String.hpp"
-#include "Builtin_Object.hpp"
-#include "protect.hpp"
-#include "detail/ruby.hpp"
-
-#include <stdarg.h>
-#define va_init_list(a,b) va_start(a,b)
-
-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(), (long)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;
-}
-
-unsigned long Rice::Struct::
-offset_of(Identifier name) const
-{
-  Symbol ruby_name(name);
-  return from_ruby<unsigned long>(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();
-}
-

data/rice/Struct.hpp

@@ -1,162 +0,0 @@
-#ifndef Rice__ruby_struct__hpp_
-#define Rice__ruby_struct__hpp_
-
-#include "Array.hpp"
-#include "Hash.hpp"
-#include "Module.hpp"
-#include "Class.hpp"
-#include "Builtin_Object.hpp"
-#include "Address_Registration_Guard.hpp"
-
-namespace Rice
-{
-	class Struct;
-
-//! Define a new Struct
-Struct define_struct();
-
-//! A wrapper for creating Struct classes.
-/*! The Struct class is used for creating new Classes.  Note that the
- *  notation used here differs slightly from the notation inside the
- *  interpreter.
- *
- *  Inside the interpreter, calling Struct.new creates a new Class:
- *  \code
- *  irb(main):001:0> MyStruct = Struct.new(:a, :b, :c)
- *  => S
- *  irb(main):002:0> MyStruct.class
- *  => Class
- *  \endcode
- *
- *  Instantiating that Class creates an instance of that Class:
- *  \code
- *  irb(main):003:0> mystruct_instance = MyStruct.new
- *  => #<struct MyStruct a=nil, b=nil, c=nil>
- *  irb(main):004:0> mystruct_instance.class
- *  => MyStruct
- *  irb(main):005:0> mystruct_instance.class.ancestors
- *  => [MyStruct, Struct, Enumerable, Object, Kernel]
- *  \endcode
- *
- *  Thus, inside the interpreter, MyStruct is a Class which inherits
- *  from Struct, and mystruct_instance is an instance of MyStruct.
- *
- *  At the C++ level, we might do this instead:
- *  \code
- *  Struct rb_cMyStruct = define_struct()
- *    .define_member("a")
- *    .define_member("b")
- *    .define_member("c")
- *    .initialize("MyStruct");
- *  Struct::Instance mystruct_instance(rb_cMyStruct.new_instance());
- *  \endcode
- *
- * Here rb_cMyStruct is an instance of Struct and that mystruct_instance
- * is an instance of Struct::Instance.
- */
-class Struct
-  : public Module_impl<Class, Struct>
-{
-public:
-  //! Create a new Struct.
-  Struct();
-
-  //! Copy constructor.
-  Struct(Struct const & s);
-
-  //! Destructor.
-  virtual ~Struct();
-
-  //! Define a new Struct member.
-  /*! Defines a new member of the Struct.  Must be called before the
-   *  Struct is initialized.
-   *  \return *this
-   */
-  Struct & define_member(
-      Identifier name);
-
-  //! Initialize the Struct class.
-  /*! Must be called after all Struct members have been defined.
-   *  \param module the module under which to define the Struct.
-   *  \param name the name of the Class at the ruby level.
-   */
-  Struct & initialize(
-      Module module,
-      Identifier name);
-
-  //! Get the offset of a member in the Struct.
-  /*! Internally, Struct members are stored as a single array of VALUE.
-   *  This function determines the offset of a given member in that
-   *  array.
-   *  \param member the name of the desired member.
-   *  \return the index of the given member.
-   */
-  unsigned long offset_of(Identifier name) const;
-
-  class Instance;
-  friend class Instance;
-  friend Struct Rice::define_struct();
-
-  //! Create a new instance of the Struct
-  /*! \param args the arguments to the constructor.
-   *  \return a new Struct::Instance
-   */
-  Instance new_instance(Array args = Array()) const;
-
-  //! Swap with another Struct.
-  void swap(Struct & other);
-
-  Array members() const { return members_; }
-
-private:
-  Array members_;
-  Address_Registration_Guard members_guard_;
-
-  Hash member_offset_;
-  Address_Registration_Guard member_offset_guard_;
-};
-
-
-//! An instance of a Struct
-//! \sa Struct
-class Struct::Instance
-  : public Builtin_Object<T_STRUCT>
-{
-public:
-  //! Create a new Instance of a Struct.
-  /*! \param type the Struct type to create.
-   *  \param args the initial values for the objects of the instance.
-   */
-  Instance(
-      Struct const & type,
-      Array args = Array());
-
-  //! Encapsulate an existing Struct instance.
-  /*! \param type the Struct type to encapsulate.
-   *  \param s the instance to encapsulate.
-   */
-  Instance(
-      Struct const & type,
-      Object s);
-
-  //! Get a member, given its offset.
-  /*! \param index the (integral) index into the Struct's internal
-   *  array or its name (an Identifier or char const *)
-   *  \return the member.
-   */
-  template<typename T>
-  Object operator[](T index);
-
-  //! Swap with another Struct::Instance.
-  void swap(Instance & other);
-
-private:
-  Struct type_;
-};
-
-} // namespace Rice
-
-#include "Struct.ipp"
-
-#endif // Rice__ruby_struct__hpp_
-