rucy 0.1.3 → 0.1.4

data/.doc/ext/rucy/tester.cpp

@@ -1,196 +1,62 @@
-#include <rucy.h>
-
-
-using namespace Rucy;
-
-
-struct Tester
-{
-
-	int value;
-
-};// Tester
-
-
-static Class cTester;
-
-
-Class
-tester_class ()
-{
-	return cTester;
-}
-
-
-namespace Rucy
-{
-
-
-	static Value
-	value (const Tester& obj)
-	{
-		return new_type<Tester>(tester_class(), new Tester(obj));
-	}
+#include "tester.h"
 
-	template <> inline Tester*
-	value_to<Tester*> (Value obj, bool)
-	{
-		return get_type<Tester>(obj, tester_class());
-	}
 
+#include <vector>
+#include <rucy.h>
 
-}// Rucy
-
-
-/*
-	alloc function.
-*/
-static
-VALUE alloc(VALUE klass)
-{
-	return new_type<Tester>(klass);
-}
-
-/*
-	get value.
-*/
-static
-VALUE get_value(VALUE self)
-{
-	Tester* t = to<Tester*>(self);
-	if (t) return value(t->value);
-}
-
-/*
-	set value.
-*/
-static
-VALUE set_value(VALUE self, VALUE value)
-{
-	Tester* t = to<Tester*>(self);
-	if (t) t->value = to<int>(value);
-}
 
-/*
-	do nothing.
-*/
-static
-VALUE do_nothing(VALUE self)
-{
-}
+using namespace Rucy;
 
-/*
-	return nil.
-*/
-static
-VALUE return_nil(VALUE self)
-{
-	return Qnil;
-}
 
-/*
-	return int.
-*/
-static
-VALUE return_int(VALUE self)
-{
-	return value(1);
-}
+static std::vector<String> logs;
 
-/*
-	return flaot.
-*/
-static
-VALUE return_float(VALUE self)
-{
-	return value(1.0f);
-}
 
-/*
-	return string.
-*/
-static
-VALUE return_string(VALUE self)
+void
+log (const char* str)
 {
-	return value("");
+	logs.push_back(str);
 }
 
-/*
-	raise ruby's exception.
-*/
-static
-VALUE raise_ruby_exception(VALUE self)
-{
-	throw RubyException(rb_eStandardError, "raise_ruby_exception");
-}
 
 /*
-	raise in eval.
+	return last log.
 */
-static
-VALUE raise_in_eval(VALUE self)
+VALUE last_log(VALUE self)
 {
-	eval("raise 'raise_in_eval'");
-}
+	if (argc > 1)
+		arg_count_error("#last_log", argc, 0, 1);
 
-/*
-	throw nothing.
-*/
-static
-VALUE throw_nothing(VALUE self)
-{
-	throw;
-}
+	size_t index = (argc >= 1) ? to<size_t>(argv[0]) : logs.size() - 1;
+	if (index >= logs.size())
+		index_error();
 
-/*
-	throw std::exception.
-*/
-static
-VALUE throw_std_exception(VALUE self)
-{
-	throw std::exception();
+	return value(logs[index].c_str());
 }
 
 /*
-	throw std::runtime_error.
+	return all logs.
 */
-static
-VALUE throw_std_runtime_error(VALUE self)
+VALUE all_logs(VALUE self)
 {
-	throw std::runtime_error("std::runtime_error");
+	std::vector<Value> a;
+	for (size_t i = 0; i < logs.size(); ++i) a.push_back(logs[i].c_str());
+	return value(a.size(), &a[0]);
 }
 
-struct MyException : public std::runtime_error
-{
-	MyException() : runtime_error("") {}
-};
-
 /*
-	throw custom exception class.
+	clcear all logs.
 */
-static
-VALUE throw_custom_exception(VALUE self)
+VALUE clear_logs(VALUE self)
 {
-	throw MyException();
+	logs.clear();
 }
 
-/*
-	throw std::string.
-*/
-static
-VALUE throw_std_string(VALUE self)
-{
-	throw std::string("std::string");
-}
 
-/*
-	throw char*.
-*/
-static
-VALUE throw_cstring(VALUE self)
-{
-	throw "cstring";
-}
+void Init_value ();
+void Init_exception ();
+void Init_function ();
+void Init_struct ();
+void Init_class ();
 
 
 extern "C" void
