rucy 0.1.3 → 0.1.4

data/ext/rucy/class.h

@@ -0,0 +1,96 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __CLASS_H__
+#define __CLASS_H__
+
+
+#include <xot/ref.h>
+#include <rucy/extension.h>
+#include "tester.h"
+
+
+class Base : public Xot::RefCountable<>
+{
+
+	public:
+
+		Base ()
+		{
+			log("Base()");
+		}
+
+		virtual ~Base ()
+		{
+			log("~Base()");
+		}
+
+		virtual const char* name () const
+		{
+			return "Base::name";
+		}
+
+		virtual const char* name_overridable () const
+		{
+			return "Base::name_overridable";
+		}
+
+		virtual const char* name_overridable_faster () const
+		{
+			return "Base::name_overridable_faster";
+		}
+
+};// Base
+
+
+class Sub : public Base
+{
+
+	public:
+
+		Sub ()
+		{
+			log("Sub()");
+		}
+
+		virtual ~Sub ()
+		{
+			log("~Sub()");
+		}
+
+		virtual const char* name () const
+		{
+			return "Sub::name";
+		}
+
+		virtual const char* name_overridable () const
+		{
+			return "Sub::name_overridable";
+		}
+
+		virtual const char* name_overridable_faster () const
+		{
+			return "Sub::name_overridable_faster";
+		}
+
+};// Sub
+
+
+class RubyObj : public Xot::RefCountable<>
+{
+
+	public:
+
+		RubyObj ()
+		{
+			log("RubyObj()");
+		}
+
+		~RubyObj ()
+		{
+			log("~RubyObj()");
+		}
+
+};// Obj
+
+
+#endif//EOH

data/ext/rucy/exception.cpp

@@ -0,0 +1,107 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+/*
+	raise ruby's exception.
+*/
+static
+RUBY_DEF0(raise_ruby_exception)
+{
+	throw RubyException(rb_eStandardError, "raise_ruby_exception");
+}
+RUBY_END
+
+/*
+	raise in eval.
+*/
+static
+RUBY_DEF0(raise_in_eval)
+{
+	eval("raise 'raise_in_eval'");
+}
+RUBY_END
+
+/*
+	throw nothing.
+*/
+static
+RUBY_DEF0(throw_nothing)
+{
+	throw;
+}
+RUBY_END
+
+/*
+	throw std::exception.
+*/
+static
+RUBY_DEF0(throw_std_exception)
+{
+	throw std::exception();
+}
+RUBY_END
+
+/*
+	throw std::runtime_error.
+*/
+static
+RUBY_DEF0(throw_std_runtime_error)
+{
+	throw std::runtime_error("std::runtime_error");
+}
+RUBY_END
+
+struct MyException : public std::runtime_error
+{
+	MyException() : runtime_error("") {}
+};
+
+/*
+	throw custom exception class.
+*/
+static
+RUBY_DEF0(throw_custom_exception)
+{
+	throw MyException();
+}
+RUBY_END
+
+/*
+	throw std::string.
+*/
+static
+RUBY_DEF0(throw_std_string)
+{
+	throw std::string("std::string");
+}
+RUBY_END
+
+/*
+	throw char*.
+*/
+static
+RUBY_DEF0(throw_cstring)
+{
+	throw "cstring";
+}
+RUBY_END
+
+
+void
+Init_exception ()
+{
+	Module mRucy   =       define_module("Rucy");
+	Module mTester = mRucy.define_module("Tester");
+
+	mTester.define_method("raise_ruby_exception", raise_ruby_exception);
+	mTester.define_method("raise_in_eval", raise_in_eval);
+	mTester.define_method("throw_nothing", throw_nothing);
+	mTester.define_method("throw_std_exception", throw_std_exception);
+	mTester.define_method("throw_std_runtime_error", throw_std_runtime_error);
+	mTester.define_method("throw_custom_exception", throw_custom_exception);
+	mTester.define_method("throw_std_string", throw_std_string);
+	mTester.define_method("throw_cstring", throw_cstring);
+}

data/ext/rucy/extconf.rb

@@ -1,11 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-%w[. ../xot].map {|s| "../../#{s}/lib"}.each do |path|
-  $: << File.expand_path(File.join File.dirname(__FILE__), *path.split('/'))
-end
-
-require 'rubygems'
+require 'bundler/setup'
 require 'mkmf'
 require 'xot/rake/helpers'
 require 'xot/module'
@@ -14,7 +10,8 @@ require 'rucy/module'
 include Xot::Rake
 
 
