rice2 2.2.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (190) hide show
  1. checksums.yaml +7 -0
  2. data/COPYING +23 -0
  3. data/Doxyfile +2268 -0
  4. data/Makefile.am +26 -0
  5. data/Makefile.in +929 -0
  6. data/README.md +1054 -0
  7. data/README.mingw +8 -0
  8. data/Rakefile +24 -0
  9. data/aclocal.m4 +1090 -0
  10. data/bootstrap +8 -0
  11. data/config.guess +1667 -0
  12. data/config.sub +1793 -0
  13. data/configure +8209 -0
  14. data/configure.ac +55 -0
  15. data/depcomp +791 -0
  16. data/doxygen.ac +314 -0
  17. data/doxygen.am +186 -0
  18. data/extconf.rb +66 -0
  19. data/install-sh +529 -0
  20. data/missing +215 -0
  21. data/post-autoconf.rb +22 -0
  22. data/post-automake.rb +28 -0
  23. data/rice/Address_Registration_Guard.cpp +22 -0
  24. data/rice/Address_Registration_Guard.hpp +7 -0
  25. data/rice/Address_Registration_Guard.ipp +37 -0
  26. data/rice/Address_Registration_Guard_defn.hpp +75 -0
  27. data/rice/Arg.hpp +8 -0
  28. data/rice/Arg_impl.hpp +129 -0
  29. data/rice/Arg_operators.cpp +21 -0
  30. data/rice/Arg_operators.hpp +19 -0
  31. data/rice/Array.hpp +214 -0
  32. data/rice/Array.ipp +256 -0
  33. data/rice/Builtin_Object.hpp +8 -0
  34. data/rice/Builtin_Object.ipp +50 -0
  35. data/rice/Builtin_Object_defn.hpp +50 -0
  36. data/rice/Class.cpp +57 -0
  37. data/rice/Class.hpp +8 -0
  38. data/rice/Class.ipp +6 -0
  39. data/rice/Class_defn.hpp +83 -0
  40. data/rice/Constructor.hpp +47 -0
  41. data/rice/Data_Object.hpp +8 -0
  42. data/rice/Data_Object.ipp +133 -0
  43. data/rice/Data_Object_defn.hpp +138 -0
  44. data/rice/Data_Type.cpp +54 -0
  45. data/rice/Data_Type.hpp +8 -0
  46. data/rice/Data_Type.ipp +365 -0
  47. data/rice/Data_Type_defn.hpp +261 -0
  48. data/rice/Data_Type_fwd.hpp +12 -0
  49. data/rice/Director.cpp +13 -0
  50. data/rice/Director.hpp +39 -0
  51. data/rice/Enum.hpp +117 -0
  52. data/rice/Enum.ipp +246 -0
  53. data/rice/Exception.cpp +59 -0
  54. data/rice/Exception.hpp +13 -0
  55. data/rice/Exception_Base.hpp +8 -0
  56. data/rice/Exception_Base.ipp +13 -0
  57. data/rice/Exception_Base_defn.hpp +27 -0
  58. data/rice/Exception_defn.hpp +69 -0
  59. data/rice/Hash.hpp +227 -0
  60. data/rice/Hash.ipp +329 -0
  61. data/rice/Identifier.cpp +8 -0
  62. data/rice/Identifier.hpp +50 -0
  63. data/rice/Identifier.ipp +33 -0
  64. data/rice/Jump_Tag.hpp +24 -0
  65. data/rice/Makefile.am +122 -0
  66. data/rice/Makefile.in +885 -0
  67. data/rice/Module.cpp +84 -0
  68. data/rice/Module.hpp +8 -0
  69. data/rice/Module.ipp +6 -0
  70. data/rice/Module_defn.hpp +88 -0
  71. data/rice/Module_impl.hpp +281 -0
  72. data/rice/Module_impl.ipp +345 -0
  73. data/rice/Object.cpp +169 -0
  74. data/rice/Object.hpp +8 -0
  75. data/rice/Object.ipp +33 -0
  76. data/rice/Object_defn.hpp +214 -0
  77. data/rice/Require_Guard.hpp +21 -0
  78. data/rice/String.cpp +94 -0
  79. data/rice/String.hpp +91 -0
  80. data/rice/Struct.cpp +117 -0
  81. data/rice/Struct.hpp +162 -0
  82. data/rice/Struct.ipp +26 -0
  83. data/rice/Symbol.cpp +25 -0
  84. data/rice/Symbol.hpp +66 -0
  85. data/rice/Symbol.ipp +44 -0
  86. data/rice/config.hpp +47 -0
  87. data/rice/config.hpp.in +46 -0
  88. data/rice/detail/Arguments.hpp +118 -0
  89. data/rice/detail/Auto_Function_Wrapper.hpp +898 -0
  90. data/rice/detail/Auto_Function_Wrapper.ipp +3694 -0
  91. data/rice/detail/Auto_Member_Function_Wrapper.hpp +897 -0
  92. data/rice/detail/Auto_Member_Function_Wrapper.ipp +2774 -0
  93. data/rice/detail/Caster.hpp +103 -0
  94. data/rice/detail/Exception_Handler.hpp +8 -0
  95. data/rice/detail/Exception_Handler.ipp +68 -0
  96. data/rice/detail/Exception_Handler_defn.hpp +96 -0
  97. data/rice/detail/Iterator.hpp +93 -0
  98. data/rice/detail/Not_Copyable.hpp +25 -0
  99. data/rice/detail/Wrapped_Function.hpp +33 -0
  100. data/rice/detail/cfp.hpp +24 -0
  101. data/rice/detail/cfp.ipp +51 -0
  102. data/rice/detail/check_ruby_type.cpp +27 -0
  103. data/rice/detail/check_ruby_type.hpp +23 -0
  104. data/rice/detail/creation_funcs.hpp +37 -0
  105. data/rice/detail/creation_funcs.ipp +36 -0
  106. data/rice/detail/default_allocation_func.hpp +23 -0
  107. data/rice/detail/default_allocation_func.ipp +11 -0
  108. data/rice/detail/define_method_and_auto_wrap.hpp +31 -0
  109. data/rice/detail/define_method_and_auto_wrap.ipp +30 -0
  110. data/rice/detail/demangle.cpp +56 -0
  111. data/rice/detail/demangle.hpp +19 -0
  112. data/rice/detail/env.hpp +11 -0
  113. data/rice/detail/from_ruby.hpp +43 -0
  114. data/rice/detail/from_ruby.ipp +60 -0
  115. data/rice/detail/method_data.cpp +92 -0
  116. data/rice/detail/method_data.hpp +21 -0
  117. data/rice/detail/node.hpp +13 -0
  118. data/rice/detail/protect.cpp +29 -0
  119. data/rice/detail/protect.hpp +34 -0
  120. data/rice/detail/ruby.hpp +74 -0
  121. data/rice/detail/ruby_version_code.hpp +6 -0
  122. data/rice/detail/ruby_version_code.hpp.in +6 -0
  123. data/rice/detail/st.hpp +22 -0
  124. data/rice/detail/to_ruby.hpp +22 -0
  125. data/rice/detail/to_ruby.ipp +36 -0
  126. data/rice/detail/traits.hpp +43 -0
  127. data/rice/detail/win32.hpp +16 -0
  128. data/rice/detail/wrap_function.hpp +66 -0
  129. data/rice/global_function.hpp +33 -0
  130. data/rice/global_function.ipp +22 -0
  131. data/rice/protect.hpp +38 -0
  132. data/rice/protect.ipp +1134 -0
  133. data/rice/ruby_mark.hpp +13 -0
  134. data/rice/ruby_try_catch.hpp +86 -0
  135. data/rice/rubypp.rb +97 -0
  136. data/rice/to_from_ruby.hpp +8 -0
  137. data/rice/to_from_ruby.ipp +418 -0
  138. data/rice/to_from_ruby_defn.hpp +70 -0
  139. data/ruby.ac +135 -0
  140. data/ruby/Makefile.am +1 -0
  141. data/ruby/Makefile.in +628 -0
  142. data/ruby/lib/Makefile.am +3 -0
  143. data/ruby/lib/Makefile.in +506 -0
  144. data/ruby/lib/mkmf-rice.rb.in +217 -0
  145. data/ruby/lib/version.rb +3 -0
  146. data/sample/Makefile.am +47 -0
  147. data/sample/Makefile.in +489 -0
  148. data/sample/enum/extconf.rb +3 -0
  149. data/sample/enum/sample_enum.cpp +54 -0
  150. data/sample/enum/test.rb +8 -0
  151. data/sample/inheritance/animals.cpp +98 -0
  152. data/sample/inheritance/extconf.rb +3 -0
  153. data/sample/inheritance/test.rb +7 -0
  154. data/sample/map/extconf.rb +3 -0
  155. data/sample/map/map.cpp +81 -0
  156. data/sample/map/test.rb +7 -0
  157. data/test/Makefile.am +72 -0
  158. data/test/Makefile.in +1213 -0
  159. data/test/ext/Makefile.am +41 -0
  160. data/test/ext/Makefile.in +483 -0
  161. data/test/ext/t1/Foo.hpp +10 -0
  162. data/test/ext/t1/extconf.rb +2 -0
  163. data/test/ext/t1/t1.cpp +15 -0
  164. data/test/ext/t2/extconf.rb +2 -0
  165. data/test/ext/t2/t2.cpp +11 -0
  166. data/test/test_Address_Registration_Guard.cpp +43 -0
  167. data/test/test_Array.cpp +248 -0
  168. data/test/test_Builtin_Object.cpp +71 -0
  169. data/test/test_Class.cpp +496 -0
  170. data/test/test_Constructor.cpp +128 -0
  171. data/test/test_Data_Object.cpp +275 -0
  172. data/test/test_Data_Type.cpp +348 -0
  173. data/test/test_Director.cpp +308 -0
  174. data/test/test_Enum.cpp +215 -0
  175. data/test/test_Exception.cpp +47 -0
  176. data/test/test_Hash.cpp +212 -0
  177. data/test/test_Identifier.cpp +70 -0
  178. data/test/test_Jump_Tag.cpp +17 -0
  179. data/test/test_Memory_Management.cpp +50 -0
  180. data/test/test_Module.cpp +497 -0
  181. data/test/test_Object.cpp +159 -0
  182. data/test/test_String.cpp +107 -0
  183. data/test/test_Struct.cpp +205 -0
  184. data/test/test_Symbol.cpp +63 -0
  185. data/test/test_To_From_Ruby.cpp +428 -0
  186. data/test/test_global_functions.cpp +114 -0
  187. data/test/test_rice.rb +41 -0
  188. data/test/unittest.cpp +136 -0
  189. data/test/unittest.hpp +294 -0
  190. metadata +297 -0
