rucy 0.1.6 → 0.1.7

data/src/exception.cpp

@@ -2,12 +2,13 @@
 #include "rucy/exception.h"
 
 
-#include <ruby.h>
-#include <rucy/rucy.h>
-
+#include <typeinfo>
 #ifdef WIN32
 	#include <windows.h>
 #endif
+#include <xot/exception.h>
+#include "rucy/ruby.h"
+#include "rucy/rucy.h"
 
 
 namespace Rucy
@@ -19,17 +20,17 @@ namespace Rucy
 	{
 	}
 
-	RubyException::RubyException (Value type, const char* format, ...)
-	:	Super(""), val(Qnil)
+	RubyException::RubyException (Value exception, const char* format, ...)
+	:	Super(""), val(nil())
 	{
 		XOT_STRINGF(format, s);
-		val = rb_exc_new2(type, s.c_str());
+		val = rb_exc_new2(exception, s.c_str());
 	}
 
 	const char*
 	RubyException::what () const throw()
 	{
-		SYM(message);
+		RUCY_SYM(message);
 		return value().call(message).c_str();
 	}
 
@@ -40,7 +41,7 @@ namespace Rucy
 	}
 
 
-	RubyJumptag::RubyJumptag (int tag)
+	RubyJumpTag::RubyJumpTag (int tag)
 	:	tag(tag)
 	{
 	}
@@ -51,98 +52,112 @@ namespace Rucy
 	{
 		if (!format) throw;
 
-		XOT_STRINGF(format, message);
-		throw message;
+		XOT_STRINGF(format, s);
+		throw s.c_str();
 	}
 
 	void
-	raise (VALUE exception, const char* format, ...)
+	raise (RubyValue exception, const char* format, ...)
 	{
-		XOT_STRINGF(format, message);
-		throw RubyException(exception, message.c_str());
+		XOT_STRINGF(format, s);
+		throw RubyException(exception, s.c_str());
 	}
 
 
 	void
-	type_error (const char* format, ...)
+	rucy_error (const char* file, int line, const char* format, ...)
 	{
-		XOT_STRINGF(format, message);
-		raise(rb_eTypeError, message.c_str());
+		XOT_STRINGF(format, s);
+		raise(Xot::error_text(file, line, s));
 	}
 
 	void
