rucy 0.1.3 → 0.1.4

data/ext/rucy/value.cpp

@@ -0,0 +1,46 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+static
+RUBY_DEFN(true_to_value)
+{
+	return value(true);
+}
+RUBY_END
+
+static
+RUBY_DEFN(false_to_value)
+{
+	return value(false);
+}
+RUBY_END
+
+static
+RUBY_DEFN(NULL_to_value)
+{
+	return nil();
+}
+RUBY_END
+
+static
+RUBY_DEFN(nil_value)
+{
+	return nil();
+}
+RUBY_END
+
+
+void
+Init_value ()
+{
+	Module mRucy   =       define_module("Rucy");
+	Module mTester = mRucy.define_module("Tester");
+
+	mTester.define_method("true_to_value", true_to_value);
+	mTester.define_method("false_to_value", false_to_value);
+	mTester.define_method("null_to_value", NULL_to_value);
+	mTester.define_method("nil_value", nil_value);
+}

data/include/rucy/defs.h.erb

@@ -56,4 +56,21 @@ namespace Rucy
 #endif
 
 
+#define RUCY_CHECK_OBJ(obj, type, klass) \
+	do \
+	{ \
+		type* p = Rucy::get_type_ptr<type>(obj, klass); \
+		if (!p) Rucy::invalid_object_error(); \
+	} \
+	while(0)
+
+#define RUCY_CHECK_OBJECT(obj, type, klass) \
+	do \
+	{ \
+		type* p = Rucy::get_type_ptr<type>(obj, klass); \
+		if (!p || !*p) Rucy::invalid_object_error(); \
+	} \
+	while(0)
+
+
 #endif//EOH

data/include/rucy/exception.h

@@ -61,6 +61,8 @@ namespace Rucy
 		int n1 = -1, int n2 = -1, int n3 = -1, int n4 = -1, int n5 = -1,
 		int n6 = -1, int n7 = -1, int n8 = -1, int n9 = -1, int n10 = -1);
 
+	void index_error (const char* format = NULL, ...);
+
 	void not_implemented_error (const char* format = NULL, ...);
 
 

data/include/rucy/extension.h

