wurlinc-rice 1.4.0.1

data/rice/Hash.ipp

@@ -0,0 +1,338 @@
+#ifndef Rice__Hash__ipp_
+#define Rice__Hash__ipp_
+
+#include "protect.hpp"
+#include "to_from_ruby.hpp"
+#include "Builtin_Object.hpp"
+#include "Exception.hpp"
+#include "Builtin_Object.hpp"
+#include <algorithm>
+
+// TODO: Evil hack
+struct st_table_entry {
+  unsigned int hash;
+  st_data_t key;
+  st_data_t record;
+  st_table_entry *next;
+};
+
+inline Rice::Hash::
+Hash()
+  : Builtin_Object<RHash, T_HASH>(protect(rb_hash_new))
+{
+}
+
+inline Rice::Hash::
+Hash(Object v)
+  : Builtin_Object<RHash, T_HASH>(v)
+{
+}
+
+inline size_t Rice::Hash::
+size() const
+{
+  return RHASH_TBL(this->value())->num_entries;
+}
+
+inline Rice::Hash::Proxy::
+Proxy(Hash hash, Object key)
+  : hash_(hash)
+  , key_(key)
+{
+}
+
+/*
+inline Rice::Hash::Proxy::
+operator VALUE() const
+{
+  return value();
+}
+*/
+
+inline Rice::Hash::Proxy::
+operator Rice::Object() const
+{
+  return value();
+}
+
+inline VALUE Rice::Hash::Proxy::
+value() const
+{
+  return protect(rb_hash_aref, hash_, key_);
+}
+
+template<typename T>
+inline Rice::Object Rice::Hash::Proxy::
+operator=(T const & value)
+{
+  return protect(rb_hash_aset, hash_, key_, to_ruby(value));
+}
+
+inline void Rice::Hash::Proxy::
+swap(Proxy & proxy)
+{
+  hash_.swap(proxy.hash_);
+  key_.swap(proxy.key_);
+}
+
+template<typename Key_T>
+inline Rice::Hash::Proxy const Rice::Hash::
+operator[](Key_T const & key) const
+{
+  return Proxy(*this, to_ruby(key));
+}
+
+template<typename Key_T>
+inline Rice::Hash::Proxy Rice::Hash::
+operator[](Key_T const & key)
+{
+  return Proxy(*this, to_ruby(key));
+}
+
+template<typename Value_T, typename Key_T>
+inline Value_T Rice::Hash::
+get(Key_T const & key)
+{
+  Object ruby_key(to_ruby(key));
+  Object value = operator[](ruby_key);
+  try
+  {
+    return from_ruby<Value_T>(value);
+  }
+  catch(Exception const & ex)
+  {
+    String s_key(ruby_key.to_s());
+    throw Exception(
+        ex,
+        "%s while converting value for key %s",
+        ex.what(),
+        s_key.c_str());
+  }
+}
+
+inline Rice::Hash::Entry::
+Entry(Hash hash, Object key)
+  : key(key)
+  , first(Hash::Entry::key)
+  , value(hash, key)
+  , second(Hash::Entry::value)
+{
+}
+
+inline Rice::Hash::Entry::
+Entry(Entry const & entry)
+  : key(entry.key)
+  , first(Hash::Entry::key)
+  , value(entry.value)
+  , second(Hash::Entry::value)
+{
+}
+
+inline Rice::Hash::Entry & Rice::Hash::Entry::
+operator=(Rice::Hash::Entry const & rhs)
+{
+  Entry tmp(rhs);
+  swap(tmp);
+  return *this;
+}
+
+inline void Rice::Hash::Entry::
+swap(Rice::Hash::Entry & entry)
+{
+  const_cast<Object &>(key).swap(const_cast<Object &>(entry.key));
+  value.swap(entry.value);
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+Iterator(Hash_Ref_T hash, st_data_t bin, st_table_entry * ptr)
+  : hash_(hash)
+  , tbl_(RHASH_TBL(hash.value()))
+  , bin_(bin)
+  , ptr_(ptr)
+  , tmp_(hash, Qnil)
+{
+  // If we aren't already at the end, then use the increment operator to
+  // point to the first element
+  if(!ptr_ && bin_ < tbl_->num_bins)
+  {
+    operator++();
+  }
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+Iterator(Iterator const & iterator)
+  : hash_(iterator.hash_.value())
+  , tbl_(iterator.tbl_)
+  , bin_(iterator.bin_)
+  , ptr_(iterator.ptr_)
+  , tmp_(iterator.hash_, Qnil)
+{
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+template<typename Iterator_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+Iterator(Iterator_T const & iterator)
+  : hash_(iterator.hash_.value())
+  , tbl_(iterator.tbl_)
+  , bin_(iterator.bin_)
+  , ptr_(iterator.ptr_)
+  , tmp_(iterator.hash_, Qnil)
+{
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T> &
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator=(Iterator const & iterator)
+{
+  Iterator tmp(iterator);
+
+  this->swap(tmp);
+
+  return *this;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T> &
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator++()
+{
+  // Go to the next element in the bin; this will be a no-op if we were
+  // called from the constructor, because ptr_ will be 0 (and if its
+  // not, this function won't get called).
+  if(ptr_)
+  {
+    ptr_ = ptr_->next;
+  }
+
+  // If we've reached the end of the bin, then try the next bin until
+  // we have run out of bins
+  while(ptr_ == 0)
+  {
+    ++bin_;
+    if(bin_ == tbl_->num_bins)
+    {
+      // At the end..
+      return *this;
+    }
+    ptr_ = tbl_->bins[bin_];
+  }
+
+  return *this;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Rice::Hash::Iterator<Hash_Ref_T, Value_T>
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator++(int)
+{
+  Iterator copy(*this);
+  ++(*this);
+  return copy;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Value_T
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator*()
+{
+  return Value_T(hash_, ptr_->key);
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline Value_T *
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator->()
+{
+  Entry tmp(hash_, ptr_->key);
+  this->tmp_.swap(tmp);
+  return &tmp_;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline bool Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator==(Iterator const & rhs) const
+{
+  return hash_.value() == rhs.hash_.value()
+    && tbl_ == rhs.tbl_
+    && bin_ == rhs.bin_
+    && ptr_ == rhs.ptr_;
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline bool Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+operator!=(Iterator const & rhs) const
+{
+  return !(*this == rhs);
+}
+
+template<typename Hash_Ref_T, typename Value_T>
+inline void
+Rice::Hash::Iterator<Hash_Ref_T, Value_T>::
+swap(Iterator& iterator)
+{
+  using namespace std;
+
+  hash_.swap(iterator.hash_);
+  swap(tbl_, iterator.tbl_);
+  swap(bin_, iterator.bin_);
+  swap(ptr_, iterator.ptr_);
+}
+
+inline Rice::Hash::iterator Rice::Hash::
+begin()
+{
+  st_table * tbl(RHASH_TBL(value()));
+  return iterator(*this, 0, tbl->bins[0]);
+}
+
+inline Rice::Hash::const_iterator Rice::Hash::
+begin() const
+{
+  st_table * tbl(RHASH_TBL(value()));
+  return const_iterator(*this, 0, tbl->bins[0]);
+}
+
+inline Rice::Hash::iterator Rice::Hash::
+end()
+{
+  st_table * tbl(RHASH_TBL(value()));
+  return iterator(*this, tbl->num_bins, 0);
+}
+
+inline Rice::Hash::const_iterator Rice::Hash::
+end() const
+{
+  st_table * tbl(RHASH_TBL(value()));
+  return const_iterator(*this, tbl->num_bins, 0);
+}
+
+inline bool Rice::
+operator<(
+    Hash::Entry const & lhs, Hash::Entry const & rhs)
+{
+  Object lhs_key(lhs.key);
+  Object rhs_key(rhs.key);
+  if(lhs_key < rhs_key)
+  {
+    return true;
+  }
+  else if(lhs_key > rhs_key)
+  {
+    return false;
+  }
+  else if(Object(lhs.value.value()) < Object(rhs.value.value()))
+  {
+    return true;
+  }
+  else
+  {
+    return false;
+  }
+}
+
+#endif // Rice__Hash__ipp_
+

data/rice/Identifier.cpp

@@ -0,0 +1,8 @@
+#include "Symbol.hpp"
+
+Rice::Identifier::
+Identifier(Symbol const & symbol)
+  : id_(SYM2ID(symbol.value()))
+{
+}
+

data/rice/Identifier.hpp

@@ -0,0 +1,50 @@
+#ifndef Rice__Identifier__hpp_
+#define Rice__Identifier__hpp_
+
+#include "detail/ruby.hpp"
+#include <string>
+
+namespace Rice
+{
+
+class Symbol;
+
+//! A wrapper for the ID type
+/*! An ID is ruby's internal representation of a Symbol object.
+ */
+class Identifier
+{
+public:
+  //! Construct a new Identifier from an ID.
+  Identifier(ID id);
+
+  //! Construct a new Identifier from a Symbol.
+  Identifier(Symbol const & symbol);
+
+  //! Construct a new Identifier from a string.
+  Identifier(char const * s = "");
+
+  //! Return a string representation of the Identifier.
+  char const * c_str() const;
+
+  //! Return a string representation of the Identifier.
+  std::string str() const;
+
+  //! Return the underlying ID
+  ID id() const { return id_; }
+
+  //! Return the underlying ID
+  operator ID() const { return id_; }
+
+  //! Return the ID as a Symbol
+  VALUE to_sym() const;
+
+private:
+  ID id_;
+};
+
+} // namespace Rice
+
+#include "Identifier.ipp"
+
+#endif // Rice__Identifier__hpp_

data/rice/Identifier.ipp

@@ -0,0 +1,33 @@
+inline Rice::Identifier::
+Identifier(ID id)
+  : id_(id)
+{
+}
+
+inline Rice::Identifier::
+Identifier(char const * s)
+  : id_(rb_intern(s))
+{
+}
+
+inline char const *
+Rice::Identifier::
+c_str() const
+{
+  return rb_id2name(id_);
+}
+
+inline std::string
+Rice::Identifier::
+str() const
+{
+  return c_str();
+}
+
+inline VALUE
+Rice::Identifier::
+to_sym() const
+{
+  return ID2SYM(id_);
+}
+

data/rice/Jump_Tag.hpp

@@ -0,0 +1,24 @@
+#ifndef Rice__Jump_Tag__hpp_
+#define Rice__Jump_Tag__hpp_
+
+namespace Rice
+{
+
+//! A placeholder for Ruby longjmp data.
+/*! When a Ruby exception is caught, the tag used for the longjmp is stored in
+ *  a Jump_Tag, then later passed to rb_jump_tag() when there is no more
+ *  C++ code to pass over.
+ */
+struct Jump_Tag
+{
+  //! Construct a Jump_Tag with tag t.
+  Jump_Tag(int t) : tag(t) { }
+
+  //! The tag being held.
+  int tag;
+};
+
+} // namespace Rice
+
+#endif // Rice__Jump_Tag__hpp_
+

data/rice/Makefile.am

@@ -0,0 +1,129 @@
+lib_LIBRARIES = librice.a
+
+librice_a_SOURCES = \
+Class.cpp \
+Data_Type.cpp \
+Director.cpp \
+Exception.cpp \
+Identifier.cpp \
+Module.cpp \
+Object.cpp \
+String.cpp \
+Struct.cpp \
+Symbol.cpp \
+VM.cpp \
+Arg_operators.cpp \
+detail/check_ruby_type.cpp \
+detail/demangle.cpp \
+detail/method_data.cpp \
+detail/protect.cpp
+
+nobase_include_HEADERS = \
+Address_Registration_Guard.hpp \
+Address_Registration_Guard.ipp \
+Address_Registration_Guard_defn.hpp \
+Allocation_Strategies.hpp \
+Array.hpp \
+Array.ipp \
+Arg.hpp \
+Arg_impl.hpp \
+Arg_operators.hpp \
+Builtin_Object.hpp \
+Builtin_Object.ipp \
+Builtin_Object_defn.hpp \
+Class.hpp \
+Class.ipp \
+Class_defn.hpp \
+Constructor.hpp \
+Critical_Guard.hpp \
+Critical_Guard.ipp \
+Data_Object.hpp \
+Data_Object.ipp \
+Data_Object_defn.hpp \
+Data_Type.hpp \
+Data_Type.ipp \
+Data_Type_defn.hpp \
+Data_Type_fwd.hpp \
+Director.hpp \
+Enum.hpp \
+Enum.ipp \
+Exception.hpp \
+Exception_defn.hpp \
+Exception_Base.hpp \
+Exception_Base.ipp \
+Exception_Base_defn.hpp \
+Hash.hpp \
+Hash.ipp \
+Identifier.hpp \
+Identifier.ipp \
+Jump_Tag.hpp \
+Makefile \
+Module.hpp \
+Module.ipp \
+Module_defn.hpp \
+Module_impl.hpp \
+Module_impl.ipp \
+Object.hpp \
+Object.ipp \
+Object_defn.hpp \
+Require_Guard.hpp \
+String.hpp \
+Struct.hpp \
+Struct.ipp \
+Symbol.hpp \
+Symbol.ipp \
+VM.hpp \
+global_function.hpp \
+global_function.ipp \
+protect.hpp \
+protect.ipp \
+ruby_try_catch.hpp \
+to_from_ruby.hpp \
+to_from_ruby.ipp \
+to_from_ruby_defn.hpp \
+ruby_mark.hpp \
+detail/Auto_Function_Wrapper.hpp \
+detail/Auto_Function_Wrapper.ipp \
+detail/Auto_Member_Function_Wrapper.hpp \
+detail/Auto_Member_Function_Wrapper.ipp \
+detail/Arguments.hpp \
+detail/Caster.hpp \
+detail/Exception_Handler.hpp \
+detail/Exception_Handler.ipp \
+detail/Exception_Handler_defn.hpp \
+detail/Iterator.hpp \
+detail/Not_Copyable.hpp \
+detail/Wrapped_Function.hpp \
+detail/check_ruby_type.hpp \
+detail/creation_funcs.hpp \
+detail/creation_funcs.ipp \
+detail/default_allocation_func.hpp \
+detail/default_allocation_func.ipp \
+detail/define_method_and_auto_wrap.hpp \
+detail/define_method_and_auto_wrap.ipp \
+detail/demangle.hpp \
+detail/env.hpp \
+detail/from_ruby.hpp \
+detail/from_ruby.ipp \
+detail/method_data.hpp \
+detail/node.hpp \
+detail/object_call.hpp \
+detail/object_call.ipp \
+detail/protect.hpp \
+detail/ruby.hpp \
+detail/rubysig.hpp \
+detail/st.hpp \
+detail/traits.hpp \
+detail/to_ruby.hpp \
+detail/to_ruby.ipp \
+detail/win32.hpp \
+detail/wrap_function.hpp \
+detail/wrap_function.ipp \
+detail/ruby_version_code.hpp
+
+includedir = ${prefix}/include/rice
+
+AM_CPPFLAGS = @RUBY_CPPFLAGS@
+
+AM_CXXFLAGS = @RUBY_CXXFLAGS@
+

data/rice/Module.cpp

@@ -0,0 +1,84 @@
+#include "Module.hpp"
+#include "Symbol.hpp"
+#include "String.hpp"
+#include "Array.hpp"
+#include "Exception.hpp"
+#include "protect.hpp"
+
+Rice::Module::
+Module()
+  : Module_impl<Module_base, Module>(rb_cObject)
+{
+}
+
+Rice::Module::
+Module(VALUE v)
+  : Module_impl<Module_base, Module>(v)
+{
+  if(::rb_type(v) != T_CLASS && ::rb_type(v) != T_MODULE)
+  {
+    throw Exception(
+        rb_eTypeError,
+        "Expected a Module but got a %s",
+        rb_class2name(CLASS_OF(v))); // TODO: might raise an exception
+  }
+}
+
+Rice::String Rice::Module::
+name() const
+{
+  Object name = rb_mod_name(*this);
+  if(name.is_nil())
+  {
+    // 1.9
+    return String("");
+  }
+  else
+  {
+    return name;
+  }
+}
+
+Rice::Module Rice::
+define_module_under(
+    Rice::Object module,
+    char const * name)
+{
+  VALUE v = rb_define_module_under(module, name);
+  return Module(v);
+}
+
+Rice::Module Rice::
+define_module(
+    char const * name)
+{
+  VALUE v = rb_define_module(name);
+  return Module(v);
+}
+
+Rice::Module Rice::
+anonymous_module()
+{
+  return Module(protect(rb_module_new));
+}
+
+void Rice::Module::
+swap(Rice::Module & other)
+{
+  Module_base::swap(other);
+}
+
+Rice::Array
+Rice::Module::
+ancestors() const
+{
+  return protect(rb_mod_ancestors, *this);
+}
+
+Rice::Class
+Rice::Module::
+singleton_class() const
+{
+  return CLASS_OF(value());
+}
+

data/rice/Module.hpp

@@ -0,0 +1,8 @@
+#ifndef Rice__builtin__Module__hpp_
+#define Rice__builtin__Module__hpp_
+
+#include "Module_defn.hpp"
+#include "Module.ipp"
+
+#endif // Rice__builtin__Module__hpp_
+

data/rice/Module.ipp

@@ -0,0 +1,6 @@
+#ifndef Rice__Module__ipp_
+#define Rice__Module__ipp_
+
+#include "Module_impl.ipp"
+
+#endif // Rice__Module__ipp_