-	argument_error (const char* format, ...)
+	type_error (const char* file, int line, const char* format, ...)
 	{
-		XOT_STRINGF(format, message);
-		raise(rb_eArgError, message.c_str());
+		XOT_STRINGF(format, s);
+		raise(rb_eTypeError, Xot::error_text(file, line, s));
+	}
+
+	void
+	argument_error (const char* file, int line, const char* format, ...)
+	{
+		XOT_STRINGF(format, s);
+		raise(rb_eArgError, Xot::error_text(file, line, s));
 	}
 
 	void
 	arg_count_error (
+		const char* file, int line,
 		const char* method, int nargs, int nargs_expected,
 		int n1, int n2, int n3, int n4, int n5,
 		int n6, int n7, int n8, int n9, int n10)
 	{
-		String message = Xot::stringf(
+		Xot::String s = Xot::stringf(
 			"wrong number of arguments for %s: %d for %d",
 			method, nargs, nargs_expected);
 
 		int n[10] = {n1, n2, n3, n4, n5, n6, n7, n8, n9, n10};
 		for (int i = 0; i < 5 && n[i] >= 0; ++i)
-			message += Xot::stringf(" or %d", n[i]);
+			s += Xot::stringf(" or %d", n[i]);
 
-		message += ".";
-		argument_error(message.c_str());
+		s += ".";
+		argument_error(file, line, s);
+	}
+
+	void
+	invalid_state_error (const char* file, int line, const char* format, ...)
+	{
+		XOT_STRINGF(format, s);
+		raise(invalid_state_error_class(), Xot::error_text(file, line, s));
 	}
 
 	void
-	index_error (const char* format, ...)
+	invalid_object_error (const char* file, int line, const char* format, ...)
 	{
-		XOT_STRINGF(format, message);
-		raise(rb_eIndexError, message.c_str());
+		XOT_STRINGF(format, s);
+		raise(invalid_object_error_class(), Xot::error_text(file, line, s));
 	}
 
 	void
-	not_implemented_error (const char* format, ...)
+	index_error (const char* file, int line, const char* format, ...)
 	{
-		XOT_STRINGF(format, message);
-		raise(rb_eNotImpError, message.c_str());
+		XOT_STRINGF(format, s);
+		raise(rb_eIndexError, Xot::error_text(file, line, s));
 	}
 
+	void
+	not_implemented_error (const char* file, int line, const char* format, ...)
+	{
+		XOT_STRINGF(format, s);
+		raise(rb_eNotImpError, Xot::error_text(file, line, s));
+	}
 
 	void
-	system_error (const char* format, ...)
+	system_error (const char* file, int line, const char* format, ...)
 	{
-		XOT_STRINGF(format, message);
+		XOT_STRINGF(format, s);
 
 		#ifdef WIN32
-		DWORD lasterror = GetLastError();
-		if (lasterror != 0)
-		{
-			LPVOID msg = NULL;
-			DWORD flags =
-				FORMAT_MESSAGE_ALLOCATE_BUFFER |
-				FORMAT_MESSAGE_FROM_SYSTEM |
-				FORMAT_MESSAGE_IGNORE_INSERTS;
-			if (FormatMessageA(
-				flags, NULL, lasterror, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
-				(LPSTR) &msg, 0, NULL))
+			DWORD lasterror = GetLastError();
+			if (lasterror != 0)
 			{
-				String s = (LPCSTR) msg;
-				if (!s.empty()) message = s + ": " + message;
+				LPVOID msg = NULL;
+				DWORD flags =
+					FORMAT_MESSAGE_ALLOCATE_BUFFER |
+					FORMAT_MESSAGE_FROM_SYSTEM |
+					FORMAT_MESSAGE_IGNORE_INSERTS;
+				if (FormatMessageA(
+					flags, NULL, lasterror, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+					(LPSTR) &msg, 0, NULL))
+				{
+					Xot::String m = (LPCSTR) msg;
+					if (!m.empty()) s += ": " + m;
+				}
+				LocalFree(msg);
 			}
-			LocalFree(msg);
-		}
 		#endif
 
-		raise(system_error_class(), message.c_str());
-	}
-
-	void
-	invalid_object_error (const char* format, ...)
-	{
-		XOT_STRINGF(format, message);
-		raise(invalid_object_error_class(), message.c_str());
+		raise(system_error_class(), Xot::error_text(file, line, s));
 	}
 
 

data/src/extension.cpp

@@ -0,0 +1,59 @@
+// -*- c++ -*-
+#include "rucy/extension.h"
+
+
+#include <xot/string.h>
+
+
+namespace Rucy
+{
+
+
+	void
+	check_class (Value obj, Value klass)
+	{
+		if (!klass)
+			argument_error(__FILE__, __LINE__);
+
+		if (!obj.is_kind_of(klass))
+		{
+			RUCY_SYMBOL(clas, "class");
+			RUCY_SYM(name);
+			type_error(__FILE__, __LINE__,
+				Xot::stringf(
+					"object is instance of %s, but %s is expected.",
+					obj(clas)(name).c_str(), klass(name).c_str()));
+		}
+	}
+
+	void
+	check_arg_count (
+		const char* file, int line,
+		const char* method, int nargs, int nargs_expected_n0,
+		int n1, int n2, int n3, int n4, int n5,
+		int n6, int n7, int n8, int n9, int n10)
+	{
+		if (nargs < 0 || nargs_expected_n0 < 0)
+			argument_error(__FILE__, __LINE__);
+
+		if (
+			nargs != nargs_expected_n0 &&
+			(n1  < 0 || nargs != n1)   &&
+			(n2  < 0 || nargs != n2)   &&
+			(n3  < 0 || nargs != n3)   &&
+			(n4  < 0 || nargs != n4)   &&
+			(n5  < 0 || nargs != n5)   &&
+			(n6  < 0 || nargs != n6)   &&
+			(n7  < 0 || nargs != n7)   &&
+			(n8  < 0 || nargs != n8)   &&
+			(n9  < 0 || nargs != n9)   &&
+			(n10 < 0 || nargs != n10))
+		{
+			arg_count_error(
+				file, line, method, nargs, nargs_expected_n0,
+				n1, n2, n3, n4, n5, n6, n7, n8, n9, n10);
+		}
+	}
+
+
+}// Rucy

data/src/function.cpp.erb

@@ -2,7 +2,7 @@
 #include "rucy/function.h"
 
 
-#include <rucy/exception.h>
+#include "rucy/exception.h"
 
 
 #ifndef TAG_RAISE
@@ -14,57 +14,49 @@ namespace Rucy
 {
 
 
-	void
-	define_function (const char* name, RubyFunctionN fun)
-	{
-		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), -1);
-	}
-%	NTIMES.each do |n|
-	void
-	define_function (const char* name, RubyFunction<%= n %> fun)
-	{
-		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), <%= n %>);
-	}
-%	end
-
 	Value
 	call (Symbol name, int argc, const Value* argv)
 	{
-		return protect(rb_funcall2, Qnil, name.id(), argc, (const VALUE*) argv);
+		return protect(
+			rb_funcall2, nil().value(), name.symbol(), argc, (const RubyValue*) argv);
 	}
 %	NTIMES.each do |n|