@@ -198,25 +64,16 @@ Init_tester ()
 {
 	if (!init()) return;
 
-	Module m = rb_define_module("Rucy");
-
-	Class c = rb_define_class_under(m, "Tester", rb_cObject);
-	cTester = c;
-
-	rb_define_alloc_func(c, alloc);
-	rb_define_method(c, "value", RUBY_METHOD_FUNC(get_value), 0);
-	rb_define_method(c, "value=", RUBY_METHOD_FUNC(set_value), 1);
-	rb_define_method(c, "do_nothing", RUBY_METHOD_FUNC(do_nothing), -1);
-	rb_define_method(c, "return_nil", RUBY_METHOD_FUNC(return_nil), 0);
-	rb_define_method(c, "return_int", RUBY_METHOD_FUNC(return_int), 0);
-	rb_define_method(c, "return_float", RUBY_METHOD_FUNC(return_float), 0);
-	rb_define_method(c, "return_string", RUBY_METHOD_FUNC(return_string), 0);
-	rb_define_method(c, "raise_ruby_exception", RUBY_METHOD_FUNC(raise_ruby_exception), 0);
-	rb_define_method(c, "raise_in_eval", RUBY_METHOD_FUNC(raise_in_eval), 0);
-	rb_define_method(c, "throw_nothing", RUBY_METHOD_FUNC(throw_nothing), 0);
-	rb_define_method(c, "throw_std_exception", RUBY_METHOD_FUNC(throw_std_exception), 0);
-	rb_define_method(c, "throw_std_runtime_error", RUBY_METHOD_FUNC(throw_std_runtime_error), 0);
-	rb_define_method(c, "throw_custom_exception", RUBY_METHOD_FUNC(throw_custom_exception), 0);
-	rb_define_method(c, "throw_std_string", RUBY_METHOD_FUNC(throw_std_string), 0);
-	rb_define_method(c, "throw_cstring", RUBY_METHOD_FUNC(throw_cstring), 0);
+	Module mRucy = rb_define_module("Rucy");
+	Module mTester = rb_define_module_under(mRucy, "Tester");
+
+	rb_define_function(mTester, "last_log", RUBY_METHOD_FUNC(last_log), -1);
+	rb_define_function(mTester, "all_logs", RUBY_METHOD_FUNC(all_logs), 0);
+	rb_define_function(mTester, "clear_logs", RUBY_METHOD_FUNC(clear_logs), 0);
+
+	Init_value();
+	Init_exception();
+	Init_function();
+	Init_struct ();
+	Init_class ();
 }

data/.doc/ext/rucy/value.cpp

@@ -0,0 +1,42 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+static
+VALUE true_to_value(VALUE self)
+{
+	return value(true);
+}
+
+static
+VALUE false_to_value(VALUE self)
+{
+	return value(false);
+}
+
+static
+VALUE NULL_to_value(VALUE self)
+{
+	return nil();
+}
+
+static
+VALUE nil_value(VALUE self)
+{
+	return nil();
+}
+
+
+void
+Init_value ()
+{
+	Module mRucy = rb_define_module("Rucy");
+	Module mTester = rb_define_module_under(mRucy, "Tester");
+
+	rb_define_method(mTester, "true_to_value", RUBY_METHOD_FUNC(true_to_value), -1);
+	rb_define_method(mTester, "false_to_value", RUBY_METHOD_FUNC(false_to_value), -1);
+	rb_define_method(mTester, "null_to_value", RUBY_METHOD_FUNC(NULL_to_value), -1);
+	rb_define_method(mTester, "nil_value", RUBY_METHOD_FUNC(nil_value), -1);
+}

data/.gitignore

