rucy 0.1.6 → 0.1.7

data/include/rucy/rucy.h

@@ -1,10 +1,9 @@
 // -*- c++ -*-
 #pragma once
-#ifndef __RUCY_H__
-#define __RUCY_H__
+#ifndef __RUCY_RUCY_H__
+#define __RUCY_RUCY_H__
 
 
-#include <ruby.h>
 #include <rucy/class.h>
 
 
@@ -12,81 +11,23 @@ namespace Rucy
 {
 
 
-	bool init ();
-
-	bool check_class (Value obj, Value klass);
+	void init ();
 
 
 	Module rucy_module ();
 	// module Rucy
 
-
 	Class native_error_class ();
 	// class Rucy::NativeError < RuntimeError
 
-	Class system_error_class ();
-	// class Rucy::SystemError < Rucy::NativeError
+	Class invalid_state_error_class ();
+	// class Rucy::InvalidStateError < Rucy::NativeError
 
 	Class invalid_object_error_class ();
 	// class Rucy::InvalidObjectError < Rucy::NativeError
 
-
-	template <typename T> inline void mark_type (void* p)
-	{
-		if (p) ((T*) p)->mark();
-	}
-
-	template <typename T> inline void delete_type (void* p)
-	{
-		delete (T*) p;
-	}
-
-	template <typename T> inline void release_type (void* p)
-	{
-		if (p) ((T*) p)->release();
-	}
-
-	template <typename T> inline Value new_type (
-		Value klass, T* ptr,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = delete_type<T>)
-	{
-		if (!ptr) return Qnil;
-		return Data_Wrap_Struct(klass, mark, free, ptr);
-	}
-
-	template <typename T> inline Value new_type (
-		Value klass,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = delete_type<T>)
-	{
-		return new_type(klass, new T, mark, free);
-	}
-
-	template <typename T> inline Value new_ref (
-		Value klass, T* ptr,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = release_type<T>)
-	{
-		if (ptr) ptr->retain();
-		return new_type(klass, ptr, mark, free);
-	}
-
-	template <typename T> inline Value new_ref (
-		Value klass,
-		RUBY_DATA_FUNC mark = NULL,
-		RUBY_DATA_FUNC free = release_type<T>)
-	{
-		return new_ref(klass, new T, mark, free);
-	}
-
-	template <typename T> inline T* get_type_ptr (Value obj, Value klass = Qnil)
-	{
-		if (klass && !check_class(obj, klass)) return NULL;
-		T* p = NULL;
-		Data_Get_Struct(obj.value(), T, p);
-		return p;
-	}
+	Class system_error_class ();
+	// class Rucy::SystemError < Rucy::NativeError
 
 
 }// Rucy

data/include/rucy/symbol.h

@@ -4,14 +4,14 @@
 #define __RUCY_SYMBOL_H__
 
 
-#include <ruby.h>
+#include <rucy/ruby.h>
 
 
-#define SYMBOL(name, str) static const Rucy::Symbol name (str)
+#define RUCY_SYMBOL(name, str) static const Rucy::Symbol name (str)
 
-#define SYM(s)   SYMBOL(s, #s)
-#define SYM_Q(s) SYMBOL(s, #s "?")
-#define SYM_B(s) SYMBOL(s, #s "!")
+#define RUCY_SYM(s)   RUCY_SYMBOL(s, #s)
+#define RUCY_SYM_Q(s) RUCY_SYMBOL(s, #s "?")
+#define RUCY_SYM_B(s) RUCY_SYMBOL(s, #s "!")
 
 
 namespace Rucy
@@ -28,15 +28,15 @@ namespace Rucy
 
 			Symbol ();
 
-			Symbol (ID id);
+			Symbol (const char* s);
 
-			Symbol (const Value& value);
+			Symbol (const char* s, size_t len);
 
-			Symbol (const char* str);
+			Symbol (RubySymbol symbol);
 
-			ID id () const;
+			RubySymbol symbol () const;
 
-			VALUE value () const;
+			Value value () const;
 
 			const char* c_str () const;
 
@@ -50,7 +50,7 @@ namespace Rucy
 
 		private:
 
-			ID id_;
+			RubySymbol sym;
 
 	};// Symbol
 

data/include/rucy/value.h.erb

@@ -4,7 +4,7 @@
 #define __RUCY_VALUE_H__
 
 
-#include <ruby.h>
+#include <rucy/ruby.h>
 #include <rucy/symbol.h>
 
 
