rucy 0.1.3 → 0.1.4

data/.doc/ext/rucy/class.cpp

@@ -0,0 +1,244 @@
+#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
+VALUE base_alloc(VALUE klass)
+{
+	return value(new RubyBase<Base>, klass);
+}
+
+static
+VALUE name(VALUE self)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name());
+}
+
+static
+VALUE call_name(VALUE self)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name());
+}
+
+static
+VALUE base_name_overridable(VALUE self)
+{
+	CHECK(Base);
+	return value(CALL(Base, THIS(Base), name_overridable()));
+}
+
+static
+VALUE call_name_overridable(VALUE self)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name_overridable());
+}
+
+static
+VALUE base_name_overridable_faster(VALUE self)
+{
+	CHECK(Base);
+	return value(CALL(Base, THIS(Base), name_overridable_faster()));
+}
+
+static
+VALUE call_name_overridable_faster(VALUE self)
+{
+	CHECK(Base);
+	return value(THIS(Base)->name_overridable_faster());
+}
+
+template <typename T>
+static
+VALUE is_name_overridable_faster_overridden(VALUE self)
+{
+	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());
+}
+
+template <typename T>
+static
+VALUE clear_override_flags(VALUE self)
+{
+	RUCY_CHECK_OBJ(self, T, get_class<T>());
+	ClassWrapper<T>* obj = dynamic_cast<ClassWrapper<T>*>(THIS(T));
+	if (obj) obj->clear_override_flags();
+}
+
+template <bool singleton>
+static
+VALUE method_added_or_removed(VALUE self, VALUE 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());
+}
+
+static
+VALUE base_new_raw(VALUE self)
+{
+	return value(new Base);
+}
+
+
+/*
+	alloc function.
+*/
+static
+VALUE sub_alloc(VALUE klass)
+{
+	return value(new RubyBase<Sub>, klass);
+}
+
+static
+VALUE sub_name_overridable(VALUE self)
+{
+	CHECK(Sub);
+	return value(CALL(Sub, THIS(Sub), name_overridable()));
+}
+
+static
+VALUE sub_name_overridable_faster(VALUE self)
+{
+	CHECK(Sub);
+	return value(CALL(Sub, THIS(Sub), name_overridable_faster()));
+}
+
+static
+VALUE sub_new_raw(VALUE self)
+{
+	return value(new Sub);
+}
+
+
+/*
+	alloc function.
+*/
+static
+VALUE rubyobj_alloc(VALUE klass)
+{
+	return value(new ClassWrapper<RubyObj>, klass);
+}
+
+static Xot::Ref<RubyObj> rubyobj_ref;
+
+static
+VALUE rubyobj_set_ref(VALUE self, VALUE obj)
+{
+	rubyobj_ref = to<RubyObj*>(obj);
+	return obj;
+}
+
+static
+VALUE rubyobj_clear_ref(VALUE self)
+{
+	rubyobj_ref.reset();
+}
+
+
+void
+Init_class ()
+{
+	Module mRucy = rb_define_module("Rucy");
+	Module mTester = rb_define_module_under(mRucy, "Tester");
+
+	cBase = rb_define_class_under(mTester, "Base", rb_cObject);
+	rb_define_alloc_func(cBase, base_alloc);
+	rb_define_method(cBase, "name", RUBY_METHOD_FUNC(name), 0);
+	rb_define_method(cBase, "name_overridable", RUBY_METHOD_FUNC(base_name_overridable), 0);
+	rb_define_method(cBase, "name_overridable_faster", RUBY_METHOD_FUNC(base_name_overridable_faster), 0);
+	rb_define_method(cBase, "call_name", RUBY_METHOD_FUNC(call_name), 0);
+	rb_define_method(cBase, "call_name_overridable", RUBY_METHOD_FUNC(call_name_overridable), 0);
+	rb_define_method(cBase, "call_name_overridable_faster", RUBY_METHOD_FUNC(call_name_overridable_faster), 0);
+	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>);
+	rb_define_singleton_method(cBase, "new_raw", RUBY_METHOD_FUNC(base_new_raw), 0);
+
+	cSub = rb_define_class_under(mTester, "Sub", cBase);
+	rb_define_alloc_func(cSub, sub_alloc);
+	rb_define_method(cSub, "name_overridable", RUBY_METHOD_FUNC(sub_name_overridable), 0);
+	rb_define_method(cSub, "name_overridable_faster", RUBY_METHOD_FUNC(sub_name_overridable_faster), 0);
+	cSub.define_method(
+		"is_name_overridable_faster_overridden",
+		 is_name_overridable_faster_overridden<Sub>);
+	cSub.define_method("clear_override_flags",    clear_override_flags<Sub>);
+	rb_define_singleton_method(cSub, "new_raw", RUBY_METHOD_FUNC(sub_new_raw), 0);
+
+	cRubyObj = rb_define_class_under(mTester, "RubyObj", rb_cObject);
+	rb_define_alloc_func(cRubyObj, rubyobj_alloc);
+	rb_define_function(cRubyObj, "set_ref", RUBY_METHOD_FUNC(rubyobj_set_ref), 1);
+	rb_define_function(cRubyObj, "clear_ref", RUBY_METHOD_FUNC(rubyobj_clear_ref), 0);
+}