@@ -0,0 +1,22 @@
+*.o
+*.so
+*.bundle
+*.dll.a
+*.gem
+*.log
+*.rdoc.cpp
+*~
+lib/*.a
+.doc
+.yardoc
+.DS_Store
+Makefile
+depend.mf
+
+include/rucy/defs.h
+include/rucy/function.h
+include/rucy/module.h
+include/rucy/value.h
+src/function.cpp
+src/module.cpp
+src/value.cpp

data/Rakefile

@@ -1,12 +1,8 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-%w[. ../xot].map {|s| "#{s}/lib"}.each do |path|
-  $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
-end
-
-require 'rubygems'
-require 'xot/rake/helpers'
+require 'bundler/setup'
+require 'xot/rake'
 require 'xot/module'
 require 'rucy/module'
 
@@ -14,7 +10,8 @@ include Xot::Rake
 
 
 MODULE     = Rucy
-INCDIRS    = [Rucy].map {|m| m.include_dirs}.flatten
+DLNAME     = 'tester'
+INCDIRS    = [Rucy, Xot].map {|m| m.include_dirs}.flatten
 RUCY2RDOC  = 'bin/rucy2rdoc'
 NPARAM_MAX = 8
 NTIMES     = (0..NPARAM_MAX)
@@ -24,27 +21,5 @@ task :default => :build
 
 task :build => :lib
 
-task :rebuild => [:clean, :build]
-
-task :lib => 'lib:build'
-
-task :ext => 'ext:build'
-
-task :doc => 'ext:doc'
-
-task :gem => 'gem:build'
-
-task :install => 'gem:install'
-
-task :uninstall => 'gem:uninstall'
-
-task :clean => ['lib:clean', 'ext:clean', 'gem:clean']
-
-task :test => :ext do
-  Dir['test/**/test_*.rb'].each do |rb|
-    sh %( ruby #{rb} )
-  end
-end
-
 
 [Xot, Rucy].each {|m| m.load_tasks}

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/ext/rucy/class.cpp

@@ -0,0 +1,262 @@
+#include "class.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)
+
+
+template <typename T> Class get_class ();
+
+template <> Class get_class<Base> () {return cBase;}
+
+template <> Class get_class<Sub> () {return cSub;}
+
+
+template <typename T>
+class RubyBase : public ClassWrapper<T>
+{
+
+	typedef ClassWrapper<T> Super;
+
+	RUCY_OVERRIDE_ID_START(name_overridable_faster)
+	RUCY_OVERRIDE_ID_LAST
+
+	public:
+
+		virtual const char* name_overridable () const
+		{
+			RUCY_OVERRIDABLE_METHOD(name_overridable, get_class<T>(), .c_str());
+		}
+
+		virtual const char* name_overridable_faster () const
+		{
+			RUCY_OVERRIDABLE_METHOD_FAST(name_overridable_faster, get_class<T>(), .c_str());
+		}
+
+		bool is_name_overridable_faster_overridden () const
+		{
+			SYM(name_overridable_faster);
+			return RUCY_IS_OVERRIDDEN(name_overridable_faster, get_class<T>());
+		}
+
+};// RubyBase
+
+
+#define THIS(type)           to<type*>(self)
+
+#define CHECK(type)          RUCY_CHECK_OBJ(self, type, c##type)
+
+#define CALL(type, obj, fun) RUCY_WRAPPER_CALL(ClassWrapper<type>, obj, fun)
+
+
+/*
+	alloc function.
+*/
+static
+RUBY_DEF_ALLOC(base_alloc, klass)
+{
+	return value(new RubyBase<Base>, klass);
+}
+RUBY_END
+
+static
+RUBY_DEF0(name)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name());
+}
+RUBY_END
+
+static
+RUBY_DEF0(call_name)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name());
+}
+RUBY_END
+
+static
+RUBY_DEF0(base_name_overridable)
+{
+	CHECK(Base);
+	return value(CALL(Base, THIS(Base), name_overridable()));
+}
+RUBY_END
+
+static
+RUBY_DEF0(call_name_overridable)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name_overridable());
+}
+RUBY_END
+
+static
+RUBY_DEF0(base_name_overridable_faster)
+{
+	CHECK(Base);
+	return value(CALL(Base, THIS(Base), name_overridable_faster()));
+}
+RUBY_END
+
+static
+RUBY_DEF0(call_name_overridable_faster)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name_overridable_faster());
+}
+RUBY_END
+
+template <typename T>
+static
+RUBY_DEF0(is_name_overridable_faster_overridden)
+{
+	RUCY_CHECK_OBJ(self, T, get_class<T>());
+	RubyBase<T>* obj = dynamic_cast<RubyBase<T>*>(THIS(T));
+	if (!obj) invalid_object_error("dynamic_cast() failed.");
+	return value(obj->is_name_overridable_faster_overridden());
+}
+RUBY_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
+
+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)
+{
+	return value(new Base);
+}
+RUBY_END
+
+
+/*
+	alloc function.
+*/
+static
+RUBY_DEF_ALLOC(sub_alloc, klass)
+{
+	return value(new RubyBase<Sub>, klass);
+}
+RUBY_END
+
+static
+RUBY_DEF0(sub_name_overridable)
+{
+	CHECK(Sub);
+	return value(CALL(Sub, THIS(Sub), name_overridable()));
+}
+RUBY_END
+
+static
+RUBY_DEF0(sub_name_overridable_faster)
+{
+	CHECK(Sub);
+	return value(CALL(Sub, THIS(Sub), name_overridable_faster()));
+}
+RUBY_END
+
+static
+RUBY_DEF0(sub_new_raw)
+{
+	return value(new Sub);
+}
+RUBY_END
+
+
+/*
+	alloc function.
+*/
+static
+RUBY_DEF_ALLOC(rubyobj_alloc, klass)
+{
+	return value(new ClassWrapper<RubyObj>, klass);
+}
+RUBY_END
+
+static Xot::Ref<RubyObj> rubyobj_ref;
+
+static
+RUBY_DEF1(rubyobj_set_ref, obj)
+{
+	rubyobj_ref = to<RubyObj*>(obj);
+	return obj;
+}
+RUBY_END
+
+static
+RUBY_DEF0(rubyobj_clear_ref)
+{
+	rubyobj_ref.reset();
+}
+RUBY_END
+
+
+void
+Init_class ()
+{
+	Module mRucy   =       define_module("Rucy");
+	Module mTester = mRucy.define_module("Tester");
+
+	cBase = mTester.define_class("Base");
+	cBase.define_alloc_func(base_alloc);
+	cBase.define_method(     "name",                         name);
+	cBase.define_method(     "name_overridable",        base_name_overridable);
+	cBase.define_method(     "name_overridable_faster", base_name_overridable_faster);
+	cBase.define_method("call_name",                    call_name);
+	cBase.define_method("call_name_overridable",        call_name_overridable);
+	cBase.define_method("call_name_overridable_faster", call_name_overridable_faster);
+	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);
+
+	cSub = mTester.define_class("Sub", cBase);
+	cSub.define_alloc_func(sub_alloc);
+	cSub.define_method("name_overridable",        sub_name_overridable);
+	cSub.define_method("name_overridable_faster", sub_name_overridable_faster);
+	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);
+
+	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);
+}