@@ -21,61 +21,59 @@ namespace Rucy
 
 			Value (bool b);
 
-			Value (int i);
+			Value (         int n);
 
-			Value (float f);
+			Value (unsigned int n);
 
-			Value (double d);
+			Value (float n);
 
-			Value (const char* s, bool tainted = false);
+			Value (double n);
 
-			Value (const char* s, size_t len, bool tainted = false);
+			Value (const char* s);
 
-			Value (size_t size, const Value* values);
+			Value (const char* s, size_t len);
 
-			Value (VALUE v);
+			Value (size_t size, const Value* array);
 
-			void mark () const;
-
-			bool is_kind_of (Value klass) const;
+			Value (RubyValue v);
 
-			VALUE value () const;
+			bool is_i () const;
 
-			int type () const;
+			bool is_f () const;
 
-			Value klass () const;
+			bool is_s () const;
 
-			int size () const;
+			bool is_sym () const;
 
-			int length () const;
+			bool is_array () const;
 
-			Value to_i () const;
+			bool is_hash () const;
 
-			Value to_f () const;
+			bool is_nil () const;
 
-			Value to_s () const;
+			int          as_i (bool convert = false) const;
 
-			Value to_sym () const;
+			double       as_f (bool convert = false) const;
 
-			int         as_i (bool convert = false) const;
+			const char*  as_s (bool convert = false) const;
 
-			double      as_f (bool convert = false) const;
+			Symbol       as_sym (bool convert = false) const;
 
-			const char* as_s (bool convert = false) const;
+			      Value* as_array (bool convert = false);
 
-			Symbol      as_sym (bool convert = false) const;
+			const Value* as_array (bool convert = false) const;
 
-			bool is_i () const;
+			Value to_i () const;
 
-			bool is_f () const;
+			Value to_f () const;
 
-			bool is_s () const;
+			Value to_s () const;
 
-			bool is_sym () const;
+			Value to_sym () const;
 
-			bool is_a () const;
+			Value to_array () const;
 
-			bool is_nil () const;
+			template <typename T> T as (bool convert = false) const;
 
 %			["call", "operator ()"].each do |op|
 			Value <%= op %> (Symbol name, int argc, const Value* argv) const;
@@ -84,15 +82,13 @@ namespace Rucy
 %				end
 %			end
 
-			Value inspect () const;
-
-			const char* c_str () const;
+			void mark () const;
 
-			      Value& operator [] (int i);
+			RubyValue value () const;
 
-			const Value& operator [] (int i) const;
+			RubyValueType type () const;
 
-			operator VALUE () const;
+			operator RubyValue () const;
 
 			operator bool () const;
 
@@ -100,8 +96,20 @@ namespace Rucy
 
 			bool operator == (const Value& rhs) const;
 
+			bool operator == (RubyValue rhs) const;
+
 			bool operator != (const Value& rhs) const;
 
+			bool operator != (RubyValue rhs) const;
+
+			// Object
+
+			Value klass () const;
+
+			bool is_kind_of (Value klass) const;
+
+			Value inspect () const;
+
 			// Array
 
 			Value push (Value obj);
@@ -112,9 +120,23 @@ namespace Rucy
 
 			Value unshift (Value obj);
 
+			      Value& operator [] (int i);
+
+			const Value& operator [] (int i) const;
+
+			// String
+
+			const char* c_str () const;
+
+			// Array / String
+
+			int length () const;
+
+			int size () const;
+
 		protected:
 
-			VALUE v;
+			RubyValue val;
 
 	};// Value
 
@@ -130,21 +152,23 @@ namespace Rucy
 
 			GlobalValue (bool b, bool gc = false);
 
-			GlobalValue (int i, bool gc = false);
+			GlobalValue (         int n, bool gc = false);
+
+			GlobalValue (unsigned int n, bool gc = false);
 
-			GlobalValue (float f, bool gc = false);
+			GlobalValue (float n, bool gc = false);
 
-			GlobalValue (double d, bool gc = false);
+			GlobalValue (double n, bool gc = false);
 
-			GlobalValue (const char* s, bool tainted = false, bool gc = false);
+			GlobalValue (const char* s, bool gc = false);
 
-			GlobalValue (const char* s, size_t len, bool tainted = false, bool gc = false);
+			GlobalValue (const char* s, size_t len, bool gc = false);
 
-			GlobalValue (size_t size, const Value* values, bool gc = false);
+			GlobalValue (size_t size, const Value* array, bool gc = false);
 