data/.doc/ext/rucy/exception.cpp

@@ -0,0 +1,99 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+/*
+	raise ruby's exception.
+*/
+static
+VALUE raise_ruby_exception(VALUE self)
+{
+	throw RubyException(rb_eStandardError, "raise_ruby_exception");
+}
+
+/*
+	raise in eval.
+*/
+static
+VALUE raise_in_eval(VALUE self)
+{
+	eval("raise 'raise_in_eval'");
+}
+
+/*
+	throw nothing.
+*/
+static
+VALUE throw_nothing(VALUE self)
+{
+	throw;
+}
+
+/*
+	throw std::exception.
+*/
+static
+VALUE throw_std_exception(VALUE self)
+{
+	throw std::exception();
+}
+
+/*
+	throw std::runtime_error.
+*/
+static
+VALUE throw_std_runtime_error(VALUE self)
+{
+	throw std::runtime_error("std::runtime_error");
+}
+
+struct MyException : public std::runtime_error
+{
+	MyException() : runtime_error("") {}
+};
+
+/*
+	throw custom exception class.
+*/
+static
+VALUE throw_custom_exception(VALUE self)
+{
+	throw MyException();
+}
+
+/*
+	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_exception ()
+{
+	Module mRucy = rb_define_module("Rucy");
+	Module mTester = rb_define_module_under(mRucy, "Tester");
+
+	rb_define_method(mTester, "raise_ruby_exception", RUBY_METHOD_FUNC(raise_ruby_exception), 0);
+	rb_define_method(mTester, "raise_in_eval", RUBY_METHOD_FUNC(raise_in_eval), 0);
+	rb_define_method(mTester, "throw_nothing", RUBY_METHOD_FUNC(throw_nothing), 0);
+	rb_define_method(mTester, "throw_std_exception", RUBY_METHOD_FUNC(throw_std_exception), 0);
+	rb_define_method(mTester, "throw_std_runtime_error", RUBY_METHOD_FUNC(throw_std_runtime_error), 0);
+	rb_define_method(mTester, "throw_custom_exception", RUBY_METHOD_FUNC(throw_custom_exception), 0);
+	rb_define_method(mTester, "throw_std_string", RUBY_METHOD_FUNC(throw_std_string), 0);
+	rb_define_method(mTester, "throw_cstring", RUBY_METHOD_FUNC(throw_cstring), 0);
+}

data/.doc/ext/rucy/function.cpp

@@ -0,0 +1,63 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+/*
+	do nothing.
+*/
+static
+VALUE do_nothing(VALUE self)
+{
+}
+
+/*
+	return nil.
+*/
+static
+VALUE return_nil(VALUE self)
+{
+	return Qnil;
+}
+
+/*
+	return int.
+*/
+static
+VALUE return_int(VALUE self)
+{
+	return value(1);
+}
+
+/*
+	return flaot.
+*/
+static
+VALUE return_float(VALUE self)
+{
+	return value(1.0f);
+}
+
+/*
+	return string.
+*/
+static
+VALUE return_string(VALUE self)
+{
+	return value("");
+}
+
+
+void
+Init_function ()
+{
+	Module mRucy = rb_define_module("Rucy");
+	Module mTester = rb_define_module_under(mRucy, "Tester");
+
+	rb_define_method(mTester, "do_nothing", RUBY_METHOD_FUNC(do_nothing), -1);
+	rb_define_method(mTester, "return_nil", RUBY_METHOD_FUNC(return_nil), 0);
+	rb_define_method(mTester, "return_int", RUBY_METHOD_FUNC(return_int), 0);
+	rb_define_method(mTester, "return_float", RUBY_METHOD_FUNC(return_float), 0);
+	rb_define_method(mTester, "return_string", RUBY_METHOD_FUNC(return_string), 0);
+}

data/.doc/ext/rucy/struct.cpp

@@ -0,0 +1,80 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+struct Struct
+{
+
+	int num;
+
+	Struct () : num(0) {}
+
+};// 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
+
+
+/*
+	alloc function.
+*/
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Struct>(klass);
+}
+
+/*
+	get num.
+*/
+static
+VALUE get_num(VALUE self)
+{
+	Struct* obj = to<Struct*>(self);
+	if (obj) return value(obj->num);
+}
+
+/*
+	set num.
+*/
+static
+VALUE set_num(VALUE self, VALUE num)
+{
+	Struct* obj = to<Struct*>(self);
+	if (obj) obj->num = to<int>(num);
+}
+
+
+void
+Init_struct ()
+{
+	Module mRucy = rb_define_module("Rucy");
+	Module mTester = rb_define_module_under(mRucy, "Tester");
+
+	cStruct = rb_define_class_under(mTester, "Struct", rb_cObject);
+	rb_define_alloc_func(cStruct, alloc);
+	rb_define_method(cStruct, "num", RUBY_METHOD_FUNC(get_num), 0);
+	rb_define_method(cStruct, "num=", RUBY_METHOD_FUNC(set_num), 1);
+}