@@ -0,0 +1,13 @@
1
+ #ifndef ruby_mark__hpp
2
+ #define ruby_mark__hpp
3
+
4
+ //! Default function to call to mark a data object.
5
+ /*! This function can be specialized for a particular type to override
6
+ * the default behavior (which is to not mark any additional objects).
7
+ */
8
+ template<typename T>
9
+ void ruby_mark(T * /* obj */)
10
+ {
11
+ }
12
+
13
+ #endif // ruby_mark__hpp
@@ -0,0 +1,86 @@
1
+ #ifndef Rice__ruby_try_catch__hpp_
2
+ #define Rice__ruby_try_catch__hpp_
3
+
4
+ #include "Exception_Base_defn.hpp"
5
+ #include "Jump_Tag.hpp"
6
+ #include "detail/ruby.hpp"
7
+ #include <stdexcept>
8
+
9
+ /*! \def RUBY_TRY
10
+ * \brief Start a block to catch Ruby exceptions and rethrow them.
11
+ */
12
+ // Goto is used here to avoid having to use a second try/catch block (we
13
+ // can't rb_exc_raise directly out of the catch blocks below, since the
14
+ // exceptions will not get properly cleaned up).
15
+ // The labels are located before the try and not after it so the function can't
16
+ // "fall through" into the exception-handling code accidentally.
17
+ #define RUBY_TRY \
18
+ VALUE Rice__ruby_exc = Qnil; \
19
+ int Rice__ruby_jump_tag = 0; \
20
+ \
21
+ goto start_of_RUBY_TRY; \
22
+ \
23
+ Rice__ruby_exception: \
24
+ rb_exc_raise(Rice__ruby_exc); \
25
+ Rice__ruby_jump_tag: \
26
+ rb_jump_tag(Rice__ruby_jump_tag); \
27
+ \
28
+ start_of_RUBY_TRY: \
29
+ try
30
+
31
+ /*! \def RUBY_RETHROW(ex)
32
+ * \brief Given a Ruby exception as a VALUE, safely raise the exception as a
33
+ * Ruby exception. This should be used inside a RUBY_TRY/RUBY_CATCH
34
+ * block.
35
+ */
36
+ #define RUBY_RETHROW(ex) \
37
+ Rice__ruby_exc = ex; \
38
+ goto Rice__ruby_exception;
39
+
40
+ /*! \def RUBY_CATCH
41
+ * \brief End a RUBY_TRY block.
42
+ */
43
+ #define RUBY_CATCH \
44
+ catch(::Rice::Exception_Base const & ex) \
45
+ { \
46
+ RUBY_RETHROW(ex.value()); \
47
+ } \
48
+ catch(::Rice::Jump_Tag const & ex) \
49
+ { \
50
+ Rice__ruby_jump_tag = ex.tag; \
51
+ goto Rice__ruby_jump_tag; \
52
+ } \
53
+ catch(std::bad_alloc const & ex) \
54
+ { \
55
+ /* This won't work quite right if the rb_exc_new2 fails; not */ \
56
+ /* much we can do about that, since Ruby doesn't give us access */ \
57
+ /* to a pre-allocated NoMemoryError object */ \
58
+ RUBY_RETHROW(rb_exc_new2(rb_eNoMemError, ex.what())); \
59
+ } \
60
+ catch(std::invalid_argument const & ex) \
61
+ { \
62
+ /* This can raise a NoMemoryError in VERY rare circumstances */ \
63
+ RUBY_RETHROW(rb_exc_new2(rb_eArgError, ex.what())); \
64
+ } \
65
+ catch(std::domain_error const & ex) \
66
+ { \
67
+ /* This can raise a NoMemoryError in VERY rare circumstances */ \
68
+ RUBY_RETHROW(rb_exc_new2(rb_eFloatDomainError, ex.what())); \
69
+ } \
70
+ catch(std::out_of_range const & ex) \
71
+ { \
72
+ /* This can raise a NoMemoryError in VERY rare circumstances */ \
73
+ RUBY_RETHROW(rb_exc_new2(rb_eRangeError, ex.what())); \
74
+ } \
75
+ catch(std::exception const & ex) \
76
+ { \
77
+ /* This can raise a NoMemoryError in VERY rare circumstances */ \
78
+ RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, ex.what())); \
79
+ } \
80
+ catch(...) \
81
+ { \
82
+ RUBY_RETHROW(rb_exc_new2(rb_eRuntimeError, "unknown C++ exception thrown")); \
83
+ } \
84
+
85
+ #endif // Rice__ruby_try_catch__hpp_
86
+
@@ -0,0 +1,97 @@
1
+ class Preprocessor
2
+ def initialize(input, output, filename)
3
+ @input = input
4
+ @output = output
5
+ @filename = filename
6
+ @linenum = 1
7
+ end
8
+
9
+ def getline
10
+ line = @input.gets
11
+ @linenum += 1 if not line.nil?
12
+ return line
13
+ end
14
+
15
+ def preprocess
16
+ success = false
17
+ begin
18
+ loop do
19
+ line = getline
20
+ break if line.nil?
21
+ case line
22
+ when /(.*[^\\]|^)\#\{(.*?)\}(.*)/
23
+ puts "#{$1}#{evaluate($2, @linenum)}#{$3}"
24
+ when /^\#ruby\s+<<(.*)/
25
+ marker = $1
26
+ str = ''
27
+ evalstart = @linenum
28
+ loop do
29
+ line = getline
30
+ if line.nil? then
31
+ raise "End of input without #{marker}"
32
+ end
33
+ break if line.chomp == marker
34
+ str << line
35
+ end
36
+ result = evaluate(str, evalstart)
37
+ puts result if not result.nil?
38
+ when /^\#ruby\s+(.*)/
39
+ str = line = $1
40
+ while line[-1] == ?\\
41
+ str.chop!
42
+ line = getline
43
+ break if line.nil?
44
+ line.chomp!
45
+ str << line
46
+ end
47
+ result = evaluate(str, @linenum)
48
+ puts result if not result.nil?
49
+ else
50
+ puts line
51
+ end
52
+ end
53
+ success = true
54
+ ensure
55
+ if not success then
56
+ $stderr.puts "Error on line #{@linenum}:"
57
+ end
58
+ end
59
+ end
60
+
61
+ def evaluate(str, linenum)
62
+ result = eval(str, TOPLEVEL_BINDING, @filename, linenum)
63
+ success = true
64
+ return result
65
+ end
66
+
67
+ def puts(line='')
68
+ @output.puts(line)
69
+ end
70
+ end
71
+
72
+ def puts(line='')
73
+ $preprocessor.puts(line)
74
+ end
75
+
76
+ def rubypp(input_file, output_file)
77
+ input = input_file ? File.open(input_file) : $stdin
78
+ output = output_file ? File.open(output_file, 'w') : $stdout
79
+
80
+ success = false
81
+ begin
82
+ $preprocessor = Preprocessor.new(input, output, input_file || "(stdin)")
83
+ $preprocessor.preprocess()
84
+ success = true
85
+ ensure
86
+ if not success then
87
+ File.unlink(output_file) rescue Errno::ENOENT
88
+ end
89
+ end
90
+ end
91
+
92
+ if __FILE__ == $0 then
93
+ input_file = ARGV[0]
94
+ output_file = ARGV[1]
95
+ rubypp(input_file, output_file)
96
+ end
97
+
@@ -0,0 +1,8 @@
1
+ #ifndef Rice__to_from_ruby__hpp_
2
+ #define Rice__to_from_ruby__hpp_
3
+
4
+ #include "to_from_ruby_defn.hpp"
5
+ #include "to_from_ruby.ipp"
6
+
7
+ #endif // Rice__to_from_ruby__hpp_
8
+
@@ -0,0 +1,418 @@
1
+ #include "protect.hpp"
2
+ #include "Object.hpp"
3
+ #include "detail/from_ruby.ipp"
4
+ #include "detail/to_ruby.ipp"
5
+
6
+ // ---------------------------------------------------------------------
7
+ template<>
8
+ inline
9
+ Rice::Object from_ruby<Rice::Object>(Rice::Object x)
10
+ {
11
+ return x;
12
+ }
13
+
14
+ template<>
15
+ inline
16
+ Rice::Object to_ruby<Rice::Object>(Rice::Object const & x)
17
+ {
18
+ return x;
19
+ }
20
+
21
+ // ---------------------------------------------------------------------
22
+ namespace Rice
23
+ {
24
+ namespace detail
25
+ {
26
+ inline short num2short(VALUE x)
27
+ {
28
+ return NUM2SHORT(x);
29
+ }
30
+
31
+ inline VALUE short2num(short x)
32
+ {
33
+ return INT2NUM(x);
34
+ }
35
+ }
36
+ }
37
+
38
+ template<>
39
+ inline
40
+ short from_ruby<short>(Rice::Object x)
41
+ {
42
+ return Rice::detail::num2short(x);
43
+ }
44
+
45
+ template<>
46
+ inline
47
+ Rice::Object to_ruby<short>(short const & x)
48
+ {
49
+ return Rice::protect(Rice::detail::short2num, x);
50
+ }
51
+
52
+ // ---------------------------------------------------------------------
53
+ namespace Rice
54
+ {
55
+ namespace detail
56
+ {
57
+ inline int num2int(VALUE x)
58
+ {
59
+ return NUM2INT(x);
60
+ }
61
+
62
+ inline VALUE int2num(int x)
63
+ {
64
+ return INT2NUM(x);
65
+ }
66
+ }
67
+ }
68
+
69
+ template<>
70
+ inline
71
+ int from_ruby<int>(Rice::Object x)
72
+ {
73
+ return Rice::detail::num2int(x);
74
+ }
75
+
76
+ template<>
77
+ inline
78
+ Rice::Object to_ruby<int>(int const & x)
79
+ {
80
+ return Rice::protect(Rice::detail::int2num, x);
81
+ }
82
+
83
+ // ---------------------------------------------------------------------
84
+ namespace Rice
85
+ {
86
+ namespace detail
87
+ {
88
+ inline long num2long(VALUE x)
89
+ {
90
+ return NUM2LONG(x);
91
+ }
92
+
93
+ inline VALUE long2num(long x)
94
+ {
95
+ return LONG2NUM(x);
96
+ }
97
+ }
98
+ }
99
+
100
+ template<>
101
+ inline
102
+ long from_ruby<long>(Rice::Object x)
103
+ {
104
+ return Rice::protect(Rice::detail::num2long, x);
105
+ }
106
+
107
+ template<>
108
+ inline
109
+ Rice::Object to_ruby<long>(long const & x)
110
+ {
111
+ return Rice::protect(Rice::detail::long2num, x);
112
+ }
113
+
114
+ // ---------------------------------------------------------------------
115
+ namespace Rice
116
+ {
117
+ namespace detail
118
+ {
119
+ inline long long num2longlong(VALUE x)
120
+ {
121
+ return NUM2LL(x);
122
+ }
123
+
124
+ inline VALUE longlong2num(long long x)
125
+ {
126
+ return LL2NUM(x);
127
+ }
128
+ }
129
+ }
130
+
131
+ template<>
132
+ inline
133
+ long long from_ruby<long long>(Rice::Object x)
134
+ {
135
+ return Rice::protect(Rice::detail::num2longlong, x);
136
+ }
137
+
138
+ template<>
139
+ inline
140
+ Rice::Object to_ruby<long long>(long long const & x)
141
+ {
142
+ return Rice::protect(Rice::detail::longlong2num, x);
143
+ }
144
+
145
+ // ---------------------------------------------------------------------
146
+ namespace Rice
147
+ {
148
+ namespace detail
149
+ {
150
+ inline unsigned short num2ushort(VALUE x)
151
+ {
152
+ return NUM2USHORT(x);
153
+ }
154
+
155
+ inline VALUE ushort2num(unsigned short x)
156
+ {
157
+ return UINT2NUM(x);
158
+ }
159
+ }
160
+ }
161
+
162
+ template<>
163
+ inline
164
+ unsigned short from_ruby<unsigned short>(Rice::Object x)
165
+ {
166
+ return Rice::detail::num2ushort(x);
167
+ }
168
+
169
+ template<>
170
+ inline
171
+ Rice::Object to_ruby<unsigned short>(unsigned short const & x)
172
+ {
173
+ return Rice::protect(Rice::detail::ushort2num, x);
174
+ }
175
+
176
+ // ---------------------------------------------------------------------
177
+ namespace Rice
178
+ {
179
+ namespace detail
180
+ {
181
+ inline unsigned int num2uint(VALUE x)
182
+ {
183
+ return NUM2UINT(x);
184
+ }
185
+
186
+ inline VALUE uint2num(unsigned int x)
187
+ {
188
+ return UINT2NUM(x);
189
+ }
190
+ }
191
+ }
192
+
193
+ template<>
194
+ inline
195
+ unsigned int from_ruby<unsigned int>(Rice::Object x)
196
+ {
197
+ return Rice::detail::num2uint(x);
198
+ }
199
+
200
+ template<>
201
+ inline
202
+ Rice::Object to_ruby<unsigned int>(unsigned int const & x)
203
+ {
204
+ return Rice::protect(Rice::detail::uint2num, x);
205
+ }
206
+
207
+ // ---------------------------------------------------------------------
208
+ namespace Rice
209
+ {
210
+ namespace detail
211
+ {
212
+ inline unsigned long num2ulong(VALUE x)
213
+ {
214
+ return NUM2ULONG(x);
215
+ }
216
+
217
+ inline VALUE ulong2num(unsigned long x)
218
+ {
219
+ return ULONG2NUM(x);
220
+ }
221
+ }
222
+ }
223
+
224
+ template<>
225
+ inline
226
+ unsigned long from_ruby<unsigned long>(Rice::Object x)
227
+ {
228
+ return Rice::protect(Rice::detail::num2ulong, x);
229
+ }
230
+
231
+ template<>
232
+ inline
233
+ Rice::Object to_ruby<unsigned long>(unsigned long const & x)
234
+ {
235
+ return Rice::protect(Rice::detail::ulong2num, x);
236
+ }
237
+
238
+ // ---------------------------------------------------------------------
239
+ namespace Rice
240
+ {
241
+ namespace detail
242
+ {
243
+ inline unsigned long long num2ulonglong(VALUE x)
244
+ {
245
+ return NUM2ULL(x);
246
+ }
247
+
248
+ inline VALUE ulonglong2num(unsigned long long x)
249
+ {
250
+ return ULL2NUM(x);
251
+ }
252
+ }
253
+ }
254
+
255
+ template<>
256
+ inline
257
+ unsigned long long from_ruby<unsigned long long>(Rice::Object x)
258
+ {
259
+ return Rice::protect(Rice::detail::num2ulonglong, x);
260
+ }
261
+
262
+ template<>
263
+ inline
264
+ Rice::Object to_ruby<unsigned long long>(unsigned long long const & x)
265
+ {
266
+ return Rice::protect(Rice::detail::ulonglong2num, x);
267
+ }
268
+
269
+ // ---------------------------------------------------------------------
270
+ template<>
271
+ inline
272
+ bool from_ruby<bool>(Rice::Object x)
273
+ {
274
+ return RTEST(x);
275
+ }
276
+
277
+ template<>
278
+ inline
279
+ Rice::Object to_ruby<bool>(bool const & x)
280
+ {
281
+ return x ? Qtrue : Qfalse;
282
+ }
283
+
284
+ // ---------------------------------------------------------------------
285
+ template<>
286
+ inline
287
+ char from_ruby<char>(Rice::Object x)
288
+ {
289
+ if(x.rb_type() == T_STRING)
290
+ {
291
+ if(RSTRING_LEN(x.value()) == 1)
292
+ {
293
+ return RSTRING_PTR(x.value())[0];
294
+ }
295
+ else
296
+ {
297
+ throw std::invalid_argument("from_ruby<char>: string must have length 1");
298
+ }
299
+ }
300
+ else
301
+ {
302
+ return from_ruby<int>(x) & 0xff;
303
+ }
304
+ }
305
+
306
+ template<>
307
+ inline
308
+ Rice::Object to_ruby<char>(char const & x)
309
+ {
310
+ return to_ruby<int>(x);
311
+ }
312
+
313
+ // ---------------------------------------------------------------------
314
+
315
+ template<>
316
+ inline
317
+ unsigned char from_ruby<unsigned char>(Rice::Object x)
318
+ {
319
+ // TODO: I'm not sure if this is the right behavior yet
320
+ return from_ruby<char>(x);
321
+ }
322
+
323
+ template<>
324
+ inline
325
+ Rice::Object to_ruby<unsigned char>(unsigned char const & x)
326
+ {
327
+ return to_ruby<unsigned int>(x);
328
+ }
329
+
330
+ // ---------------------------------------------------------------------
331
+
332
+ namespace Rice
333
+ {
334
+ namespace detail
335
+ {
336
+ inline VALUE num2dbl(VALUE x, double * d)
337
+ {
338
+ *d = NUM2DBL(x);
339
+ return Qnil;
340
+ }
341
+
342
+ inline VALUE dbl2num(double x)
343
+ {
344
+ return rb_float_new(x);
345
+ }
346
+ }
347
+ }
348
+
349
+ template<>
350
+ inline
351
+ float from_ruby<float>(Rice::Object x)
352
+ {
353
+ double d;
354
+ Rice::protect(Rice::detail::num2dbl, x, &d);
355
+ return float(d);
356
+ }
357
+
358
+ template<>
359
+ inline
360
+ Rice::Object to_ruby<float>(float const & x)
361
+ {
362
+ return Rice::protect(Rice::detail::dbl2num, x);
363
+ }
364
+
365
+ // ---------------------------------------------------------------------
366
+
367
+ template<>
368
+ inline
369
+ double from_ruby<double>(Rice::Object x)
370
+ {
371
+ double d;
372
+ Rice::protect(Rice::detail::num2dbl, x, &d);
373
+ return d;
374
+ }
375
+
376
+ template<>
377
+ inline
378
+ Rice::Object to_ruby<double>(double const & x)
379
+ {
380
+ return Rice::protect(Rice::detail::dbl2num, x);
381
+ }
382
+
383
+ // ---------------------------------------------------------------------
384
+ template<>
385
+ inline
386
+ char const * from_ruby<char const *>(Rice::Object x)
387
+ {
388
+ return Rice::String(x).c_str();
389
+ }
390
+
391
+ template<>
392
+ inline
393
+ Rice::Object to_ruby<char const *>(char const * const & x)
394
+ {
395
+ return Rice::protect(rb_str_new2, x);
396
+ }
397
+
398
+ // ---------------------------------------------------------------------
399
+ template<>
400
+ inline
401
+ std::string from_ruby<std::string>(Rice::Object x)
402
+ {
403
+ return Rice::String(x).str();
404
+ }
405
+
406
+ template<>
407
+ inline
408
+ Rice::Object to_ruby<std::string>(std::string const & x)
409
+ {
410
+ return Rice::protect(rb_str_new, x.data(), x.size());
411
+ }
412
+
413
+ template<>
414
+ inline
415
+ std::string* from_ruby<std::string* >(Rice::Object x)
416
+ {
417
+ return new std::string(Rice::String(x).str());
418
+ }