rucy 0.1.0

data/src/value.cpp

@@ -0,0 +1,511 @@
+// -*- c++ -*-
+#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);
+	}
+
+	Value
+	Value::call (Symbol name, int argc, const Value* argv) const
+	{
+		return protect(rb_funcall2, value(), name.id(), argc, (const VALUE*) argv);
+	}
+	Value
+	Value::call (Symbol name) const
+	{
+		const VALUE args[] = {};
+		return protect(rb_funcall2, value(), name.id(), 0, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1) const
+	{
+		const VALUE args[] = {v1};
+		return protect(rb_funcall2, value(), name.id(), 1, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1, Value v2) const
+	{
+		const VALUE args[] = {v1, v2};
+		return protect(rb_funcall2, value(), name.id(), 2, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1, Value v2, Value v3) const
+	{
+		const VALUE args[] = {v1, v2, v3};
+		return protect(rb_funcall2, value(), name.id(), 3, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1, Value v2, Value v3, Value v4) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4};
+		return protect(rb_funcall2, value(), name.id(), 4, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5};
+		return protect(rb_funcall2, value(), name.id(), 5, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6};
+		return protect(rb_funcall2, value(), name.id(), 6, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6, v7};
+		return protect(rb_funcall2, value(), name.id(), 7, args);
+	}
+	Value
+	Value::call (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7, Value v8) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6, v7, v8};
+		return protect(rb_funcall2, value(), name.id(), 8, args);
+	}
+	Value
+	Value::operator () (Symbol name, int argc, const Value* argv) const
+	{
+		return protect(rb_funcall2, value(), name.id(), argc, (const VALUE*) argv);
+	}
+	Value
+	Value::operator () (Symbol name) const
+	{
+		const VALUE args[] = {};
+		return protect(rb_funcall2, value(), name.id(), 0, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1) const
+	{
+		const VALUE args[] = {v1};
+		return protect(rb_funcall2, value(), name.id(), 1, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1, Value v2) const
+	{
+		const VALUE args[] = {v1, v2};
+		return protect(rb_funcall2, value(), name.id(), 2, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1, Value v2, Value v3) const
+	{
+		const VALUE args[] = {v1, v2, v3};
+		return protect(rb_funcall2, value(), name.id(), 3, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1, Value v2, Value v3, Value v4) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4};
+		return protect(rb_funcall2, value(), name.id(), 4, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5};
+		return protect(rb_funcall2, value(), name.id(), 5, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6};
+		return protect(rb_funcall2, value(), name.id(), 6, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6, v7};
+		return protect(rb_funcall2, value(), name.id(), 7, args);
+	}
+	Value
+	Value::operator () (Symbol name, Value v1, Value v2, Value v3, Value v4, Value v5, Value v6, Value v7, Value v8) const
+	{
+		const VALUE args[] = {v1, v2, v3, v4, v5, v6, v7, v8};
+		return protect(rb_funcall2, value(), name.id(), 8, args);
+	}
+
+	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