rucy 0.1.0

data/src/value.cpp.erb

@@ -0,0 +1,409 @@
+// -*- c++ -*-
+% require 'support'
+#include "rucy/value.h"
+
+
+#include <rucy/rucy.h>
+#include <rucy/function.h>
+#include <rucy/exception.h>
+
+
+namespace Rucy
+{
+
+
+	Value::Value ()
+	:	v(Qnil)
+	{
+	}
+
+	Value::Value (bool b)
+	:	v(b ? Qtrue : Qfalse)
+	{
+	}
+
+	Value::Value (int n)
+	:	v(INT2FIX(n))
+	{
+	}
+
+	Value::Value (float f)
+	:	v(rb_float_new(f))
+	{
+	}
+
+	Value::Value (double d)
+	:	v(rb_float_new(d))
+	{
+	}
+
+	Value::Value (const char* s, bool tainted)
+	:	v(tainted ? rb_tainted_str_new2(s) : rb_str_new2(s))
+	{
+	}
+
+	Value::Value (const char* s, size_t len, bool tainted)
+	:	v(tainted ? rb_tainted_str_new(s, len) : rb_str_new(s, len))
+	{
+	}
+
+	Value::Value (size_t size, const Value* values)
+	:	v(size > 0 ? rb_ary_new2(size) : rb_ary_new())
+	{
+		if (!values) return;
+		for (size_t i = 0; i < size; ++i)
+			push(values[i]);
+	}
+
+	Value::Value (VALUE v)
+	:	v(v)
+	{
+	}
+
+	VALUE
+	Value::value () const
+	{
+		return v;
+	}
+
+	void
+	Value::mark () const
+	{
+		rb_gc_mark(v);
+	}
+
+	int
+	Value::type () const
+	{
+		return TYPE(v);
+	}
+
+	Value
+	Value::klass () const
+	{
+		return RBASIC(v)->klass;
+	}
+
+	bool
+	Value::is_kind_of (Value klass) const
+	{
+		SYM_Q(kind_of);
+		return call(kind_of, klass);
+	}
+
+	static int
+	get_object_size (Value obj, Symbol method)
+	{
+		if (obj.type() == T_STRING)
+			return RSTRING_LEN(obj.value());
+		else if (obj.type() == T_ARRAY)
+			return RARRAY_LEN(obj.value());
+		else
+			return obj.call(method);
+	}
+
+	int
+	Value::size () const
+	{
+		SYM(size);
+		return get_object_size(v, size);
+	}
+
+	int
+	Value::length () const
+	{
+		SYM(length);
+		return get_object_size(v, length);
+	}
+
+	Value
+	Value::to_i () const
+	{
+		if (FIXNUM_P(v) || TYPE(v) == T_BIGNUM) return *this;
+		SYM(to_i);
+		return call(to_i);
+	}
+
+	Value
+	Value::to_f () const
+	{
+		if (TYPE(v) == T_FLOAT) return *this;
+		SYM(to_f);
+		return call(to_f);
+	}
+
+	Value
+	Value::to_s () const
+	{
+		if (TYPE(v) == T_STRING) return *this;
+		SYM(to_s);
+		return call(to_s);
+	}
+
+	Value
+	Value::to_sym () const
+	{
+		if (TYPE(v) == T_SYMBOL) return *this;
+		SYM(to_sym);
+		return call(to_sym);
+	}
+
+	bool
+	Value::is_i () const
+	{
+		return is_kind_of(rb_cFixnum);
+	}
+
+	bool
+	Value::is_f () const
+	{
+		return is_kind_of(rb_cFloat);
+	}
+
+	bool
+	Value::is_s () const
+	{
+		return is_kind_of(rb_cString);
+	}
+
+	bool
+	Value::is_sym () const
+	{
+		return is_kind_of(rb_cSymbol);
+	}
+
+	bool
+	Value::is_a () const
+	{
+		return is_kind_of(rb_cArray);
+	}
+
+	int
+	Value::as_i (bool convert) const
+	{
+		return to<int>(*this, convert);
+	}
+
+	double
+	Value::as_f (bool convert) const
+	{
+		return to<double>(*this, convert);
+	}
+
+	const char*
+	Value::as_s (bool convert) const
+	{
+		return to<const char*>(*this, convert);
+	}
+
+	Symbol
+	Value::as_sym (bool convert) const
+	{
+		return to<Symbol>(*this, convert);
+	}
+
+%	["call", "operator ()"].each do |op|
+	Value
+	Value::<%= op %> (Symbol name, int argc, const Value* argv) const
+	{
+		return protect(rb_funcall2, value(), name.id(), argc, (const VALUE*) argv);
+	}
+%		NTIMES.each do |n|
+	Value
+	Value::<%= op %> (Symbol name<%= params(n) {|i| ", Value v#{i}"} %>) const
+	{
+		const VALUE args[] = {<%= params(n, ", ") {|i| "v#{i}"} %>};
+		return protect(rb_funcall2, value(), name.id(), <%= n %>, args);
+	}
+%		end
+%	end
+
+	Value
+	Value::inspect () const
+	{
+		SYM(inspect);
+		return call(inspect);
+	}
+
+	const char*
+	Value::c_str () const
+	{
+		return value_to<const char*>(*this);
+	}
+
+	Value&
+	Value::operator [] (int i)
+	{
+		if (type() != T_ARRAY) type_error();
+		return *(Value*) &RARRAY_PTR(v)[i];
+	}
+
+	const Value&
+	Value::operator [] (int i) const
+	{
+		return const_cast<Value*>(this)->operator[](i);
+	}
+
+	Value::operator VALUE () const
+	{
+		return value();
+	}
+
+	static bool
+	test_value (VALUE v)
+	{
+		return !NIL_P(v) && v != Qfalse;// RTEST(v);
+	}
+
+	Value::operator bool () const
+	{
+		return test_value(v);
+	}
+
+	bool
+	Value::operator ! () const
+	{
+		return !operator bool();
+	}
+
+	bool
+	Value::operator == (const Value& rhs) const
+	{
+		return v == rhs.v;// test_value(rb_obj_equal(v, rhs.v);
+	}
+
+	bool
+	Value::operator != (const Value& rhs) const
+	{
+		return !operator==(rhs);
+	}
+
+	Value
+	Value::push (Value obj)
+	{
+		return rb_ary_push(value(), obj.value());
+	}
+
+	Value
+	Value::pop ()
+	{
+		return rb_ary_pop(value());
+	}
+
+	Value
+	Value::shift ()
+	{
+		return rb_ary_shift(value());
+	}
+
+	Value
+	Value::unshift (Value obj)
+	{
+		return rb_ary_unshift(value(), obj.value());
+	}
+
+
+	Value
+	value (bool b)
+	{
+		return b;
+	}
+
+	Value
+	value (char n)
+	{
+		return (int) n;
+	}
+
+	Value
+	value (unsigned char n)
+	{
+		return (int) n;
+	}
+
+	Value
+	value (short n)
+	{
+		return (int) n;
+	}
+
+	Value
+	value (unsigned short n)
+	{
+		return (int) n;
+	}
+
+	Value
+	value (int n)
+	{
+		return n;
+	}
+
+	Value
+	value (unsigned int n)
+	{
+		return UINT2NUM(n);
+	}
+
+	Value
+	value (long n)
+	{
+		return LONG2NUM(n);
+	}
+
+	Value
+	value (unsigned long n)
+	{
+		return ULONG2NUM(n);
+	}
+
+	Value
+	value (long long n)
+	{
+		return LL2NUM(n);
+	}
+
+	Value
+	value (unsigned long long n)
+	{
+		return ULL2NUM(n);
+	}
+
+	Value
+	value (float f)
+	{
+		return f;
+	}
+
+	Value
+	value (double d)
+	{
+		return d;
+	}
+
+	Value
+	value (const char* s, bool tainted)
+	{
+		return Value(s, tainted);
+	}
+
+	Value
+	value (const char* s, size_t len, bool tainted)
+	{
+		return Value(s, len, tainted);
+	}
+
+	Value
+	value (size_t size, const Value* values)
+	{
+		return Value(size, values);
+	}
+
+	Value
+	value (Symbol sym)
+	{
+		return ID2SYM(sym.id());
+	}
+
+
+}// Rucy

