rucy 0.1.0

data/src/module.cpp

@@ -0,0 +1,321 @@
+// -*- c++ -*-
+#include "rucy/module.h"
+
+
+#include <rucy/class.h>
+
+
+namespace Rucy
+{
+
+
+	Module::Module (VALUE v)
+	:	Super(v)
+	{
+	}
+
+	Module
+	Module::define_module (const char* name)
+	{
+		return rb_define_module_under(value(), name);
+	}
+
+	Class
+	Module::define_class (const char* name, Value super)
+	{
+		return rb_define_class_under(value(), name, super);
+	}
+
+	Module
+	Module::define_const (const char* name, Value val)
+	{
+		rb_define_const(value(), name, val);
+		return *this;
+	}
+
+	Module
+	Module::define_attr (const char* name, bool read, bool write)
+	{
+		rb_define_attr(value(), name, read, write);
+		return *this;
+	}
+
+	Module
+	Module::define_alias (const char* new_, const char* old)
+	{
+		rb_define_alias(value(), new_, old);
+		return *this;
+	}
+
+	Module
+	Module::undef_method (const char* name)
+	{
+		rb_undef_method(value(), name);
+		return *this;
+	}
+
+	Module
+	Module::include_module (Value module)
+	{
+		rb_include_module(value(), module);
+		return *this;
+	}
+
+	Module
+	Module::define_function (const char* name, RubyFunctionN fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), -1);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction0 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 0);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction1 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 1);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction2 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 2);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction3 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 3);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction4 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 4);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction5 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 5);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction6 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 6);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction7 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 7);
+		return *this;
+	}
+	Module
+	Module::define_function (const char* name, RubyFunction8 fun)
+	{
+		rb_define_module_function(value(), name, RUBY_METHOD_FUNC(fun), 8);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunctionN fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), -1);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction0 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 0);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction1 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 1);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction2 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 2);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction3 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 3);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction4 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 4);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction5 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 5);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction6 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 6);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction7 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 7);
+		return *this;
+	}
+	Module
+	Module::define_method (const char* name, RubyFunction8 fun)
+	{
+		rb_define_method(value(), name, RUBY_METHOD_FUNC(fun), 8);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunctionN fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), -1);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction0 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 0);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction1 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 1);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction2 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 2);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction3 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 3);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction4 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 4);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction5 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 5);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction6 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 6);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction7 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 7);
+		return *this;
+	}
+	Module
+	Module::define_private_method (const char* name, RubyFunction8 fun)
+	{
+		rb_define_private_method(value(), name, RUBY_METHOD_FUNC(fun), 8);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunctionN fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), -1);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction0 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 0);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction1 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 1);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction2 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 2);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction3 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 3);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction4 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 4);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction5 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 5);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction6 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 6);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction7 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 7);
+		return *this;
+	}
+	Module
+	Module::define_singleton_method (const char* name, RubyFunction8 fun)
+	{
+		rb_define_singleton_method(value(), name, RUBY_METHOD_FUNC(fun), 8);
+		return *this;
+	}
+
+
+	Module
+	define_module (const char* name)
+	{
+		return rb_define_module(name);
+	}
+
+
+	Module
+	rucy_module ()
+	{
+		static Module m = define_module("Rucy");
+		return m;
+	}
+
+
+}// Rucy

data/src/module.cpp.erb

@@ -0,0 +1,103 @@
+// -*- c++ -*-
+% require 'support'
+#include "rucy/module.h"
+
+
+#include <rucy/class.h>
+
+
+namespace Rucy
+{
+
+
+	Module::Module (VALUE v)
+	:	Super(v)
+	{
+	}
+
+	Module
+	Module::define_module (const char* name)
+	{
+		return rb_define_module_under(value(), name);
+	}
+
+	Class
+	Module::define_class (const char* name, Value super)
+	{
+		return rb_define_class_under(value(), name, super);
+	}
+
+	Module
+	Module::define_const (const char* name, Value val)
+	{
+		rb_define_const(value(), name, val);
+		return *this;
+	}
+
+	Module
+	Module::define_attr (const char* name, bool read, bool write)
+	{
+		rb_define_attr(value(), name, read, write);
+		return *this;
+	}
+
+	Module
+	Module::define_alias (const char* new_, const char* old)
+	{
+		rb_define_alias(value(), new_, old);
+		return *this;
+	}
+
+	Module
+	Module::undef_method (const char* name)
+	{
+		rb_undef_method(value(), name);
+		return *this;
+	}
+
+	Module
+	Module::include_module (Value module)
+	{
+		rb_include_module(value(), module);
+		return *this;
+	}
+
+%	[
+%		['define_function',         'rb_define_module_function'],
+%		['define_method',           'rb_define_method'],
+%		['define_private_method',   'rb_define_private_method'],
+%		['define_singleton_method', 'rb_define_singleton_method']
+%	].each do |(op, rb_op)|
+	Module
+	Module::<%= op %> (const char* name, RubyFunctionN fun)
+	{
+		<%= rb_op %>(value(), name, RUBY_METHOD_FUNC(fun), -1);
+		return *this;
+	}
+%		NTIMES.each do |n|
+	Module
+	Module::<%= op %> (const char* name, RubyFunction<%= n %> fun)
+	{
+		<%= rb_op %>(value(), name, RUBY_METHOD_FUNC(fun), <%= n %>);
+		return *this;
+	}
+%		end
+%	end
+
+
+	Module
+	define_module (const char* name)
+	{
+		return rb_define_module(name);
+	}
+
+
+	Module
+	rucy_module ()
+	{
+		static Module m = define_module("Rucy");
+		return m;
+	}
+
+
+}// Rucy