-			GlobalValue (VALUE v, bool gc = false);
+			GlobalValue (RubyValue v, bool gc = false);
 
-			GlobalValue (const Value& obj, bool gc = false);
+			GlobalValue (const Value& v, bool gc = false);
 
 			GlobalValue (const GlobalValue& obj, bool gc = false);
 
@@ -152,174 +176,72 @@ namespace Rucy
 
 			~GlobalValue ();
 
-			void gc (bool enable = true);
+			void gc (bool enable) const;
 
 		private:
 
-			short gc_disable_count;
+			mutable short gc_disable_count;
 
-			bool gc_guarded;
+			mutable bool gc_guarded;
 
 			void init (bool gc);
 
-			void update_guard ();
+			void update_guard () const;
 
 	};// GlobalValue
 
 
-	Value value (bool b);
+	Value nil ();
 
-	Value value (char c);
+	Value value (bool b);
 
-	Value value (unsigned char c);
+	Value value (         char n);
 
-	Value value (short s);
+	Value value (unsigned char n);
 
-	Value value (unsigned short s);
+	Value value (         short n);
 
-	Value value (int i);
+	Value value (unsigned short n);
 
-	Value value (unsigned int i);
+	Value value (         int n);
 
-	Value value (long l);
+	Value value (unsigned int n);
 
-	Value value (unsigned long l);
+	Value value (         long n);
 
-	Value value (long long ll);
+	Value value (unsigned long n);
 
-	Value value (unsigned long long ll);
+	Value value (         long long n);
 
-	Value value (float f);
+	Value value (unsigned long long n);
 
-	Value value (double d);
+	Value value (float n);
 
-	Value value (const char* s, bool tainted = false);
+	Value value (double n);
 
-	Value value (const char* s, size_t len, bool tainted = false);
+	Value value (const char* s);
 
-	Value value (size_t size, const Value* values);
+	Value value (const char* s, size_t len);
 
-	Value value (Symbol sym);
+	Value value (size_t size, const Value* array);
 
 	Value value (void* ptr);
+%	(1..10).each do |n|
 
-	Value nil ();
-
-
-	template <typename T> T value_to (Value obj, bool convert = true);
-
-	template <> inline bool
-	value_to<bool> (Value obj, bool convert)
-	{
-		return (bool) obj;
-	}
-
-	template <> inline int
-	value_to<int> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2INT(obj.value());
-	}
-
-	template <> inline unsigned int
-	value_to<unsigned int> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2UINT(obj.value());
-	}
-
-	template <> inline char
-	value_to<char> (Value obj, bool convert)
-	{
-		return (char) value_to<int>(obj, convert);
-	}
-
-	template <> inline unsigned char
-	value_to<unsigned char> (Value obj, bool convert)
-	{
-		return (unsigned char) value_to<int>(obj, convert);
-	}
-
-	template <> inline short
-	value_to<short> (Value obj, bool convert)
-	{
-		return (short) value_to<int>(obj, convert);
-	}
-
-	template <> inline unsigned short
-	value_to<unsigned short> (Value obj, bool convert)
-	{
-		return (unsigned short) value_to<int>(obj, convert);
-	}
-
-	template <> inline long
-	value_to<long> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2LONG(obj.value());
-	}
-
-	template <> inline unsigned long
-	value_to<unsigned long> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2ULONG(obj.value());
-	}
-
-	template <> inline long long
-	value_to<long long> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2LL(obj.value());
-	}
-
-	template <> inline unsigned long long
-	value_to<unsigned long long> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_i();
-		return NUM2ULL(obj.value());
-	}
-
-	template <> inline double
-	value_to<double> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_f();
-		Check_Type(obj, T_FLOAT);
-		return RFLOAT_VALUE(obj.value());
-	}
+	Value array (<%= params(n, ', ') {|i| "Value v#{i}"} %>);
+%	end
 
-	template <> inline float
-	value_to<float> (Value obj, bool convert)
-	{
-		return (float) value_to<double>(obj, convert);
-	}
 
-	template <> inline char*
-	value_to<char*> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_s();
-		VALUE s = obj.value();
-		return StringValueCStr(s);
-	}
+	template <typename T>        T value_to (Value obj, bool convert = true);
 