data/support.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+require 'erb'
+require 'pp'
+
+
+NPARAM_MAX = 8
+NTIMES     = (0..NPARAM_MAX)
+
+
+def version ()
+  open("VERSION") {|f| f.readline.chomp}
+end
+
+def glob (*patterns)
+  paths = []
+  patterns.each do |pattern|
+    paths.concat Dir.glob(pattern)
+  end
+  paths
+end
+
+def erb (str)
+  ERB.new(str, nil, "%").result binding
+end
+
+def compile (path, out)
+  open(path) do |input|
+    open(out, "w") do |output|
+      output.write erb(input.read)
+    end
+  end
+#rescue
+end
+
+def params (n, sep = "", &block)
+  raise "block not given." unless block
+  return "" if n == 0
+  (1..n).map(&block).join(sep)
+end
+
+def convertions (paths, convs)
+  raise "empty conversion." if convs.empty?
+  paths.map! do |path|
+    convpath = path
+    convs.each do |from, to|
+      convpath = convpath.sub(/#{from.gsub('.', '\.')}$/, to)
+    end
+    [path, convpath]
+  end
+  Hash[*paths.flatten]
+end
+
+alias sh_original sh
+
+def sh (s)
+  sh_original s
+#rescue
+end

data/task/ext.rake

@@ -0,0 +1,36 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+namespace :ext do
+
+  dir     = "#{EXTDIR}/#{NAME}"
+  name    = "#{NAME}/tester"
+  outname = "#{name}.#{EXTEXT}"
+  out     = File.join EXTDIR, outname
+
+  extconf  = File.join dir, "extconf.rb"
+  makefile = File.join dir, "Makefile"
+  depends  = File.join dir, "depends"
+
+  cpps = Dir.glob("#{dir}/**/*.cpp")
+
+  task :build => out
+
+  task :clean do
+    sh %( cd #{dir} && #{MAKE} clean ) if File.exist? makefile
+    sh %( rm -f #{makefile} #{depends} )
+  end
+
+  file out => makefile do
+    sh %( cd #{dir} && #{MAKE} )
+  end
+
+  file makefile => [extconf, "lib:build"] do #, depends] do
+    sh %( cd #{dir} && #{RUBY} #{File.basename extconf} )
+  end
+
+  file depends => cpps do
+    sh %( cd #{dir} && touch #{depends} )
+  end
+
+end# :ext

data/task/gem.rake

@@ -0,0 +1,33 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+namespace :gem do
+
+  name = NAME
+
+  gemspec = "#{name}.gemspec"
+  gem     = "#{name}-#{version}.gem"
+
+  task :build => gem
+
+  task :install => gem do
+    sh %( #{GEM} install #{gem} )
+  end
+
+  task :uninstall do
+    sh %( #{GEM} uninstall #{name} )
+  end
+
+  task :clean do
+    sh %( rm -f #{gem} )
+  end
+
+  task :upload => gem do
+    sh %( #{GEM} push #{gem} )
+  end
+
+  file gem => "lib:build" do
+    sh %( #{GEM} build #{gemspec} )
+  end
+
+end# :gem

data/task/lib.rake

@@ -0,0 +1,47 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+namespace :lib do
+
+  name    = NAME
+  outname = "lib#{name}.a"
+  out     = File.join LIBDIR, outname
+
+  erbs    = convertions glob("**/*.erb"), {".erb" => ""}
+  headers = glob("include/**/*.h") | erbs.values.grep(/\.h$/)
+  srcs    = glob("src/**/*.cpp")   | erbs.values.grep(/\.cpp$/)
+
+  objs = convertions srcs, {".cpp" => ".o"}
+  tmps = objs.values | erbs.values
+
+  task :build => out
+
+  task :compile => objs.values
+
+  task :erb => erbs.values
+
+  task :clean do
+    sh %( rm -rf #{tmps.join " "} #{out} )
+  end
+
+  file out => objs.values do
+    sh %( #{AR} #{ARFLAGS} #{out} #{objs.values.join " "} )
+  end
+
+  objs.each do |(src, obj)|
+    incdirs = INCDIRS.map{|s| " -I#{s}"}.join
+
+    file obj => [src] + erbs.values do
+      sh %( #{CC} -c #{CFLAGS} #{incdirs} -o #{obj} #{src} )
+    end
+  end
+
+  erbs.each do |(erb, out)|
+    file out => [erb] + RBS do
+      print "#{erb}: compiling to #{out}..."
+      compile erb, out
+      puts "ok"
+    end
+  end
+
+end# :lib

data/test/test_rucy.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+$: << File.expand_path(File.join File.dirname(__FILE__), "..", "ext")
+require 'test/unit'
+require 'rucy/tester'
+
+
+class TestTester < Test::Unit::TestCase
+
+  def setup ()
+    @t = Rucy::Tester.new
+  end
+
+  def test_no_return_returns_nil ()
+    assert_equal nil, @t.do_nothing
+  end
+
+  def test_returns_nil ()
+    assert_equal nil, @t.return_nil
+  end
+
+  def test_return_int ()
+    assert_kind_of Integer, @t.return_int
+  end
+
+  def test_return_float ()
+    assert_kind_of Float, @t.return_float
+  end
+
+  def test_return_string ()
+    assert_kind_of String, @t.return_string
+  end
+
+  def test_raise_ruby_exception ()
+    assert_raise(StandardError) {@t.raise_ruby_exception}
+  end
+
+  def test_raise_in_eval ()
+    assert_raise(RuntimeError) {@t.raise_in_eval}
+  end
+
+  def test_throw_std_exception ()
+    assert_raise(Rucy::NativeError) {@t.throw_std_exception}
+  end
+
+  def test_throw_std_runtime_error ()
+    assert_raise(Rucy::NativeError) {@t.throw_std_runtime_error}
+  end
+
+  def test_throw_std_string ()
+    assert_raise(Rucy::NativeError) {@t.throw_std_string}
+  end
+
+  def test_throw_cstring ()
+    assert_raise(Rucy::NativeError) {@t.throw_cstring}
+  end
+
+end # TestTester