rucy 0.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+gem "rake"
+gem "gemcutter"

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    gemcutter (0.7.0)
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gemcutter
+  rake

data/README

@@ -0,0 +1,4 @@
+
+= Rucy - A Ruby C++ Extension Helper Library
+
+== by @tokujiros

data/Rakefile

@@ -0,0 +1,58 @@
+# -*- mode: ruby; coding: utf-8 -*-
+$: << File.expand_path(File.dirname __FILE__)
+require 'rbconfig'
+require 'support'
+
+
+NAME = 'rucy'
+
+SRCDIR  = 'src'
+INCDIR  = 'include'
+LIBDIR  = 'lib'
+EXTDIR  = 'ext'
+TASKDIR = 'task'
+
+EXTEXT = RbConfig::CONFIG['DLEXT'] || 'so'
+
+incroot = RbConfig::CONFIG['rubyhdrdir']
+INCDIRS = [
+  'include',
+  incroot,
+  "#{incroot}/#{RUBY_PLATFORM}",
+  '/opt/local/include',
+  '/opt/include'
+]
+
+RBS = glob '**/*.rb'
+
+RUBY    = ENV['RUBY'] || 'ruby'
+GEM     = ENV['GEM']  || 'gem'
+MAKE    = ENV['MAKE'] || 'make'
+CC      = RbConfig::CONFIG['CC'] || ENV['CC'] || 'g++'
+CFLAGS  = '-Wall -O'
+AR      = ENV['AR'] || 'ar'
+ARFLAGS = 'crs'
+
+
+task :default => :ext
+
+task :lib => 'lib:build'
+
+task :ext => 'ext:build'
+
+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
+
+
+Dir["#{TASKDIR}/**/*.rake"].each {|path| load path}

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/ext/rucy/extconf.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+%w[../../lib].each do |path|
+  $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
+end
+require 'rubygems'
+require 'mkmf'
+require 'rucy'
+
+
+DEBUG = ENV["DEBUG"] || false
+
+DEFS    = []
+INCDIRS = %w[/opt/local/include /opt/include]
+LIBDIRS = []
+
+HEADERS = %w[
+	boost/noncopyable.hpp
+	ruby.h
+	rucy.h
+]
+LIBS = %w[stdc++ rucy]
+
+
+DEFS << "_DEBUG" if DEBUG
+
+case RUBY_PLATFORM
+when /cygwin/
+  DEFS << "WIN32" << "WINDOWS" << "CYGWIN"
+when /mswin/
+  DEFS << "WIN32" << "WINDOWS"
+when /darwin/
+  DEFS << "COCOA"
+end
+
+$CPPFLAGS << DEFS.map    {|s| " -D#{s}"}.join
+$CPPFLAGS << INCDIRS.map {|s| " -I#{s}"}.join
+$LDFLAGS  << LIBDIRS.map {|s| " -L#{s}"}.join
+$LOCAL_LIBS << " -lrucy"
+
+dir_config "boost"
+dir_config "rucy", Rucy.root_dir
+
+
+Config::CONFIG.each {|key, val| val.gsub!(/gcc/, "g++")}
+
+exit 1 unless HEADERS.all? {|s| have_header(s)}
+exit 1 unless LIBS.all?    {|s| have_library(s)}
+
+
+create_makefile "rucy/tester"

data/ext/rucy/tester.cpp

@@ -0,0 +1,102 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+static
+RUBY_DEF0(do_nothing)
+{
+}
+RUBY_END
+
+static
+RUBY_DEF0(return_nil)
+{
+	return Qnil;
+}
+RUBY_END
+
+static
+RUBY_DEF0(return_int)
+{
+	return Value(1);
+}
+RUBY_END
+
+static
+RUBY_DEF0(return_float)
+{
+	return Value(1.0f);
+}
+RUBY_END
+
+static
+RUBY_DEF0(return_string)
+{
+	return Value("");
+}
+RUBY_END
+
+static
+RUBY_DEF0(raise_ruby_exception)
+{
+	throw RubyException(rb_eStandardError, "raise_ruby_exception");
+}
+RUBY_END
+
+static
+RUBY_DEF0(raise_in_eval)
+{
+	eval("raise 'raise_in_eval'");
+}
+RUBY_END
+
+static
+RUBY_DEF0(throw_std_exception)
+{
+	throw std::exception();
+}
+RUBY_END
+
+static
+RUBY_DEF0(throw_std_runtime_error)
+{
+	throw std::runtime_error("std::runtime_error");
+}
+RUBY_END
+
+static
+RUBY_DEF0(throw_std_string)
+{
+	throw std::string("std::string");
+}
+RUBY_END
+
+static
+RUBY_DEF0(throw_cstring)
+{
+	throw "cstring";
+}
+RUBY_END
+
+
+extern "C" void
+Init_tester ()
+{
+	if (!init()) return;
+
+	define_module("Rucy")
+		.define_class("Tester")
+			.define_method("do_nothing", do_nothing)
+			.define_method("return_nil", return_nil)
+			.define_method("return_int", return_int)
+			.define_method("return_float", return_float)
+			.define_method("return_string", return_string)
+			.define_method("raise_ruby_exception", raise_ruby_exception)
+			.define_method("raise_in_eval", raise_in_eval)
+			.define_method("throw_std_exception", throw_std_exception)
+			.define_method("throw_std_runtime_error", throw_std_runtime_error)
+			.define_method("throw_std_string", throw_std_string)
+			.define_method("throw_cstring", throw_cstring);
+}