-DEBUG = env :DEBUG, false
+debug = env :DEBUG, false
+
 
 DEFS    = []
 INCDIRS = %w[
@@ -36,7 +33,8 @@ LIBS = %w[
 ]
 
 
-DEFS << '_DEBUG' if DEBUG
+DEFS << '_DEBUG' if debug
+DEFS << 'NDEBUG' unless debug
 DEFS << 'WINDOWS' << 'WIN32' if win32?
 DEFS << 'COCOA' if cocoa?
 DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
@@ -44,9 +42,12 @@ DEFS << $~[0].upcase if RUBY_PLATFORM =~ /mswin|ming|cygwin|darwin/i
 $CPPFLAGS   << DEFS.map    {|s| " -D#{s}"}.join
 $CPPFLAGS   << INCDIRS.map {|s| " -I#{s}"}.join
 $LDFLAGS    << LIBDIRS.map {|s| " -L#{s}"}.join
+$CFLAGS     << ' --stdlib=libc++' if clang?
 $LOCAL_LIBS << ' -lrucy'
 
-Config::CONFIG.each {|key, val| val.gsub!(/gcc/, 'g++')}
+RbConfig::CONFIG.each do |key, val|
+  {'gcc' => 'g++', 'clang' => 'clang++'}.each {|from, to| val.gsub! from, to}
+end
 
 
 dir_config 'boost'

data/ext/rucy/function.cpp

@@ -0,0 +1,68 @@
+#include <rucy.h>
+
+
+using namespace Rucy;
+
+
+/*
+	do nothing.
+*/
+static
+RUBY_DEFN(do_nothing)
+{
+}
+RUBY_END
+
+/*
+	return nil.
+*/
+static
+RUBY_DEF0(return_nil)
+{
+	return Qnil;
+}
+RUBY_END
+
+/*
+	return int.
+*/
+static
+RUBY_DEF0(return_int)
+{
+	return value(1);
+}
+RUBY_END
+
+/*
+	return flaot.
+*/
+static
+RUBY_DEF0(return_float)
+{
+	return value(1.0f);
+}
+RUBY_END
+
+/*
+	return string.
+*/
+static
+RUBY_DEF0(return_string)
+{
+	return value("");
+}
+RUBY_END
+
+
+void
+Init_function ()
+{
+	Module mRucy   =       define_module("Rucy");
+	Module mTester = mRucy.define_module("Tester");
+
+	mTester.define_method("do_nothing", do_nothing);
+	mTester.define_method("return_nil", return_nil);
+	mTester.define_method("return_int", return_int);
+	mTester.define_method("return_float", return_float);
+	mTester.define_method("return_string", return_string);
+}

data/ext/rucy/struct.cpp

@@ -0,0 +1,83 @@
+#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
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Struct>(klass);
+}
+RUBY_END
+
+/*
+	get num.
+*/
+static
+RUBY_DEF0(get_num)
+{
+	Struct* obj = to<Struct*>(self);
+	if (obj) return value(obj->num);
+}
+RUBY_END
+
+/*
+	set num.
+*/
+static
+RUBY_DEF1(set_num, num)
+{
+	Struct* obj = to<Struct*>(self);
+	if (obj) obj->num = to<int>(num);
+}
+RUBY_END
+
+
+void
+Init_struct ()
+{
+	Module mRucy   =       define_module("Rucy");
+	Module mTester = mRucy.define_module("Tester");
+
+	cStruct = mTester.define_class("Struct");
+	cStruct.define_alloc_func(alloc);
+	cStruct.define_method("num", get_num);
+	cStruct.define_method("num=", set_num);
+}

data/ext/rucy/tester.cpp

@@ -1,212 +1,65 @@
-#include <rucy.h>
-
-
-using namespace Rucy;
+#include "tester.h"
 
 
-struct Tester
-{
+#include <vector>
+#include <rucy.h>
 
-	int value;
 
-};// Tester
+using namespace Rucy;
 
 
-static Class cTester;
+static std::vector<String> logs;
 
 
-Class
-tester_class ()
+void
+log (const char* str)
 {
-	return cTester;
+	logs.push_back(str);
 }
 
 
-namespace Rucy
-{
-
-
-	static Value
-	value (const Tester& obj)
-	{
-		return new_type<Tester>(tester_class(), new Tester(obj));
-	}
-
-	template <> inline Tester*
-	value_to<Tester*> (Value obj, bool)
-	{
-		return get_type<Tester>(obj, tester_class());
-	}
-
-
-}// Rucy
-
-
 /*
-	alloc function.
+	return last log.
 */
-static
-RUBY_DEF_ALLOC(alloc, klass)
+RUBY_DEFN(last_log)
 {
-	return new_type<Tester>(klass);
-}
-RUBY_END
+	if (argc > 1)
+		arg_count_error("#last_log", argc, 0, 1);
 
-/*
-	get value.
-*/
-static
-RUBY_DEF0(get_value)
-{
-	Tester* t = to<Tester*>(self);
-	if (t) return value(t->value);
-}
-RUBY_END
+	size_t index = (argc >= 1) ? to<size_t>(argv[0]) : logs.size() - 1;
+	if (index >= logs.size())
+		index_error();
 
