looksee 3.1.1 → 4.0.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (47) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG +9 -0
  3. data/README.markdown +61 -81
  4. data/ext/extconf.rb +3 -7
  5. data/ext/mri/2.3.0/internal.h +1404 -0
  6. data/ext/mri/2.3.0/method.h +213 -0
  7. data/ext/mri/mri.c +21 -264
  8. data/ext/rbx/rbx.c +0 -9
  9. data/lib/looksee/JRuby.jar +0 -0
  10. data/lib/looksee/adapter/base.rb +19 -54
  11. data/lib/looksee/adapter/rubinius.rb +3 -62
  12. data/lib/looksee/clean.rb +5 -1
  13. data/lib/looksee/editor.rb +1 -1
  14. data/lib/looksee/help.rb +3 -2
  15. data/lib/looksee/lookup_path.rb +7 -3
  16. data/lib/looksee/version.rb +1 -1
  17. data/spec/looksee/adapter_spec.rb +72 -365
  18. data/spec/looksee/editor_spec.rb +1 -1
  19. data/spec/looksee/inspector_spec.rb +21 -21
  20. data/spec/looksee/lookup_path_spec.rb +34 -21
  21. data/spec/spec_helper.rb +2 -0
  22. data/spec/support/temporary_classes.rb +10 -14
  23. data/spec/support/test_adapter.rb +2 -53
  24. metadata +6 -29
  25. data/ext/mri/1.9.2/debug.h +0 -36
  26. data/ext/mri/1.9.2/id.h +0 -170
  27. data/ext/mri/1.9.2/method.h +0 -103
  28. data/ext/mri/1.9.2/node.h +0 -483
  29. data/ext/mri/1.9.2/thread_pthread.h +0 -27
  30. data/ext/mri/1.9.2/vm_core.h +0 -707
  31. data/ext/mri/1.9.2/vm_opts.h +0 -51
  32. data/ext/mri/1.9.3/atomic.h +0 -56
  33. data/ext/mri/1.9.3/debug.h +0 -41
  34. data/ext/mri/1.9.3/id.h +0 -175
  35. data/ext/mri/1.9.3/internal.h +0 -227
  36. data/ext/mri/1.9.3/internal_falcon.h +0 -248
  37. data/ext/mri/1.9.3/method.h +0 -105
  38. data/ext/mri/1.9.3/node.h +0 -503
  39. data/ext/mri/1.9.3/thread_pthread.h +0 -51
  40. data/ext/mri/1.9.3/vm_core.h +0 -755
  41. data/ext/mri/1.9.3/vm_opts.h +0 -51
  42. data/ext/mri/2.0.0/internal.h +0 -378
  43. data/ext/mri/2.0.0/method.h +0 -138
  44. data/ext/mri/env-1.8.h +0 -27
  45. data/ext/mri/eval_c-1.8.h +0 -27
  46. data/ext/mri/node-1.9.h +0 -35
  47. data/lib/looksee/mri.bundle +0 -0
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 81d8dcd1c55d9f4b87a06cd70b4c4195ad736f48
4
- data.tar.gz: 80d6c929ef32a099625260796a191f00851f4b08
3
+ metadata.gz: 94926312f6e243fc27dad9367ed553896e64a7ec
4
+ data.tar.gz: 3671e93f8e5bdc1b9dd57b3330820f6aa384831c
5
5
  SHA512:
6
- metadata.gz: 9a76780516dd78d24579b8cea3bc3f8e06d029ef19f690d872c6220c49666138b2a6f0efe738f5fd013bd602e64f3c20a23e143dffba6c89f0e34d5d50246d45
7
- data.tar.gz: 41aa1cb0b83c1cd7e71dd8d037e331ab180cdab4b2813df2c86515e036055909916ea4ed0c200b0738fe41fdce9e6b5a355d4963c61ee821666aa10558916661
6
+ metadata.gz: 73171209bd7c657d39109b4f97f5b7f4791b19ad6ba4453be38b3e729131119692772e64718597ec0843f77264d337cf317ac65dac049714963404753c07d742
7
+ data.tar.gz: 267162f6045559ab2ed5ed3f141518444578c3967bcf6106daf5593e23139e0f8bcd558327666524a6ae0d71956131047c7c4cee974d0772e654c03d97296525
data/CHANGELOG CHANGED
@@ -1,3 +1,12 @@
1
+ == 4.0.0 2016-08-09
2
+
3
+ * Incomplete ruby 2.3 compatibility. Undef'd methods cannot be rendered; a
4
+ warning will be emitted the first time this may affect something.
5
+ * Looksee no longer supports MRI < 2.1, Rubinius < 3, or JRuby < 9.
6
+ * "Origin classes" are no longer shown. If you don't know what these are, good!
7
+ * Internal overhaul. The extensions have been shrunk to minimize the use of
8
+ private interpreter APIs.
9
+
1
10
  == 3.1.1 2016-08-02
2
11
 
3
12
  * Prevent installation on ruby 2.3, as compilation fails. Sorry! [Mathieu Jobin]
@@ -17,86 +17,75 @@ Now each object has a method `ls`, which shows you all its methods.
17
17
 
18
18
  irb> [].ls
19
19
  => BasicObject
20
- ! __send__ instance_exec singleton_method_undefined
21
- != equal? method_missing
22
- == initialize singleton_method_added
23
- __id__ instance_eval singleton_method_removed
20
+ ! __id__ initialize method_missing singleton_method_undefined
21
+ != __send__ instance_eval singleton_method_added
22
+ == equal? instance_exec singleton_method_removed
24
23
  Kernel
25
- !~ frozen? puts
26
- <=> gem raise
27
- === gem_original_require rand
28
- =~ gets readline
29
- Array global_variables readlines
30
- Complex hash remove_instance_variable
31
- Float initialize_clone require
32
- Integer initialize_copy require_relative
33
- Rational initialize_dup respond_to?
34
- String inspect respond_to_missing?
35
- __callee__ instance_of? select
36
- __method__ instance_variable_defined? send
37
- ` instance_variable_get set_trace_func
38
- abort instance_variable_set singleton_class
39
- at_exit instance_variables singleton_methods
40
- autoload is_a? sleep
41
- autoload? iterator? spawn
42
- binding kind_of? sprintf
43
- block_given? lambda srand
44
- caller load syscall
45
- catch local_variables system
46
- class loop taint
47
- clone method tainted?
48
- define_singleton_method methods tap
49
- display nil? test
50
- dup object_id throw
51
- enum_for open to_enum
52
- eql? p to_s
53
- eval print trace_var
54
- exec printf trap
55
- exit private_methods trust
56
- exit! proc untaint
57
- extend protected_methods untrace_var
58
- fail public_method untrust
59
- fork public_methods untrusted?
60
- format public_send warn
61
- freeze putc
24
+ !~ enum_for kind_of? respond_to_missing?
25
+ <=> eql? lambda select
26
+ === eval load send
27
+ =~ exec local_variables set_trace_func
28
+ Array exit loop singleton_class
29
+ Complex exit! method singleton_method
30
+ Float extend methods singleton_methods
31
+ Hash fail nil? sleep
32
+ Integer fork object_id spawn
33
+ Rational format open sprintf
34
+ String freeze p srand
35
+ __callee__ frozen? print syscall
36
+ __dir__ gem printf system
37
+ __method__ gem_original_require private_methods taint
38
+ ` gets proc tainted?
39
+ abort global_variables protected_methods tap
40
+ at_exit hash public_method test
41
+ autoload initialize_clone public_methods throw
42
+ autoload? initialize_copy public_send to_enum
43
+ binding initialize_dup putc to_s
44
+ block_given? inspect puts trace_var
45
+ caller instance_of? raise trap
46
+ caller_locations instance_variable_defined? rand trust
47
+ catch instance_variable_get readline untaint
48
+ class instance_variable_set readlines untrace_var
49
+ clone instance_variables remove_instance_variable untrust
50
+ define_singleton_method is_a? require untrusted?
51
+ display iterator? require_relative warn
52
+ dup itself respond_to?
62
53
  Looksee::ObjectMixin
63
54
  ls
64
55
  Object
65
- default_src_encoding irb_binding
56
+ DelegateClass default_src_encoding irb_binding
66
57
  Enumerable
67
- all? each_cons flat_map min_by slice_before
68
- any? each_entry grep minmax sort
69
- chunk each_slice group_by minmax_by sort_by
70
- collect each_with_index include? none? take
71
- collect_concat each_with_object inject one? take_while
72
- count entries map partition to_a
73
- cycle find max reduce to_set
74
- detect find_all max_by reject zip
75
- drop find_index member? reverse_each
76
- drop_while first min select
58
+ all? detect entries group_by min reject take
59
+ any? drop find include? min_by reverse_each take_while
60
+ chunk drop_while find_all inject minmax select to_a
61
+ chunk_while each_cons find_index lazy minmax_by slice_after to_h
62
+ collect each_entry first map none? slice_before to_set
63
+ collect_concat each_slice flat_map max one? slice_when zip
64
+ count each_with_index grep max_by partition sort
65
+ cycle each_with_object grep_v member? reduce sort_by
77
66
  Array
