rucy 0.1.6 → 0.1.7

data/ext/rucy/class.cpp

@@ -1,19 +1,17 @@
 #include "class.h"
 
 
-#include <rucy.h>
+#include "rucy.h"
 
 
 using namespace Rucy;
 
 
-static Class cBase, cSub, cRubyObj;
-
-
-RUCY_WRAPPER_VALUE_FROM_TO(Base,    cBase)
-RUCY_WRAPPER_VALUE_FROM_TO(Sub,     cSub)
-RUCY_WRAPPER_VALUE_FROM_TO(RubyObj, cRubyObj)
+static Class cBase, cSub, cSimpleObj;
 
+RUCY_WRAPPER_VALUE_FROM_TO(Base,      cBase)
+RUCY_WRAPPER_VALUE_FROM_TO(Sub,       cSub)
+RUCY_WRAPPER_VALUE_FROM_TO(SimpleObj, cSimpleObj)
 
 template <typename T> Class get_class ();
 
@@ -26,26 +24,32 @@ template <typename T>
 class RubyBase : public ClassWrapper<T>
 {
 
-	typedef ClassWrapper<T> Super;
+	public:
 
-	RUCY_OVERRIDE_ID_START(name_overridable_faster)
-	RUCY_OVERRIDE_ID_LAST
+		RUCY_OVERRIDE_BEGIN(ClassWrapper<T>)
 
-	public:
+		RUCY_OVERRIDE_ID(name_overridable_faster)
+
+		RUCY_OVERRIDE_END
 
 		virtual const char* name_overridable () const
 		{
-			RUCY_OVERRIDABLE_METHOD(name_overridable, get_class<T>(), .c_str());
+			RUCY_SYM(name_overridable);
+			return this->value.call(name_overridable).c_str();
 		}
 
 		virtual const char* name_overridable_faster () const
 		{
-			RUCY_OVERRIDABLE_METHOD_FAST(name_overridable_faster, get_class<T>(), .c_str());
+			RUCY_SYM(name_overridable_faster);
+			if (RUCY_IS_OVERRIDDEN(name_overridable_faster, get_class<T>()))
+				return this->value.call(name_overridable_faster).c_str();
+			else
+				return Super::name_overridable_faster();
 		}
 
 		bool is_name_overridable_faster_overridden () const
 		{
-			SYM(name_overridable_faster);
+			RUCY_SYM(name_overridable_faster);
 			return RUCY_IS_OVERRIDDEN(name_overridable_faster, get_class<T>());
 		}
 
@@ -54,171 +58,161 @@ class RubyBase : public ClassWrapper<T>
 
 #define THIS(type)           to<type*>(self)
 
-#define CHECK(type)          RUCY_CHECK_OBJ(self, type, c##type)
+#define CHECK(type)          RUCY_CHECK_OBJ(type, c##type, self)
 
-#define CALL(type, obj, fun) RUCY_WRAPPER_CALL(ClassWrapper<type>, obj, fun)
+#define CALL(type, obj, fun) RUCY_WRAPPER_CALL(type, obj, fun)
 
 
 /*
 	alloc function.
 */
 static
-RUBY_DEF_ALLOC(base_alloc, klass)
+RUCY_DEF_ALLOC(base_alloc, klass)
 {
 	return value(new RubyBase<Base>, klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(name)
+RUCY_DEF0(name)
 {
 	CHECK(Base);
 	return value(THIS(Base)->name());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(call_name)
+RUCY_DEF0(call_name)
 {
 	CHECK(Base);
 	return value(THIS(Base)->name());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(base_name_overridable)
+RUCY_DEF0(base_name_overridable)
 {
 	CHECK(Base);
 	return value(CALL(Base, THIS(Base), name_overridable()));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(call_name_overridable)
+RUCY_DEF0(call_name_overridable)
 {
 	CHECK(Base);
 	return value(THIS(Base)->name_overridable());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(base_name_overridable_faster)
+RUCY_DEF0(base_name_overridable_faster)
 {
 	CHECK(Base);
 	return value(CALL(Base, THIS(Base), name_overridable_faster()));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(call_name_overridable_faster)
+RUCY_DEF0(call_name_overridable_faster)
 {
 	CHECK(Base);
 	return value(THIS(Base)->name_overridable_faster());
 }
-RUBY_END
+RUCY_END
 
 template <typename T>
 static
-RUBY_DEF0(is_name_overridable_faster_overridden)
+RUCY_DEF0(is_name_overridable_faster_overridden)
 {
-	RUCY_CHECK_OBJ(self, T, get_class<T>());
+	RUCY_CHECK_OBJ(T, get_class<T>(), self);
 	RubyBase<T>* obj = dynamic_cast<RubyBase<T>*>(THIS(T));
-	if (!obj) invalid_object_error("dynamic_cast() failed.");
+	if (!obj) invalid_object_error(__FILE__, __LINE__, "dynamic_cast() failed.");
 	return value(obj->is_name_overridable_faster_overridden());
 }
-RUBY_END
+RUCY_END
 
-template <typename T>
-static
-RUBY_DEF0(clear_override_flags)
-{
-	RUCY_CHECK_OBJ(self, T, get_class<T>());
-	ClassWrapper<T>* obj = dynamic_cast<ClassWrapper<T>*>(THIS(T));
-	if (obj) obj->clear_override_flags();
-}
-RUBY_END
+static RUCY_DEF_clear_override_flags(Base_clear_override_flags, Base, cBase);
+static RUCY_DEF_clear_override_flags(Sub_clear_override_flags,  Sub,  cSub);
 
-template <bool singleton>
 static
-RUBY_DEF1(method_added_or_removed, method_name)
-{
-	SYMBOL(klass, "class");
-	SYM(name);
-	eval(
-		Xot::stringf(
-			"ObjectSpace.each_object(%s) {|o| o.clear_override_flags}",
-			(singleton ? self(klass) : self)(name).c_str()).c_str());
-}
-RUBY_END
-
-static
-RUBY_DEF0(base_new_raw)
+RUCY_DEF0(base_new_raw)
 {
 	return value(new Base);
 }
-RUBY_END
+RUCY_END
 
 
 /*
 	alloc function.
 */
 static
-RUBY_DEF_ALLOC(sub_alloc, klass)
+RUCY_DEF_ALLOC(sub_alloc, klass)
 {
 	return value(new RubyBase<Sub>, klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(sub_name_overridable)
+RUCY_DEF0(sub_name_overridable)
 {
 	CHECK(Sub);
 	return value(CALL(Sub, THIS(Sub), name_overridable()));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(sub_name_overridable_faster)
+RUCY_DEF0(sub_name_overridable_faster)
 {
 	CHECK(Sub);
 	return value(CALL(Sub, THIS(Sub), name_overridable_faster()));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(sub_new_raw)
+RUCY_DEF0(sub_new_raw)
 {
 	return value(new Sub);
 }
-RUBY_END
+RUCY_END
 
 
 /*
 	alloc function.
 */
 static
-RUBY_DEF_ALLOC(rubyobj_alloc, klass)
+RUCY_DEF_ALLOC(simpleobj_alloc, klass)
+{
+	return value(new ClassWrapper<SimpleObj>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(simpleobj_initialize, name)
 {
-	return value(new ClassWrapper<RubyObj>, klass);
+	CHECK(SimpleObj);
+	THIS(SimpleObj)->init(name.c_str());
 }
-RUBY_END
+RUCY_END
 
-static Xot::Ref<RubyObj> rubyobj_ref;
+static std::vector<Xot::Ref<SimpleObj> > simpleobj_refs;
 
 static
-RUBY_DEF1(rubyobj_set_ref, obj)
+RUCY_DEF1(simpleobj_set_refs, objs)
 {
-	rubyobj_ref = to<RubyObj*>(obj);
-	return obj;
+	int size = objs.size();
+	for (int i = 0; i < size; ++i)
+		simpleobj_refs.push_back(to<SimpleObj*>(objs[i]));
+	return objs;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(rubyobj_clear_ref)
+RUCY_DEF0(simpleobj_clear_refs)
 {
-	rubyobj_ref.reset();
+	simpleobj_refs.clear();
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -238,12 +232,8 @@ Init_class ()
 	cBase.define_method(
 		"is_name_overridable_faster_overridden",
 		 is_name_overridable_faster_overridden<Base>);
-	cBase.define_method("clear_override_flags",         clear_override_flags<Base>);
-	cBase.define_method("singleton_method_added",       method_added_or_removed<true>);
-	cBase.define_method("singleton_method_removed",     method_added_or_removed<true>);
-	cBase.define_singleton_method("method_added",       method_added_or_removed<false>);
-	cBase.define_singleton_method("method_removed",     method_added_or_removed<false>);
 	cBase.define_singleton_method("new_raw",            base_new_raw);
+	cBase.define_clear_override_flags(Base_clear_override_flags);
 
 	cSub = mTester.define_class("Sub", cBase);
 	cSub.define_alloc_func(sub_alloc);
@@ -252,11 +242,12 @@ Init_class ()
 	cSub.define_method(
 		"is_name_overridable_faster_overridden",
 		 is_name_overridable_faster_overridden<Sub>);
-	cSub.define_method("clear_override_flags",    clear_override_flags<Sub>);
 	cSub.define_singleton_method("new_raw",       sub_new_raw);
+	cSub.define_clear_override_flags(Sub_clear_override_flags);
 
-	cRubyObj = mTester.define_class("RubyObj");
-	cRubyObj.define_alloc_func(rubyobj_alloc);
-	cRubyObj.define_function("set_ref",   rubyobj_set_ref);
-	cRubyObj.define_function("clear_ref", rubyobj_clear_ref);
+	cSimpleObj = mTester.define_class("SimpleObj");
+	cSimpleObj.define_alloc_func(simpleobj_alloc);
+	cSimpleObj.define_private_method("initialize", simpleobj_initialize);
+	cSimpleObj.define_function("set_refs",   simpleobj_set_refs);
+	cSimpleObj.define_function("clear_refs", simpleobj_clear_refs);
 }

data/ext/rucy/class.h

@@ -5,6 +5,7 @@
 
 
 #include <xot/ref.h>
+#include <xot/string.h>
 #include <rucy/extension.h>
 #include "tester.h"
 
@@ -75,22 +76,27 @@ class Sub : public Base
 };// Sub
 
 
-class RubyObj : public Xot::RefCountable<>
+class SimpleObj : public Xot::RefCountable<>
 {
 
 	public:
 
-		RubyObj ()
+		void init (const char* name_)
 		{
-			log("RubyObj()");
+			name = name_;
+			log("SimpleObj(" + name + ")");
 		}
 
-		~RubyObj ()
+		~SimpleObj ()
 		{
-			log("~RubyObj()");
+			log("~SimpleObj(" + name + ")");
 		}
 
-};// Obj
+	private:
+
+		Xot::String name;
+
+};// SimpleObj
 
 
 #endif//EOH

data/ext/rucy/exception.cpp

@@ -1,4 +1,4 @@
-#include <rucy.h>
+#include "rucy.h"
 
 
 using namespace Rucy;
@@ -8,51 +8,51 @@ using namespace Rucy;
 	raise ruby's exception.
 */
 static
-RUBY_DEF0(raise_ruby_exception)
+RUCY_DEF0(raise_ruby_exception)
 {
 	throw RubyException(rb_eStandardError, "raise_ruby_exception");
 }
-RUBY_END
+RUCY_END
 
 /*
 	raise in eval.
 */
 static
-RUBY_DEF0(raise_in_eval)
+RUCY_DEF0(raise_in_eval)
 {
 	eval("raise 'raise_in_eval'");
 }
-RUBY_END
+RUCY_END
 
 /*
 	throw nothing.
 */
 static
-RUBY_DEF0(throw_nothing)
+RUCY_DEF0(throw_nothing)
 {
 	throw;
 }
-RUBY_END
+RUCY_END
 
 /*
 	throw std::exception.
 */
 static
-RUBY_DEF0(throw_std_exception)
+RUCY_DEF0(throw_std_exception)
 {
 	throw std::exception();
 }
-RUBY_END
+RUCY_END
 
 /*
 	throw std::runtime_error.
 */
 static
-RUBY_DEF0(throw_std_runtime_error)
+RUCY_DEF0(throw_std_runtime_error)
 {
 	throw std::runtime_error("std::runtime_error");
 }
-RUBY_END
+RUCY_END
 
 struct MyException : public std::runtime_error
 {
@@ -63,31 +63,31 @@ struct MyException : public std::runtime_error
 	throw custom exception class.
 */
 static
-RUBY_DEF0(throw_custom_exception)
+RUCY_DEF0(throw_custom_exception)
 {
 	throw MyException();
 }
-RUBY_END
+RUCY_END
 
 /*
 	throw std::string.
 */
 static
-RUBY_DEF0(throw_std_string)
+RUCY_DEF0(throw_std_string)
 {
 	throw std::string("std::string");
 }
-RUBY_END
+RUCY_END
 
 /*
 	throw char*.
 */
 static
-RUBY_DEF0(throw_cstring)
+RUCY_DEF0(throw_cstring)
 {
 	throw "cstring";
 }
-RUBY_END
+RUCY_END
 
 
 void

data/ext/rucy/extconf.rb

@@ -1,63 +1,22 @@
 # -*- coding: utf-8 -*-
 
 
-require 'xot/load_path'
-Xot::LoadPath.unshift File.expand_path('../../../lib', __FILE__)
+%w[../xot .]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'mkmf'
-require 'xot/rake'
+require 'xot/extconf'
 require 'xot/module'
 require 'rucy/module'
 
-include Xot::Rake
 
+Xot::ExtConf.new Xot, Rucy do
+  setup do
+    headers    << 'boost/noncopyable.hpp' << 'ruby.h'
+    local_libs << 'rucy'
+  end
 
-debug = env :DEBUG, false
-
-
-DEFS    = []
-INCDIRS = %w[
-  /opt/local/include
-  /opt/include
-]
-LIBDIRS = []
-
-HEADERS = %w[
-  boost/noncopyable.hpp
-  ruby.h
-  xot.h
-  rucy.h
-]
-LIBS = %w[
-  stdc++
-  xot
-  rucy
-]
-
-
-DEFS << '_DEBUG' if debug
-DEFS << 'NDEBUG' unless debug
-DEFS << 'WINDOWS' << 'WIN32' if win32?
-DEFS << 'COCOA' if cocoa?
-DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
-
-$CPPFLAGS   << DEFS.map    {|s| " -D#{s}"}.join
-$CPPFLAGS   << INCDIRS.map {|s| " -I#{s}"}.join
-$LDFLAGS    << LIBDIRS.map {|s| " -L#{s}"}.join
-$CFLAGS     << ' --stdlib=libc++' if clang?
-$LOCAL_LIBS << ' -lrucy'
-
-RbConfig::CONFIG.each do |key, val|
-  {'gcc' => 'g++', 'clang' => 'clang++'}.each {|from, to| val.gsub! from, to}
+  dir_config 'boost'
+  create_makefile 'rucy/tester'
 end
-
-
-dir_config 'boost'
-dir_config 'xot',  Xot.root_dir
-dir_config 'rucy', Rucy.root_dir
-
-exit 1 unless HEADERS.all? {|s| have_header(s)}
-exit 1 unless LIBS.all?    {|s| have_library(s)}
-
-
-create_makefile 'rucy/tester'

data/ext/rucy/function.cpp

@@ -1,4 +1,4 @@
-#include <rucy.h>
+#include "rucy.h"
 
 
 using namespace Rucy;
@@ -8,50 +8,62 @@ using namespace Rucy;
 	do nothing.
 */
 static
-RUBY_DEFN(do_nothing)
+RUCY_DEFN(do_nothing)
 {
 }
-RUBY_END
+RUCY_END
 
 /*
 	return nil.
 */
 static
-RUBY_DEF0(return_nil)
+RUCY_DEF0(return_nil)
 {
-	return Qnil;
+	return nil();
 }
-RUBY_END
+RUCY_END
 
 /*
 	return int.
 */
 static
-RUBY_DEF0(return_int)
+RUCY_DEF0(return_int)
 {
 	return value(1);
 }
-RUBY_END
+RUCY_END
 
 /*
 	return flaot.
 */
 static
-RUBY_DEF0(return_float)
+RUCY_DEF0(return_float)
 {
 	return value(1.0f);
 }
-RUBY_END
+RUCY_END
 
 /*
 	return string.
 */
 static
-RUBY_DEF0(return_string)
+RUCY_DEF0(return_string)
 {
 	return value("");
 }
-RUBY_END
+RUCY_END
+
+/*
+	check_arg_count
+*/
+static
+RUCY_DEFN(arg_count_must_1)
+{
+	check_arg_count(__FILE__, __LINE__, "arg_count_must_1", argc, 1);
+	RUCY_SYM(ok);
+	return ok.value();
+}
+RUCY_END
 
 
 void
@@ -65,4 +77,5 @@ Init_function ()
 	mTester.define_method("return_int", return_int);
 	mTester.define_method("return_float", return_float);
 	mTester.define_method("return_string", return_string);
+	mTester.define_method("arg_count_must_1", arg_count_must_1);
 }

data/ext/rucy/struct.cpp

@@ -1,4 +1,4 @@
-#include <rucy.h>
+#include "rucy.h"
 
 
 using namespace Rucy;
@@ -16,58 +16,40 @@ struct Struct
 
 static Class cStruct;
 
-
-namespace Rucy
-{
-
-
-	static Value
-	value (const Struct& obj)
-	{
-		return new_type(cStruct, new Struct(obj));
-	}
-
-	template <> inline Struct*
-	value_to<Struct*> (Value val, bool)
-	{
-		return get_type_ptr<Struct>(val, cStruct);
-	}
-
-
-}// Rucy
+RUCY_VALUE_FROM_TO(Struct, cStruct)
 
 
 /*
 	alloc function.
 */
 static
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
 	return new_type<Struct>(klass);
 }
-RUBY_END
+RUCY_END
 
 /*
 	get num.
 */
 static
-RUBY_DEF0(get_num)
+RUCY_DEF0(get_num)
 {
 	Struct* obj = to<Struct*>(self);
 	if (obj) return value(obj->num);
 }
-RUBY_END
+RUCY_END
 
 /*
 	set num.
 */
 static
-RUBY_DEF1(set_num, num)
+RUCY_DEF1(set_num, num)
 {
 	Struct* obj = to<Struct*>(self);
 	if (obj) obj->num = to<int>(num);
 }
-RUBY_END
+RUCY_END
 
 
 void