looksee 1.1.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 89abb83fc7bfb2ca723fe3a4f9a35018836c0e81
4
- data.tar.gz: ddb31cc1363b5be2652329a2180f872e6beb5558
3
+ metadata.gz: 043c93dbfb3a9b3265c16bad31a24a55d44347dc
4
+ data.tar.gz: 7bf0c2ddc5754750249f294558b745735cd6df5c
5
5
  SHA512:
6
- metadata.gz: 9843ab0b2bc0965c470670176132bd1310faf453771a29f0100c81702f78b24dfdd67da1151a873091d82a8476465964e813fd505b4ae01ca2b68d2a072603d6
7
- data.tar.gz: ba731cc14f1e6b67382983942c0eb56eed157558cc3082cca7b00002bee9150a32c09d57bc9c2d14c3f08e348fbcb296be95fcf564d4c7b13eb659140d5a8117
6
+ metadata.gz: 3c4b7518aa4038be29936338144dec78cd168d79ff0aafefa5f9a6b952ef17e493e3bdf1b651b756a1693adcd5b8d53ab6954cc3fe86439e3e4c680204bbf6b5
7
+ data.tar.gz: dade1e434a9b715cac40ffc689bfe1d5ba2da064a7f33bcad870b693c4dbc93772e769af422161edb0eb1713e8ad02f41b75b5b697e422bd8f98d39c68389c38
data/CHANGELOG CHANGED
@@ -1,3 +1,16 @@
1
+ == 2.0.0 2014-01-01
2
+
3
+ * Support for MRI 2.1, JRuby 1.7, Rubinius 2.2.
4
+ * Looksee now only adds #ls to Object. The old way would frequently conflict
5
+ with, e.g., Rails controller conventions.
6
+
7
+ - object.edit is now object.ls.edit.
8
+ - Looksee.rename now just takes the new name for :ls.
9
+ - The LOOKSEE_METHODS env var is now LOOKSEE_METHOD, and is simply the new
10
+ name for :ls.
11
+ * Raise informative errors when #edit fails (e.g., for methods without a source
12
+ location).
13
+
1
14
  == 1.1.0 2013-03-22
2
15
 
3
16
  * Support for MRI 2.0.0.
data/README.markdown CHANGED
@@ -1,7 +1,7 @@
1
- # Looksee
1
+ # Looksee [![Build Status](https://travis-ci.org/oggy/looksee.png)](https://travis-ci.org/oggy/looksee)
2
2
 
3
3
  A tool for illustrating the ancestry and method lookup path of
4
- objects. Great for exploring unfamiliar codebases!
4
+ objects. Handy for exploring unfamiliar codebases.
5
5
 
6
6
  ## How
7
7
 
@@ -16,92 +16,83 @@ Pop this in your `.irbrc`:
16
16
  Now each object has a method `ls`, which shows you all its methods.
17
17
 
18
18
  irb> [].ls
19
- => BasicObject
20
- ! __send__ instance_eval singleton_method_added
21
- != equal? instance_exec singleton_method_removed
22
- == initialize method_missing singleton_method_undefined
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
23
24
  Kernel