data/include/rucy/class.h

@@ -0,0 +1,37 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RUCY_CLASS_H__
+#define __RUCY_CLASS_H__
+
+
+#include <rucy/module.h>
+
+
+namespace Rucy
+{
+
+
+	class Class : public Module
+	{
+
+		typedef Module Super;
+
+		public:
+
+			Class (VALUE v = Qnil);
+
+			Class define_alloc_func (RubyFunction0 fun);
+
+			Class define_alloc_func (const char* name, RubyFunction0 fun);
+			// for RUBY_METHOD macro
+
+	};// Class
+
+
+	Class define_class (const char* name, Value super = rb_cObject);
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/rucy/defs.h

@@ -0,0 +1,97 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RUCY_DEFS_H__
+#define __RUCY_DEFS_H__
+
+
+#include <ruby.h>
+
+
+namespace Rucy
+{
+
+
+	class Value;
+
+
+	typedef VALUE (*RubyFunctionN) (int argc, const Value* argv, Value self);
+	typedef VALUE (*RubyFunction0) (Value self);
+	typedef VALUE (*RubyFunction1) (Value self, Value v1);
+	typedef VALUE (*RubyFunction2) (Value self, Value v1, Value v2);
+	typedef VALUE (*RubyFunction3) (Value self, Value v1, Value v2, Value v3);
+	typedef VALUE (*RubyFunction4) (Value self, Value v1, Value v2, Value v3, Value v4);
+	typedef VALUE (*RubyFunction5) (Value self, Value v1, Value v2, Value v3, Value v4, Value v5);
+	typedef VALUE (*RubyFunction6) (Value self, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6);
+	typedef VALUE (*RubyFunction7) (Value self, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7);
+	typedef VALUE (*RubyFunction8) (Value self, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7, Value v8);
+
+
+}// Rucy
+
+
+#define RUBY_DEF_ALLOC(name, klass) \
+	VALUE name (Value klass) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEFN(name) \
+	VALUE name (int argc, const Value* argv, Value self) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF0(name) \
+	VALUE name (Value self) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF1(name, v1) \
+	VALUE name (Value self, Value v1) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF2(name, v1, v2) \
+	VALUE name (Value self, Value v1, Value v2) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF3(name, v1, v2, v3) \
+	VALUE name (Value self, Value v1, Value v2, Value v3) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF4(name, v1, v2, v3, v4) \
+	VALUE name (Value self, Value v1, Value v2, Value v3, Value v4) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF5(name, v1, v2, v3, v4, v5) \
+	VALUE name (Value self, Value v1, Value v2, Value v3, Value v4, Value v5) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF6(name, v1, v2, v3, v4, v5, v6) \
+	VALUE name (Value self, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF7(name, v1, v2, v3, v4, v5, v6, v7) \
+	VALUE name (Value self, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEF8(name, v1, v2, v3, v4, v5, v6, v7, v8) \
+	VALUE name (Value self, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7, Value v8) \
+	{ \
+		RUBY_TRY
+
+#define RUBY_END \
+		RUBY_CATCH \
+		return Qnil; \
+	}
+
+#ifdef RUCY_USE_DEF
+	#define DEFN RUBY_DEFN
+	#define DEF0 RUBY_DEF0
+	#define DEF1 RUBY_DEF1
+	#define DEF2 RUBY_DEF2
+	#define DEF3 RUBY_DEF3
+	#define DEF4 RUBY_DEF4
+	#define DEF5 RUBY_DEF5
+	#define DEF6 RUBY_DEF6
+	#define DEF7 RUBY_DEF7
+	#define DEF8 RUBY_DEF8
+	#define END RUBY_END
+#endif
+
+
+#endif//EOH

data/include/rucy/defs.h.erb

@@ -0,0 +1,56 @@
+// -*- c++ -*-
+% require 'support'
+#pragma once
+#ifndef __RUCY_DEFS_H__
+#define __RUCY_DEFS_H__
+
+
+#include <ruby.h>
+
+
+namespace Rucy
+{
+
+
+	class Value;
+
+
+	typedef VALUE (*RubyFunctionN) (int argc, const Value* argv, Value self);
+%	NTIMES.each do |n|
+	typedef VALUE (*RubyFunction<%= n %>) (Value self<%= params(n) {|i| ", Value v#{i}"} %>);
+%	end
+
+
+}// Rucy
+
+
+#define RUBY_DEF_ALLOC(name, klass) \
+	VALUE name (Value klass) \
+	{ \
+		RUBY_TRY
+#define RUBY_DEFN(name) \
+	VALUE name (int argc, const Value* argv, Value self) \
+	{ \
+		RUBY_TRY
+%	NTIMES.each do |n|
+#define RUBY_DEF<%= n %>(name<%= params(n) {|i| ", v#{i}"} %>) \
+	VALUE name (Value self<%= params(n) {|i| ", Value v#{i}"} %>) \
+	{ \
+		RUBY_TRY
+%	end
+
+#define RUBY_END \
+		RUBY_CATCH \
+		return Qnil; \
+	}
+
+#ifdef RUCY_USE_DEF
+	#define DEFN RUBY_DEFN
+%	NTIMES.each do |n|
+	#define DEF<%= n %> RUBY_DEF<%= n %>
+%	end
+	#define END RUBY_END
+#endif
+
+
+#endif//EOH

data/include/rucy/exception.h

@@ -0,0 +1,124 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __RUCY_EXCEPTION_H__
+#define __RUCY_EXCEPTION_H__
+
+
+#include <stdexcept>
+#include <rucy/value.h>
+#include <rucy/class.h>
+
+
+namespace Rucy
+{
+
+
+	Class native_error_class ();
+	// class Rucy::NativeError < RuntimeError
+
+
+	void error (const char* format, ...);
+
+	void raise (Value exception, const char* format = NULL, ...);
+
+
+	void type_error (const char* format = NULL, ...);
+
+	void argument_error (const char* format = NULL, ...);
+
+	void argument_error (
+		const char* method, int nargs, int nargs_expected,
+		int n1 = -1, int n2 = -1, int n3 = -1, int n4 = -1, int n5 = -1);
+
+	void not_implemented_error (const char* format = NULL, ...);
+
+
+	class RubyException : public std::runtime_error
+	{
+
+		typedef std::runtime_error Super;
+
+		public:
+
+			RubyException (Value exception);
+
+			RubyException (Value type, const char* format, ...);
+
+			const char* what () const throw();
+
+			Value value () const;
+
+		private:
+
+			/*Global*/Value val;
+
+	};// RubyException
+
+
+	struct RubyJumptag
+	{
+
+		public:
+
+			int tag;
+
+			RubyJumptag (int tag);
+
+	};// RubyJumptag
+
+
+}// Rucy
+
+
+#define RUBY_TRY \
+	VALUE RUCY__rubyexception__ = Qnil; \
+	int RUCY__rubyjumptag__ = 0; \
+	 \
+	goto RUCY__ruby_try_start__; \
+	 \
+	RUCY__ruby_jump_tag__: \
+	if (RUCY__rubyjumptag__) rb_jump_tag(RUCY__rubyjumptag__); \
+	RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), "Bad jump tag.")); \
+	 \
+	RUCY__ruby_raise_exception__: \
+	rb_exc_raise(RUCY__rubyexception__); \
+	 \
+	RUCY__ruby_try_start__: \
+	try \
+	{
+
+#define RUBY_CATCH \
+	} \
+	catch (const Rucy::RubyJumptag& e) \
+	{ \
+		RUCY__rubyjumptag__ = e.tag; \
+		goto RUCY__ruby_jump_tag__; \
+	} \
+	catch (const Rucy::RubyException& e) \
+	{ \
+		RUBY_THROW(e.value()); \
+	} \
+	catch (const std::exception& e) \
+	{ \
+		RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), e.what())); \
+	} \
+	catch (const std::string& s) \
+	{ \
+		RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), s.c_str())); \
+	} \
+	catch (const char* s) \
+	{ \
+		RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), s)); \
+	} \
+	catch (...) \
+	{ \
+		RUBY_THROW(rb_exc_new2( \
+			Rucy::native_error_class(), "Unknown C++ exception thrown.")); \
+	}
+
+#define RUBY_THROW(exception) \
+	RUCY__rubyexception__ = (exception); \
+	goto RUCY__ruby_raise_exception__
+
+
+#endif//EOH