78
- & count hash rassoc size
79
- * cycle include? reject slice
80
- + delete index reject! slice!
81
- - delete_at initialize repeated_combination sort
82
- << delete_if initialize_copy repeated_permutation sort!
83
- <=> drop insert replace sort_by!
84
- == drop_while inspect reverse take
85
- [] each join reverse! take_while
86
- []= each_index keep_if reverse_each to_a
87
- assoc empty? last rindex to_ary
88
- at eql? length rotate to_s
89
- clear fetch map rotate! transpose
90
- collect fill map! sample uniq
91
- collect! find_index pack select uniq!
92
- combination first permutation select! unshift
93
- compact flatten pop shift values_at
94
- compact! flatten! product shuffle zip
95
- concat frozen? push shuffle! |
67
+ & collect! eql? keep_if reverse sort!
68
+ * combination fetch last reverse! sort_by!
69
+ + compact fill length reverse_each take
70
+ - compact! find_index map rindex take_while
71
+ << concat first map! rotate to_a
72
+ <=> count flatten pack rotate! to_ary
73
+ == cycle flatten! permutation sample to_h
74
+ [] delete frozen? pop select to_s
75
+ []= delete_at hash product select! transpose
76
+ any? delete_if include? push shift uniq
77
+ assoc dig index rassoc shuffle uniq!
78
+ at drop initialize reject shuffle! unshift
79
+ bsearch drop_while initialize_copy reject! size values_at
80
+ bsearch_index each insert repeated_combination slice zip
81
+ clear each_index inspect repeated_permutation slice! |
82
+ collect empty? join replace sort
96
83
 
97
84
  Methods are colored according to whether they're public, protected,