24
- !~ freeze puts
25
- <=> frozen? raise
26
- === gem rand
27
- =~ gem_original_require readline
28
- Array gets readlines
29
- Complex global_variables remove_instance_variable
30
- Float hash require
31
- Integer initialize_clone require_relative
32
- Rational initialize_copy respond_to?
33
- String initialize_dup respond_to_missing?
34
- URI inspect select
35
- __callee__ instance_of? send
36
- __id__ instance_variable_defined? set_trace_func
37
- __method__ instance_variable_get singleton_class
38
- ` instance_variable_set singleton_methods
39
- abort instance_variables sleep
40
- at_exit is_a? spawn
41
- autoload iterator? sprintf
42
- autoload? kind_of? srand
43
- binding lambda syscall
44
- block_given? load system
45
- caller local_variables taint
46
- catch loop tainted?
47
- class method tap
48
- clone methods test
49
- define_singleton_method nil? throw
50
- display object_id to_enum
51
- dup open to_s
52
- enum_for p trace_var
53
- eql? print trap
54
- eval printf trust
55
- exec private_methods untaint
56
- exit proc untrace_var
57
- exit! protected_methods untrust
58
- extend public_method untrusted?
59
- fail public_methods warn
60
- fork public_send y
61
- format putc
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
62
62
  Looksee::ObjectMixin
63
- edit ls
63
+ ls
64
64
  Object
65
- default_src_encoding oauth taguri to_yaml_properties
66
- in? patch taguri= to_yaml_style
67
- irb_binding singleton_class timeout
68
- load_if_available syck_to_yaml to_yaml
65
+ default_src_encoding irb_binding
69
66
  Enumerable
70
- all? drop_while first min select
71
- any? each_cons flat_map min_by slice_before
72
- by each_entry grep minmax sort
73
- chunk each_slice group_by minmax_by sort_by
74
- collect each_with_index include? none? take
75
- collect_concat each_with_object inject one? take_while
76
- count entries map partition to_a
77
- cycle find max reduce to_set
78
- detect find_all max_by reject zip
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
79
75
  drop find_index member? reverse_each
76
+ drop_while first min select
80
77
  Array
81
- & drop_while map! size
82
- * each pack slice
83
- + each_index permutation slice!
84
- - empty? pop sort
85
- << eql? product sort!
86
- <=> fetch push sort_by!
87
- == fill rassoc taguri
88
- [] find_index reject taguri=
89
- []= first reject! take
90
- assoc flatten repeated_combination take_while
91
- at flatten! repeated_permutation to_a
92
- clear frozen? replace to_ary
93
- collect hash reverse to_s
94
- collect! include? reverse! to_yaml
95
- combination index reverse_each transpose
96
- compact initialize rindex uniq
97
- compact! initialize_copy rotate uniq!
98
- concat insert rotate! unshift
99
- count inspect sample values_at
100
- cycle join select yaml_initialize
101
- delete keep_if select! zip
102
- delete_at last shift |
103
- delete_if length shuffle
104
- drop map shuffle!
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! |
105
96
 
106
97
  Methods are colored according to whether they're public, protected,
107
98
  private, undefined (using Module#undef_method), or overridden.
@@ -122,12 +113,12 @@ Or filter the list by Regexp:
122
113
  Enumerable
123
114
  to_a to_set
124
115
  Array
125
- to_a to_ary to_s to_yaml
116
+ to_a to_ary to_s to_yaml
126
117
 
127
118
  And if you want to know more about any of those methods, Looksee can
128
119
  take you straight to the source in your editor:
129
120
 
130
- > [].edit('to_set')
121
+ > [].ls.edit :to_set
131
122
 
132
123
  By default, this uses `vi`; customize it like this:
133
124
 
@@ -144,10 +135,9 @@ Enjoy!
144
135
 
145
136
  Looksee supports:
146
137
 
147
- * MRI 1.8.7, 1.9.2, 1.9.3, 2.0.0
148
- * REE 1.8.7
149
- * JRuby 1.6.7
150
- * Rubinius 1.2.3, 1.2.4
138
+ * MRI 1.9.3, 2.0, 2.1
139
+ * JRuby 1.7
140
+ * Rubinius 2.2
151
141
 
152
142
  ## Contributing
153
143
 
data/ext/extconf.rb CHANGED
@@ -4,7 +4,9 @@ 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.0.0'
7
+ if RUBY_VERSION >= '2.1.0'
8
+ $CPPFLAGS << " -Imri/2.1.0"
9
+ elsif RUBY_VERSION >= '2.0.0'
8
10
  $CPPFLAGS << " -Imri/2.0.0"
9
11
  elsif RUBY_VERSION >= '1.9.3'
10
12
  $CPPFLAGS << " -Imri/1.9.3"
@@ -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 */