rucy 0.1.6 → 0.1.7

data/ext/rucy/tester.cpp

@@ -2,13 +2,13 @@
 
 
 #include <vector>
-#include <rucy.h>
+#include "rucy.h"
 
 
 using namespace Rucy;
 
 
-static std::vector<String> logs;
+static std::vector<Xot::String> logs;
 
 
 void
@@ -18,41 +18,25 @@ log (const char* str)
 }
 
 
-/*
-	return last log.
-*/
-RUBY_DEFN(last_log)
-{
-	if (argc > 1)
-		arg_count_error("#last_log", argc, 0, 1);
-
-	size_t index = (argc >= 1) ? to<size_t>(argv[0]) : logs.size() - 1;
-	if (index >= logs.size())
-		index_error();
-
-	return value(logs[index].c_str());
-}
-RUBY_END
-
 /*
 	return all logs.
 */
-RUBY_DEF0(all_logs)
+RUCY_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
+RUCY_END
 
 /*
 	clcear all logs.
 */
-RUBY_DEF0(clear_logs)
+RUCY_DEF0(clear_logs)
 {
 	logs.clear();
 }
-RUBY_END
+RUCY_END
 
 
 void Init_value ();
@@ -65,12 +49,13 @@ void Init_class ();
 extern "C" void
 Init_tester ()
 {
-	if (!init()) return;
+	RUCY_TRY
+
+	init();
 
 	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);
 
@@ -79,4 +64,6 @@ Init_tester ()
 	Init_function();
 	Init_struct ();
 	Init_class ();
+
+	RUCY_CATCH
 }

data/ext/rucy/value.cpp

@@ -1,36 +1,58 @@
-#include <rucy.h>
+#include "rucy.h"
 
 
 using namespace Rucy;
 
 
 static
-RUBY_DEFN(true_to_value)
+RUCY_DEFN(true_to_value)
 {
 	return value(true);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(false_to_value)
+RUCY_DEFN(false_to_value)
 {
 	return value(false);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(NULL_to_value)
+RUCY_DEFN(NULL_to_value)
 {
 	return nil();
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(nil_value)
+RUCY_DEFN(nil_value)
 {
 	return nil();
 }
-RUBY_END
+RUCY_END
+
+static
+RUCY_DEFN(array_value)
+{
+	const Value* a = argv;
+	switch (argc)
+	{
+		case 1:  return array(a[0]);
+		case 2:  return array(a[0], a[1]);
+		case 3:  return array(a[0], a[1], a[2]);
+		case 4:  return array(a[0], a[1], a[2], a[3]);
+		case 5:  return array(a[0], a[1], a[2], a[3], a[4]);
+		case 6:  return array(a[0], a[1], a[2], a[3], a[4], a[5]);
+		case 7:  return array(a[0], a[1], a[2], a[3], a[4], a[5], a[6]);
+		case 8:  return array(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7]);
+		case 9:  return array(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);
+		case 10: return array(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
+		case 0:
+		default: argument_error(__FILE__, __LINE__);
+	}
+}
+RUCY_END
 
 
 void
@@ -43,4 +65,5 @@ Init_value ()
 	mTester.define_method("false_to_value", false_to_value);
 	mTester.define_method("null_to_value", NULL_to_value);
 	mTester.define_method("nil_value", nil_value);
+	mTester.define_method("array_value", array_value);
 }

data/include/rucy/class.h

@@ -18,13 +18,15 @@ namespace Rucy
 
 		public:
 
-			Class (VALUE v = Qnil);
+			Class (RubyValue v = nil());
 
-			Class define_alloc_func (RubyFunction0 fun);
+			void define_alloc_func (RubyFunction0 fun);
 
-			Class define_alloc_func (const char* name, RubyFunction0 fun);
+			void define_alloc_func (const char* name, RubyFunction0 fun);
 			// for RUBY_METHOD macro
 
+			void define_clear_override_flags (RubyFunction0 fun);
+
 	};// Class
 
 

data/include/rucy/exception.h

@@ -5,8 +5,8 @@
 
 
 #include <stdexcept>
-#include <typeinfo>
-#include <rucy/class.h>
+#include <xot/exception.h>
+#include <rucy/value.h>
 
 
 namespace Rucy
@@ -22,7 +22,7 @@ namespace Rucy
 
 			RubyException (Value exception);
 
-			RubyException (Value type, const char* format, ...);
+			RubyException (Value exception, const char* format, ...);
 
 			const char* what () const throw();
 
@@ -35,100 +35,46 @@ namespace Rucy
 	};// RubyException
 
 