-/*
-	set value.
-*/
-static
-RUBY_DEF1(set_value, value)
-{
-	Tester* t = to<Tester*>(self);
-	if (t) t->value = to<int>(value);
+	return value(logs[index].c_str());
 }
 RUBY_END
 
 /*
-	do nothing.
+	return all logs.
 */
-static
-RUBY_DEFN(do_nothing)
+RUBY_DEF0(all_logs)
 {
+	std::vector<Value> a;
+	for (size_t i = 0; i < logs.size(); ++i) a.push_back(logs[i].c_str());
+	return value(a.size(), &a[0]);
 }
 RUBY_END
 
 /*
-	return nil.
+	clcear all logs.
 */
-static
-RUBY_DEF0(return_nil)
+RUBY_DEF0(clear_logs)
 {
-	return Qnil;
+	logs.clear();
 }
 RUBY_END
 
-/*
-	return int.
-*/
-static
-RUBY_DEF0(return_int)
-{
-	return value(1);
-}
-RUBY_END
 
-/*
-	return flaot.
-*/
-static
-RUBY_DEF0(return_float)
-{
-	return value(1.0f);
-}
-RUBY_END
-
-/*
-	return string.
-*/
-static
-RUBY_DEF0(return_string)
-{
-	return value("");
-}
-RUBY_END
-
-/*
-	raise ruby's exception.
-*/
-static
-RUBY_DEF0(raise_ruby_exception)
-{
-	throw RubyException(rb_eStandardError, "raise_ruby_exception");
-}
-RUBY_END
-
-/*
-	raise in eval.
-*/
-static
-RUBY_DEF0(raise_in_eval)
-{
-	eval("raise 'raise_in_eval'");
-}
-RUBY_END
-
-/*
-	throw nothing.
-*/
-static
-RUBY_DEF0(throw_nothing)
-{
-	throw;
-}
-RUBY_END
-
-/*
-	throw std::exception.
-*/
-static
-RUBY_DEF0(throw_std_exception)
-{
-	throw std::exception();
-}
-RUBY_END
-
-/*
-	throw std::runtime_error.
-*/
-static
-RUBY_DEF0(throw_std_runtime_error)
-{
-	throw std::runtime_error("std::runtime_error");
-}
-RUBY_END
-
-struct MyException : public std::runtime_error
-{
-	MyException() : runtime_error("") {}
-};
-
-/*
-	throw custom exception class.
-*/
-static
-RUBY_DEF0(throw_custom_exception)
-{
-	throw MyException();
-}
-RUBY_END
-
-/*
-	throw std::string.
-*/
-static
-RUBY_DEF0(throw_std_string)
-{
-	throw std::string("std::string");
-}
-RUBY_END
-
-/*
-	throw char*.
-*/
-static
-RUBY_DEF0(throw_cstring)
-{
-	throw "cstring";
-}
-RUBY_END
+void Init_value ();
+void Init_exception ();
+void Init_function ();
+void Init_struct ();
+void Init_class ();
 
 
 extern "C" void
@@ -214,25 +67,16 @@ Init_tester ()
 {
 	if (!init()) return;
 
-	Module m = define_module("Rucy");
-
-	Class c = m.define_class("Tester");
-	cTester = c;
-
-	c.define_alloc_func(alloc);
-	c.define_method("value", get_value);
-	c.define_method("value=", set_value);
-	c.define_method("do_nothing", do_nothing);
-	c.define_method("return_nil", return_nil);
-	c.define_method("return_int", return_int);
-	c.define_method("return_float", return_float);
-	c.define_method("return_string", return_string);
-	c.define_method("raise_ruby_exception", raise_ruby_exception);
-	c.define_method("raise_in_eval", raise_in_eval);
-	c.define_method("throw_nothing", throw_nothing);
-	c.define_method("throw_std_exception", throw_std_exception);
-	c.define_method("throw_std_runtime_error", throw_std_runtime_error);
-	c.define_method("throw_custom_exception", throw_custom_exception);
-	c.define_method("throw_std_string", throw_std_string);
-	c.define_method("throw_cstring", throw_cstring);
+	Module mRucy   =       define_module("Rucy");
+	Module mTester = mRucy.define_module("Tester");
+
+	mTester.define_function("last_log", last_log);
+	mTester.define_function("all_logs", all_logs);
+	mTester.define_function("clear_logs", clear_logs);
+
+	Init_value();
+	Init_exception();
+	Init_function();
+	Init_struct ();
+	Init_class ();
 }

data/ext/rucy/tester.h

@@ -0,0 +1,10 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __TESTER_H__
+#define __TESTER_H__
+
+
+void log (const char* str);
+
+
+#endif//EOH