98
85
  private, undefined (using Module#undef_method), or overridden.
99
86
 
87
+ (Undefined methods are not shown on MRI 2.3 due to interpreter limitations.)
88
+
100
89
  You can hide, say, private methods like this:
101
90
 
102
91
  irb> [].ls :noprivate
@@ -123,9 +112,8 @@ always do:
123
112
 
124
113
  Looksee[object]
125
114
 
126
- This method inspects the object via interpreter extensions, so it works for the
127
- most Byzantine object. It will also work for `BasicObject` instances that don't
128
- have an `ls` method. `Object#ls` is simply a wrapper around `Looksee.[]`.
115
+ This will also work for `BasicObject` instances that don't have an `ls` method.
116
+ `Object#ls` is simply a wrapper around `Looksee.[]`.
129
117
 
130
118
  ## To the source!
131
119
 
@@ -154,14 +142,6 @@ We've got one:
154
142
 
155
143
  Enjoy!
156
144
 
157
- ## Support
158
-
159
- Looksee supports:
160
-
161
- * MRI 1.9.3, 2.0, 2.1, 2.2
162
- * JRuby 1.7
163
- * Rubinius 2.4
164
-
165
145
  ## Contributing
166
146
 
167
147
  * [Bug reports](https://github.com/oggy/looksee/issues)
@@ -4,16 +4,12 @@ extension = ruby_engine == 'ruby' ? 'mri' : ruby_engine
4
4
  require 'mkmf'
5
5
  $CPPFLAGS << " -DRUBY_VERSION=#{RUBY_VERSION.tr('.', '')}"
6
6
  if extension == 'mri'
7
- if RUBY_VERSION >= '2.2.0'
7
+ if RUBY_VERSION >= '2.3.0'
8
+ $CPPFLAGS << " -Imri/2.3.0"
9
+ elsif RUBY_VERSION >= '2.2.0'
8
10
  $CPPFLAGS << " -Imri/2.2.0"
9
11
  elsif RUBY_VERSION >= '2.1.0'
10
12
  $CPPFLAGS << " -Imri/2.1.0"
11
- elsif RUBY_VERSION >= '2.0.0'
12
- $CPPFLAGS << " -Imri/2.0.0"
13
- elsif RUBY_VERSION >= '1.9.3'
14
- $CPPFLAGS << " -Imri/1.9.3"
15
- elsif RUBY_VERSION >= '1.9.2'
16
- $CPPFLAGS << " -Imri/1.9.2"
17
13
  end
18
14
  end
19
15
  create_makefile "looksee/#{extension}", extension
@@ -0,0 +1,1404 @@
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
+ #include "ruby.h"
16
+ #include "ruby/encoding.h"
17
+ #include "ruby/io.h"
18
+
19
+ #if defined(__cplusplus)
20
+ extern "C" {
21
+ #if 0
22
+ } /* satisfy cc-mode */
23
+ #endif
24
+ #endif
25
+
26
+ /* likely */
27
+ #if __GNUC__ >= 3
28
+ #define LIKELY(x) (__builtin_expect(!!(x), 1))
29
+ #define UNLIKELY(x) (__builtin_expect(!!(x), 0))
30
+ #else /* __GNUC__ >= 3 */
31
+ #define LIKELY(x) (x)
32
+ #define UNLIKELY(x) (x)
33
+ #endif /* __GNUC__ >= 3 */
34
+
35
+ #ifndef __has_attribute
36
+ # define __has_attribute(x) 0
37
+ #endif
38
+
39
+ #if __has_attribute(unused)
40
+ #define UNINITIALIZED_VAR(x) x __attribute__((unused))
41
+ #elif defined(__GNUC__) && __GNUC__ >= 3
42
+ #define UNINITIALIZED_VAR(x) x = x
43
+ #else
44
+ #define UNINITIALIZED_VAR(x) x
45
+ #endif
46
+
47
+ #if __has_attribute(warn_unused_result)
48
+ #define WARN_UNUSED_RESULT(x) x __attribute__((warn_unused_result))
49
+ #elif defined(__GNUC__) && (__GNUC__ * 1000 + __GNUC_MINOR__) >= 3004
50
+ #define WARN_UNUSED_RESULT(x) x __attribute__((warn_unused_result))
51
+ #else
52
+ #define WARN_UNUSED_RESULT(x) x
53
+ #endif
54
+
55
+ #ifdef HAVE_VALGRIND_MEMCHECK_H
56
+ # include <valgrind/memcheck.h>
57
+ # ifndef VALGRIND_MAKE_MEM_DEFINED
58
+ # define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
59
+ # endif
60
+ # ifndef VALGRIND_MAKE_MEM_UNDEFINED
61
+ # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
62
+ # endif
63
+ #else
64
+ # define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
65
+ # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
66
+ #endif
67
+
68
+ #define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
69
+
70
+ #define GCC_VERSION_SINCE(major, minor, patchlevel) \
71
+ (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
72
+ ((__GNUC__ > (major)) || \
73
+ (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \
74
+ (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))
75
+
76
+ #ifndef __has_feature
77
+ # define __has_feature(x) 0
78
+ #endif
79
+
80
+ #ifndef __has_extension
81
+ # define __has_extension __has_feature
82
+ #endif
83
+
84
+ #if GCC_VERSION_SINCE(4, 6, 0) || __has_extension(c_static_assert)
85
+ # define STATIC_ASSERT(name, expr) _Static_assert(expr, #name ": " #expr)
86
+ #else
87
+ # define STATIC_ASSERT(name, expr) typedef int static_assert_##name##_check[1 - 2*!(expr)]
88
+ #endif
89
+
90
+ #define SIGNED_INTEGER_TYPE_P(int_type) (0 > ((int_type)0)-1)
91
+ #define SIGNED_INTEGER_MAX(sint_type) \
92
+ (sint_type) \
93
+ ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) | \
94
+ ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) - 1))
95
+ #define SIGNED_INTEGER_MIN(sint_type) (-SIGNED_INTEGER_MAX(sint_type)-1)
96
+ #define UNSIGNED_INTEGER_MAX(uint_type) (~(uint_type)0)
97
+
98
+ #if SIGNEDNESS_OF_TIME_T < 0 /* signed */
99
+ # define TIMET_MAX SIGNED_INTEGER_MAX(time_t)
100
+ # define TIMET_MIN SIGNED_INTEGER_MIN(time_t)
101
+ #elif SIGNEDNESS_OF_TIME_T > 0 /* unsigned */
102
+ # define TIMET_MAX UNSIGNED_INTEGER_MAX(time_t)
103
+ # define TIMET_MIN ((time_t)0)
104
+ #endif
105
+ #define TIMET_MAX_PLUS_ONE (2*(double)(TIMET_MAX/2+1))
106
+
107
+ #define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
108
+ (a) == 0 ? 0 : \
109
+ (a) == -1 ? (b) < -(max) : \
110
+ (a) > 0 ? \
111
+ ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
112
+ ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
113
+ #define MUL_OVERFLOW_FIXNUM_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
114
+ #define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
115
+ #define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
116
+
117
+ #ifndef swap16
118
+ # ifdef HAVE_BUILTIN___BUILTIN_BSWAP16
119
+ # define swap16(x) __builtin_bswap16(x)
120
+ # endif
121
+ #endif
122
+
123
+ #ifndef swap16
124
+ # define swap16(x) ((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
125
+ #endif
126
+
127
+ #ifndef swap32
128
+ # ifdef HAVE_BUILTIN___BUILTIN_BSWAP32
129
+ # define swap32(x) __builtin_bswap32(x)
130
+ # endif
131
+ #endif
132
+
133
+ #ifndef swap32
134
+ # define swap32(x) ((uint32_t)((((x)&0xFF)<<24) \
135
+ |(((x)>>24)&0xFF) \
136
+ |(((x)&0x0000FF00)<<8) \
137
+ |(((x)&0x00FF0000)>>8) ))
138
+ #endif
139
+
140
+ #ifndef swap64
141
+ # ifdef HAVE_BUILTIN___BUILTIN_BSWAP64
142
+ # define swap64(x) __builtin_bswap64(x)
143
+ # endif
144
+ #endif
145
+
146
+ #ifndef swap64
147
+ # ifdef HAVE_INT64_T
148
+ # define byte_in_64bit(n) ((uint64_t)0xff << (n))
149
+ # define swap64(x) ((uint64_t)((((x)&byte_in_64bit(0))<<56) \
150
+ |(((x)>>56)&0xFF) \
151
+ |(((x)&byte_in_64bit(8))<<40) \
152
+ |(((x)&byte_in_64bit(48))>>40) \
153
+ |(((x)&byte_in_64bit(16))<<24) \
154
+ |(((x)&byte_in_64bit(40))>>24) \
155
+ |(((x)&byte_in_64bit(24))<<8) \
156
+ |(((x)&byte_in_64bit(32))>>8)))
157
+ # endif
158
+ #endif
159
+
160
+ static inline int
161
+ nlz_int(unsigned int x)
162
+ {
163
+ #if defined(HAVE_BUILTIN___BUILTIN_CLZ)
164
+ if (x == 0) return SIZEOF_INT * CHAR_BIT;
165
+ return __builtin_clz(x);
166
+ #else
167
+ unsigned int y;
168
+ # if 64 < SIZEOF_INT * CHAR_BIT
169
+ int n = 128;
170
+ # elif 32 < SIZEOF_INT * CHAR_BIT
171
+ int n = 64;
172
+ # else
173
+ int n = 32;
174
+ # endif
175
+ # if 64 < SIZEOF_INT * CHAR_BIT
176
+ y = x >> 64; if (y) {n -= 64; x = y;}
177
+ # endif
178
+ # if 32 < SIZEOF_INT * CHAR_BIT
179
+ y = x >> 32; if (y) {n -= 32; x = y;}
180
+ # endif
181
+ y = x >> 16; if (y) {n -= 16; x = y;}
182
+ y = x >> 8; if (y) {n -= 8; x = y;}
183
+ y = x >> 4; if (y) {n -= 4; x = y;}
184
+ y = x >> 2; if (y) {n -= 2; x = y;}
185
+ y = x >> 1; if (y) {return n - 2;}
186
+ return (int)(n - x);
187
+ #endif
188
+ }
189
+
190
+ static inline int
191
+ nlz_long(unsigned long x)
192
+ {
193
+ #if defined(HAVE_BUILTIN___BUILTIN_CLZL)
194
+ if (x == 0) return SIZEOF_LONG * CHAR_BIT;
195
+ return __builtin_clzl(x);
196
+ #else
197
+ unsigned long y;
198
+ # if 64 < SIZEOF_LONG * CHAR_BIT
199
+ int n = 128;
200
+ # elif 32 < SIZEOF_LONG * CHAR_BIT
201
+ int n = 64;
202
+ # else
203
+ int n = 32;
204
+ # endif
205
+ # if 64 < SIZEOF_LONG * CHAR_BIT
206
+ y = x >> 64; if (y) {n -= 64; x = y;}
207
+ # endif
208
+ # if 32 < SIZEOF_LONG * CHAR_BIT
209
+ y = x >> 32; if (y) {n -= 32; x = y;}
210
+ # endif
211
+ y = x >> 16; if (y) {n -= 16; x = y;}
212
+ y = x >> 8; if (y) {n -= 8; x = y;}
213
+ y = x >> 4; if (y) {n -= 4; x = y;}
214
+ y = x >> 2; if (y) {n -= 2; x = y;}
215
+ y = x >> 1; if (y) {return n - 2;}
216
+ return (int)(n - x);
217
+ #endif
218
+ }
219
+
220
+ #ifdef HAVE_LONG_LONG
221
+ static inline int
222
+ nlz_long_long(unsigned LONG_LONG x)
223
+ {
224
+ #if defined(HAVE_BUILTIN___BUILTIN_CLZLL)
225
+ if (x == 0) return SIZEOF_LONG_LONG * CHAR_BIT;
226
+ return __builtin_clzll(x);
227
+ #else
228
+ unsigned LONG_LONG y;
229
+ # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
230
+ int n = 128;
231
+ # elif 32 < SIZEOF_LONG_LONG * CHAR_BIT
232
+ int n = 64;
233
+ # else
234
+ int n = 32;
235
+ # endif
236
+ # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
237
+ y = x >> 64; if (y) {n -= 64; x = y;}
238
+ # endif
239
+ # if 32 < SIZEOF_LONG_LONG * CHAR_BIT
240
+ y = x >> 32; if (y) {n -= 32; x = y;}
241
+ # endif
242
+ y = x >> 16; if (y) {n -= 16; x = y;}
243
+ y = x >> 8; if (y) {n -= 8; x = y;}
244
+ y = x >> 4; if (y) {n -= 4; x = y;}
245
+ y = x >> 2; if (y) {n -= 2; x = y;}
246
+ y = x >> 1; if (y) {return n - 2;}
247
+ return (int)(n - x);
248
+ #endif
249
+ }
250
+ #endif
251
+
252
+ #ifdef HAVE_UINT128_T
253
+ static inline int
254
+ nlz_int128(uint128_t x)
255
+ {
256
+ uint128_t y;
257
+ int n = 128;
258
+ y = x >> 64; if (y) {n -= 64; x = y;}
259
+ y = x >> 32; if (y) {n -= 32; x = y;}
260
+ y = x >> 16; if (y) {n -= 16; x = y;}
261
+ y = x >> 8; if (y) {n -= 8; x = y;}
262
+ y = x >> 4; if (y) {n -= 4; x = y;}
263
+ y = x >> 2; if (y) {n -= 2; x = y;}
264
+ y = x >> 1; if (y) {return n - 2;}
265
+ return (int)(n - x);
266
+ }
267
+ #endif
268
+
269
+ #if defined(HAVE_UINT128_T)
270
+ # define bit_length(x) \
271
+ (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
272
+ sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
273
+ sizeof(x) <= SIZEOF_LONG_LONG ? SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)) : \
274
+ SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
275
+ #elif defined(HAVE_LONG_LONG)
276
+ # define bit_length(x) \
277
+ (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
278
+ sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
279
+ SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)))
280
+ #else
281
+ # define bit_length(x) \
282
+ (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
283
+ SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)))
284
+ #endif
285
+
286
+ #ifndef BDIGIT
287
+ # if SIZEOF_INT*2 <= SIZEOF_LONG_LONG
288
+ # define BDIGIT unsigned int
289
+ # define SIZEOF_BDIGIT SIZEOF_INT
290
+ # define BDIGIT_DBL unsigned LONG_LONG
291
+ # define BDIGIT_DBL_SIGNED LONG_LONG
292
+ # define PRI_BDIGIT_PREFIX ""
293
+ # define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX
294
+ # elif SIZEOF_INT*2 <= SIZEOF_LONG
295
+ # define BDIGIT unsigned int
296
+ # define SIZEOF_BDIGIT SIZEOF_INT
297
+ # define BDIGIT_DBL unsigned long
298
+ # define BDIGIT_DBL_SIGNED long
299
+ # define PRI_BDIGIT_PREFIX ""
300
+ # define PRI_BDIGIT_DBL_PREFIX "l"
301
+ # elif SIZEOF_SHORT*2 <= SIZEOF_LONG
302
+ # define BDIGIT unsigned short
303
+ # define SIZEOF_BDIGIT SIZEOF_SHORT
304
+ # define BDIGIT_DBL unsigned long
305
+ # define BDIGIT_DBL_SIGNED long
306
+ # define PRI_BDIGIT_PREFIX "h"
307
+ # define PRI_BDIGIT_DBL_PREFIX "l"
308
+ # else
309
+ # define BDIGIT unsigned short
310
+ # define SIZEOF_BDIGIT (SIZEOF_LONG/2)
311
+ # define SIZEOF_ACTUAL_BDIGIT SIZEOF_LONG
312
+ # define BDIGIT_DBL unsigned long
313
+ # define BDIGIT_DBL_SIGNED long
314
+ # define PRI_BDIGIT_PREFIX "h"
315
+ # define PRI_BDIGIT_DBL_PREFIX "l"
316
+ # endif
317
+ #endif
318
+ #ifndef SIZEOF_ACTUAL_BDIGIT
319
+ # define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGIT
320
+ #endif
321
+
322
+ #ifdef PRI_BDIGIT_PREFIX
323
+ # define PRIdBDIGIT PRI_BDIGIT_PREFIX"d"
324
+ # define PRIiBDIGIT PRI_BDIGIT_PREFIX"i"
325
+ # define PRIoBDIGIT PRI_BDIGIT_PREFIX"o"
326
+ # define PRIuBDIGIT PRI_BDIGIT_PREFIX"u"
327
+ # define PRIxBDIGIT PRI_BDIGIT_PREFIX"x"
328
+ # define PRIXBDIGIT PRI_BDIGIT_PREFIX"X"
329
+ #endif
330
+
331
+ #ifdef PRI_BDIGIT_DBL_PREFIX
332
+ # define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d"
333
+ # define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i"
334
+ # define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o"
335
+ # define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u"
336
+ # define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x"
337
+ # define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X"
338
+ #endif
339
+
340
+ #define BIGNUM_EMBED_LEN_NUMBITS 3
341
+ #ifndef BIGNUM_EMBED_LEN_MAX
342
+ # if (SIZEOF_VALUE*3/SIZEOF_ACTUAL_BDIGIT) < (1 << BIGNUM_EMBED_LEN_NUMBITS)-1
343
+ # define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*3/SIZEOF_ACTUAL_BDIGIT)
344
+ # else
345
+ # define BIGNUM_EMBED_LEN_MAX ((1 << BIGNUM_EMBED_LEN_NUMBITS)-1)
346
+ # endif
347
+ #endif
348
+
349
+ struct RBignum {
350
+ struct RBasic basic;
351
+ union {
352
+ struct {
353
+ size_t len;
354
+ BDIGIT *digits;
355
+ } heap;
356
+ BDIGIT ary[BIGNUM_EMBED_LEN_MAX];
357
+ } as;
358
+ };
359
+ #define BIGNUM_SIGN_BIT FL_USER1
360
+ /* sign: positive:1, negative:0 */
361
+ #define BIGNUM_SIGN(b) ((RBASIC(b)->flags & BIGNUM_SIGN_BIT) != 0)
362
+ #define BIGNUM_SET_SIGN(b,sign) \
363
+ ((sign) ? (RBASIC(b)->flags |= BIGNUM_SIGN_BIT) \
364
+ : (RBASIC(b)->flags &= ~BIGNUM_SIGN_BIT))
365
+ #define BIGNUM_POSITIVE_P(b) BIGNUM_SIGN(b)
366
+ #define BIGNUM_NEGATIVE_P(b) (!BIGNUM_SIGN(b))
367
+
368
+ #define BIGNUM_EMBED_FLAG FL_USER2
369
+ #define BIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3)
370
+ #define BIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+BIGNUM_EMBED_LEN_NUMBITS)
371
+ #define BIGNUM_LEN(b) \
372
+ ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
373
+ (long)((RBASIC(b)->flags >> BIGNUM_EMBED_LEN_SHIFT) & \
374
+ (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT)) : \
375
+ RBIGNUM(b)->as.heap.len)
376
+ /* LSB:BIGNUM_DIGITS(b)[0], MSB:BIGNUM_DIGITS(b)[BIGNUM_LEN(b)-1] */
377
+ #define BIGNUM_DIGITS(b) \
378
+ ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
379
+ RBIGNUM(b)->as.ary : \
380
+ RBIGNUM(b)->as.heap.digits)
381
+ #define BIGNUM_LENINT(b) rb_long2int(BIGNUM_LEN(b))
382
+
383
+ #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
384
+
385
+ struct RRational {
386
+ struct RBasic basic;
387
+ const VALUE num;
388
+ const VALUE den;
389
+ };
390
+
391
+ #define RRATIONAL(obj) (R_CAST(RRational)(obj))
392
+
393
+ struct RFloat {
394
+ struct RBasic basic;
395
+ double float_value;
396
+ };
397
+
398
+ #define RFLOAT(obj) (R_CAST(RFloat)(obj))
399
+
400
+ struct RComplex {
401
+ struct RBasic basic;
402
+ const VALUE real;
403
+ const VALUE imag;
404
+ };
405
+
406
+ #define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
407
+
408
+ #ifdef RCOMPLEX_SET_REAL /* shortcut macro for internal only */
409
+ #undef RCOMPLEX_SET_REAL
410
+ #undef RCOMPLEX_SET_REAL
411
+ #define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r))
412
+ #define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i))
413
+ #endif
414
+
415
+ struct RHash {
416
+ struct RBasic basic;
417
+ struct st_table *ntbl; /* possibly 0 */
418
+ int iter_lev;
419
+ const VALUE ifnone;
420
+ };
421
+
422
+ #define RHASH(obj) (R_CAST(RHash)(obj))
423
+
424
+ #ifdef RHASH_ITER_LEV
425
+ #undef RHASH_ITER_LEV
426
+ #undef RHASH_IFNONE
427
+ #undef RHASH_SIZE
428
+ #define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
429
+ #define RHASH_IFNONE(h) (RHASH(h)->ifnone)
430
+ #define RHASH_SIZE(h) (RHASH(h)->ntbl ? (st_index_t)RHASH(h)->ntbl->num_entries : 0)
431
+ #endif
432
+
433
+ /* missing/setproctitle.c */
434
+ #ifndef HAVE_SETPROCTITLE
435
+ extern void ruby_init_setproctitle(int argc, char *argv[]);
436
+ #endif
437
+
438
+ /* class.c */
439
+
440
+ struct rb_deprecated_classext_struct {
441
+ char conflict[sizeof(VALUE) * 3];
442
+ };
443
+
444
+ struct rb_subclass_entry;
445
+ typedef struct rb_subclass_entry rb_subclass_entry_t;
446
+
447
+ struct rb_subclass_entry {
448
+ VALUE klass;
449
+ rb_subclass_entry_t *next;
450
+ };
451
+
452
+ #if defined(HAVE_LONG_LONG)
453
+ typedef unsigned LONG_LONG rb_serial_t;
454
+ #define SERIALT2NUM ULL2NUM
455
+ #elif defined(HAVE_UINT64_T)
456
+ typedef uint64_t rb_serial_t;
457
+ #define SERIALT2NUM SIZET2NUM
458
+ #else
459
+ typedef unsigned long rb_serial_t;
460
+ #define SERIALT2NUM ULONG2NUM
461
+ #endif
462
+
463
+ struct rb_classext_struct {
464
+ struct st_table *iv_index_tbl;
465
+ struct st_table *iv_tbl;
466
+ struct st_table *const_tbl;
467
+ struct rb_id_table *callable_m_tbl;
468
+ rb_subclass_entry_t *subclasses;
469
+ rb_subclass_entry_t **parent_subclasses;
470
+ /**
471
+ * In the case that this is an `ICLASS`, `module_subclasses` points to the link
472
+ * in the module's `subclasses` list that indicates that the klass has been
473
+ * included. Hopefully that makes sense.
474
+ */
475
+ rb_subclass_entry_t **module_subclasses;
476
+ rb_serial_t class_serial;
477
+ const VALUE origin_;
478
+ VALUE refined_class;
479
+ rb_alloc_func_t allocator;
480
+ };
481
+
482
+ typedef struct rb_classext_struct rb_classext_t;
483
+
484
+ #undef RClass
485
+ struct RClass {
486
+ struct RBasic basic;
487
+ VALUE super;
488
+ rb_classext_t *ptr;
489
+ struct rb_id_table *m_tbl;
490
+ };
491
+
492
+ void rb_class_subclass_add(VALUE super, VALUE klass);
493
+ void rb_class_remove_from_super_subclasses(VALUE);
494
+ int rb_singleton_class_internal_p(VALUE sklass);
495
+
496
+ #define RCLASS_EXT(c) (RCLASS(c)->ptr)
497
+ #define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
498
+ #define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
499
+ #define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
500
+ #define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
501
+ #define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
502
+ #define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)
503
+ #define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
504
+ #define RCLASS_SERIAL(c) (RCLASS_EXT(c)->class_serial)
505
+
506
+ #define RICLASS_IS_ORIGIN FL_USER5
507
+
508
+ static inline void
509
+ RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
510
+ {
511
+ RB_OBJ_WRITE(klass, &RCLASS_ORIGIN(klass), origin);
512
+ if (klass != origin) FL_SET(origin, RICLASS_IS_ORIGIN);
513
+ }
514
+
515
+ #undef RCLASS_SUPER
516
+ static inline VALUE
517
+ RCLASS_SUPER(VALUE klass)
518
+ {
519
+ return RCLASS(klass)->super;
520
+ }
521
+
522
+ static inline VALUE
523
+ RCLASS_SET_SUPER(VALUE klass, VALUE super)
524
+ {
525
+ if (super) {
526
+ rb_class_remove_from_super_subclasses(klass);
527
+ rb_class_subclass_add(super, klass);
528
+ }
529
+ RB_OBJ_WRITE(klass, &RCLASS(klass)->super, super);
530
+ return super;
531
+ }
532
+ /* IMEMO: Internal memo object */
533
+
534
+ #ifndef IMEMO_DEBUG
535
+ #define IMEMO_DEBUG 0
536
+ #endif
537
+
538
+ struct RIMemo {
539
+ VALUE flags;
540
+ VALUE v0;
541
+ VALUE v1;
542
+ VALUE v2;
543
+ VALUE v3;
544
+ };
545
+
546
+ enum imemo_type {
547
+ imemo_none = 0,
548
+ imemo_cref = 1,
549
+ imemo_svar = 2,
550
+ imemo_throw_data = 3,
551
+ imemo_ifunc = 4,
552
+ imemo_memo = 5,
553
+ imemo_ment = 6,
554
+ imemo_iseq = 7,
555
+ imemo_mask = 0x07
556
+ };
557
+
558
+ static inline enum imemo_type
559
+ imemo_type(VALUE imemo)
560
+ {
561
+ return (RBASIC(imemo)->flags >> FL_USHIFT) & imemo_mask;
562
+ }
563
+
564
+ /* FL_USER0 to FL_USER2 is for type */
565
+ #define IMEMO_FL_USHIFT (FL_USHIFT + 3)
566
+ #define IMEMO_FL_USER0 FL_USER3
567
+ #define IMEMO_FL_USER1 FL_USER4
568
+ #define IMEMO_FL_USER2 FL_USER5
569
+ #define IMEMO_FL_USER3 FL_USER6
570
+ #define IMEMO_FL_USER4 FL_USER7
571
+
572
+ /* CREF in method.h */
573
+
574
+ /* SVAR */
575
+
576
+ struct vm_svar {
577
+ VALUE flags;
578
+ const VALUE cref_or_me;
579
+ const VALUE lastline;
580
+ const VALUE backref;
581
+ const VALUE others;
582
+ };
583
+
584
+ /* THROW_DATA */
585
+
586
+ struct vm_throw_data {
587
+ VALUE flags;
588
+ VALUE reserved;
589
+ const VALUE throw_obj;
590
+ const struct rb_control_frame_struct *catch_frame;
591
+ VALUE throw_state;
592
+ };
593
+
594
+ #define THROW_DATA_P(err) RB_TYPE_P((err), T_IMEMO)
595
+
596
+ /* IFUNC */
597
+
598
+ struct vm_ifunc {
599
+ VALUE flags;
600
+ VALUE reserved;
601
+ VALUE (*func)(ANYARGS);
602
+ const void *data;
603
+ ID id;
604
+ };
605
+
606
+ #define IFUNC_NEW(a, b, c) ((struct vm_ifunc *)rb_imemo_new(imemo_ifunc, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
607
+
608
+ /* MEMO */
609
+
610
+ struct MEMO {
611
+ VALUE flags;
612
+ VALUE reserved;
613
+ const VALUE v1;
614
+ const VALUE v2;
615
+ union {
616
+ long cnt;
617
+ long state;
618
+ const VALUE value;
619
+ VALUE (*func)(ANYARGS);
620
+ } u3;
621
+ };
622
+
623
+ #define MEMO_V1_SET(m, v) RB_OBJ_WRITE((memo), &(memo)->v1, (v))
624
+ #define MEMO_V2_SET(m, v) RB_OBJ_WRITE((memo), &(memo)->v2, (v))
625
+
626
+ #define MEMO_CAST(m) ((struct MEMO *)m)
627
+
628
+ #define MEMO_NEW(a, b, c) ((struct MEMO *)rb_imemo_new(imemo_memo, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
629
+
630
+ #define roomof(x, y) (((x) + (y) - 1) / (y))
631
+ #define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
632
+ #define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
633
+ #define NEW_MEMO_FOR(type, value) \
634
+ ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
635
+
636
+ /* ment is in method.h */
637
+
638
+ /* global variable */
639
+
640
+ struct rb_global_entry {
641
+ struct rb_global_variable *var;
642
+ ID id;
643
+ };
644
+
645
+ struct rb_global_entry *rb_global_entry(ID);
646
+ VALUE rb_gvar_get(struct rb_global_entry *);
647
+ VALUE rb_gvar_set(struct rb_global_entry *, VALUE);
648
+ VALUE rb_gvar_defined(struct rb_global_entry *);
649
+
650
+ struct vtm; /* defined by timev.h */
651
+
652
+ /* array.c */
653
+ VALUE rb_ary_last(int, const VALUE *, VALUE);
654
+ void rb_ary_set_len(VALUE, long);
655
+ void rb_ary_delete_same(VALUE, VALUE);
656
+ VALUE rb_ary_tmp_new_fill(long capa);
657
+ VALUE rb_ary_at(VALUE, VALUE);
658
+ size_t rb_ary_memsize(VALUE);
659
+ #ifdef __GNUC__
660
+ #define rb_ary_new_from_args(n, ...) \
661
+ __extension__ ({ \
662
+ const VALUE args_to_new_ary[] = {__VA_ARGS__}; \
663
+ if (__builtin_constant_p(n)) { \
664
+ STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); \
665
+ } \
666
+ rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); \
667
+ })
668
+ #endif
669
+
670
+ /* bignum.c */
671
+ extern const char ruby_digitmap[];
672
+ VALUE rb_big_fdiv(VALUE x, VALUE y);
673
+ VALUE rb_big_uminus(VALUE x);
674
+ VALUE rb_integer_float_cmp(VALUE x, VALUE y);
675
+ VALUE rb_integer_float_eq(VALUE x, VALUE y);
676
+
677
+ /* class.c */
678
+ void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE);
679
+ void rb_class_detach_subclasses(VALUE);
680
+ void rb_class_detach_module_subclasses(VALUE);
681
+ void rb_class_remove_from_module_subclasses(VALUE);
682
+ VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj);
683
+ VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj);
684
+ VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj);
685
+ VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj);
686
+ int rb_obj_basic_to_s_p(VALUE);
687
+ VALUE rb_special_singleton_class(VALUE);
688
+ VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach);
689
+ VALUE rb_singleton_class_get(VALUE obj);
690
+ void Init_class_hierarchy(void);
691
+
692
+ int rb_class_has_methods(VALUE c);
693
+
694
+ /* compar.c */
695
+ VALUE rb_invcmp(VALUE, VALUE);
696
+
697
+ /* compile.c */
698
+ int rb_dvar_defined(ID);
699
+ int rb_local_defined(ID);
700
+ int rb_parse_in_eval(void);
701
+ int rb_parse_in_main(void);
702
+ const char * rb_insns_name(int i);
703
+ VALUE rb_insns_name_array(void);
704
+
705
+ /* cont.c */
706
+ VALUE rb_obj_is_fiber(VALUE);
707
+ void rb_fiber_reset_root_local_storage(VALUE);
708
+ void ruby_register_rollback_func_for_ensure(VALUE (*ensure_func)(ANYARGS), VALUE (*rollback_func)(ANYARGS));
709
+
710
+ /* debug.c */
711
+ PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
712
+
713
+ /* dmyext.c */
714
+ void Init_enc(void);
715
+ void Init_ext(void);
716
+
717
+ /* encoding.c */
718
+ ID rb_id_encoding(void);
719
+ void rb_gc_mark_encodings(void);
720
+ rb_encoding *rb_enc_get_from_index(int index);
721
+ rb_encoding *rb_enc_check_str(VALUE str1, VALUE str2);
722
+ int rb_encdb_replicate(const char *alias, const char *orig);
723
+ int rb_encdb_alias(const char *alias, const char *orig);
724
+ int rb_encdb_dummy(const char *name);
725
+ void rb_encdb_declare(const char *name);
726
+ void rb_enc_set_base(const char *name, const char *orig);
727
+ int rb_enc_set_dummy(int index);
728
+ void rb_encdb_set_unicode(int index);
729
+ int rb_data_is_encoding(VALUE obj);
730
+
731
+ /* enum.c */
732
+ VALUE rb_f_send(int argc, VALUE *argv, VALUE recv);
733
+
734
+ /* error.c */
735
+ extern VALUE rb_eEAGAIN;
736
+ extern VALUE rb_eEWOULDBLOCK;
737
+ extern VALUE rb_eEINPROGRESS;
738
+ NORETURN(PRINTF_ARGS(void rb_compile_bug(const char*, int, const char*, ...), 3, 4));
739
+ NORETURN(PRINTF_ARGS(void rb_compile_bug_str(VALUE file, int line, const char *fmt, ...), 3, 4));
740
+ PRINTF_ARGS(void rb_compile_error_str(VALUE file, int line, void *enc, const char *fmt, ...), 4, 5);
741
+ VALUE rb_check_backtrace(VALUE);
742
+ NORETURN(void rb_async_bug_errno(const char *,int));
743
+ const char *rb_builtin_type_name(int t);
744
+ const char *rb_builtin_class_name(VALUE x);
745
+ PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
746
+ PRINTF_ARGS(void rb_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
747
+ PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
748
+ VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
749
+ #define rb_name_err_raise_str(mesg, recv, name) \
750
+ rb_exc_raise(rb_name_err_new(mesg, recv, name))
751
+ #define rb_name_err_raise(mesg, recv, name) \
752
+ rb_name_err_raise_str(rb_fstring_cstr(mesg), (recv), (name))
753
+
754
+ /* eval.c */
755
+ VALUE rb_refinement_module_get_refined_class(VALUE module);
756
+
757
+ /* eval_error.c */
758
+ void ruby_error_print(void);
759
+ VALUE rb_get_backtrace(VALUE info);
760
+
761
+ /* eval_jump.c */
762
+ void rb_call_end_proc(VALUE data);
763
+ void rb_mark_end_proc(void);
764
+
765
+ /* file.c */
766
+ VALUE rb_home_dir_of(VALUE user, VALUE result);
767
+ VALUE rb_default_home_dir(VALUE result);
768
+ VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
769
+ void rb_file_const(const char*, VALUE);
770
+ int rb_file_load_ok(const char *);
771
+ VALUE rb_file_expand_path_fast(VALUE, VALUE);
772
+ VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE);
773
+ VALUE rb_get_path_check_to_string(VALUE, int);
774
+ VALUE rb_get_path_check_convert(VALUE, VALUE, int);
775
+ void Init_File(void);
776
+ int ruby_is_fd_loadable(int fd);
777
+
778
+ #ifdef RUBY_FUNCTION_NAME_STRING
779
+ # if defined __GNUC__ && __GNUC__ >= 4
780
+ # pragma GCC visibility push(default)
781
+ # endif
782
+ NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
783
+ NORETURN(void rb_syserr_fail_path_in(const char *func_name, int err, VALUE path));
784
+ # if defined __GNUC__ && __GNUC__ >= 4
785
+ # pragma GCC visibility pop
786
+ # endif
787
+ # define rb_sys_fail_path(path) rb_sys_fail_path_in(RUBY_FUNCTION_NAME_STRING, path)
788
+ # define rb_syserr_fail_path(err, path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
789
+ #else
790
+ # define rb_sys_fail_path(path) rb_sys_fail_str(path)
791
+ # define rb_syserr_fail_path(err, path) rb_syserr_fail_str((err), (path))
792
+ #endif
793
+
794
+ /* gc.c */
795
+ extern VALUE *ruby_initial_gc_stress_ptr;
796
+ extern int ruby_disable_gc;
797
+ void Init_heap(void);
798
+ void *ruby_mimmalloc(size_t size);
799
+ void ruby_mimfree(void *ptr);
800
+ void rb_objspace_set_event_hook(const rb_event_flag_t event);
801
+ #if USE_RGENGC
802
+ void rb_gc_writebarrier_remember(VALUE obj);
803
+ #else
804
+ #define rb_gc_writebarrier_remember(obj) 0
805
+ #endif
806
+ void ruby_gc_set_params(int safe_level);
807
+ void rb_copy_wb_protected_attribute(VALUE dest, VALUE obj);
808
+
809
+ #if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
810
+ #define ruby_sized_xrealloc(ptr, new_size, old_size) ruby_xrealloc(ptr, new_size)
811
+ #define ruby_sized_xrealloc2(ptr, new_count, element_size, old_count) ruby_xrealloc(ptr, new_count, element_size)
812
+ #define ruby_sized_xfree(ptr, size) ruby_xfree(ptr)
813
+ #define SIZED_REALLOC_N(var,type,n,old_n) REALLOC_N(var, type, n)
814
+ #else
815
+ void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_ALLOC_SIZE((2));
816
+ void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_ALLOC_SIZE((2, 3));
817
+ void ruby_sized_xfree(void *x, size_t size);
818
+ #define SIZED_REALLOC_N(var,type,n,old_n) ((var)=(type*)ruby_sized_xrealloc((char*)(var), (n) * sizeof(type), (old_n) * sizeof(type)))
819
+ #endif
820
+
821
+ void rb_gc_resurrect(VALUE ptr);
822
+
823
+ /* optimized version of NEWOBJ() */
824
+ #undef NEWOBJF_OF
825
+ #undef RB_NEWOBJ_OF
826
+ #define RB_NEWOBJ_OF(obj,type,klass,flags) \
827
+ type *(obj) = (type*)(((flags) & FL_WB_PROTECTED) ? \
828
+ rb_wb_protected_newobj_of(klass, (flags) & ~FL_WB_PROTECTED) : \
829
+ rb_wb_unprotected_newobj_of(klass, flags))
830
+ #define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags)
831
+
832
+ /* hash.c */
833
+ struct st_table *rb_hash_tbl_raw(VALUE hash);
834
+ VALUE rb_hash_has_key(VALUE hash, VALUE key);
835
+ VALUE rb_hash_default_value(VALUE hash, VALUE key);
836
+ VALUE rb_hash_set_default_proc(VALUE hash, VALUE proc);
837
+ long rb_objid_hash(st_index_t index);
838
+ st_table *rb_init_identtable(void);
839
+ st_table *rb_init_identtable_with_size(st_index_t size);
840
+
841
+ #define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h)
842
+ VALUE rb_hash_keys(VALUE hash);
843
+ VALUE rb_hash_values(VALUE hash);
844
+ VALUE rb_hash_rehash(VALUE hash);
845
+ #define HASH_DELETED FL_USER1
846
+ #define HASH_PROC_DEFAULT FL_USER2
847
+
848
+ /* inits.c */
849
+ void rb_call_inits(void);
850
+
851
+ /* io.c */
852
+ const char *ruby_get_inplace_mode(void);
853
+ void ruby_set_inplace_mode(const char *);
854
+ ssize_t rb_io_bufread(VALUE io, void *buf, size_t size);
855
+ void rb_stdio_set_default_encoding(void);
856
+ void rb_write_error_str(VALUE mesg);
857
+ VALUE rb_io_flush_raw(VALUE, int);
858
+ size_t rb_io_memsize(const rb_io_t *);
859
+
860
+ /* load.c */
861
+ VALUE rb_get_load_path(void);
862
+ VALUE rb_get_expanded_load_path(void);
863
+ int rb_require_internal(VALUE fname, int safe);
864
+ NORETURN(void rb_load_fail(VALUE, const char*));
865
+
866
+ /* loadpath.c */
867
+ extern const char ruby_exec_prefix[];
868
+ extern const char ruby_initial_load_paths[];
869
+
870
+ /* localeinit.c */
871
+ int Init_enc_set_filesystem_encoding(void);
872
+
873
+ /* math.c */
874
+ VALUE rb_math_atan2(VALUE, VALUE);
875
+ VALUE rb_math_cos(VALUE);
876
+ VALUE rb_math_cosh(VALUE);
877
+ VALUE rb_math_exp(VALUE);
878
+ VALUE rb_math_hypot(VALUE, VALUE);
879
+ VALUE rb_math_log(int argc, const VALUE *argv);
880
+ VALUE rb_math_sin(VALUE);
881
+ VALUE rb_math_sinh(VALUE);
882
+ #if 0
883
+ VALUE rb_math_sqrt(VALUE);
884
+ #endif
885
+
886
+ /* newline.c */
887
+ void Init_newline(void);
888
+
889
+ /* numeric.c */
890
+ int rb_num_to_uint(VALUE val, unsigned int *ret);
891
+ VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
892
+ int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl);
893
+ double ruby_float_mod(double x, double y);
894
+ int rb_num_negative_p(VALUE);
895
+ VALUE rb_int_succ(VALUE num);
896
+ VALUE rb_int_pred(VALUE num);
897
+ VALUE rb_dbl_hash(double d);
898
+
899
+ #if USE_FLONUM
900
+ #define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
901
+ #define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
902
+ #endif
903
+
904
+ static inline double
905
+ rb_float_flonum_value(VALUE v)
906
+ {
907
+ #if USE_FLONUM
908
+ if (v != (VALUE)0x8000000000000002) { /* LIKELY */
909
+ union {
910
+ double d;
911
+ VALUE v;
912
+ } t;
913
+
914
+ VALUE b63 = (v >> 63);
915
+ /* e: xx1... -> 011... */
916
+ /* xx0... -> 100... */
917
+ /* ^b63 */
918
+ t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~0x03), 3);
919
+ return t.d;
920
+ }
921
+ #endif
922
+ return 0.0;
923
+ }
924
+
925
+ static inline double
926
+ rb_float_noflonum_value(VALUE v)
927
+ {
928
+ return ((struct RFloat *)v)->float_value;
929
+ }
930
+
931
+ static inline double
932
+ rb_float_value_inline(VALUE v)
933
+ {
934
+ if (FLONUM_P(v)) {
935
+ return rb_float_flonum_value(v);
936
+ }
937
+ return rb_float_noflonum_value(v);
938
+ }
939
+
940
+ static inline VALUE
941
+ rb_float_new_inline(double d)
942
+ {
943
+ #if USE_FLONUM
944
+ union {
945
+ double d;
946
+ VALUE v;
947
+ } t;
948
+ int bits;
949
+
950
+ t.d = d;
951
+ bits = (int)((VALUE)(t.v >> 60) & 0x7);
952
+ /* bits contains 3 bits of b62..b60. */
953
+ /* bits - 3 = */
954
+ /* b011 -> b000 */
955
+ /* b100 -> b001 */
956
+
957
+ if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
958
+ !((bits-3) & ~0x01)) {
959
+ return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
960
+ }
961
+ else if (t.v == (VALUE)0) {
962
+ /* +0.0 */
963
+ return 0x8000000000000002;
964
+ }
965
+ /* out of range */
966
+ #endif
967
+ return rb_float_new_in_heap(d);
968
+ }
969
+
970
+ #define rb_float_value(v) rb_float_value_inline(v)
971
+ #define rb_float_new(d) rb_float_new_inline(d)
972
+
973
+ /* object.c */
974
+ void rb_obj_copy_ivar(VALUE dest, VALUE obj);
975
+ VALUE rb_obj_equal(VALUE obj1, VALUE obj2);
976
+ VALUE rb_class_search_ancestor(VALUE klass, VALUE super);
977
+ NORETURN(void rb_undefined_alloc(VALUE klass));
978
+ double rb_num_to_dbl(VALUE val);
979
+ VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound);
980
+
981
+ struct RBasicRaw {
982
+ VALUE flags;
983
+ VALUE klass;
984
+ };
985
+
986
+ #define RBASIC_CLEAR_CLASS(obj) (((struct RBasicRaw *)((VALUE)(obj)))->klass = 0)
987
+ #define RBASIC_SET_CLASS_RAW(obj, cls) (((struct RBasicRaw *)((VALUE)(obj)))->klass = (cls))
988
+ #define RBASIC_SET_CLASS(obj, cls) do { \
989
+ VALUE _obj_ = (obj); \
990
+ RB_OBJ_WRITE(_obj_, &((struct RBasicRaw *)(_obj_))->klass, cls); \
991
+ } while (0)
992
+
993
+ /* parse.y */
994
+ #ifndef USE_SYMBOL_GC
995
+ #define USE_SYMBOL_GC 1
996
+ #endif
997
+ VALUE rb_parser_get_yydebug(VALUE);
998
+ VALUE rb_parser_set_yydebug(VALUE, VALUE);
999
+ int rb_is_const_name(VALUE name);
1000
+ int rb_is_class_name(VALUE name);
1001
+ int rb_is_global_name(VALUE name);
1002
+ int rb_is_instance_name(VALUE name);
1003
+ int rb_is_attrset_name(VALUE name);
1004
+ int rb_is_local_name(VALUE name);
1005
+ int rb_is_method_name(VALUE name);
1006
+ int rb_is_junk_name(VALUE name);
1007
+ int rb_is_const_sym(VALUE sym);
1008
+ int rb_is_class_sym(VALUE sym);
1009
+ int rb_is_global_sym(VALUE sym);
1010
+ int rb_is_instance_sym(VALUE sym);
1011
+ int rb_is_attrset_sym(VALUE sym);
1012
+ int rb_is_local_sym(VALUE sym);
1013
+ int rb_is_method_sym(VALUE sym);
1014
+ int rb_is_junk_sym(VALUE sym);
1015
+ ID rb_make_internal_id(void);
1016
+ void rb_gc_free_dsymbol(VALUE);
1017
+ ID rb_id_attrget(ID id);
1018
+
1019
+ /* proc.c */
1020
+ VALUE rb_proc_location(VALUE self);
1021
+ st_index_t rb_hash_proc(st_index_t hash, VALUE proc);
1022
+ int rb_block_arity(void);
1023
+ VALUE rb_func_proc_new(rb_block_call_func_t func, VALUE val);
1024
+ VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val);
1025
+
1026
+ /* process.c */
1027
+ #define RB_MAX_GROUPS (65536)
1028
+
1029
+ struct rb_execarg {
1030
+ union {
1031
+ struct {
1032
+ VALUE shell_script;
1033
+ } sh;
1034
+ struct {
1035
+ VALUE command_name;
1036
+ VALUE command_abspath; /* full path string or nil */
1037
+ VALUE argv_str;
1038
+ VALUE argv_buf;
1039
+ } cmd;
1040
+ } invoke;
1041
+ VALUE redirect_fds;
1042
+ VALUE envp_str;
1043
+ VALUE envp_buf;
1044
+ VALUE dup2_tmpbuf;
1045
+ unsigned use_shell : 1;
1046
+ unsigned pgroup_given : 1;
1047
+ unsigned umask_given : 1;
1048
+ unsigned unsetenv_others_given : 1;
1049
+ unsigned unsetenv_others_do : 1;
1050
+ unsigned close_others_given : 1;
1051
+ unsigned close_others_do : 1;
1052
+ unsigned chdir_given : 1;
1053
+ unsigned new_pgroup_given : 1;
1054
+ unsigned new_pgroup_flag : 1;
1055
+ unsigned uid_given : 1;
1056
+ unsigned gid_given : 1;
1057
+ rb_pid_t pgroup_pgid; /* asis(-1), new pgroup(0), specified pgroup (0<V). */
1058
+ VALUE rlimit_limits; /* Qfalse or [[rtype, softlim, hardlim], ...] */
1059
+ mode_t umask_mask;
1060
+ rb_uid_t uid;
1061
+ rb_gid_t gid;
1062
+ int close_others_maxhint;
1063
+ VALUE fd_dup2;
1064
+ VALUE fd_close;
1065
+ VALUE fd_open;
1066
+ VALUE fd_dup2_child;
1067
+ VALUE env_modification; /* Qfalse or [[k1,v1], ...] */
1068
+ VALUE chdir_dir;
1069
+ };
1070
+
1071
+ /* argv_str contains extra two elements.
1072
+ * The beginning one is for /bin/sh used by exec_with_sh.
1073
+ * The last one for terminating NULL used by execve.
1074
+ * See rb_exec_fillarg() in process.c. */
1075
+ #define ARGVSTR2ARGC(argv_str) (RSTRING_LEN(argv_str) / sizeof(char *) - 2)
1076
+ #define ARGVSTR2ARGV(argv_str) ((char **)RSTRING_PTR(argv_str) + 1)
1077
+
1078
+ rb_pid_t rb_fork_ruby(int *status);
1079
+ void rb_last_status_clear(void);
1080
+
1081
+ /* rational.c */
1082
+ VALUE rb_lcm(VALUE x, VALUE y);
1083
+ VALUE rb_rational_reciprocal(VALUE x);
1084
+ VALUE rb_cstr_to_rat(const char *, int);
1085
+
1086
+ /* re.c */
1087
+ VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
1088
+ VALUE rb_reg_check_preprocess(VALUE);
1089
+ long rb_reg_search0(VALUE, VALUE, long, int, int);
1090
+ void rb_backref_set_string(VALUE string, long pos, long len);
1091
+
1092
+ /* signal.c */
1093
+ extern int ruby_enable_coredump;
1094
+ int rb_get_next_signal(void);
1095
+ int rb_sigaltstack_size(void);
1096
+
1097
+ /* strftime.c */
1098
+ #ifdef RUBY_ENCODING_H
1099
+ size_t rb_strftime_timespec(char *s, size_t maxsize, const char *format, rb_encoding *enc,
1100
+ const struct vtm *vtm, struct timespec *ts, int gmt);
1101
+ size_t rb_strftime(char *s, size_t maxsize, const char *format, rb_encoding *enc,
1102
+ const struct vtm *vtm, VALUE timev, int gmt);
1103
+ #endif
1104
+
1105
+ /* string.c */
1106
+ void Init_frozen_strings(void);
1107
+ VALUE rb_fstring(VALUE);
1108
+ VALUE rb_fstring_new(const char *ptr, long len);
1109
+ #define rb_fstring_lit(str) rb_fstring_new((str), rb_strlen_lit(str))
1110
+ #define rb_fstring_literal(str) rb_fstring_lit(str)
1111
+ VALUE rb_fstring_cstr(const char *str);
1112
+ #if defined(__GNUC__) && !defined(__PCC__)
1113
+ #define rb_fstring_cstr(str) __extension__ ( \
1114
+ { \
1115
+ (__builtin_constant_p(str)) ? \
1116
+ rb_fstring_new((str), (long)strlen(str)) : \
1117
+ rb_fstring_cstr(str); \
1118
+ })
1119
+ #endif
1120
+ int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
1121
+ int rb_str_symname_p(VALUE);
1122
+ VALUE rb_str_quote_unprintable(VALUE);
1123
+ VALUE rb_id_quote_unprintable(ID);
1124
+ #define QUOTE(str) rb_str_quote_unprintable(str)
1125
+ #define QUOTE_ID(id) rb_id_quote_unprintable(id)
1126
+ void rb_str_fill_terminator(VALUE str, const int termlen);
1127
+ VALUE rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg);
1128
+ #ifdef RUBY_ENCODING_H
1129
+ VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc);
1130
+ VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
1131
+ rb_encoding *from, int ecflags, VALUE ecopts);
1132
+ #endif
1133
+ #define STR_NOEMBED FL_USER1
1134
+ #define STR_SHARED FL_USER2 /* = ELTS_SHARED */
1135
+ #define STR_EMBED_P(str) (!FL_TEST_RAW((str), STR_NOEMBED))
1136
+ #define STR_SHARED_P(s) FL_ALL_RAW((s), STR_NOEMBED|ELTS_SHARED)
1137
+ #define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
1138
+ #define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
1139
+ size_t rb_str_memsize(VALUE);
1140
+ VALUE rb_sym_proc_call(VALUE args, VALUE sym, int argc, const VALUE *argv, VALUE passed_proc);
1141
+ VALUE rb_sym_to_proc(VALUE sym);
1142
+
1143
+ /* symbol.c */
1144
+ #ifdef RUBY_ENCODING_H
1145
+ VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc);
1146
+ VALUE rb_sym_intern_cstr(const char *ptr, rb_encoding *enc);
1147
+ #ifdef __GNUC__
1148
+ #define rb_sym_intern_cstr(ptr, enc) __extension__ ( \
1149
+ { \
1150
+ (__builtin_constant_p(ptr)) ? \
1151
+ rb_sym_intern((ptr), (long)strlen(ptr), (enc)) : \
1152
+ rb_sym_intern_cstr((ptr), (enc)); \
1153
+ })
1154
+ #endif
1155
+ #endif
1156
+ VALUE rb_sym_intern_ascii(const char *ptr, long len);
1157
+ VALUE rb_sym_intern_ascii_cstr(const char *ptr);
1158
+ #ifdef __GNUC__
1159
+ #define rb_sym_intern_ascii_cstr(ptr) __extension__ ( \
1160
+ { \
1161
+ (__builtin_constant_p(ptr)) ? \
1162
+ rb_sym_intern_ascii((ptr), (long)strlen(ptr)) : \
1163
+ rb_sym_intern_ascii_cstr(ptr); \
1164
+ })
1165
+ #endif
1166
+
1167
+ /* struct.c */
1168
+ VALUE rb_struct_init_copy(VALUE copy, VALUE s);
1169
+ VALUE rb_struct_lookup(VALUE s, VALUE idx);
1170
+
1171
+ /* time.c */
1172
+ struct timeval rb_time_timeval(VALUE);
1173
+
1174
+ /* thread.c */
1175
+ VALUE rb_obj_is_mutex(VALUE obj);
1176
+ VALUE rb_suppress_tracing(VALUE (*func)(VALUE), VALUE arg);
1177
+ void rb_thread_execute_interrupts(VALUE th);
1178
+ void rb_clear_trace_func(void);
1179
+ VALUE rb_get_coverages(void);
1180
+ VALUE rb_thread_shield_new(void);
1181
+ VALUE rb_thread_shield_wait(VALUE self);
1182
+ VALUE rb_thread_shield_release(VALUE self);
1183
+ VALUE rb_thread_shield_destroy(VALUE self);
1184
+ int rb_thread_to_be_killed(VALUE thread);
1185
+ void rb_mutex_allow_trap(VALUE self, int val);
1186
+ VALUE rb_uninterruptible(VALUE (*b_proc)(ANYARGS), VALUE data);
1187
+ VALUE rb_mutex_owned_p(VALUE self);
1188
+ void ruby_kill(rb_pid_t pid, int sig);
1189
+
1190
+ /* thread_pthread.c, thread_win32.c */
1191
+ void Init_native_thread(void);
1192
+ int rb_divert_reserved_fd(int fd);
1193
+
1194
+ /* transcode.c */
1195
+ extern VALUE rb_cEncodingConverter;
1196
+ size_t rb_econv_memsize(rb_econv_t *);
1197
+
1198
+ /* us_ascii.c */
1199
+ extern rb_encoding OnigEncodingUS_ASCII;
1200
+
1201
+ /* util.c */
1202
+ char *ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve);
1203
+ char *ruby_hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rve);
1204
+
1205
+ /* utf_8.c */
1206
+ extern rb_encoding OnigEncodingUTF_8;
1207
+
1208
+ /* variable.c */
1209
+ size_t rb_generic_ivar_memsize(VALUE);
1210
+ VALUE rb_search_class_path(VALUE);
1211
+ VALUE rb_attr_delete(VALUE, ID);
1212
+ VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef);
1213
+ void rb_autoload_str(VALUE mod, ID id, VALUE file);
1214
+
1215
+ /* version.c */
1216
+ extern const char ruby_engine[];
1217
+
1218
+ /* vm_insnhelper.h */
1219
+ rb_serial_t rb_next_class_serial(void);
1220
+
1221
+ /* vm.c */
1222
+ VALUE rb_obj_is_thread(VALUE obj);
1223
+ void rb_vm_mark(void *ptr);
1224
+ void Init_BareVM(void);
1225
+ void Init_vm_objects(void);
1226
+ VALUE rb_vm_top_self(void);
1227
+ void rb_thread_recycle_stack_release(VALUE *);
1228
+ void rb_vm_change_state(void);
1229
+ void rb_vm_inc_const_missing_count(void);
1230
+ void rb_thread_mark(void *th);
1231
+ const void **rb_vm_get_insns_address_table(void);
1232
+ VALUE rb_sourcefilename(void);
1233
+ VALUE rb_source_location(int *pline);
1234
+ const char *rb_source_loc(int *pline);
1235
+ void rb_vm_pop_cfunc_frame(void);
1236
+ int rb_vm_add_root_module(ID id, VALUE module);
1237
+ void rb_vm_check_redefinition_by_prepend(VALUE klass);
1238
+ VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements);
1239
+ VALUE ruby_vm_sysstack_error_copy(void);
1240
+
1241
+ /* vm_dump.c */
1242
+ void rb_print_backtrace(void);
1243
+
1244
+ /* vm_eval.c */
1245
+ void Init_vm_eval(void);
1246
+ VALUE rb_current_realfilepath(void);
1247
+ VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE);
1248
+ typedef void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE);
1249
+ VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv,
1250
+ rb_check_funcall_hook *hook, VALUE arg);
1251
+ VALUE rb_check_funcall_default(VALUE, ID, int, const VALUE *, VALUE);
1252
+ VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, int *stateptr);
1253
+ VALUE rb_yield_1(VALUE val);
1254
+
1255
+ /* vm_insnhelper.c */
1256
+ VALUE rb_equal_opt(VALUE obj1, VALUE obj2);
1257
+
1258
+ /* vm_method.c */
1259
+ void Init_eval_method(void);
1260
+ int rb_method_defined_by(VALUE obj, ID mid, VALUE (*cfunc)(ANYARGS));
1261
+
1262
+ /* miniprelude.c, prelude.c */
1263
+ void Init_prelude(void);
1264
+
1265
+ /* vm_backtrace.c */
1266
+ void Init_vm_backtrace(void);
1267
+ VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval);
1268
+ VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval);
1269
+
1270
+ VALUE rb_make_backtrace(void);
1271
+ void rb_backtrace_print_as_bugreport(void);
1272
+ int rb_backtrace_p(VALUE obj);
1273
+ VALUE rb_backtrace_to_str_ary(VALUE obj);
1274
+ VALUE rb_backtrace_to_location_ary(VALUE obj);
1275
+ void rb_backtrace_print_to(VALUE output);
1276
+ VALUE rb_vm_backtrace_object(void);
1277
+
1278
+ RUBY_SYMBOL_EXPORT_BEGIN
1279
+ const char *rb_objspace_data_type_name(VALUE obj);
1280
+
1281
+ /* Temporary. This API will be removed (renamed). */
1282
+ VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd);
1283
+
1284
+ /* bignum.c (export) */
1285
+ VALUE rb_big_mul_normal(VALUE x, VALUE y);
1286
+ VALUE rb_big_mul_balance(VALUE x, VALUE y);
1287
+ VALUE rb_big_mul_karatsuba(VALUE x, VALUE y);
1288
+ VALUE rb_big_mul_toom3(VALUE x, VALUE y);
1289
+ VALUE rb_big_sq_fast(VALUE x);
1290
+ VALUE rb_big_divrem_normal(VALUE x, VALUE y);
1291
+ VALUE rb_big2str_poweroftwo(VALUE x, int base);
1292
+ VALUE rb_big2str_generic(VALUE x, int base);
1293
+ VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck);
1294
+ VALUE rb_str2big_normal(VALUE arg, int base, int badcheck);
1295
+ VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck);
1296
+ #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
1297
+ VALUE rb_big_mul_gmp(VALUE x, VALUE y);
1298
+ VALUE rb_big_divrem_gmp(VALUE x, VALUE y);
1299
+ VALUE rb_big2str_gmp(VALUE x, int base);
1300
+ VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
1301
+ #endif
1302
+
1303
+ /* error.c (export) */
1304
+ int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
1305
+
1306
+ /* file.c (export) */
1307
+ #ifdef HAVE_READLINK
1308
+ VALUE rb_readlink(VALUE path, rb_encoding *enc);
1309
+ #endif
1310
+ #ifdef __APPLE__
1311
+ VALUE rb_str_normalize_ospath(const char *ptr, long len);
1312
+ #endif
1313
+
1314
+ /* hash.c (export) */
1315
+ VALUE rb_hash_delete_entry(VALUE hash, VALUE key);
1316
+ VALUE rb_ident_hash_new(void);
1317
+
1318
+ /* io.c (export) */
1319
+ void rb_maygvl_fd_fix_cloexec(int fd);
1320
+ int rb_gc_for_fd(int err);
1321
+
1322
+ /* numeric.c (export) */
1323
+ VALUE rb_int_positive_pow(long x, unsigned long y);
1324
+
1325
+ /* process.c (export) */
1326
+ int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen);
1327
+ 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);
1328
+ VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell);
1329
+ struct rb_execarg *rb_execarg_get(VALUE execarg_obj); /* dangerous. needs GC guard. */
1330
+ VALUE rb_execarg_init(int argc, const VALUE *argv, int accept_shell, VALUE execarg_obj);
1331
+ int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val);
1332
+ void rb_execarg_parent_start(VALUE execarg_obj);
1333
+ void rb_execarg_parent_end(VALUE execarg_obj);
1334
+ int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char* errmsg, size_t errmsg_buflen);
1335
+ VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash);
1336
+ void rb_execarg_setenv(VALUE execarg_obj, VALUE env);
1337
+
1338
+ /* rational.c (export) */
1339
+ VALUE rb_gcd_normal(VALUE self, VALUE other);
1340
+ #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
1341
+ VALUE rb_gcd_gmp(VALUE x, VALUE y);
1342
+ #endif
1343
+
1344
+ /* string.c (export) */
1345
+ #ifdef RUBY_ENCODING_H
1346
+ /* internal use */
1347
+ VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
1348
+ #endif
1349
+
1350
+ /* thread.c (export) */
1351
+ int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
1352
+
1353
+ /* util.c (export) */
1354
+ extern const signed char ruby_digit36_to_number_table[];
1355
+ extern const char ruby_hexdigits[];
1356
+ extern unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow);
1357
+
1358
+ /* variable.c (export) */
1359
+ void rb_gc_mark_global_tbl(void);
1360
+ void rb_mark_generic_ivar(VALUE);
1361
+ VALUE rb_const_missing(VALUE klass, VALUE name);
1362
+ int rb_class_ivar_set(VALUE klass, ID vid, VALUE value);
1363
+ st_table *rb_st_copy(VALUE obj, struct st_table *orig_tbl);
1364
+
1365
+ /* gc.c (export) */
1366
+ VALUE rb_wb_protected_newobj_of(VALUE, VALUE);
1367
+ VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE);
1368
+
1369
+ size_t rb_obj_memsize_of(VALUE);
1370
+ void rb_gc_verify_internal_consistency(void);
1371
+
1372
+ #define RB_OBJ_GC_FLAGS_MAX 5
1373
+ size_t rb_obj_gc_flags(VALUE, ID[], size_t);
1374
+ void rb_gc_mark_values(long n, const VALUE *values);
1375
+
1376
+ #if IMEMO_DEBUG
1377
+ VALUE rb_imemo_new_debug(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0, const char *file, int line);
1378
+ #define rb_imemo_new(type, v1, v2, v3, v0) rb_imemo_new_debug(type, v1, v2, v3, v0, __FILE__, __LINE__)
1379
+ #else
1380
+ VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
1381
+ #endif
1382
+
1383
+ RUBY_SYMBOL_EXPORT_END
1384
+
1385
+ #define RUBY_DTRACE_CREATE_HOOK(name, arg) \
1386
+ RUBY_DTRACE_HOOK(name##_CREATE, arg)
1387
+ #define RUBY_DTRACE_HOOK(name, arg) \
1388
+ do { \
1389
+ if (UNLIKELY(RUBY_DTRACE_##name##_ENABLED())) { \
1390
+ int dtrace_line; \
1391
+ const char *dtrace_file = rb_source_loc(&dtrace_line); \
1392
+ if (!dtrace_file) dtrace_file = ""; \
1393
+ RUBY_DTRACE_##name(arg, dtrace_file, dtrace_line); \
1394
+ } \
1395
+ } while (0)
1396
+
1397
+ #if defined(__cplusplus)
1398
+ #if 0
1399
+ { /* satisfy cc-mode */
1400
+ #endif
1401
+ } /* extern "C" { */
1402
+ #endif
1403
+
1404
+ #endif /* RUBY_INTERNAL_H */