@@ -0,0 +1,206 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RUCY_EXTENSION_H__
+#define __RUCY_EXTENSION_H__
+
+
+#include <boost/dynamic_bitset.hpp>
+#include <xot/ref.h>
+#include <rucy/module.h>
+
+
+namespace Rucy
+{
+
+
+	template <typename T>
+	class ClassWrapper : public T
+	{
+
+		typedef ClassWrapper This;
+
+		public:
+
+			typedef T Super;
+
+			GlobalValue value;
+
+			ClassWrapper ()
+			:	value(Qnil, true)
+			{
+			}
+
+			virtual void retain ()
+			{
+				value.gc(false);
+				Super::retain();
+			}
+
+			virtual void release ()
+			{
+				Super::release();
+				value.gc(true);
+			}
+
+			virtual void clear_override_flags ()
+			{
+				override_flags.reset();
+			}
+
+			virtual bool is_overridden (const Value& klass, const Symbol& name, uint id) const
+			{
+				if (id <= OVERRIDE_ID_UNKNOWN)
+					return false;
+
+				bool checked = false, overridden = false;
+				get_override_flag(&checked, &overridden, id);
+				if (checked) return overridden;
+
+				overridden = check_overridden(klass, name);
+				if (!const_cast<This*>(this)->set_override_flag(id, true, overridden))
+					return false;
+
+				return overridden;
+			}
+
+		protected:
+
+			enum
+			{
+
+				OVERRIDE_ID_UNKNOWN = 0,
+
+				OVERRIDE_ID_LAST,
+
+				OVERRIDE_ID_MAX = 256
+
+			};
+
+		private:
+
+			boost::dynamic_bitset<> override_flags;
+
+			bool check_overridden (const Value& klass, const Symbol& name) const
+			{
+				SYM(method);
+				SYM(owner);
+				return this->value.call(method, name.value()).call(owner) != klass;
+			}
+
+			void get_override_flag (bool* checked, bool* overridden, uint id) const
+			{
+				assert(checked || overridden);
+
+				int checked_pos    = id2index(id);
+				int overridden_pos = checked_pos + 1;
+				bool valid = 0 <= checked_pos && overridden_pos < (int) override_flags.size();
+				if (checked)    *checked    = valid ? override_flags[checked_pos]    : false;
+				if (overridden) *overridden = valid ? override_flags[overridden_pos] : false;
+			}
+
+			bool set_override_flag (uint id, bool checked, bool overridden)
+			{
+				assert(id < OVERRIDE_ID_MAX);
+
+				int checked_pos = id2index(id);
+				if (checked_pos < 0) return true;
+
+				int overridden_pos = checked_pos + 1;
+				if (overridden_pos >= (int) override_flags.size())
+					override_flags.resize(overridden_pos + 1);
+
+				override_flags[checked_pos]    = checked;
+				override_flags[overridden_pos] = overridden;
+				return true;
+			}
+
+			int id2index (uint id) const
+			{
+				return (id - 1) * 2;
+			}
+
+	};// ClassWrapper
+
+
+	template <typename T> inline void release_wrapper (void* p)
+	{
+		if (p) ((T*) p)->Xot::template RefCountable<>::release();
+	}
+
+	template <typename T> inline Value new_wrapper (
+		Value klass, T* ptr,
+		RUBY_DATA_FUNC mark = NULL,
+		RUBY_DATA_FUNC free = release_wrapper<T>)
+	{
+		if (ptr) ptr->Xot::template RefCountable<>::retain();
+		return new_type(klass, ptr, mark, free);
+	}
+
+	template <typename T> inline Value new_wrapper (
+		Value klass,
+		RUBY_DATA_FUNC mark = NULL,
+		RUBY_DATA_FUNC free = release_wrapper<T>)
+	{
+		return new_wrapper(klass, new T, mark, free);
+	}
+
+
+}// Rucy
+
+
+#define RUCY_WRAPPER_VALUE_FROM(wrapped_class, ruby_class) \
+	namespace Rucy \
+	{ \
+		inline Value \
+		value (wrapped_class* obj, Value klass = ruby_class) \
+		{ \
+			if (!obj) return Qnil; \
+			ClassWrapper<wrapped_class>* p = dynamic_cast<ClassWrapper<wrapped_class>*>(obj); \
+			if (!p) return new_ref(klass, obj); \
+			if (p->value.is_nil()) p->value = new_wrapper(klass, obj); \
+			return p->value; \
+		} \
+	}
+
+#define RUCY_WRAPPER_VALUE_TO(wrapped_class, ruby_class) \
+	namespace Rucy \
+	{ \
+		template <> inline wrapped_class* \
+		value_to<wrapped_class*> (Value value, bool convert) \
+		{ \
+			return get_type_ptr<wrapped_class>(value, ruby_class); \
+		} \
+	}
+
+#define RUCY_WRAPPER_VALUE_FROM_TO(wrapped_class, ruby_class) \
+	RUCY_WRAPPER_VALUE_FROM(wrapped_class, ruby_class) \
+	RUCY_WRAPPER_VALUE_TO(wrapped_class, ruby_class)
+
+
+#define RUCY_WRAPPER_CALL(wrapper_class, obj, fun) \
+	(dynamic_cast<wrapper_class*>(obj) \
+		? reinterpret_cast<wrapper_class*>(obj)->Super::fun \
+		: (obj)->fun)
+
+
+#define RUCY_OVERRIDE_ID_START(name) enum { OID_##name = Super::OVERRIDE_ID_LAST,
+#define RUCY_OVERRIDE_ID(name)              OID_##name,
+#define RUCY_OVERRIDE_ID_LAST               OVERRIDE_ID_LAST };
+
+
+#define RUCY_IS_OVERRIDDEN(name, ruby_class) \
+	this->is_overridden(ruby_class, name, OID_##name)
+
+#define RUCY_OVERRIDABLE_METHOD(name, ruby_class, suffix) \
+	SYM(name); \
+	return this->value.call(name) suffix ;
+
+#define RUCY_OVERRIDABLE_METHOD_FAST(name, ruby_class, suffix) \
+	SYM(name); \
+	if (RUCY_IS_OVERRIDDEN(name, ruby_class)) \
+		return this->value.call(name) suffix ; \
+	else \
+		return this->Super::name();
+
+
+#endif//EOH

data/include/rucy/rucy.h

@@ -33,7 +33,7 @@ namespace Rucy
 
 	template <typename T> inline void mark_type (void* p)
 	{
-		((T*) p)->mark();
+		if (p) ((T*) p)->mark();
 	}
 
 	template <typename T> inline void delete_type (void* p)
@@ -41,11 +41,17 @@ namespace Rucy
 		delete (T*) p;
 	}
 
