unmixer 0.1.0

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml ADDED
@@ -0,0 +1,7 @@
1
+ ---
2
+ SHA1:
3
+ metadata.gz: 5a952ec2f6409147008426c46f4a15c75786d0a1
4
+ data.tar.gz: de27755a1162205f2f87be49d2ec6ca6bd4ba970
5
+ SHA512:
6
+ metadata.gz: 7fbcb863a733baa48689292bb286add91d43065dd4a4dd453c0b660b6ebf95d66c432e3ede24d80fc63de2df640df53fa960452603f288c764bc2d364beff010
7
+ data.tar.gz: 815580c887f8a318abcc5168b1314e7404f06ef5326db0ac274b1b92a1b3264a3df8feb62cf433c255279d1f6d4d67461d8fa9e263c8dfc40f2c40633c4d15db
data/.gitignore ADDED
@@ -0,0 +1,12 @@
1
+ /.bundle/
2
+ /.yardoc
3
+ /Gemfile.lock
4
+ /_yardoc/
5
+ /coverage/
6
+ /doc/
7
+ /pkg/
8
+ /spec/reports/
9
+ /tmp/
10
+
11
+ # rspec failure tracking
12
+ .rspec_status
data/.rspec ADDED
@@ -0,0 +1,2 @@
1
+ --format documentation
2
+ --color
data/.travis.yml ADDED
@@ -0,0 +1,10 @@
1
+ sudo: false
2
+ language: ruby
3
+ rvm:
4
+ - 2.4.0
5
+ - 2.3.0
6
+ - 2.2.0
7
+ - 2.1.0
8
+ before_install: gem install bundler -v 1.14.3
9
+ before_script:
10
+ - rake compile
data/Gemfile ADDED
@@ -0,0 +1,4 @@
1
+ source 'https://rubygems.org'
2
+
3
+ # Specify your gem's dependencies in unmixer.gemspec
4
+ gemspec
data/README.md ADDED
@@ -0,0 +1,89 @@
1
+ [![Build Status](https://travis-ci.org/osyo-manga/gem-unmixer.svg?branch=master)](https://travis-ci.org/osyo-manga/gem-unmixer)
2
+
3
+ # Unmixer
4
+
5
+ Unmixer is removing mixin modules.
6
+
7
+ ## Installation
8
+
9
+ Add this line to your application's Gemfile:
10
+
11
+ ```ruby
12
+ gem 'unmixer'
13
+ ```
14
+
15
+ And then execute:
16
+
17
+ $ bundle
18
+
19
+ Or install it yourself as:
20
+
21
+ $ gem install unmixer
22
+
23
+ ## Usage
24
+
25
+ ```ruby
26
+ require "unmixer"
27
+
28
+ # unmixer is using refinements.
29
+ using Unmixer
30
+
31
+ module M1; end
32
+ module M2; end
33
+ module M3; end
34
+
35
+ class X
36
+ include M1
37
+ prepend M2
38
+ end
39
+
40
+ p X.ancestors
41
+ # => [M2, X, M1, Object, Kernel, BasicObject]
42
+
43
+ # Remove include module.
44
+ X.instance_eval { uninclude M1 }
45
+ p X.ancestors
46
+ # => [M2, X, Object, Kernel, BasicObject]
47
+
48
+ # Not remove prepend module. #uninclude is only include modules.
49
+ X.instance_eval { uninclude M2 }
50
+ p X.ancestors
51
+ # => [M2, X, Object, Kernel, BasicObject]
52
+
53
+
54
+ # Remove prepend module.
55
+ X.instance_eval { unprepend M2 }
56
+ p X.ancestors
57
+ # => [X, Object, Kernel, BasicObject]
58
+
59
+
60
+ X.extend M3
61
+ p X.singleton_class.ancestors
62
+ # => [#<Class:X>, M3, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
63
+
64
+ # Remove extend module.
65
+ X.unextend M3
66
+ p X.singleton_class.ancestors
67
+ # => [#<Class:X>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
68
+
69
+
70
+ # #extend with block
71
+ X.extend M1 do
72
+ # mixin only in block.
73
+ p X.singleton_class.ancestors
74
+ # => [#<Class:X>, M1, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
75
+ end
76
+ p X.singleton_class.ancestors
77
+ # => [#<Class:X>, #<Class:Object>, #<Class:BasicObject>, Class, Module, Object, Kernel, BasicObject]
78
+ ```
79
+
80
+ ## Development
81
+
82
+ After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
83
+
84
+ To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
85
+
86
+ ## Contributing
87
+
88
+ Bug reports and pull requests are welcome on GitHub at https://github.com/osyo-manga/gem-unmixer.
89
+
data/Rakefile ADDED
@@ -0,0 +1,13 @@
1
+ require "bundler/gem_tasks"
2
+ require "rspec/core/rake_task"
3
+
4
+ RSpec::Core::RakeTask.new(:spec)
5
+
6
+ task :default => :spec
7
+
8
+
9
+ require "rake/extensiontask"
10
+
11
+ Rake::ExtensionTask.new("unmixer") do |ext|
12
+ ext.lib_dir = "lib/unmixer"
13
+ end
data/bin/console ADDED
@@ -0,0 +1,14 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ require "bundler/setup"
4
+ require "unmixer"
5
+
6
+ # You can add fixtures and/or initialization code here to make experimenting
7
+ # with your gem easier. You can also use a different console, if you like.
8
+
9
+ # (If you use this, don't forget to add pry to your Gemfile!)
10
+ # require "pry"
11
+ # Pry.start
12
+
13
+ require "irb"
14
+ IRB.start(__FILE__)
data/bin/setup ADDED
@@ -0,0 +1,8 @@
1
+ #!/usr/bin/env bash
2
+ set -euo pipefail
3
+ IFS=$'\n\t'
4
+ set -vx
5
+
6
+ bundle install
7
+
8
+ # Do any other automated setup that you need to do here
@@ -0,0 +1,889 @@
1
+ /**********************************************************************
2
+
3
+ internal.h -
4
+
5
+ $Author$
6
+ created at: Tue May 17 11:42:20 JST 2011
7
+
8
+ Copyright (C) 2011 Yukihiro Matsumoto
9
+
10
+ **********************************************************************/
11
+
12
+ #ifndef RUBY_INTERNAL_H
13
+ #define RUBY_INTERNAL_H 1
14
+
15
+ #if defined(__cplusplus)
16
+ extern "C" {
17
+ #if 0
18
+ } /* satisfy cc-mode */
19
+ #endif
20
+ #endif
21
+
22
+ #ifdef HAVE_VALGRIND_MEMCHECK_H
23
+ # include <valgrind/memcheck.h>
24
+ # ifndef VALGRIND_MAKE_MEM_DEFINED
25
+ # define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
26
+ # endif
27
+ # ifndef VALGRIND_MAKE_MEM_UNDEFINED
28
+ # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
29
+ # endif
30
+ #else
31
+ # define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
32
+ # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
33
+ #endif
34
+
35
+ #define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
36
+
37
+ #define STATIC_ASSERT(name, expr) typedef int static_assert_##name##_check[1 - 2*!(expr)]
38
+
39
+ #define GCC_VERSION_SINCE(major, minor, patchlevel) \
40
+ (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
41
+ ((__GNUC__ > (major)) || \
42
+ (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \
43
+ (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))
44
+
45
+ #define SIGNED_INTEGER_TYPE_P(int_type) (0 > ((int_type)0)-1)
46
+ #define SIGNED_INTEGER_MAX(sint_type) \
47
+ (sint_type) \
48
+ ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) | \
49
+ ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) - 1))
50
+ #define SIGNED_INTEGER_MIN(sint_type) (-SIGNED_INTEGER_MAX(sint_type)-1)
51
+ #define UNSIGNED_INTEGER_MAX(uint_type) (~(uint_type)0)
52
+
53
+ #if SIGNEDNESS_OF_TIME_T < 0 /* signed */
54
+ # define TIMET_MAX SIGNED_INTEGER_MAX(time_t)
55
+ # define TIMET_MIN SIGNED_INTEGER_MIN(time_t)
56
+ #elif SIGNEDNESS_OF_TIME_T > 0 /* unsigned */
57
+ # define TIMET_MAX UNSIGNED_INTEGER_MAX(time_t)
58
+ # define TIMET_MIN ((time_t)0)
59
+ #endif
60
+ #define TIMET_MAX_PLUS_ONE (2*(double)(TIMET_MAX/2+1))
61
+
62
+ #define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
63
+ (a) == 0 ? 0 : \
64
+ (a) == -1 ? (b) < -(max) : \
65
+ (a) > 0 ? \
66
+ ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
67
+ ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
68
+ #define MUL_OVERFLOW_FIXNUM_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
69
+ #define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
70
+ #define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
71
+
72
+ #ifndef swap16
73
+ # ifdef HAVE_BUILTIN___BUILTIN_BSWAP16
74
+ # define swap16(x) __builtin_bswap16(x)
75
+ # endif
76
+ #endif
77
+
78
+ #ifndef swap16
79
+ # define swap16(x) ((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
80
+ #endif
81
+
82
+ #ifndef swap32
83
+ # ifdef HAVE_BUILTIN___BUILTIN_BSWAP32
84
+ # define swap32(x) __builtin_bswap32(x)
85
+ # endif
86
+ #endif
87
+
88
+ #ifndef swap32
89
+ # define swap32(x) ((uint32_t)((((x)&0xFF)<<24) \
90
+ |(((x)>>24)&0xFF) \
91
+ |(((x)&0x0000FF00)<<8) \
92
+ |(((x)&0x00FF0000)>>8) ))
93
+ #endif
94
+
95
+ #ifndef swap64
96
+ # ifdef HAVE_BUILTIN___BUILTIN_BSWAP64
97
+ # define swap64(x) __builtin_bswap64(x)
98
+ # endif
99
+ #endif
100
+
101
+ #ifndef swap64
102
+ # ifdef HAVE_INT64_T
103
+ # define byte_in_64bit(n) ((uint64_t)0xff << (n))
104
+ # define swap64(x) ((uint64_t)((((x)&byte_in_64bit(0))<<56) \
105
+ |(((x)>>56)&0xFF) \
106
+ |(((x)&byte_in_64bit(8))<<40) \
107
+ |(((x)&byte_in_64bit(48))>>40) \
108
+ |(((x)&byte_in_64bit(16))<<24) \
109
+ |(((x)&byte_in_64bit(40))>>24) \
110
+ |(((x)&byte_in_64bit(24))<<8) \
111
+ |(((x)&byte_in_64bit(32))>>8)))
112
+ # endif
113
+ #endif
114
+
115
+ static inline int
116
+ nlz_int(unsigned int x)
117
+ {
118
+ #if defined(HAVE_BUILTIN___BUILTIN_CLZ)
119
+ if (x == 0) return SIZEOF_INT * CHAR_BIT;
120
+ return __builtin_clz(x);
121
+ #else
122
+ unsigned int y;
123
+ # if 64 < SIZEOF_INT * CHAR_BIT
124
+ int n = 128;
125
+ # elif 32 < SIZEOF_INT * CHAR_BIT
126
+ int n = 64;
127
+ # else
128
+ int n = 32;
129
+ # endif
130
+ # if 64 < SIZEOF_INT * CHAR_BIT
131
+ y = x >> 64; if (y) {n -= 64; x = y;}
132
+ # endif
133
+ # if 32 < SIZEOF_INT * CHAR_BIT
134
+ y = x >> 32; if (y) {n -= 32; x = y;}
135
+ # endif
136
+ y = x >> 16; if (y) {n -= 16; x = y;}
137
+ y = x >> 8; if (y) {n -= 8; x = y;}
138
+ y = x >> 4; if (y) {n -= 4; x = y;}
139
+ y = x >> 2; if (y) {n -= 2; x = y;}
140
+ y = x >> 1; if (y) {return n - 2;}
141
+ return (int)(n - x);
142
+ #endif
143
+ }
144
+
145
+ static inline int
146
+ nlz_long(unsigned long x)
147
+ {
148
+ #if defined(HAVE_BUILTIN___BUILTIN_CLZL)
149
+ if (x == 0) return SIZEOF_LONG * CHAR_BIT;
150
+ return __builtin_clzl(x);
151
+ #else
152
+ unsigned long y;
153
+ # if 64 < SIZEOF_LONG * CHAR_BIT
154
+ int n = 128;
155
+ # elif 32 < SIZEOF_LONG * CHAR_BIT
156
+ int n = 64;
157
+ # else
158
+ int n = 32;
159
+ # endif
160
+ # if 64 < SIZEOF_LONG * CHAR_BIT
161
+ y = x >> 64; if (y) {n -= 64; x = y;}
162
+ # endif
163
+ # if 32 < SIZEOF_LONG * CHAR_BIT
164
+ y = x >> 32; if (y) {n -= 32; x = y;}
165
+ # endif
166
+ y = x >> 16; if (y) {n -= 16; x = y;}
167
+ y = x >> 8; if (y) {n -= 8; x = y;}
168
+ y = x >> 4; if (y) {n -= 4; x = y;}
169
+ y = x >> 2; if (y) {n -= 2; x = y;}
170
+ y = x >> 1; if (y) {return n - 2;}
171
+ return (int)(n - x);
172
+ #endif
173
+ }
174
+
175
+ #ifdef HAVE_LONG_LONG
176
+ static inline int
177
+ nlz_long_long(unsigned LONG_LONG x)
178
+ {
179
+ #if defined(HAVE_BUILTIN___BUILTIN_CLZLL)
180
+ if (x == 0) return SIZEOF_LONG_LONG * CHAR_BIT;
181
+ return __builtin_clzll(x);
182
+ #else
183
+ unsigned LONG_LONG y;
184
+ # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
185
+ int n = 128;
186
+ # elif 32 < SIZEOF_LONG_LONG * CHAR_BIT
187
+ int n = 64;
188
+ # else
189
+ int n = 32;
190
+ # endif
191
+ # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
192
+ y = x >> 64; if (y) {n -= 64; x = y;}
193
+ # endif
194
+ # if 32 < SIZEOF_LONG_LONG * CHAR_BIT
195
+ y = x >> 32; if (y) {n -= 32; x = y;}
196
+ # endif
197
+ y = x >> 16; if (y) {n -= 16; x = y;}
198
+ y = x >> 8; if (y) {n -= 8; x = y;}
199
+ y = x >> 4; if (y) {n -= 4; x = y;}
200
+ y = x >> 2; if (y) {n -= 2; x = y;}
201
+ y = x >> 1; if (y) {return n - 2;}
202
+ return (int)(n - x);
203
+ #endif
204
+ }
205
+ #endif
206
+
207
+ #ifdef HAVE_UINT128_T
208
+ static inline int
209
+ nlz_int128(uint128_t x)
210
+ {
211
+ uint128_t y;
212
+ int n = 128;
213
+ y = x >> 64; if (y) {n -= 64; x = y;}
214
+ y = x >> 32; if (y) {n -= 32; x = y;}
215
+ y = x >> 16; if (y) {n -= 16; x = y;}
216
+ y = x >> 8; if (y) {n -= 8; x = y;}
217
+ y = x >> 4; if (y) {n -= 4; x = y;}
218
+ y = x >> 2; if (y) {n -= 2; x = y;}
219
+ y = x >> 1; if (y) {return n - 2;}
220
+ return (int)(n - x);
221
+ }
222
+ #endif
223
+
224
+ #if defined(HAVE_UINT128_T)
225
+ # define bit_length(x) \
226
+ (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
227
+ sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
228
+ sizeof(x) <= SIZEOF_LONG_LONG ? SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)) : \
229
+ SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
230
+ #elif defined(HAVE_LONG_LONG)
231
+ # define bit_length(x) \
232
+ (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
233
+ sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
234
+ SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)))
235
+ #else
236
+ # define bit_length(x) \
237
+ (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
238
+ SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)))
239
+ #endif
240
+
241
+ struct rb_deprecated_classext_struct {
242
+ char conflict[sizeof(VALUE) * 3];
243
+ };
244
+
245
+ struct rb_subclass_entry;
246
+ typedef struct rb_subclass_entry rb_subclass_entry_t;
247
+
248
+ struct rb_subclass_entry {
249
+ VALUE klass;
250
+ rb_subclass_entry_t *next;
251
+ };
252
+
253
+ #if defined(HAVE_LONG_LONG)
254
+ typedef unsigned LONG_LONG rb_serial_t;
255
+ #define SERIALT2NUM ULL2NUM
256
+ #elif defined(HAVE_UINT64_T)
257
+ typedef uint64_t rb_serial_t;
258
+ #define SERIALT2NUM SIZET2NUM
259
+ #else
260
+ typedef unsigned long rb_serial_t;
261
+ #define SERIALT2NUM ULONG2NUM
262
+ #endif
263
+
264
+ struct rb_classext_struct {
265
+ struct st_table *iv_index_tbl;
266
+ struct st_table *iv_tbl;
267
+ struct st_table *const_tbl;
268
+ rb_subclass_entry_t *subclasses;
269
+ rb_subclass_entry_t **parent_subclasses;
270
+ /**
271
+ * In the case that this is an `ICLASS`, `module_subclasses` points to the link
272
+ * in the module's `subclasses` list that indicates that the klass has been
273
+ * included. Hopefully that makes sense.
274
+ */
275
+ rb_subclass_entry_t **module_subclasses;
276
+ rb_serial_t class_serial;
277
+ VALUE origin;
278
+ VALUE refined_class;
279
+ rb_alloc_func_t allocator;
280
+ };
281
+
282
+ struct method_table_wrapper {
283
+ st_table *tbl;
284
+ size_t serial;
285
+ };
286
+
287
+ /* class.c */
288
+ void rb_class_subclass_add(VALUE super, VALUE klass);
289
+ void rb_class_remove_from_super_subclasses(VALUE);
290
+
291
+ #define RCLASS_EXT(c) (RCLASS(c)->ptr)
292
+ #define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
293
+ #define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
294
+ #define RCLASS_M_TBL_WRAPPER(c) (RCLASS(c)->m_tbl_wrapper)
295
+ #define RCLASS_M_TBL(c) (RCLASS_M_TBL_WRAPPER(c) ? RCLASS_M_TBL_WRAPPER(c)->tbl : 0)
296
+ #define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
297
+ #define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin)
298
+ #define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
299
+ #define RCLASS_SERIAL(c) (RCLASS_EXT(c)->class_serial)
300
+
301
+ static inline void
302
+ RCLASS_M_TBL_INIT(VALUE c)
303
+ {
304
+ struct method_table_wrapper *wrapper;
305
+ wrapper = ALLOC(struct method_table_wrapper);
306
+ wrapper->tbl = st_init_numtable();
307
+ wrapper->serial = 0;
308
+ RCLASS_M_TBL_WRAPPER(c) = wrapper;
309
+ }
310
+
311
+ #undef RCLASS_SUPER
312
+ static inline VALUE
313
+ RCLASS_SUPER(VALUE klass)
314
+ {
315
+ return RCLASS(klass)->super;
316
+ }
317
+
318
+ static inline VALUE
319
+ RCLASS_SET_SUPER(VALUE klass, VALUE super)
320
+ {
321
+ if (super) {
322
+ rb_class_remove_from_super_subclasses(klass);
323
+ rb_class_subclass_add(super, klass);
324
+ }
325
+ RB_OBJ_WRITE(klass, &RCLASS(klass)->super, super);
326
+ return super;
327
+ }
328
+
329
+ struct vtm; /* defined by timev.h */
330
+
331
+ /* array.c */
332
+ VALUE rb_ary_last(int, VALUE *, VALUE);
333
+ void rb_ary_set_len(VALUE, long);
334
+ void rb_ary_delete_same(VALUE, VALUE);
335
+
336
+ /* bignum.c */
337
+ VALUE rb_big_fdiv(VALUE x, VALUE y);
338
+ VALUE rb_big_uminus(VALUE x);
339
+ VALUE rb_integer_float_cmp(VALUE x, VALUE y);
340
+ VALUE rb_integer_float_eq(VALUE x, VALUE y);
341
+
342
+ /* class.c */
343
+ void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE));
344
+ void rb_class_detach_subclasses(VALUE);
345
+ void rb_class_detach_module_subclasses(VALUE);
346
+ void rb_class_remove_from_module_subclasses(VALUE);
347
+ VALUE rb_obj_methods(int argc, VALUE *argv, VALUE obj);
348
+ VALUE rb_obj_protected_methods(int argc, VALUE *argv, VALUE obj);
349
+ VALUE rb_obj_private_methods(int argc, VALUE *argv, VALUE obj);
350
+ VALUE rb_obj_public_methods(int argc, VALUE *argv, VALUE obj);
351
+ int rb_obj_basic_to_s_p(VALUE);
352
+ VALUE rb_special_singleton_class(VALUE);
353
+ VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach);
354
+ VALUE rb_singleton_class_get(VALUE obj);
355
+ void Init_class_hierarchy(void);
356
+
357
+ /* compar.c */
358
+ VALUE rb_invcmp(VALUE, VALUE);
359
+
360
+ /* compile.c */
361
+ int rb_dvar_defined(ID);
362
+ int rb_local_defined(ID);
363
+ int rb_parse_in_eval(void);
364
+ int rb_parse_in_main(void);
365
+ const char * rb_insns_name(int i);
366
+ VALUE rb_insns_name_array(void);
367
+
368
+ /* cont.c */
369
+ VALUE rb_obj_is_fiber(VALUE);
370
+ void rb_fiber_reset_root_local_storage(VALUE);
371
+ void ruby_register_rollback_func_for_ensure(VALUE (*ensure_func)(ANYARGS), VALUE (*rollback_func)(ANYARGS));
372
+
373
+ /* debug.c */
374
+ PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
375
+
376
+ /* dmyext.c */
377
+ void Init_ext(void);
378
+
379
+ /* encoding.c */
380
+ #ifdef RUBY_ENCODING_H
381
+ enum ruby_preserved_encindex {
382
+ ENCINDEX_ASCII,
383
+ ENCINDEX_UTF_8,
384
+ ENCINDEX_US_ASCII,
385
+
386
+ /* preserved indexes */
387
+ ENCINDEX_UTF_16BE,
388
+ ENCINDEX_UTF_16LE,
389
+ ENCINDEX_UTF_32BE,
390
+ ENCINDEX_UTF_32LE,
391
+ ENCINDEX_UTF_16,
392
+ ENCINDEX_UTF_32,
393
+ ENCINDEX_UTF8_MAC,
394
+
395
+ /* for old options of regexp */
396
+ ENCINDEX_EUC_JP,
397
+ ENCINDEX_Windows_31J,
398
+
399
+ ENCINDEX_BUILTIN_MAX
400
+ };
401
+ #endif
402
+ #define rb_ascii8bit_encindex() ENCINDEX_ASCII
403
+ #define rb_utf8_encindex() ENCINDEX_UTF_8
404
+ #define rb_usascii_encindex() ENCINDEX_US_ASCII
405
+ ID rb_id_encoding(void);
406
+ void rb_gc_mark_encodings(void);
407
+
408
+ /* error.c */
409
+ NORETURN(PRINTF_ARGS(void rb_compile_bug(const char*, int, const char*, ...), 3, 4));
410
+ VALUE rb_check_backtrace(VALUE);
411
+ NORETURN(void rb_async_bug_errno(const char *,int));
412
+ const char *rb_builtin_type_name(int t);
413
+ const char *rb_builtin_class_name(VALUE x);
414
+
415
+ /* eval.c */
416
+ VALUE rb_refinement_module_get_refined_class(VALUE module);
417
+
418
+ /* eval_error.c */
419
+ void ruby_error_print(void);
420
+ VALUE rb_get_backtrace(VALUE info);
421
+
422
+ /* eval_jump.c */
423
+ void rb_call_end_proc(VALUE data);
424
+ void rb_mark_end_proc(void);
425
+
426
+ /* file.c */
427
+ VALUE rb_home_dir_of(VALUE user, VALUE result);
428
+ VALUE rb_default_home_dir(VALUE result);
429
+ VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
430
+ void rb_file_const(const char*, VALUE);
431
+ int rb_file_load_ok(const char *);
432
+ VALUE rb_file_expand_path_fast(VALUE, VALUE);
433
+ VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE);
434
+ VALUE rb_get_path_check_to_string(VALUE, int);
435
+ VALUE rb_get_path_check_convert(VALUE, VALUE, int);
436
+ void Init_File(void);
437
+
438
+ #ifdef RUBY_FUNCTION_NAME_STRING
439
+ # if defined __GNUC__ && __GNUC__ >= 4
440
+ # pragma GCC visibility push(default)
441
+ # endif
442
+ NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
443
+ NORETURN(void rb_syserr_fail_path_in(const char *func_name, int err, VALUE path));
444
+ # if defined __GNUC__ && __GNUC__ >= 4
445
+ # pragma GCC visibility pop
446
+ # endif
447
+ # define rb_sys_fail_path(path) rb_sys_fail_path_in(RUBY_FUNCTION_NAME_STRING, path)
448
+ # define rb_syserr_fail_path(err, path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
449
+ #else
450
+ # define rb_sys_fail_path(path) rb_sys_fail_str(path)
451
+ # define rb_syserr_fail_path(err, path) rb_syserr_fail_str((err), (path))
452
+ #endif
453
+
454
+ /* gc.c */
455
+ void Init_heap(void);
456
+ void *ruby_mimmalloc(size_t size);
457
+ void ruby_mimfree(void *ptr);
458
+ void rb_objspace_set_event_hook(const rb_event_flag_t event);
459
+ void rb_gc_writebarrier_remember_promoted(VALUE obj);
460
+ void ruby_gc_set_params(int safe_level);
461
+
462
+ #if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
463
+ #define ruby_sized_xrealloc(ptr, new_size, old_size) ruby_xrealloc(ptr, new_size)
464
+ #define ruby_sized_xrealloc2(ptr, new_count, element_size, old_count) ruby_xrealloc(ptr, new_count, element_size)
465
+ #define ruby_sized_xfree(ptr, size) ruby_xfree(ptr)
466
+ #define SIZED_REALLOC_N(var,type,n,old_n) REALLOC_N(var, type, n)
467
+ #else
468
+ void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_ALLOC_SIZE((2));
469
+ void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_ALLOC_SIZE((2, 3));
470
+ void ruby_sized_xfree(void *x, size_t size);
471
+ #define SIZED_REALLOC_N(var,type,n,old_n) ((var)=(type*)ruby_sized_xrealloc((char*)(var), (n) * sizeof(type), (old_n) * sizeof(type)))
472
+ #endif
473
+
474
+ void rb_gc_resurrect(VALUE ptr);
475
+
476
+ /* hash.c */
477
+ struct st_table *rb_hash_tbl_raw(VALUE hash);
478
+ #define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h)
479
+ VALUE rb_hash_keys(VALUE hash);
480
+ VALUE rb_hash_values(VALUE hash);
481
+ #define HASH_DELETED FL_USER1
482
+ #define HASH_PROC_DEFAULT FL_USER2
483
+
484
+ /* inits.c */
485
+ void rb_call_inits(void);
486
+
487
+ /* io.c */
488
+ const char *ruby_get_inplace_mode(void);
489
+ void ruby_set_inplace_mode(const char *);
490
+ ssize_t rb_io_bufread(VALUE io, void *buf, size_t size);
491
+ void rb_stdio_set_default_encoding(void);
492
+ void rb_write_error_str(VALUE mesg);
493
+ VALUE rb_io_flush_raw(VALUE, int);
494
+
495
+ /* iseq.c */
496
+ VALUE rb_iseq_clone(VALUE iseqval, VALUE newcbase);
497
+ VALUE rb_iseq_path(VALUE iseqval);
498
+ VALUE rb_iseq_absolute_path(VALUE iseqval);
499
+ VALUE rb_iseq_label(VALUE iseqval);
500
+ VALUE rb_iseq_base_label(VALUE iseqval);
501
+ VALUE rb_iseq_first_lineno(VALUE iseqval);
502
+ VALUE rb_iseq_klass(VALUE iseqval); /* completely temporary fucntion */
503
+ VALUE rb_iseq_method_name(VALUE self);
504
+
505
+ /* load.c */
506
+ VALUE rb_get_load_path(void);
507
+ VALUE rb_get_expanded_load_path(void);
508
+ NORETURN(void rb_load_fail(VALUE, const char*));
509
+
510
+ /* math.c */
511
+ VALUE rb_math_atan2(VALUE, VALUE);
512
+ VALUE rb_math_cos(VALUE);
513
+ VALUE rb_math_cosh(VALUE);
514
+ VALUE rb_math_exp(VALUE);
515
+ VALUE rb_math_hypot(VALUE, VALUE);
516
+ VALUE rb_math_log(int argc, VALUE *argv);
517
+ VALUE rb_math_sin(VALUE);
518
+ VALUE rb_math_sinh(VALUE);
519
+ VALUE rb_math_sqrt(VALUE);
520
+
521
+ /* newline.c */
522
+ void Init_newline(void);
523
+
524
+ /* numeric.c */
525
+ int rb_num_to_uint(VALUE val, unsigned int *ret);
526
+ VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
527
+ int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl);
528
+ double ruby_float_mod(double x, double y);
529
+ int rb_num_negative_p(VALUE);
530
+ VALUE rb_int_succ(VALUE num);
531
+ VALUE rb_int_pred(VALUE num);
532
+
533
+ #if USE_FLONUM
534
+ #define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
535
+ #define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
536
+ #endif
537
+
538
+ static inline double
539
+ rb_float_value_inline(VALUE v)
540
+ {
541
+ #if USE_FLONUM
542
+ if (FLONUM_P(v)) {
543
+ if (v != (VALUE)0x8000000000000002) { /* LIKELY */
544
+ union {
545
+ double d;
546
+ VALUE v;
547
+ } t;
548
+
549
+ VALUE b63 = (v >> 63);
550
+ /* e: xx1... -> 011... */
551
+ /* xx0... -> 100... */
552
+ /* ^b63 */
553
+ t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~0x03), 3);
554
+ return t.d;
555
+ }
556
+ else {
557
+ return 0.0;
558
+ }
559
+ }
560
+ #endif
561
+ return ((struct RFloat *)v)->float_value;
562
+ }
563
+
564
+ static inline VALUE
565
+ rb_float_new_inline(double d)
566
+ {
567
+ #if USE_FLONUM
568
+ union {
569
+ double d;
570
+ VALUE v;
571
+ } t;
572
+ int bits;
573
+
574
+ t.d = d;
575
+ bits = (int)((VALUE)(t.v >> 60) & 0x7);
576
+ /* bits contains 3 bits of b62..b60. */
577
+ /* bits - 3 = */
578
+ /* b011 -> b000 */
579
+ /* b100 -> b001 */
580
+
581
+ if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
582
+ !((bits-3) & ~0x01)) {
583
+ return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
584
+ }
585
+ else if (t.v == (VALUE)0) {
586
+ /* +0.0 */
587
+ return 0x8000000000000002;
588
+ }
589
+ /* out of range */
590
+ #endif
591
+ return rb_float_new_in_heap(d);
592
+ }
593
+
594
+ #define rb_float_value(v) rb_float_value_inline(v)
595
+ #define rb_float_new(d) rb_float_new_inline(d)
596
+
597
+ /* object.c */
598
+ VALUE rb_obj_equal(VALUE obj1, VALUE obj2);
599
+
600
+ struct RBasicRaw {
601
+ VALUE flags;
602
+ VALUE klass;
603
+ };
604
+
605
+ #define RBASIC_CLEAR_CLASS(obj) (((struct RBasicRaw *)((VALUE)(obj)))->klass = 0)
606
+ #define RBASIC_SET_CLASS_RAW(obj, cls) (((struct RBasicRaw *)((VALUE)(obj)))->klass = (cls))
607
+ #define RBASIC_SET_CLASS(obj, cls) do { \
608
+ VALUE _obj_ = (obj); \
609
+ RB_OBJ_WRITE(_obj_, &((struct RBasicRaw *)(_obj_))->klass, cls); \
610
+ } while (0)
611
+
612
+ /* parse.y */
613
+ VALUE rb_parser_get_yydebug(VALUE);
614
+ VALUE rb_parser_set_yydebug(VALUE, VALUE);
615
+ int rb_is_const_name(VALUE name);
616
+ int rb_is_class_name(VALUE name);
617
+ int rb_is_global_name(VALUE name);
618
+ int rb_is_instance_name(VALUE name);
619
+ int rb_is_attrset_name(VALUE name);
620
+ int rb_is_local_name(VALUE name);
621
+ int rb_is_method_name(VALUE name);
622
+ int rb_is_junk_name(VALUE name);
623
+ void rb_gc_mark_parser(void);
624
+ void rb_gc_mark_symbols(int full_mark);
625
+
626
+ /* proc.c */
627
+ VALUE rb_proc_location(VALUE self);
628
+ st_index_t rb_hash_proc(st_index_t hash, VALUE proc);
629
+ int rb_block_arity(void);
630
+
631
+ /* process.c */
632
+ #define RB_MAX_GROUPS (65536)
633
+
634
+ struct rb_execarg {
635
+ int use_shell;
636
+ union {
637
+ struct {
638
+ VALUE shell_script;
639
+ } sh;
640
+ struct {
641
+ VALUE command_name;
642
+ VALUE command_abspath; /* full path string or nil */
643
+ VALUE argv_str;
644
+ VALUE argv_buf;
645
+ } cmd;
646
+ } invoke;
647
+ VALUE redirect_fds;
648
+ VALUE envp_str;
649
+ VALUE envp_buf;
650
+ VALUE dup2_tmpbuf;
651
+ unsigned pgroup_given : 1;
652
+ unsigned umask_given : 1;
653
+ unsigned unsetenv_others_given : 1;
654
+ unsigned unsetenv_others_do : 1;
655
+ unsigned close_others_given : 1;
656
+ unsigned close_others_do : 1;
657
+ unsigned chdir_given : 1;
658
+ unsigned new_pgroup_given : 1;
659
+ unsigned new_pgroup_flag : 1;
660
+ unsigned uid_given : 1;
661
+ unsigned gid_given : 1;
662
+ rb_pid_t pgroup_pgid; /* asis(-1), new pgroup(0), specified pgroup (0<V). */
663
+ VALUE rlimit_limits; /* Qfalse or [[rtype, softlim, hardlim], ...] */
664
+ mode_t umask_mask;
665
+ rb_uid_t uid;
666
+ rb_gid_t gid;
667
+ VALUE fd_dup2;
668
+ VALUE fd_close;
669
+ VALUE fd_open;
670
+ VALUE fd_dup2_child;
671
+ int close_others_maxhint;
672
+ VALUE env_modification; /* Qfalse or [[k1,v1], ...] */
673
+ VALUE chdir_dir;
674
+ };
675
+
676
+ /* argv_str contains extra two elements.
677
+ * The beginning one is for /bin/sh used by exec_with_sh.
678
+ * The last one for terminating NULL used by execve.
679
+ * See rb_exec_fillarg() in process.c. */
680
+ #define ARGVSTR2ARGC(argv_str) (RSTRING_LEN(argv_str) / sizeof(char *) - 2)
681
+ #define ARGVSTR2ARGV(argv_str) ((char **)RSTRING_PTR(argv_str) + 1)
682
+
683
+ rb_pid_t rb_fork_ruby(int *status);
684
+ void rb_last_status_clear(void);
685
+
686
+ /* rational.c */
687
+ VALUE rb_lcm(VALUE x, VALUE y);
688
+ VALUE rb_rational_reciprocal(VALUE x);
689
+
690
+ /* re.c */
691
+ VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
692
+ VALUE rb_reg_check_preprocess(VALUE);
693
+
694
+ /* signal.c */
695
+ int rb_get_next_signal(void);
696
+ int rb_sigaltstack_size(void);
697
+
698
+ /* strftime.c */
699
+ #ifdef RUBY_ENCODING_H
700
+ size_t rb_strftime_timespec(char *s, size_t maxsize, const char *format, rb_encoding *enc,
701
+ const struct vtm *vtm, struct timespec *ts, int gmt);
702
+ size_t rb_strftime(char *s, size_t maxsize, const char *format, rb_encoding *enc,
703
+ const struct vtm *vtm, VALUE timev, int gmt);
704
+ #endif
705
+
706
+ /* string.c */
707
+ VALUE rb_fstring(VALUE);
708
+ int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
709
+ int rb_str_symname_p(VALUE);
710
+ VALUE rb_str_quote_unprintable(VALUE);
711
+ VALUE rb_id_quote_unprintable(ID);
712
+ #define QUOTE(str) rb_str_quote_unprintable(str)
713
+ #define QUOTE_ID(id) rb_id_quote_unprintable(id)
714
+ void rb_str_fill_terminator(VALUE str, const int termlen);
715
+ VALUE rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg);
716
+ #ifdef RUBY_ENCODING_H
717
+ VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc);
718
+ #endif
719
+ #define STR_NOEMBED FL_USER1
720
+ #define STR_SHARED FL_USER2 /* = ELTS_SHARED */
721
+ #define STR_ASSOC FL_USER3
722
+ #define STR_SHARED_P(s) FL_ALL((s), STR_NOEMBED|ELTS_SHARED)
723
+ #define STR_ASSOC_P(s) FL_ALL((s), STR_NOEMBED|STR_ASSOC)
724
+ #define STR_NOCAPA (STR_NOEMBED|ELTS_SHARED|STR_ASSOC)
725
+ #define STR_NOCAPA_P(s) (FL_TEST((s),STR_NOEMBED) && FL_ANY((s),ELTS_SHARED|STR_ASSOC))
726
+ #define STR_EMBED_P(str) (!FL_TEST((str), STR_NOEMBED))
727
+ #define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
728
+ #define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
729
+
730
+ /* struct.c */
731
+ VALUE rb_struct_init_copy(VALUE copy, VALUE s);
732
+
733
+ /* time.c */
734
+ struct timeval rb_time_timeval(VALUE);
735
+
736
+ /* thread.c */
737
+ VALUE rb_obj_is_mutex(VALUE obj);
738
+ VALUE rb_suppress_tracing(VALUE (*func)(VALUE), VALUE arg);
739
+ void rb_thread_execute_interrupts(VALUE th);
740
+ void rb_clear_trace_func(void);
741
+ VALUE rb_get_coverages(void);
742
+ VALUE rb_thread_shield_new(void);
743
+ VALUE rb_thread_shield_wait(VALUE self);
744
+ VALUE rb_thread_shield_release(VALUE self);
745
+ VALUE rb_thread_shield_destroy(VALUE self);
746
+ void rb_mutex_allow_trap(VALUE self, int val);
747
+ VALUE rb_uninterruptible(VALUE (*b_proc)(ANYARGS), VALUE data);
748
+ VALUE rb_mutex_owned_p(VALUE self);
749
+ void ruby_kill(rb_pid_t pid, int sig);
750
+
751
+ /* thread_pthread.c, thread_win32.c */
752
+ void Init_native_thread(void);
753
+
754
+ /* vm_insnhelper.h */
755
+ rb_serial_t rb_next_class_serial(void);
756
+
757
+ /* vm.c */
758
+ VALUE rb_obj_is_thread(VALUE obj);
759
+ void rb_vm_mark(void *ptr);
760
+ void Init_BareVM(void);
761
+ VALUE rb_vm_top_self(void);
762
+ void rb_thread_recycle_stack_release(VALUE *);
763
+ void rb_vm_change_state(void);
764
+ void rb_vm_inc_const_missing_count(void);
765
+ void rb_thread_mark(void *th);
766
+ const void **rb_vm_get_insns_address_table(void);
767
+ VALUE rb_sourcefilename(void);
768
+
769
+ /* vm_dump.c */
770
+ void rb_vm_bugreport(void);
771
+ void rb_print_backtrace(void);
772
+
773
+ /* vm_eval.c */
774
+ void Init_vm_eval(void);
775
+ VALUE rb_current_realfilepath(void);
776
+ VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE);
777
+ typedef void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE);
778
+ VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv,
779
+ rb_check_funcall_hook *hook, VALUE arg);
780
+ VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, int *stateptr);
781
+
782
+ /* vm_insnhelper.c */
783
+ VALUE rb_equal_opt(VALUE obj1, VALUE obj2);
784
+ int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *);
785
+ VALUE rb_extract_keywords(VALUE *orighash);
786
+
787
+ /* vm_method.c */
788
+ void Init_eval_method(void);
789
+ int rb_method_defined_by(VALUE obj, ID mid, VALUE (*cfunc)(ANYARGS));
790
+
791
+ /* miniprelude.c, prelude.c */
792
+ void Init_prelude(void);
793
+
794
+ /* vm_backtrace.c */
795
+ void Init_vm_backtrace(void);
796
+ VALUE rb_vm_thread_backtrace(int argc, VALUE *argv, VALUE thval);
797
+ VALUE rb_vm_thread_backtrace_locations(int argc, VALUE *argv, VALUE thval);
798
+
799
+ VALUE rb_make_backtrace(void);
800
+ void rb_backtrace_print_as_bugreport(void);
801
+ int rb_backtrace_p(VALUE obj);
802
+ VALUE rb_backtrace_to_str_ary(VALUE obj);
803
+ VALUE rb_backtrace_to_location_ary(VALUE obj);
804
+ void rb_backtrace_print_to(VALUE output);
805
+ VALUE rb_vm_backtrace_object(void);
806
+
807
+ RUBY_SYMBOL_EXPORT_BEGIN
808
+ const char *rb_objspace_data_type_name(VALUE obj);
809
+
810
+ /* Temporary. This API will be removed (renamed). */
811
+ VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd);
812
+
813
+ /* bignum.c */
814
+ VALUE rb_big_mul_normal(VALUE x, VALUE y);
815
+ VALUE rb_big_mul_balance(VALUE x, VALUE y);
816
+ VALUE rb_big_mul_karatsuba(VALUE x, VALUE y);
817
+ VALUE rb_big_mul_toom3(VALUE x, VALUE y);
818
+ VALUE rb_big_sq_fast(VALUE x);
819
+ VALUE rb_big_divrem_normal(VALUE x, VALUE y);
820
+ VALUE rb_big2str_poweroftwo(VALUE x, int base);
821
+ VALUE rb_big2str_generic(VALUE x, int base);
822
+ VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck);
823
+ VALUE rb_str2big_normal(VALUE arg, int base, int badcheck);
824
+ VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck);
825
+ #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
826
+ VALUE rb_big_mul_gmp(VALUE x, VALUE y);
827
+ VALUE rb_big_divrem_gmp(VALUE x, VALUE y);
828
+ VALUE rb_big2str_gmp(VALUE x, int base);
829
+ VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
830
+ #endif
831
+
832
+ /* error.c */
833
+ int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
834
+
835
+ /* file.c */
836
+ #ifdef __APPLE__
837
+ VALUE rb_str_normalize_ospath(const char *ptr, long len);
838
+ #endif
839
+
840
+ /* io.c */
841
+ void rb_maygvl_fd_fix_cloexec(int fd);
842
+
843
+ /* numeric.c */
844
+ VALUE rb_int_positive_pow(long x, unsigned long y);
845
+
846
+ /* process.c */
847
+ int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen);
848
+ rb_pid_t rb_fork_async_signal_safe(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, char *errmsg, size_t errmsg_buflen);
849
+ VALUE rb_execarg_new(int argc, VALUE *argv, int accept_shell);
850
+ struct rb_execarg *rb_execarg_get(VALUE execarg_obj); /* dangerous. needs GC guard. */
851
+ VALUE rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj);
852
+ int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val);
853
+ void rb_execarg_fixup(VALUE execarg_obj);
854
+ int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char* errmsg, size_t errmsg_buflen);
855
+ VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash);
856
+ void rb_execarg_setenv(VALUE execarg_obj, VALUE env);
857
+
858
+ /* rational.c */
859
+ VALUE rb_gcd_normal(VALUE self, VALUE other);
860
+ #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
861
+ VALUE rb_gcd_gmp(VALUE x, VALUE y);
862
+ #endif
863
+
864
+ /* util.c */
865
+ extern const signed char ruby_digit36_to_number_table[];
866
+
867
+ /* variable.c */
868
+ void rb_gc_mark_global_tbl(void);
869
+ void rb_mark_generic_ivar(VALUE);
870
+ void rb_mark_generic_ivar_tbl(void);
871
+
872
+ int rb_st_insert_id_and_value(VALUE obj, st_table *tbl, ID key, VALUE value);
873
+ st_table *rb_st_copy(VALUE obj, struct st_table *orig_tbl);
874
+
875
+ /* gc.c */
876
+ size_t rb_obj_memsize_of(VALUE);
877
+ #define RB_OBJ_GC_FLAGS_MAX 5
878
+ size_t rb_obj_gc_flags(VALUE, ID[], size_t);
879
+
880
+ RUBY_SYMBOL_EXPORT_END
881
+
882
+ #if defined(__cplusplus)
883
+ #if 0
884
+ { /* satisfy cc-mode */
885
+ #endif
886
+ } /* extern "C" { */
887
+ #endif
888
+
889
+ #endif /* RUBY_INTERNAL_H */