rucy 0.1.0

data/src/exception.cpp

@@ -0,0 +1,124 @@
+// -*- c++ -*-
+#include "rucy/exception.h"
+
+
+#include <ruby.h>
+#include <rucy/rucy.h>
+#include <rucy/string.h>
+
+
+#define VA_STRING(format, result) \
+	String result; \
+	do \
+	{ \
+		if (format) \
+		{ \
+			va_list args; \
+			va_start(args, format); \
+			result = stringf(format, args); \
+			va_end(args); \
+		} \
+	} \
+	while (false)
+
+
+namespace Rucy
+{
+
+
+	Class
+	native_error_class ()
+	{
+		static Class c =
+			rucy_module().define_class("NativeError", rb_eRuntimeError);
+		return c;
+	}
+
+
+	void
+	error (const char* format, ...)
+	{
+		VA_STRING(format, message);
+		throw message;
+	}
+
+	void
+	raise (Value type, const char* format, ...)
+	{
+		VA_STRING(format, message);
+		throw RubyException(type, message.c_str());
+	}
+
+
+	void
+	type_error (const char* format, ...)
+	{
+		VA_STRING(format, message);
+		raise(rb_eTypeError, message.c_str());
+	}
+
+	void
+	argument_error (const char* format, ...)
+	{
+		VA_STRING(format, message);
+		raise(rb_eArgError, message.c_str());
+	}
+
+	void
+	argument_error (
+		const char* method, int nargs, int nargs_expected,
+		int n1, int n2, int n3, int n4, int n5)
+	{
+		String message = stringf(
+			"wrong number of arguments for %s: %d for %d",
+			method, nargs, nargs_expected);
+
+		int n[5] = {n1, n2, n3, n4, n5};
+		for (int i = 0; i < 5 && n[i] >= 0; ++i)
+			message += stringf(" or %d", n[i]);
+
+		message += ".";
+		argument_error(message.c_str());
+	}
+
+	void
+	not_implemented_error (const char* format, ...)
+	{
+		VA_STRING(format, message);
+		raise(rb_eNotImpError, message.c_str());
+	}
+
+
+	RubyException::RubyException (Value exception)
+	:	Super(""), val(exception)
+	{
+	}
+
+	RubyException::RubyException (Value type, const char* format, ...)
+	:	Super(""), val(Qnil)
+	{
+		VA_STRING(format, message);
+		val = rb_exc_new2(type, message.c_str());
+	}
+
+	const char*
+	RubyException::what () const throw()
+	{
+		SYM(message);
+		return value().call(message).c_str();
+	}
+
+	Value
+	RubyException::value () const
+	{
+		return val;
+	}
+
+
+	RubyJumptag::RubyJumptag (int tag)
+	:	tag(tag)
+	{
+	}
+
+
+}// Rucy

data/src/function.cpp