+	template <typename T> inline void release_type (void* p)
+	{
+		if (p) ((T*) p)->release();
+	}
+
 	template <typename T> inline Value new_type (
 		Value klass, T* ptr,
 		RUBY_DATA_FUNC mark = NULL,
 		RUBY_DATA_FUNC free = delete_type<T>)
 	{
+		if (!ptr) return Qnil;
 		return Data_Wrap_Struct(klass, mark, free, ptr);
 	}
 
@@ -57,7 +63,24 @@ namespace Rucy
 		return new_type(klass, new T, mark, free);
 	}
 
-	template <typename T> inline T* get_type (Value obj, Value klass = Qnil)
+	template <typename T> inline Value new_ref (
+		Value klass, T* ptr,
+		RUBY_DATA_FUNC mark = NULL,
+		RUBY_DATA_FUNC free = release_type<T>)
+	{
+		if (ptr) ptr->retain();
+		return new_type(klass, ptr, mark, free);
+	}
+
+	template <typename T> inline Value new_ref (
+		Value klass,
+		RUBY_DATA_FUNC mark = NULL,
+		RUBY_DATA_FUNC free = release_type<T>)
+	{
+		return new_ref(klass, new T, mark, free);
+	}
+
+	template <typename T> inline T* get_type_ptr (Value obj, Value klass = Qnil)
 	{
 		if (klass && !check_class(obj, klass)) return NULL;
 		T* p = NULL;

data/include/rucy/symbol.h

@@ -18,6 +18,9 @@ namespace Rucy
 {
 
 
+	class Value;
+
+
 	class Symbol
 	{
 
@@ -27,16 +30,24 @@ namespace Rucy
 
 			Symbol (ID id);
 
+			Symbol (const Value& value);
+
 			Symbol (const char* str);
 
 			ID id () const;
 
+			VALUE value () const;
+
 			const char* c_str () const;
 
 			operator bool () const;
 
 			bool operator ! () const;
 
+			friend bool operator == (const Symbol& lhs, const Symbol& rhs);
+
+			friend bool operator != (const Symbol& lhs, const Symbol& rhs);
+
 		private:
 
 			ID id_;

data/include/rucy/value.h.erb

@@ -35,16 +35,16 @@ namespace Rucy
 
 			Value (VALUE v);
 
-			VALUE value () const;
-
 			void mark () const;
 
+			bool is_kind_of (Value klass) const;
+
+			VALUE value () const;
+
 			int type () const;
 
 			Value klass () const;
 
-			bool is_kind_of (Value klass) const;
-
 			int size () const;
 
 			int length () const;
@@ -57,6 +57,14 @@ namespace Rucy
 
 			Value to_sym () const;
 
+			int         as_i (bool convert = false) const;
+
+			double      as_f (bool convert = false) const;
+
+			const char* as_s (bool convert = false) const;
+
+			Symbol      as_sym (bool convert = false) const;
+
 			bool is_i () const;
 
 			bool is_f () const;
@@ -67,13 +75,7 @@ namespace Rucy
 
 			bool is_a () const;
 
-			int         as_i (bool convert = false) const;
-
-			double      as_f (bool convert = false) const;
-
-			const char* as_s (bool convert = false) const;
-
-			Symbol      as_sym (bool convert = false) const;
+			bool is_nil () const;
 
 %			["call", "operator ()"].each do |op|
 			Value <%= op %> (Symbol name, int argc, const Value* argv) const;
@@ -110,15 +112,61 @@ namespace Rucy
 
 			Value unshift (Value obj);
 
-		private:
+		protected:
 
 			VALUE v;
 
-			friend class GCGuard;
-
 	};// Value
 
 
+	class GlobalValue : public Value
+	{
+
+		typedef Value Super;
+
+		public:
+
+			GlobalValue ();// gc = false
+
+			GlobalValue (bool b, bool gc = false);
+
+			GlobalValue (int i, bool gc = false);
+
+			GlobalValue (float f, bool gc = false);
+
+			GlobalValue (double d, bool gc = false);
+
+			GlobalValue (const char* s, bool tainted = false, bool gc = false);
+
+			GlobalValue (const char* s, size_t len, bool tainted = false, bool gc = false);
+
+			GlobalValue (size_t size, const Value* values, bool gc = false);
+
+			GlobalValue (VALUE v, bool gc = false);
+
+			GlobalValue (const Value& obj, bool gc = false);
+
+			GlobalValue (const GlobalValue& obj, bool gc = false);
+
+			GlobalValue& operator = (const Value& v);
+
+			~GlobalValue ();
+
+			void gc (bool enable = true);
+
+		private:
+
+			short gc_disable_count;
+
+			bool gc_guarded;
+
+			void init (bool gc);
+
+			void update_guard ();
+
+	};// GlobalValue
+
+
 	Value value (bool b);
 
 	Value value (char c);
@@ -153,6 +201,10 @@ namespace Rucy
 
 	Value value (Symbol sym);
 
+	Value value (void* ptr);
+
+	Value nil ();
+
 
 	template <typename T> T value_to (Value obj, bool convert = true);
 

data/include/rucy.h

@@ -7,4 +7,4 @@
 #include <rucy/module.h>
 #include <rucy/class.h>
 #include <rucy/symbol.h>
-#include <rucy/gc.h>
+#include <rucy/extension.h>

data/lib/rucy/module.rb

@@ -22,8 +22,15 @@ module Rucy
       File.join root_dir, 'task'
     end
 
-    def load_tasks ()
-      Dir["#{task_dir}/**/*.rake"].each {|path| load path}
+    def load_tasks (*names)
+      if names.empty?
+        Dir["#{task_dir}/**/*.rake"].each {|path| load path}
+      else
+        names.each do |name|
+          path = "#{task_dir}/#{name}.rake"
+          load path if File.exist? path
+        end
+      end
     end
 
     def version ()

data/rucy.gemspec

@@ -1,66 +1,42 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-$: << File.join(File.dirname(__FILE__), 'lib')
+$: << File.expand_path('../lib', __FILE__)
 
-require 'rake'
 require 'rucy/module'
 
 
-MODULE = Rucy
-NAME   = MODULE.name.downcase
-
-
-FILES = FileList[*%W[
-  README
-  ChangeLog
-  Rakefile
-  #{NAME}.gemspec
-  VERSION
-  task/**/*.rake
-  ext/**/*.rb
-  ext/**/*.h
-  ext/**/*.cpp
-  include/**/*.erb
-  include/**/*.h
-  lib/**/*.rb
-  src/**/*.erb
-  src/**/*.h
-  src/**/*.cpp
-  test/**/*.rb
-]]
-
-RDOCS = FileList[*%W[
-  README
-  .doc/ext/**/*.cpp
-]]
+Gem::Specification.new do |s|
+  def glob (*patterns)
+    patterns.map {|pat| Dir.glob(pat).to_a}.flatten
+  end
 
+  mod   = Rucy
+  name  = mod.name.downcase
+  rdocs = glob *%w[README .doc/ext/**/*.cpp]
 
-Gem::Specification.new do |s|
-  s.name        = NAME
+  s.name        = name
   s.summary     = 'A Ruby C++ Extension Helper Library.'
   s.description = 'This library helps you to develop Ruby Extension by C++.'
-  s.version     = MODULE.version
+  s.version     = mod.version
 
   s.authors  = %w[snori]
   s.email    = 'snori@xord.org'
-  s.homepage = "http://github.com/xord/#{NAME}"
+  s.homepage = "http://github.com/xord/#{name}"
 
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>=1.9.0'
-  s.require_paths         << 'ext'
 
+  s.add_runtime_dependency 'bundler'
   s.add_runtime_dependency 'xot'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'gemcutter'
 
-  s.files      = FILES.to_a
-  s.test_files = FileList['test/**/test_*.rb'].to_a
-
+  s.files            = `git ls-files`.split $/
+  s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}
+  s.test_files       = s.files.grep %r{^(test|spec|features)/}
+  s.extra_rdoc_files = rdocs.to_a
   s.has_rdoc         = true
-  s.extra_rdoc_files = RDOCS.to_a
-
-  s.executables << 'rucy2rdoc'
 
   s.extensions << 'Rakefile'
 end

data/src/exception.cpp

@@ -10,21 +10,6 @@
 #endif
 
 
-#define VA_STRING(format, result) \
-	String result; \
-	do \
-	{ \
-		if (format) \
-		{ \
-			va_list args; \
-			va_start(args, format); \
-			result = Xot::stringf(format, args); \
-			va_end(args); \
-		} \
-	} \
-	while (false)
-
-
 namespace Rucy
 {
 
@@ -37,7 +22,7 @@ namespace Rucy
 	RubyException::RubyException (Value type, const char* format, ...)
 	:	Super(""), val(Qnil)
 	{
-		VA_STRING(format, s);
+		XOT_STRINGF(format, s);
 		val = rb_exc_new2(type, s.c_str());
 	}
 
@@ -66,29 +51,29 @@ namespace Rucy
 	{
 		if (!format) throw;
 
-		VA_STRING(format, message);
+		XOT_STRINGF(format, message);
 		throw message;
 	}
 
 	void
-	raise (Value type, const char* format, ...)
+	raise (VALUE exception, const char* format, ...)
 	{
-		VA_STRING(format, message);
-		throw RubyException(type, message.c_str());
+		XOT_STRINGF(format, message);
+		throw RubyException(exception, message.c_str());
 	}
 
 
 	void
 	type_error (const char* format, ...)
 	{
-		VA_STRING(format, message);
+		XOT_STRINGF(format, message);
 		raise(rb_eTypeError, message.c_str());
 	}
 
 	void
 	argument_error (const char* format, ...)
 	{
-		VA_STRING(format, message);
+		XOT_STRINGF(format, message);
 		raise(rb_eArgError, message.c_str());
 	}
 
@@ -110,10 +95,17 @@ namespace Rucy
 		argument_error(message.c_str());
 	}
 
+	void
+	index_error (const char* format, ...)
+	{
+		XOT_STRINGF(format, message);
+		raise(rb_eIndexError, message.c_str());
+	}
+
 	void
 	not_implemented_error (const char* format, ...)
 	{
-		VA_STRING(format, message);
+		XOT_STRINGF(format, message);
 		raise(rb_eNotImpError, message.c_str());
 	}
 
@@ -121,7 +113,7 @@ namespace Rucy
 	void
 	system_error (const char* format, ...)
 	{
-		VA_STRING(format, message);
+		XOT_STRINGF(format, message);
 
 		#ifdef WIN32
 		DWORD lasterror = GetLastError();
@@ -149,7 +141,7 @@ namespace Rucy
 	void
 	invalid_object_error (const char* format, ...)
 	{
-		VA_STRING(format, message);
+		XOT_STRINGF(format, message);
 		raise(invalid_object_error_class(), message.c_str());
 	}