+
 	Value
 	call (Symbol name<%= params(n) {|i| ", Value v#{i}"} %>)
 	{
-		const VALUE args[] = {<%= params(n, ", ") {|i| "v#{i}"} %>};
-		return protect(rb_funcall2, Qnil, name.id(), <%= n %>, args);
+		const RubyValue args[] = {<%= params(n, ', ') {|i| "v#{i}.value()"} %>};
+		return protect(
+			rb_funcall2, nil().value(), name.symbol(), <%= n %>, args);
 	}
 %	end
 
+
 	Value
-	eval (const char* str)
+	eval (const char* format, ...)
 	{
-		SYM(eval);
-		return call(eval, str);
+		RUCY_SYM(eval);
+		XOT_STRINGF(format, s);
+		return call(eval, s.c_str());
 	}
 
 
 	Value
-	call_protect (VALUE (*fun)(VALUE), VALUE arg)
+	call_protect (RubyValue (*fun)(RubyValue), RubyValue data)
 	{
 		int state = 0;
-		VALUE ret = rb_protect(fun, arg, &state);
+		RubyValue ret = rb_protect(fun, data, &state);
 
 		if (state != 0)
 		{
-			VALUE exception = rb_errinfo();
+			RubyValue exception = rb_errinfo();
 			if (state == TAG_RAISE && RTEST(exception))
 			{
-				rb_set_errinfo(Qnil);
+				rb_set_errinfo(nil().value());
 				throw RubyException(exception);
 			}
 
-			throw RubyJumptag(state);
+			throw RubyJumpTag(state);
 		}
 
 		return ret;

data/src/module.cpp.erb

@@ -2,14 +2,14 @@
 #include "rucy/module.h"
 
 
-#include <rucy/class.h>
+#include "rucy/class.h"
 
 
 namespace Rucy
 {
 
 
-	Module::Module (VALUE v)
+	Module::Module (RubyValue v)
 	:	Super(v)
 	{
 	}
@@ -23,42 +23,38 @@ namespace Rucy
 	Class
 	Module::define_class (const char* name, Value super)
 	{
+		if (super.is_nil()) super = rb_cObject;
 		return rb_define_class_under(value(), name, super);
 	}
 
-	Module
+	void
 	Module::define_const (const char* name, Value val)
 	{
 		rb_define_const(value(), name, val);
-		return *this;
 	}
 
-	Module
+	void
 	Module::define_attr (const char* name, bool read, bool write)
 	{
 		rb_define_attr(value(), name, read, write);
-		return *this;
 	}
 
-	Module
+	void
 	Module::define_alias (const char* new_, const char* old)
 	{
 		rb_define_alias(value(), new_, old);
-		return *this;
 	}
 
-	Module
+	void
 	Module::undef_method (const char* name)
 	{
 		rb_undef_method(value(), name);
-		return *this;
 	}
 
-	Module
+	void
 	Module::include_module (Value module)
 	{
 		rb_include_module(value(), module);
-		return *this;
 	}
 
 %	[
@@ -67,18 +63,16 @@ namespace Rucy
 %		['define_private_method',   'rb_define_private_method'],
 %		['define_singleton_method', 'rb_define_singleton_method']
 %	].each do |(op, rb_op)|
-	Module
+	void
 	Module::<%= op %> (const char* name, RubyFunctionN fun)
 	{
 		<%= rb_op %>(value(), name, RUBY_METHOD_FUNC(fun), -1);
-		return *this;
 	}
 %		NTIMES.each do |n|
-	Module
+	void
 	Module::<%= op %> (const char* name, RubyFunction<%= n %> fun)
 	{
 		<%= rb_op %>(value(), name, RUBY_METHOD_FUNC(fun), <%= n %>);
-		return *this;
 	}
 %		end
 %	end
@@ -93,6 +87,7 @@ namespace Rucy
 	Class
 	define_class (const char* name, Value super)
 	{
+		if (super.is_nil()) super = rb_cObject;
 		return rb_define_class(name, super);
 	}
 
@@ -102,5 +97,19 @@ namespace Rucy
 		rb_define_global_const(name, val);
 	}
 
+	void
+	define_function (const char* name, RubyFunctionN fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), -1);
+	}
+%	NTIMES.each do |n|
+
+	void
+	define_function (const char* name, RubyFunction<%= n %> fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), <%= n %>);
+	}
+%	end
+
 
 }// Rucy

