rucy 0.1.6 → 0.1.7

data/src/value.cpp.erb

@@ -3,287 +3,303 @@
 
 
 #include <assert.h>
-#include <rucy/rucy.h>
-#include <rucy/function.h>
-#include <rucy/exception.h>
+#include "rucy/function.h"
+#include "rucy/exception.h"
 
 
 namespace Rucy
 {
 
 
-	Value::Value ()
-	:	v(Qnil)
+	static void
+	check_type (RubyValue value, RubyValueType type)
 	{
+		return rb_check_type(value, type);
 	}
 
-	Value::Value (bool b)
-	:	v(b ? Qtrue : Qfalse)
+	static bool
+	test_value (RubyValue value)
 	{
+		return RTEST(value); //!NIL_P(v) && v != Qfalse;
 	}
 
-	Value::Value (int n)
-	:	v(INT2FIX(n))
-	{
-	}
 
-	Value::Value (float f)
-	:	v(rb_float_new(f))
+	Value::Value ()
+	:	val(nil())
 	{
 	}
 
-	Value::Value (double d)
-	:	v(rb_float_new(d))
+	Value::Value (bool b)
+	:	val(b ? Qtrue : Qfalse)
 	{
 	}
 
-	Value::Value (const char* s, bool tainted)
-	:	v(!s ? Qnil : tainted ? rb_tainted_str_new2(s) : rb_str_new2(s))
+	Value::Value (int n)
+	:	val(INT2NUM(n))
 	{
 	}
 
-	Value::Value (const char* s, size_t len, bool tainted)
-	:	v(!s ? Qnil : tainted ? rb_tainted_str_new(s, len) : rb_str_new(s, len))
+	Value::Value (unsigned int n)
+	:	val(UINT2NUM(n))
 	{
 	}
 
-	Value::Value (size_t size, const Value* values)
-	:	v(size > 0 ? rb_ary_new2(size) : rb_ary_new())
+	Value::Value (float n)
+	:	val(rb_float_new(n))
 	{
-		if (!values) return;
-		for (size_t i = 0; i < size; ++i)
-			push(values[i]);
 	}
 
-	Value::Value (VALUE v)
-	:	v(v)
+	Value::Value (double n)
+	:	val(rb_float_new(n))
 	{
 	}
 
-	VALUE
-	Value::value () const
+	Value::Value (const char* s)
+	:	val(s ? rb_str_new2(s) : Qnil)
 	{
-		return v;
+		if (!s)
+			argument_error(__FILE__, __LINE__);
 	}
 
-	void
-	Value::mark () const
+	Value::Value (const char* s, size_t len)
+	:	val(s ? rb_str_new(s, len) : Qnil)
 	{
-		rb_gc_mark(v);
+		if (!s)
+			argument_error(__FILE__, __LINE__);
 	}
 
-	int
-	Value::type () const
+	Value::Value (size_t size, const Value* array)
 	{
-		return TYPE(v);
+		if (size == 0)
+		{
+			val = rb_ary_new();
+		}
+		else if (array)
+		{
+			val = rb_ary_new4(size, (const RubyValue*) array);
+		}
+		else
+		{
+			val = rb_ary_new2(size);
+		}
 	}
 
-	Value
-	Value::klass () const
+	Value::Value (RubyValue v)
+	:	val(v)
 	{
-		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)
+	Value::is_i () const
 	{
-		if (obj.type() == T_STRING)
-			return (int) RSTRING_LEN(obj.value());
-		else if (obj.type() == T_ARRAY)
-			return (int) RARRAY_LEN(obj.value());
-		else
-			return obj.call(method);
+		return FIXNUM_P(val) || type() == RUBY_T_BIGNUM || is_kind_of(rb_cInteger);
 	}
 
-	int
-	Value::size () const
+	bool
+	Value::is_f () const
 	{
-		SYM(size);
-		return get_object_size(v, size);
+		return RB_FLOAT_TYPE_P(val) || is_kind_of(rb_cFloat);
 	}
 
-	int
-	Value::length () const
+	bool
+	Value::is_s () const
 	{
-		SYM(length);
-		return get_object_size(v, length);
+		return type() == RUBY_T_STRING || is_kind_of(rb_cString);
 	}
 
-	Value
-	Value::to_i () const
+	bool
+	Value::is_sym () const
 	{
-		if (FIXNUM_P(v) || TYPE(v) == T_BIGNUM) return *this;
-		SYM(to_i);
-		return call(to_i);
+		return SYMBOL_P(val) || is_kind_of(rb_cSymbol);
 	}
 
-	Value
-	Value::to_f () const
+	bool
+	Value::is_array () const
 	{
-		if (TYPE(v) == T_FLOAT) return *this;
-		SYM(to_f);
-		return call(to_f);
+		return type() == RUBY_T_ARRAY || is_kind_of(rb_cArray);
 	}
 
-	Value
-	Value::to_s () const
+	bool
+	Value::is_hash () const
 	{
-		if (TYPE(v) == T_STRING) return *this;
-		SYM(to_s);
-		return call(to_s);
+		return type() == RUBY_T_HASH || is_kind_of(rb_cHash);
 	}
 
-	Value
-	Value::to_sym () const
+	bool
+	Value::is_nil () const
 	{
-		if (TYPE(v) == T_SYMBOL) return *this;
-		SYM(to_sym);
-		return call(to_sym);
+		return NIL_P(val);
 	}
 
 	int
 	Value::as_i (bool convert) const
 	{
-		return to<int>(*this, convert);
+		return as<int>(convert);
 	}
 
 	double
 	Value::as_f (bool convert) const
 	{
-		return to<double>(*this, convert);
+		return as<double>(convert);
 	}
 
 	const char*
 	Value::as_s (bool convert) const
 	{
-		return to<const char*>(*this, convert);
+		return as<const char*>(convert);
 	}
 
 	Symbol
 	Value::as_sym (bool convert) const
 	{
-		return to<Symbol>(*this, convert);
+		return as<Symbol>(convert);
 	}
 
-	bool
-	Value::is_i () const
+	Value*
+	Value::as_array (bool convert)
 	{
-		return is_kind_of(rb_cFixnum);
+		return as<Value*>(convert);
 	}
 
-	bool
-	Value::is_f () const
+	const Value*
+	Value::as_array (bool convert) const
 	{
-		return is_kind_of(rb_cFloat);
+		return as<const Value*>(convert);
 	}
 
-	bool
-	Value::is_s () const
+	Value
+	Value::to_i () const
 	{
-		return is_kind_of(rb_cString);
+		if (is_i()) return *this;
+		RUCY_SYM(to_i);
+		return call(to_i);
 	}
 
-	bool
-	Value::is_sym () const
+	Value
+	Value::to_f () const
 	{
-		return is_kind_of(rb_cSymbol);
+		if (is_f()) return *this;
+		RUCY_SYM(to_f);
+		return call(to_f);
 	}
 
-	bool
-	Value::is_a () const
+	Value
+	Value::to_s () const
 	{
-		return is_kind_of(rb_cArray);
+		if (is_s()) return *this;
+		RUCY_SYM(to_s);
+		return call(to_s);
 	}
 
-	bool
-	Value::is_nil () const
+	Value
+	Value::to_sym () const
+	{
+		if (is_sym()) return *this;
+		RUCY_SYM(to_sym);
+		return call(to_sym);
+	}
+
+	Value
+	Value::to_array () const
 	{
-		return NIL_P(v);
+		if (is_array()) return *this;
+		RUCY_SYM(to_a);
+		return call(to_a);
 	}
 
 %	["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);
+		return protect(rb_funcall2, val, name.symbol(), argc, (const RubyValue*) 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);
+		const RubyValue args[] = {<%= params(n, ', ') {|i| "v#{i}"} %>};
+		return protect(rb_funcall2, val, name.symbol(), <%= n %>, args);
 	}
 %		end
 %	end
 
-	Value
-	Value::inspect () const
+	void
+	Value::mark () const
 	{
-		SYM(inspect);
-		return call(inspect);
+		rb_gc_mark(val);
 	}
 
-	const char*
-	Value::c_str () const
+	RubyValue
+	Value::value () const
 	{
-		return value_to<const char*>(*this);
+		return val;
 	}
 
-	Value&
-	Value::operator [] (int i)
+	RubyValueType
+	Value::type () const
 	{
-		if (type() != T_ARRAY) type_error();
-		return *(Value*) &RARRAY_PTR(v)[i];
+		return TYPE(val);
 	}
 
-	const Value&
-	Value::operator [] (int i) const
+	Value::operator RubyValue () const
 	{
-		return const_cast<Value*>(this)->operator[](i);
+		return val;
 	}
 
-	Value::operator VALUE () const
+	Value::operator bool () const
 	{
-		return value();
+		return test_value(val);
 	}
 
-	static bool
-	test_value (VALUE v)
+	bool
+	Value::operator ! () const
 	{
-		return !NIL_P(v) && v != Qfalse;// RTEST(v);
+		return !operator bool();
 	}
 
-	Value::operator bool () const
+	bool
+	Value::operator == (const Value& rhs) const
 	{
-		return test_value(v);
+		return operator==(rhs.val);
 	}
 
 	bool
-	Value::operator ! () const
+	Value::operator == (RubyValue rhs) const
 	{
-		return !operator bool();
+		return val == rhs;// test_value(rb_obj_equal(val, rhs);
 	}
 
 	bool
-	Value::operator == (const Value& rhs) const
+	Value::operator != (const Value& rhs) const
 	{
-		return v == rhs.v;// test_value(rb_obj_equal(v, rhs.v);
+		return !operator==(rhs);
 	}
 
 	bool
-	Value::operator != (const Value& rhs) const
+	Value::operator != (RubyValue rhs) const
 	{
 		return !operator==(rhs);
 	}
 
+	Value
+	Value::klass () const
+	{
+		return RBASIC(val)->klass;
+	}
+
+	bool
+	Value::is_kind_of (Value klass) const
+	{
+		return rb_obj_is_kind_of(val, klass);
+	}
+
+	Value
+	Value::inspect () const
+	{
+		RUCY_SYM(inspect);
+		return call(inspect);
+	}
+
 	Value
 	Value::push (Value obj)
 	{
@@ -308,6 +324,49 @@ namespace Rucy
 		return rb_ary_unshift(value(), obj.value());
 	}
 
+	Value&
+	Value::operator [] (int i)
+	{
+		return as_array()[i];
+	}
+
+	const Value&
+	Value::operator [] (int i) const
+	{
+		return const_cast<Value*>(this)->operator[](i);
+	}
+
+	const char*
+	Value::c_str () const
+	{
+		return as<const char*>(true);
+	}
+
+	static int
+	get_length (const Value& value, RubySymbol symbol)
+	{
+		if (value.type() == RUBY_T_ARRAY)
+			return (int) RARRAY_LEN(value.value());
+		else if (value.type() == RUBY_T_STRING)
+			return (int) RSTRING_LEN(value.value());
+		else
+			return value.call(symbol);
+	}
+
+	int
+	Value::length () const
+	{
+		RUCY_SYM(length);
+		return get_length(*this, length);
+	}
+
+	int
+	Value::size () const
+	{
+		RUCY_SYM(size);
+		return get_length(*this, size);
+	}
+
 
 	GlobalValue::GlobalValue ()
 	{
@@ -320,50 +379,56 @@ namespace Rucy
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (int i, bool gc_)
-	:	Super(i)
+	GlobalValue::GlobalValue (int n, bool gc_)
+	:	Super(n)
 	{
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (float f, bool gc_)
-	:	Super(f)
+	GlobalValue::GlobalValue (unsigned int n, bool gc_)
+	:	Super(n)
 	{
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (double d, bool gc_)
-	:	Super(d)
+	GlobalValue::GlobalValue (float n, bool gc_)
+	:	Super(n)
 	{
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (const char* s, bool tainted, bool gc_)
-	:	Super(s, tainted)
+	GlobalValue::GlobalValue (double n, bool gc_)
+	:	Super(n)
 	{
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (const char* s, size_t len, bool tainted, bool gc_)
-	:	Super(s, len, tainted)
+	GlobalValue::GlobalValue (const char* s, bool gc_)
+	:	Super(s)
 	{
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (size_t size, const Value* values, bool gc_)
-	:	Super(size, values)
+	GlobalValue::GlobalValue (const char* s, size_t len, bool gc_)
+	:	Super(s, len)
 	{
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (VALUE v, bool gc_)
+	GlobalValue::GlobalValue (size_t size, const Value* array, bool gc_)
+	:	Super(size, array)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (RubyValue v, bool gc_)
 	:	Super(v)
 	{
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (const Value& obj, bool gc_)
-	:	Super(obj)
+	GlobalValue::GlobalValue (const Value& v, bool gc_)
+	:	Super(v)
 	{
 		init(gc_);
 	}
@@ -375,9 +440,9 @@ namespace Rucy
 	}
 
 	GlobalValue&
-	GlobalValue::operator = (const Value& obj)
+	GlobalValue::operator = (const Value& v)
 	{
-		Super::operator=(obj);
+		Super::operator=(v);
 		update_guard();
 		return *this;
 	}
@@ -388,7 +453,7 @@ namespace Rucy
 	}
 
 	void
-	GlobalValue::gc (bool enable)
+	GlobalValue::gc (bool enable) const
 	{
 		gc_disable_count += enable ? -1 : +1;
 		update_guard();
@@ -403,28 +468,34 @@ namespace Rucy
 	}
 
 	void
-	GlobalValue::update_guard ()
+	GlobalValue::update_guard () const
 	{
 		assert(gc_disable_count >= 0);
 
-		if (IMMEDIATE_P(v))
+		if (IMMEDIATE_P(val))
 		{
-			if (gc_guarded) rb_gc_unregister_address(&v);
+			if (gc_guarded) rb_gc_unregister_address((RubyValue*) &val);
 			gc_guarded = false;
 		}
 		else if (gc_disable_count > 0)
 		{
-			if (!gc_guarded) rb_gc_register_address(&v);
+			if (!gc_guarded) rb_gc_register_address((RubyValue*) &val);
 			gc_guarded = true;
 		}
 		else
 		{
-			if (gc_guarded) rb_gc_unregister_address(&v);
+			if (gc_guarded) rb_gc_unregister_address((RubyValue*) &val);
 			gc_guarded = false;
 		}
 	}
 
 
+	Value
+	nil ()
+	{
+		return Qnil;
+	}
+
 	Value
 	value (bool b)
 	{
@@ -440,7 +511,7 @@ namespace Rucy
 	Value
 	value (unsigned char n)
 	{
-		return (int) n;
+		return (unsigned int) n;
 	}
 
 	Value
@@ -452,7 +523,7 @@ namespace Rucy
 	Value
 	value (unsigned short n)
 	{
-		return (int) n;
+		return (unsigned int) n;
 	}
 
 	Value
@@ -464,7 +535,7 @@ namespace Rucy
 	Value
 	value (unsigned int n)
 	{
-		return UINT2NUM(n);
+		return n;
 	}
 
 	Value
@@ -492,52 +563,180 @@ namespace Rucy
 	}
 
 	Value
-	value (float f)
+	value (float n)
 	{
-		return f;
+		return n;
 	}
 
 	Value
-	value (double d)
+	value (double n)
 	{
-		return d;
+		return n;
 	}
 
 	Value
-	value (const char* s, bool tainted)
+	value (const char* s)
 	{
-		return Value(s, tainted);
+		return Value(s);
 	}
 
 	Value
-	value (const char* s, size_t len, bool tainted)
+	value (const char* s, size_t len)
 	{
-		return Value(s, len, tainted);
+		return Value(s, len);
 	}
 
 	Value
-	value (size_t size, const Value* values)
+	value (size_t size, const Value* array)
 	{
-		return Value(size, values);
+		return Value(size, array);
 	}
 
 	Value
-	value (Symbol sym)
+	value (void* ptr)
 	{
-		return ID2SYM(sym.id());
+		if (ptr)
+			argument_error(__FILE__, __LINE__, "Rucy::value(void*) can take only (void*) NULL.");
+
+		return nil();
 	}
+%	(1..10).each do |n|
 
 	Value
-	value (void* ptr)
+	array (<%= params(n, ', ') {|i| "Value v#{i}"} %>)
 	{
-		if (ptr) argument_error("Rucy::value(void*) can take only (void*) NULL.");
-		return Qnil;
+		Value tmp[] = {<%= params(n, ', ') {|i| "v#{i}"} %>};
+		return value(<%= n %>, tmp);
 	}
+%	end
 
-	Value
-	nil ()
+
+	template <> bool
+	value_to<bool> (Value obj, bool convert)
 	{
-		return Qnil;
+		return (bool) obj;
+	}
+
+	template <> int
+	value_to<int> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		return NUM2INT(obj.value());
+	}
+
+	template <> unsigned int
+	value_to<unsigned int> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		return NUM2UINT(obj.value());
+	}
+
+	template <> char
+	value_to<char> (Value obj, bool convert)
+	{
+		return (char) value_to<int>(obj, convert);
+	}
+
+	template <> unsigned char
+	value_to<unsigned char> (Value obj, bool convert)
+	{
+		return (unsigned char) value_to<unsigned int>(obj, convert);
+	}
+
+	template <> short
+	value_to<short> (Value obj, bool convert)
+	{
+		return (short) value_to<int>(obj, convert);
+	}
+
+	template <> unsigned short
+	value_to<unsigned short> (Value obj, bool convert)
+	{
+		return (unsigned short) value_to<unsigned int>(obj, convert);
+	}
+
+	template <> long
+	value_to<long> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		return NUM2LONG(obj.value());
+	}
+
+	template <> unsigned long
+	value_to<unsigned long> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		return NUM2ULONG(obj.value());
+	}
+
+	template <> long long
+	value_to<long long> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		return NUM2LL(obj.value());
+	}
+
+	template <> unsigned long long
+	value_to<unsigned long long> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_i();
+		return NUM2ULL(obj.value());
+	}
+
+	template <> double
+	value_to<double> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_f();
+		check_type(obj, RUBY_T_FLOAT);
+
+		return RFLOAT_VALUE(obj.value());
+	}
+
+	template <> float
+	value_to<float> (Value obj, bool convert)
+	{
+		return (float) value_to<double>(obj, convert);
+	}
+
+	template <> char*
+	value_to<char*> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_s();
+		RubyValue s = obj.value();
+		return StringValueCStr(s);
+	}
+
+	template <> const char*
+	value_to<const char*> (Value obj, bool convert)
+	{
+		return value_to<char*>(obj, convert);
+	}
+
+	template <> Symbol
+	value_to<Symbol> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_sym();
+		check_type(obj, RUBY_T_SYMBOL);
+
+		return SYM2ID(obj.value());
+	}
+
+	template <> Value*
+	value_to<Value*> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_array();
+		check_type(obj, RUBY_T_ARRAY);
+
+		return (Value*) RARRAY_PTR(obj.value());
+	}
+
+	template <> const Value*
+	value_to<const Value*> (Value obj, bool convert)
+	{
+		if (convert) obj = obj.to_array();
+		check_type(obj, RUBY_T_ARRAY);
+
+		return (const Value*) RARRAY_PTR(obj.value());
 	}