data/src/rucy.cpp

@@ -0,0 +1,56 @@
+// -*- c++ -*-
+#include "rucy/rucy.h"
+
+
+#include <rucy/module.h>
+#include <rucy/exception.h>
+
+
+namespace Rucy
+{
+
+
+	bool
+	init ()
+	{
+		static bool done = false;
+		if (done) return true;
+		done = true;
+
+		rucy_module();
+		native_error_class();
+		return true;
+	}
+
+
+	Value
+	require (const char* name)
+	{
+		return rb_require(name);
+	}
+
+	void
+	define_const (const char* name, Value val)
+	{
+		rb_define_global_const(name, val);
+	}
+
+
+	bool
+	check_class (Value obj, Value class_)
+	{
+		return class_ && obj.is_kind_of(class_);
+
+#if 0
+		SYMBOL(klass, "class");
+		SYM(name);
+		String message = stringf(
+			"object is instance of %s, bug %s is expected.",
+			obj(klass)(name).c_str(), class_(name).c_str());
+
+		throw RubyException(rb_eTypeError, message);
+#endif
+	}
+
+
+}// Rucy

data/src/string.cpp

@@ -0,0 +1,78 @@
+// -*- c++ -*-
+#include "rucy/string.h"
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <boost/scoped_array.hpp>
+
+
+namespace Rucy
+{
+
+
+	String
+	stringf (const char* format, ...)
+	{
+		va_list args;
+		va_start(args, format);
+		String ret = stringf(format, args);
+		va_end(args);
+		return ret;
+	}
+
+	String
+	stringf (const char* format, va_list args)
+	{
+		enum {BUFSIZE = 256};
+		char stack[BUFSIZE];
+		if (vsnprintf(&stack[0], BUFSIZE, format, args) <= BUFSIZE)
+			return &stack[0];
+
+		int bufsize = BUFSIZE;// vscprintf(format, args);
+		boost::scoped_array<char> heap;
+		while (true)
+		{
+			bufsize *= 2;
+			heap.reset(new char[bufsize]);
+			if (vsnprintf(&heap[0], bufsize, format, args) <= bufsize)
+				return &heap[0];
+		}
+
+		return NULL;
+	}
+
+	template <> String
+	to_s<int> (const int& val)
+	{
+		return stringf("%d", val);
+	}
+
+	template <> String
+	to_s<float> (const float& val)
+	{
+		return stringf("%f", val);
+	}
+
+	template <> String
+	to_s<double> (const double& val)
+	{
+		return stringf("%f", val);
+	}
+
+	typedef const char* const_char_p;
+
+	template <> String
+	to_s<const_char_p> (const const_char_p& val)
+	{
+		return val;
+	}
+
+	template <> String
+	to_s<String> (const String& val)
+	{
+		return val;
+	}
+
+
+}// Rucy

data/src/symbol.cpp

@@ -0,0 +1,51 @@
+// -*- c++ -*-
+#include "rucy/symbol.h"
+
+
+#include <rucy/rucy.h>
+
+
+namespace Rucy
+{
+
+
+	Symbol::Symbol ()
+	:	id_(0)
+	{
+	}
+
+	Symbol::Symbol (ID id)
+	:	id_(id)
+	{
+	}
+
+	Symbol::Symbol (const char* str)
+	:	id_(rb_intern(str))
+	{
+	}
+
+	ID
+	Symbol::id () const
+	{
+		return id_;
+	}
+
+	const char*
+	Symbol::c_str () const
+	{
+		return rb_id2name(id_);
+	}
+
+	Symbol::operator bool () const
+	{
+		return id_ != 0;
+	}
+
+	bool
+	Symbol::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Rucy