@@ -0,0 +1,157 @@
+// -*- c++ -*-
+#include "rucy/function.h"
+
+
+#include <rucy/exception.h>
+
+
+#ifndef TAG_RAISE
+	#define TAG_RAISE 0x6
+#endif
+
+
+namespace Rucy
+{
+
+	void
+	define_function (const char* name, RubyFunctionN fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), -1);
+	}
+	void
+	define_function (const char* name, RubyFunction0 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 0);
+	}
+	void
+	define_function (const char* name, RubyFunction1 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 1);
+	}
+	void
+	define_function (const char* name, RubyFunction2 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 2);
+	}
+	void
+	define_function (const char* name, RubyFunction3 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 3);
+	}
+	void
+	define_function (const char* name, RubyFunction4 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 4);
+	}
+	void
+	define_function (const char* name, RubyFunction5 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 5);
+	}
+	void
+	define_function (const char* name, RubyFunction6 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 6);
+	}
+	void
+	define_function (const char* name, RubyFunction7 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 7);
+	}
+	void
+	define_function (const char* name, RubyFunction8 fun)
+	{
+		rb_define_global_function(name, RUBY_METHOD_FUNC(fun), 8);
+	}
+
+	Value
+	call (Symbol name, int argc, const Value* argv)
+	{
+		return protect(rb_funcall2, Qnil, name.id(), argc, (const VALUE*) argv);
+	}
+	Value
+	call (Symbol name)
+	{
+		const VALUE args[] = {};
+		return protect(rb_funcall2, Qnil, name.id(), 0, args);
+	}
+	Value
+	call (Symbol name, Value v1)
+	{
+		const VALUE args[] = {v1};
+		return protect(rb_funcall2, Qnil, name.id(), 1, args);
+	}
+	Value
+	call (Symbol name, Value v1, Value v2)
+	{
+		const VALUE args[] = {v1, v2};
+		return protect(rb_funcall2, Qnil, name.id(), 2, args);
+	}
+	Value
+	call (Symbol name, Value v1, Value v2, Value v3)
+	{
+		const VALUE args[] = {v1, v2, v3};
+		return protect(rb_funcall2, Qnil, name.id(), 3, args);
+	}
+	Value
+	call (Symbol name, Value v1, Value v2, Value v3, Value v4)
+	{
+		const VALUE args[] = {v1, v2, v3, v4};
+		return protect(rb_funcall2, Qnil, name.id(), 4, args);
+	}
+	Value
+	call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5)
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5};
+		return protect(rb_funcall2, Qnil, name.id(), 5, args);
+	}
+	Value
+	call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6)
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6};
+		return protect(rb_funcall2, Qnil, name.id(), 6, args);
+	}
+	Value
+	call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7)
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6, v7};
+		return protect(rb_funcall2, Qnil, name.id(), 7, args);
+	}
+	Value
+	call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7, Value v8)
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6, v7, v8};
+		return protect(rb_funcall2, Qnil, name.id(), 8, args);
+	}
+
+	Value
+	eval (const char* str)
+	{
+		SYM(eval);
+		return call(eval, str);
+	}
+
+
+	Value
+	call_protect (VALUE (*fun)(VALUE), VALUE arg)
+	{
+		int state = 0;
+		VALUE ret = rb_protect(fun, arg, &state);
+
+		if (state != 0)
+		{
+			VALUE exception = rb_errinfo();
+			if (state == TAG_RAISE && RTEST(exception))
+			{
+				rb_set_errinfo(Qnil);
+				throw RubyException(exception);
+			}
+
+			throw RubyJumptag(state);
+		}
+
+		return ret;
+	}
+
+
+}// Rucy

data/src/function.cpp.erb

@@ -0,0 +1,74 @@
+// -*- c++ -*-
+% require 'support'
+#include "rucy/function.h"
+
+
+#include <rucy/exception.h>
+
+
+#ifndef TAG_RAISE
+	#define TAG_RAISE 0x6
+#endif
+
+
+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);
+	}
+%	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);
+	}
+%	end
+
+	Value
+	eval (const char* str)
+	{
+		SYM(eval);
+		return call(eval, str);
+	}
+
+
+	Value
+	call_protect (VALUE (*fun)(VALUE), VALUE arg)
+	{
+		int state = 0;
+		VALUE ret = rb_protect(fun, arg, &state);
+
+		if (state != 0)
+		{
+			VALUE exception = rb_errinfo();
+			if (state == TAG_RAISE && RTEST(exception))
+			{
+				rb_set_errinfo(Qnil);
+				throw RubyException(exception);
+			}
+
+			throw RubyJumptag(state);
+		}
+
+		return ret;
+	}
+
+
+}// Rucy

data/src/gc.cpp

@@ -0,0 +1,63 @@
+// -*- c++ -*-
+#include "rucy/gc.h"
+
+
+namespace Rucy
+{
+
+
+	static void
+	register_value (VALUE* v)
+	{
+		if (!v) return;
+		rb_gc_register_address(v);
+	}
+
+	static void
+	unregister_value (VALUE* v)
+	{
+		if (!v) return;
+		rb_gc_unregister_address(v);
+	}
+
+	GCGuard::GCGuard (VALUE* v)
+	:	pval(v)
+	{
+		register_value(pval);
+	}
+
+	GCGuard::GCGuard (Value* v)
+	:	pval(v ? &v->v : NULL)
+	{
+		register_value(pval);
+	}
+
+	GCGuard::~GCGuard ()
+	{
+		unregister_value(pval);
+	}
+
+
+	GlobalValue::GlobalValue (Value v)
+	:	val(v), guard(&val)
+	{
+	}
+
+	Value
+	GlobalValue::value () const
+	{
+		return val;
+	}
+
+	GlobalValue::operator VALUE () const
+	{
+		return value();
+	}
+
+	GlobalValue::operator Value () const
+	{
+		return value();
+	}
+
+
+}// Rucy