rucy 0.1.3 → 0.1.4
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/.doc/ext/rucy/class.cpp +244 -0
- data/.doc/ext/rucy/exception.cpp +99 -0
- data/.doc/ext/rucy/function.cpp +63 -0
- data/.doc/ext/rucy/struct.cpp +80 -0
- data/.doc/ext/rucy/tester.cpp +41 -184
- data/.doc/ext/rucy/value.cpp +42 -0
- data/.gitignore +22 -0
- data/Rakefile +4 -29
- data/VERSION +1 -1
- data/ext/rucy/class.cpp +262 -0
- data/ext/rucy/class.h +96 -0
- data/ext/rucy/exception.cpp +107 -0
- data/ext/rucy/extconf.rb +9 -8
- data/ext/rucy/function.cpp +68 -0
- data/ext/rucy/struct.cpp +83 -0
- data/ext/rucy/tester.cpp +41 -197
- data/ext/rucy/tester.h +10 -0
- data/ext/rucy/value.cpp +46 -0
- data/include/rucy/defs.h.erb +17 -0
- data/include/rucy/exception.h +2 -0
- data/include/rucy/extension.h +206 -0
- data/include/rucy/rucy.h +25 -2
- data/include/rucy/symbol.h +11 -0
- data/include/rucy/value.h.erb +66 -14
- data/include/rucy.h +1 -1
- data/lib/rucy/module.rb +9 -2
- data/rucy.gemspec +16 -40
- data/src/exception.cpp +17 -25
- data/src/rucy.cpp +2 -2
- data/src/symbol.cpp +24 -0
- data/src/value.cpp.erb +161 -25
- data/task/doc.rake +50 -0
- data/test/helpers.rb +7 -0
- data/test/test_class.rb +161 -0
- data/test/test_exception.rb +39 -0
- data/test/test_function.rb +31 -0
- data/test/test_struct.rb +30 -0
- data/test/test_value.rb +18 -0
- metadata +123 -74
- data/include/rucy/defs.h +0 -101
- data/include/rucy/function.h +0 -245
- data/include/rucy/gc.h +0 -59
- data/include/rucy/module.h +0 -98
- data/include/rucy/value.h +0 -291
- data/src/function.cpp +0 -158
- data/src/gc.cpp +0 -63
- data/src/module.cpp +0 -325
- data/src/value.cpp +0 -511
- data/task/ext.rake +0 -96
- data/test/test_rucy.rb +0 -73
@@ -0,0 +1,244 @@
|
|
1
|
+
#include "class.h"
|
2
|
+
|
3
|
+
|
4
|
+
#include <rucy.h>
|
5
|
+
|
6
|
+
|
7
|
+
using namespace Rucy;
|
8
|
+
|
9
|
+
|
10
|
+
static Class cBase, cSub, cRubyObj;
|
11
|
+
|
12
|
+
|
13
|
+
RUCY_WRAPPER_VALUE_FROM_TO(Base, cBase)
|
14
|
+
RUCY_WRAPPER_VALUE_FROM_TO(Sub, cSub)
|
15
|
+
RUCY_WRAPPER_VALUE_FROM_TO(RubyObj, cRubyObj)
|
16
|
+
|
17
|
+
|
18
|
+
template <typename T> Class get_class ();
|
19
|
+
|
20
|
+
template <> Class get_class<Base> () {return cBase;}
|
21
|
+
|
22
|
+
template <> Class get_class<Sub> () {return cSub;}
|
23
|
+
|
24
|
+
|
25
|
+
template <typename T>
|
26
|
+
class RubyBase : public ClassWrapper<T>
|
27
|
+
{
|
28
|
+
|
29
|
+
typedef ClassWrapper<T> Super;
|
30
|
+
|
31
|
+
RUCY_OVERRIDE_ID_START(name_overridable_faster)
|
32
|
+
RUCY_OVERRIDE_ID_LAST
|
33
|
+
|
34
|
+
public:
|
35
|
+
|
36
|
+
virtual const char* name_overridable () const
|
37
|
+
{
|
38
|
+
RUCY_OVERRIDABLE_METHOD(name_overridable, get_class<T>(), .c_str());
|
39
|
+
}
|
40
|
+
|
41
|
+
virtual const char* name_overridable_faster () const
|
42
|
+
{
|
43
|
+
RUCY_OVERRIDABLE_METHOD_FAST(name_overridable_faster, get_class<T>(), .c_str());
|
44
|
+
}
|
45
|
+
|
46
|
+
bool is_name_overridable_faster_overridden () const
|
47
|
+
{
|
48
|
+
SYM(name_overridable_faster);
|
49
|
+
return RUCY_IS_OVERRIDDEN(name_overridable_faster, get_class<T>());
|
50
|
+
}
|
51
|
+
|
52
|
+
};// RubyBase
|
53
|
+
|
54
|
+
|
55
|
+
#define THIS(type) to<type*>(self)
|
56
|
+
|
57
|
+
#define CHECK(type) RUCY_CHECK_OBJ(self, type, c##type)
|
58
|
+
|
59
|
+
#define CALL(type, obj, fun) RUCY_WRAPPER_CALL(ClassWrapper<type>, obj, fun)
|
60
|
+
|
61
|
+
|
62
|
+
/*
|
63
|
+
alloc function.
|
64
|
+
*/
|
65
|
+
static
|
66
|
+
VALUE base_alloc(VALUE klass)
|
67
|
+
{
|
68
|
+
return value(new RubyBase<Base>, klass);
|
69
|
+
}
|
70
|
+
|
71
|
+
static
|
72
|
+
VALUE name(VALUE self)
|
73
|
+
{
|
74
|
+
CHECK(Base);
|
75
|
+
return value(THIS(Base)->name());
|
76
|
+
}
|
77
|
+
|
78
|
+
static
|
79
|
+
VALUE call_name(VALUE self)
|
80
|
+
{
|
81
|
+
CHECK(Base);
|
82
|
+
return value(THIS(Base)->name());
|
83
|
+
}
|
84
|
+
|
85
|
+
static
|
86
|
+
VALUE base_name_overridable(VALUE self)
|
87
|
+
{
|
88
|
+
CHECK(Base);
|
89
|
+
return value(CALL(Base, THIS(Base), name_overridable()));
|
90
|
+
}
|
91
|
+
|
92
|
+
static
|
93
|
+
VALUE call_name_overridable(VALUE self)
|
94
|
+
{
|
95
|
+
CHECK(Base);
|
96
|
+
return value(THIS(Base)->name_overridable());
|
97
|
+
}
|
98
|
+
|
99
|
+
static
|
100
|
+
VALUE base_name_overridable_faster(VALUE self)
|
101
|
+
{
|
102
|
+
CHECK(Base);
|
103
|
+
return value(CALL(Base, THIS(Base), name_overridable_faster()));
|
104
|
+
}
|
105
|
+
|
106
|
+
static
|
107
|
+
VALUE call_name_overridable_faster(VALUE self)
|
108
|
+
{
|
109
|
+
CHECK(Base);
|
110
|
+
return value(THIS(Base)->name_overridable_faster());
|
111
|
+
}
|
112
|
+
|
113
|
+
template <typename T>
|
114
|
+
static
|
115
|
+
VALUE is_name_overridable_faster_overridden(VALUE self)
|
116
|
+
{
|
117
|
+
RUCY_CHECK_OBJ(self, T, get_class<T>());
|
118
|
+
RubyBase<T>* obj = dynamic_cast<RubyBase<T>*>(THIS(T));
|
119
|
+
if (!obj) invalid_object_error("dynamic_cast() failed.");
|
120
|
+
return value(obj->is_name_overridable_faster_overridden());
|
121
|
+
}
|
122
|
+
|
123
|
+
template <typename T>
|
124
|
+
static
|
125
|
+
VALUE clear_override_flags(VALUE self)
|
126
|
+
{
|
127
|
+
RUCY_CHECK_OBJ(self, T, get_class<T>());
|
128
|
+
ClassWrapper<T>* obj = dynamic_cast<ClassWrapper<T>*>(THIS(T));
|
129
|
+
if (obj) obj->clear_override_flags();
|
130
|
+
}
|
131
|
+
|
132
|
+
template <bool singleton>
|
133
|
+
static
|
134
|
+
VALUE method_added_or_removed(VALUE self, VALUE method_name)
|
135
|
+
{
|
136
|
+
SYMBOL(klass, "class");
|
137
|
+
SYM(name);
|
138
|
+
eval(
|
139
|
+
Xot::stringf(
|
140
|
+
"ObjectSpace.each_object(%s) {|o| o.clear_override_flags}",
|
141
|
+
(singleton ? self(klass) : self)(name).c_str()).c_str());
|
142
|
+
}
|
143
|
+
|
144
|
+
static
|
145
|
+
VALUE base_new_raw(VALUE self)
|
146
|
+
{
|
147
|
+
return value(new Base);
|
148
|
+
}
|
149
|
+
|
150
|
+
|
151
|
+
/*
|
152
|
+
alloc function.
|
153
|
+
*/
|
154
|
+
static
|
155
|
+
VALUE sub_alloc(VALUE klass)
|
156
|
+
{
|
157
|
+
return value(new RubyBase<Sub>, klass);
|
158
|
+
}
|
159
|
+
|
160
|
+
static
|
161
|
+
VALUE sub_name_overridable(VALUE self)
|
162
|
+
{
|
163
|
+
CHECK(Sub);
|
164
|
+
return value(CALL(Sub, THIS(Sub), name_overridable()));
|
165
|
+
}
|
166
|
+
|
167
|
+
static
|
168
|
+
VALUE sub_name_overridable_faster(VALUE self)
|
169
|
+
{
|
170
|
+
CHECK(Sub);
|
171
|
+
return value(CALL(Sub, THIS(Sub), name_overridable_faster()));
|
172
|
+
}
|
173
|
+
|
174
|
+
static
|
175
|
+
VALUE sub_new_raw(VALUE self)
|
176
|
+
{
|
177
|
+
return value(new Sub);
|
178
|
+
}
|
179
|
+
|
180
|
+
|
181
|
+
/*
|
182
|
+
alloc function.
|
183
|
+
*/
|
184
|
+
static
|
185
|
+
VALUE rubyobj_alloc(VALUE klass)
|
186
|
+
{
|
187
|
+
return value(new ClassWrapper<RubyObj>, klass);
|
188
|
+
}
|
189
|
+
|
190
|
+
static Xot::Ref<RubyObj> rubyobj_ref;
|
191
|
+
|
192
|
+
static
|
193
|
+
VALUE rubyobj_set_ref(VALUE self, VALUE obj)
|
194
|
+
{
|
195
|
+
rubyobj_ref = to<RubyObj*>(obj);
|
196
|
+
return obj;
|
197
|
+
}
|
198
|
+
|
199
|
+
static
|
200
|
+
VALUE rubyobj_clear_ref(VALUE self)
|
201
|
+
{
|
202
|
+
rubyobj_ref.reset();
|
203
|
+
}
|
204
|
+
|
205
|
+
|
206
|
+
void
|
207
|
+
Init_class ()
|
208
|
+
{
|
209
|
+
Module mRucy = rb_define_module("Rucy");
|
210
|
+
Module mTester = rb_define_module_under(mRucy, "Tester");
|
211
|
+
|
212
|
+
cBase = rb_define_class_under(mTester, "Base", rb_cObject);
|
213
|
+
rb_define_alloc_func(cBase, base_alloc);
|
214
|
+
rb_define_method(cBase, "name", RUBY_METHOD_FUNC(name), 0);
|
215
|
+
rb_define_method(cBase, "name_overridable", RUBY_METHOD_FUNC(base_name_overridable), 0);
|
216
|
+
rb_define_method(cBase, "name_overridable_faster", RUBY_METHOD_FUNC(base_name_overridable_faster), 0);
|
217
|
+
rb_define_method(cBase, "call_name", RUBY_METHOD_FUNC(call_name), 0);
|
218
|
+
rb_define_method(cBase, "call_name_overridable", RUBY_METHOD_FUNC(call_name_overridable), 0);
|
219
|
+
rb_define_method(cBase, "call_name_overridable_faster", RUBY_METHOD_FUNC(call_name_overridable_faster), 0);
|
220
|
+
cBase.define_method(
|
221
|
+
"is_name_overridable_faster_overridden",
|
222
|
+
is_name_overridable_faster_overridden<Base>);
|
223
|
+
cBase.define_method("clear_override_flags", clear_override_flags<Base>);
|
224
|
+
cBase.define_method("singleton_method_added", method_added_or_removed<true>);
|
225
|
+
cBase.define_method("singleton_method_removed", method_added_or_removed<true>);
|
226
|
+
cBase.define_singleton_method("method_added", method_added_or_removed<false>);
|
227
|
+
cBase.define_singleton_method("method_removed", method_added_or_removed<false>);
|
228
|
+
rb_define_singleton_method(cBase, "new_raw", RUBY_METHOD_FUNC(base_new_raw), 0);
|
229
|
+
|
230
|
+
cSub = rb_define_class_under(mTester, "Sub", cBase);
|
231
|
+
rb_define_alloc_func(cSub, sub_alloc);
|
232
|
+
rb_define_method(cSub, "name_overridable", RUBY_METHOD_FUNC(sub_name_overridable), 0);
|
233
|
+
rb_define_method(cSub, "name_overridable_faster", RUBY_METHOD_FUNC(sub_name_overridable_faster), 0);
|
234
|
+
cSub.define_method(
|
235
|
+
"is_name_overridable_faster_overridden",
|
236
|
+
is_name_overridable_faster_overridden<Sub>);
|
237
|
+
cSub.define_method("clear_override_flags", clear_override_flags<Sub>);
|
238
|
+
rb_define_singleton_method(cSub, "new_raw", RUBY_METHOD_FUNC(sub_new_raw), 0);
|
239
|
+
|
240
|
+
cRubyObj = rb_define_class_under(mTester, "RubyObj", rb_cObject);
|
241
|
+
rb_define_alloc_func(cRubyObj, rubyobj_alloc);
|
242
|
+
rb_define_function(cRubyObj, "set_ref", RUBY_METHOD_FUNC(rubyobj_set_ref), 1);
|
243
|
+
rb_define_function(cRubyObj, "clear_ref", RUBY_METHOD_FUNC(rubyobj_clear_ref), 0);
|
244
|
+
}
|
@@ -0,0 +1,99 @@
|
|
1
|
+
#include <rucy.h>
|
2
|
+
|
3
|
+
|
4
|
+
using namespace Rucy;
|
5
|
+
|
6
|
+
|
7
|
+
/*
|
8
|
+
raise ruby's exception.
|
9
|
+
*/
|
10
|
+
static
|
11
|
+
VALUE raise_ruby_exception(VALUE self)
|
12
|
+
{
|
13
|
+
throw RubyException(rb_eStandardError, "raise_ruby_exception");
|
14
|
+
}
|
15
|
+
|
16
|
+
/*
|
17
|
+
raise in eval.
|
18
|
+
*/
|
19
|
+
static
|
20
|
+
VALUE raise_in_eval(VALUE self)
|
21
|
+
{
|
22
|
+
eval("raise 'raise_in_eval'");
|
23
|
+
}
|
24
|
+
|
25
|
+
/*
|
26
|
+
throw nothing.
|
27
|
+
*/
|
28
|
+
static
|
29
|
+
VALUE throw_nothing(VALUE self)
|
30
|
+
{
|
31
|
+
throw;
|
32
|
+
}
|
33
|
+
|
34
|
+
/*
|
35
|
+
throw std::exception.
|
36
|
+
*/
|
37
|
+
static
|
38
|
+
VALUE throw_std_exception(VALUE self)
|
39
|
+
{
|
40
|
+
throw std::exception();
|
41
|
+
}
|
42
|
+
|
43
|
+
/*
|
44
|
+
throw std::runtime_error.
|
45
|
+
*/
|
46
|
+
static
|
47
|
+
VALUE throw_std_runtime_error(VALUE self)
|
48
|
+
{
|
49
|
+
throw std::runtime_error("std::runtime_error");
|
50
|
+
}
|
51
|
+
|
52
|
+
struct MyException : public std::runtime_error
|
53
|
+
{
|
54
|
+
MyException() : runtime_error("") {}
|
55
|
+
};
|
56
|
+
|
57
|
+
/*
|
58
|
+
throw custom exception class.
|
59
|
+
*/
|
60
|
+
static
|
61
|
+
VALUE throw_custom_exception(VALUE self)
|
62
|
+
{
|
63
|
+
throw MyException();
|
64
|
+
}
|
65
|
+
|
66
|
+
/*
|
67
|
+
throw std::string.
|
68
|
+
*/
|
69
|
+
static
|
70
|
+
VALUE throw_std_string(VALUE self)
|
71
|
+
{
|
72
|
+
throw std::string("std::string");
|
73
|
+
}
|
74
|
+
|
75
|
+
/*
|
76
|
+
throw char*.
|
77
|
+
*/
|
78
|
+
static
|
79
|
+
VALUE throw_cstring(VALUE self)
|
80
|
+
{
|
81
|
+
throw "cstring";
|
82
|
+
}
|
83
|
+
|
84
|
+
|
85
|
+
void
|
86
|
+
Init_exception ()
|
87
|
+
{
|
88
|
+
Module mRucy = rb_define_module("Rucy");
|
89
|
+
Module mTester = rb_define_module_under(mRucy, "Tester");
|
90
|
+
|
91
|
+
rb_define_method(mTester, "raise_ruby_exception", RUBY_METHOD_FUNC(raise_ruby_exception), 0);
|
92
|
+
rb_define_method(mTester, "raise_in_eval", RUBY_METHOD_FUNC(raise_in_eval), 0);
|
93
|
+
rb_define_method(mTester, "throw_nothing", RUBY_METHOD_FUNC(throw_nothing), 0);
|
94
|
+
rb_define_method(mTester, "throw_std_exception", RUBY_METHOD_FUNC(throw_std_exception), 0);
|
95
|
+
rb_define_method(mTester, "throw_std_runtime_error", RUBY_METHOD_FUNC(throw_std_runtime_error), 0);
|
96
|
+
rb_define_method(mTester, "throw_custom_exception", RUBY_METHOD_FUNC(throw_custom_exception), 0);
|
97
|
+
rb_define_method(mTester, "throw_std_string", RUBY_METHOD_FUNC(throw_std_string), 0);
|
98
|
+
rb_define_method(mTester, "throw_cstring", RUBY_METHOD_FUNC(throw_cstring), 0);
|
99
|
+
}
|
@@ -0,0 +1,63 @@
|
|
1
|
+
#include <rucy.h>
|
2
|
+
|
3
|
+
|
4
|
+
using namespace Rucy;
|
5
|
+
|
6
|
+
|
7
|
+
/*
|
8
|
+
do nothing.
|
9
|
+
*/
|
10
|
+
static
|
11
|
+
VALUE do_nothing(VALUE self)
|
12
|
+
{
|
13
|
+
}
|
14
|
+
|
15
|
+
/*
|
16
|
+
return nil.
|
17
|
+
*/
|
18
|
+
static
|
19
|
+
VALUE return_nil(VALUE self)
|
20
|
+
{
|
21
|
+
return Qnil;
|
22
|
+
}
|
23
|
+
|
24
|
+
/*
|
25
|
+
return int.
|
26
|
+
*/
|
27
|
+
static
|
28
|
+
VALUE return_int(VALUE self)
|
29
|
+
{
|
30
|
+
return value(1);
|
31
|
+
}
|
32
|
+
|
33
|
+
/*
|
34
|
+
return flaot.
|
35
|
+
*/
|
36
|
+
static
|
37
|
+
VALUE return_float(VALUE self)
|
38
|
+
{
|
39
|
+
return value(1.0f);
|
40
|
+
}
|
41
|
+
|
42
|
+
/*
|
43
|
+
return string.
|
44
|
+
*/
|
45
|
+
static
|
46
|
+
VALUE return_string(VALUE self)
|
47
|
+
{
|
48
|
+
return value("");
|
49
|
+
}
|
50
|
+
|
51
|
+
|
52
|
+
void
|
53
|
+
Init_function ()
|
54
|
+
{
|
55
|
+
Module mRucy = rb_define_module("Rucy");
|
56
|
+
Module mTester = rb_define_module_under(mRucy, "Tester");
|
57
|
+
|
58
|
+
rb_define_method(mTester, "do_nothing", RUBY_METHOD_FUNC(do_nothing), -1);
|
59
|
+
rb_define_method(mTester, "return_nil", RUBY_METHOD_FUNC(return_nil), 0);
|
60
|
+
rb_define_method(mTester, "return_int", RUBY_METHOD_FUNC(return_int), 0);
|
61
|
+
rb_define_method(mTester, "return_float", RUBY_METHOD_FUNC(return_float), 0);
|
62
|
+
rb_define_method(mTester, "return_string", RUBY_METHOD_FUNC(return_string), 0);
|
63
|
+
}
|
@@ -0,0 +1,80 @@
|
|
1
|
+
#include <rucy.h>
|
2
|
+
|
3
|
+
|
4
|
+
using namespace Rucy;
|
5
|
+
|
6
|
+
|
7
|
+
struct Struct
|
8
|
+
{
|
9
|
+
|
10
|
+
int num;
|
11
|
+
|
12
|
+
Struct () : num(0) {}
|
13
|
+
|
14
|
+
};// Struct
|
15
|
+
|
16
|
+
|
17
|
+
static Class cStruct;
|
18
|
+
|
19
|
+
|
20
|
+
namespace Rucy
|
21
|
+
{
|
22
|
+
|
23
|
+
|
24
|
+
static Value
|
25
|
+
value (const Struct& obj)
|
26
|
+
{
|
27
|
+
return new_type(cStruct, new Struct(obj));
|
28
|
+
}
|
29
|
+
|
30
|
+
template <> inline Struct*
|
31
|
+
value_to<Struct*> (Value val, bool)
|
32
|
+
{
|
33
|
+
return get_type_ptr<Struct>(val, cStruct);
|
34
|
+
}
|
35
|
+
|
36
|
+
|
37
|
+
}// Rucy
|
38
|
+
|
39
|
+
|
40
|
+
/*
|
41
|
+
alloc function.
|
42
|
+
*/
|
43
|
+
static
|
44
|
+
VALUE alloc(VALUE klass)
|
45
|
+
{
|
46
|
+
return new_type<Struct>(klass);
|
47
|
+
}
|
48
|
+
|
49
|
+
/*
|
50
|
+
get num.
|
51
|
+
*/
|
52
|
+
static
|
53
|
+
VALUE get_num(VALUE self)
|
54
|
+
{
|
55
|
+
Struct* obj = to<Struct*>(self);
|
56
|
+
if (obj) return value(obj->num);
|
57
|
+
}
|
58
|
+
|
59
|
+
/*
|
60
|
+
set num.
|
61
|
+
*/
|
62
|
+
static
|
63
|
+
VALUE set_num(VALUE self, VALUE num)
|
64
|
+
{
|
65
|
+
Struct* obj = to<Struct*>(self);
|
66
|
+
if (obj) obj->num = to<int>(num);
|
67
|
+
}
|
68
|
+
|
69
|
+
|
70
|
+
void
|
71
|
+
Init_struct ()
|
72
|
+
{
|
73
|
+
Module mRucy = rb_define_module("Rucy");
|
74
|
+
Module mTester = rb_define_module_under(mRucy, "Tester");
|
75
|
+
|
76
|
+
cStruct = rb_define_class_under(mTester, "Struct", rb_cObject);
|
77
|
+
rb_define_alloc_func(cStruct, alloc);
|
78
|
+
rb_define_method(cStruct, "num", RUBY_METHOD_FUNC(get_num), 0);
|
79
|
+
rb_define_method(cStruct, "num=", RUBY_METHOD_FUNC(set_num), 1);
|
80
|
+
}
|