data/src/rucy.cpp

@@ -2,42 +2,25 @@
 #include "rucy/rucy.h"
 
 
-#include <rucy/exception.h>
+#include "rucy/exception.h"
 
 
 namespace Rucy
 {
 
 
-	bool
+	void
 	init ()
 	{
 		static bool done = false;
-		if (done) return true;
+		if (done) return;
 		done = true;
 
 		rucy_module();
 		native_error_class();
-		system_error_class();
+		invalid_state_error_class();
 		invalid_object_error_class();
-
-		return true;
-	}
-
-	bool
-	check_class (Value obj, Value klass)
-	{
-		return klass && obj.is_kind_of(klass);
-
-#if 0
-		SYMBOL(klass, "class");
-		SYM(name);
-		String message = stringf(
-			"object is instance of %s, but %s is expected.",
-			obj(klass)(name).c_str(), class_(name).c_str());
-
-		type_error(message.c_str());
-#endif
+		system_error_class();
 	}
 
 
@@ -48,7 +31,6 @@ namespace Rucy
 		return m;
 	}
 
-
 	Class
 	native_error_class ()
 	{
@@ -58,10 +40,10 @@ namespace Rucy
 	}
 
 	Class
-	system_error_class ()
+	invalid_state_error_class ()
 	{
 		static Class c =
-			rucy_module().define_class("SystemError", native_error_class());
+			rucy_module().define_class("InvalidStateError", native_error_class());
 		return c;
 	}
 
@@ -73,5 +55,13 @@ namespace Rucy
 		return c;
 	}
 
+	Class
+	system_error_class ()
+	{
+		static Class c =
+			rucy_module().define_class("SystemError", native_error_class());
+		return c;
+	}
+
 
 }// Rucy

data/src/symbol.cpp

@@ -2,8 +2,8 @@
 #include "rucy/symbol.h"
 
 
-#include <rucy/rucy.h>
-#include <rucy/value.h>
+#include "rucy/rucy.h"
+#include "rucy/value.h"
 
 
 namespace Rucy
@@ -11,46 +11,47 @@ namespace Rucy
 
 
 	Symbol::Symbol ()
-	:	id_(0)
+	:	sym(0)
 	{
 	}
 
-	Symbol::Symbol (ID id)
-	:	id_(id)
+	Symbol::Symbol (const char* s)
+	:	sym(rb_intern(s))
 	{
 	}
 
-	Symbol::Symbol (const Value& value)
-	:	id_(value.as_sym().id())
+	Symbol::Symbol (const char* s, size_t len)
+	:	sym(rb_intern2(s, len))
 	{
 	}
 
-	Symbol::Symbol (const char* str)
-	:	id_(rb_intern(str))
+	Symbol::Symbol (RubySymbol symbol)
+	:	sym(symbol)
 	{
 	}
 
-	ID
-	Symbol::id () const
+	RubySymbol
+	Symbol::symbol () const
 	{
-		return id_;
+		return sym;
 	}
 
-	VALUE
+	Value
 	Symbol::value () const
 	{
-		return id_ != 0 ? ID2SYM(id_) : Qnil;
+		if (sym == 0) return nil();
+		return ID2SYM(sym);
 	}
 
 	const char*
 	Symbol::c_str () const
 	{
-		return rb_id2name(id_);
+		return rb_id2name(sym);
 	}
 
 	Symbol::operator bool () const
 	{
-		return id_ != 0;
+		return sym != 0;
 	}
 
 	bool
@@ -62,7 +63,7 @@ namespace Rucy
 	bool
 	operator == (const Symbol& lhs, const Symbol& rhs)
 	{
-		return lhs.id_ == rhs.id_;
+		return lhs.sym == rhs.sym;
 	}
 
 	bool