-	template <> inline const char*
-	value_to<const char*> (Value obj, bool convert)
+	template <typename T> inline T       to (Value obj, bool convert = true)
 	{
-		return value_to<char*>(obj, convert);
-	}
-
-	template <> inline Symbol
-	value_to<Symbol> (Value obj, bool convert)
-	{
-		if (convert) obj = obj.to_sym();
-		Check_Type(obj, T_SYMBOL);
-		return SYM2ID(obj.value());
+		return value_to<T>(obj, convert);
 	}
 
-
-	template <typename T> inline T to (Value obj, bool convert = true)
+	template <typename T> inline T Value::as (bool convert) const
 	{
-		return value_to<T>(obj, convert);
+		return value_to<T>(*this, convert);
 	}
 
 

data/include/rucy.h

@@ -1,5 +1,10 @@
 // -*- c++ -*-
-#include <rucy/defs.h>
+#pragma once
+#ifndef __RUCY_H__
+#define __RUCY_H__
+
+
+#include <rucy/ruby.h>
 #include <rucy/rucy.h>
 #include <rucy/value.h>
 #include <rucy/exception.h>
@@ -8,3 +13,6 @@
 #include <rucy/class.h>
 #include <rucy/symbol.h>
 #include <rucy/extension.h>
+
+
+#endif//EOH

data/lib/rucy/module.rb

@@ -4,7 +4,11 @@
 module Rucy
 
 
-  extend module ModuleInfo
+  module Module
+
+    def name ()
+      super.split('::')[-2]
+    end
 
     def version ()
       open(root_dir 'VERSION') {|f| f.readline.chomp}
@@ -14,12 +18,12 @@ module Rucy
       File.expand_path "../../../#{path}", __FILE__
     end
 
-    def include_dirs ()
-      %w[include].map {|dir| root_dir dir}
+    def include_dir ()
+      root_dir 'include'
     end
 
-    def lib_dirs ()
-      %w[lib].map {|dir| root_dir dir}
+    def lib_dir ()
+      root_dir 'lib'
     end
 
     def task_dir ()
@@ -37,9 +41,9 @@ module Rucy
       end
     end
 
-    self
+    extend self
 
-  end# ModuleInfo
+  end# Module
 
 
 end# Rucy

data/rucy.gemspec

@@ -1,9 +1,8 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-$:.unshift File.expand_path('../lib', __FILE__) do |path|
-  $:.unshift path if !$:.include?(path) && File.directory?(path)
-end
+File.expand_path('../lib', __FILE__)
+  .tap {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'rucy/module'
 
@@ -13,7 +12,7 @@ Gem::Specification.new do |s|
     patterns.map {|pat| Dir.glob(pat).to_a}.flatten
   end
 
-  mod   = Rucy
+  mod   = Rucy::Module
   name  = mod.name.downcase
   rdocs = glob.call *%w[README .doc/ext/**/*.cpp]
 

data/src/class.cpp

@@ -2,26 +2,54 @@
 #include "rucy/class.h"
 
 
+#include <xot/string.h>
+#include "rucy/symbol.h"
+#include "rucy/extension.h"
+
+
 namespace Rucy
 {
 
 
-	Class::Class (VALUE v)
+	Class::Class (RubyValue v)
 	:	Super(v)
 	{
 	}
 
-	Class
+	void
 	Class::define_alloc_func (RubyFunction0 fun)
 	{
-		rb_define_alloc_func(value(), (VALUE(*)(VALUE)) fun);
-		return *this;
+		rb_define_alloc_func(value(), (RubyValue(*)(RubyValue)) fun);
 	}
 
-	Class
+	void
 	Class::define_alloc_func (const char*, RubyFunction0 fun)
 	{
-		return define_alloc_func(fun);
+		define_alloc_func(fun);
+	}
+
+	template <bool singleton>
+	static
+	RUCY_DEF1(method_added_or_removed, method_name)
+	{
+		RUCY_SYMBOL(klass, "class");
+		RUCY_SYM(name);
+		Xot::String code =
+			Xot::stringf(
+				"ObjectSpace.each_object(%s) {|o| o.clear_override_flags}",
+				(singleton ? self(klass) : self)(name).c_str());
+		eval(code);
+	}
+	RUCY_END
+
+	void
+	Class::define_clear_override_flags (RubyFunction0 fun)
+	{
+		define_method("clear_override_flags",     fun);
+		define_method("singleton_method_added",   method_added_or_removed<true>);
+		define_method("singleton_method_removed", method_added_or_removed<true>);
+		define_singleton_method("method_added",   method_added_or_removed<false>);
+		define_singleton_method("method_removed", method_added_or_removed<false>);
 	}