-	struct RubyJumptag
+	struct RubyJumpTag
 	{
 
 		public:
 
 			int tag;
 
-			RubyJumptag (int tag);
+			RubyJumpTag (int tag);
 
-	};// RubyJumptag
+	};// RubyJumpTag
 
 
 	void raise (const char* format = NULL, ...);
 
-	void raise (VALUE exception, const char* format = NULL, ...);
+	void raise (RubyValue exception, const char* format = NULL, ...);
 
 
-	void type_error (const char* format = NULL, ...);
+	void rucy_error            (const char* file, int line, const char* format = NULL, ...);
 
-	void argument_error (const char* format = NULL, ...);
+	void type_error            (const char* file, int line, const char* format = NULL, ...);
 
-	void arg_count_error (
+	void argument_error        (const char* file, int line, const char* format = NULL, ...);
+
+	void arg_count_error       (const char* file, int line,
 		const char* method, int nargs, int nargs_expected,
 		int n1 = -1, int n2 = -1, int n3 = -1, int n4 = -1, int n5 = -1,
 		int n6 = -1, int n7 = -1, int n8 = -1, int n9 = -1, int n10 = -1);
 
-	void index_error (const char* format = NULL, ...);
+	void invalid_state_error   (const char* file, int line, const char* format = NULL, ...);
 
-	void not_implemented_error (const char* format = NULL, ...);
+	void invalid_object_error  (const char* file, int line, const char* format = NULL, ...);
 
+	void index_error           (const char* file, int line, const char* format = NULL, ...);
 
-	void system_error (const char* format = NULL, ...);
+	void not_implemented_error (const char* file, int line, const char* format = NULL, ...);
 
-	void invalid_object_error (const char* format = NULL, ...);
+	void system_error          (const char* file, int line, const char* format = NULL, ...);
 
 
 }// Rucy
 
 
-#define RUBY_TRY \
-	VALUE RUCY__rubyexception__ = Qnil; \
-	int RUCY__rubyjumptag__ = 0; \
-	 \
-	goto RUCY__ruby_try_start__; \
-	 \
-	RUCY__ruby_jump_tag__: \
-	if (RUCY__rubyjumptag__) rb_jump_tag(RUCY__rubyjumptag__); \
-	RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), "Bad jump tag.")); \
-	 \
-	RUCY__ruby_raise_exception__: \
-	rb_exc_raise(RUCY__rubyexception__); \
-	 \
-	RUCY__ruby_try_start__: \
-	try \
-	{
-
-#define RUBY_CATCH \
-	} \
-	catch (const Rucy::RubyJumptag& e) \
-	{ \
-		RUCY__rubyjumptag__ = e.tag; \
-		goto RUCY__ruby_jump_tag__; \
-	} \
-	catch (const Rucy::RubyException& e) \
-	{ \
-		RUBY_THROW(e.value()); \
-	} \
-	catch (const std::exception& e) \
-	{ \
-		Rucy::String text = e.what(), type = typeid(e).name(); \
-		if (!type.empty()) \
-		{ \
-			if (!text.empty()) text += " "; \
-			text += "[" + type + "]"; \
-		} \
-		RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), text.c_str())); \
-	} \
-	catch (const std::string& s) \
-	{ \
-		RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), s.c_str())); \
-	} \
-	catch (const char* s) \
-	{ \
-		RUBY_THROW(rb_exc_new2(Rucy::native_error_class(), s)); \
-	} \
-	catch (...) \
-	{ \
-		RUBY_THROW(rb_exc_new2( \
-			Rucy::native_error_class(), "Unknown C++ exception was thrown.")); \
-	}
-
-#define RUBY_THROW(exception) \
-	RUCY__rubyexception__ = (exception); \
-	goto RUCY__ruby_raise_exception__
-
-
 #endif//EOH