Ruby 2.1.5p273(2014-11-13revision48405)

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

internal.h
Go to the documentation of this file.
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;
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 void rb_obj_copy_ivar(VALUE dest, VALUE obj);
599 VALUE rb_obj_equal(VALUE obj1, VALUE obj2);
600 VALUE rb_class_search_ancestor(VALUE klass, VALUE super);
601
602 struct RBasicRaw {
603 VALUE flags;
604 VALUE klass;
605 };
606
607 #define RBASIC_CLEAR_CLASS(obj) (((struct RBasicRaw *)((VALUE)(obj)))->klass = 0)
608 #define RBASIC_SET_CLASS_RAW(obj, cls) (((struct RBasicRaw *)((VALUE)(obj)))->klass = (cls))
609 #define RBASIC_SET_CLASS(obj, cls) do { \
610 VALUE _obj_ = (obj); \
611 RB_OBJ_WRITE(_obj_, &((struct RBasicRaw *)(_obj_))->klass, cls); \
612 } while (0)
613
614 /* parse.y */
615 VALUE rb_parser_get_yydebug(VALUE);
616 VALUE rb_parser_set_yydebug(VALUE, VALUE);
617 int rb_is_const_name(VALUE name);
618 int rb_is_class_name(VALUE name);
619 int rb_is_global_name(VALUE name);
620 int rb_is_instance_name(VALUE name);
621 int rb_is_attrset_name(VALUE name);
622 int rb_is_local_name(VALUE name);
623 int rb_is_method_name(VALUE name);
624 int rb_is_junk_name(VALUE name);
625 void rb_gc_mark_parser(void);
626 void rb_gc_mark_symbols(int full_mark);
627
628 /* proc.c */
629 VALUE rb_proc_location(VALUE self);
630 st_index_t rb_hash_proc(st_index_t hash, VALUE proc);
631 int rb_block_arity(void);
632
633 /* process.c */
634 #define RB_MAX_GROUPS (65536)
635
636 struct rb_execarg {
637 int use_shell;
638 union {
639 struct {
640 VALUE shell_script;
641 } sh;
642 struct {
643 VALUE command_name;
644 VALUE command_abspath; /* full path string or nil */
645 VALUE argv_str;
646 VALUE argv_buf;
647 } cmd;
648 } invoke;
649 VALUE redirect_fds;
650 VALUE envp_str;
651 VALUE envp_buf;
652 VALUE dup2_tmpbuf;
653 unsigned pgroup_given : 1;
654 unsigned umask_given : 1;
655 unsigned unsetenv_others_given : 1;
656 unsigned unsetenv_others_do : 1;
657 unsigned close_others_given : 1;
658 unsigned close_others_do : 1;
659 unsigned chdir_given : 1;
660 unsigned new_pgroup_given : 1;
661 unsigned new_pgroup_flag : 1;
662 unsigned uid_given : 1;
663 unsigned gid_given : 1;
664 rb_pid_t pgroup_pgid; /* asis(-1), new pgroup(0), specified pgroup (0<V). */
665 VALUE rlimit_limits; /* Qfalse or [[rtype, softlim, hardlim], ...] */
666 mode_t umask_mask;
667 rb_uid_t uid;
668 rb_gid_t gid;
669 VALUE fd_dup2;
670 VALUE fd_close;
671 VALUE fd_open;
672 VALUE fd_dup2_child;
673 int close_others_maxhint;
674 VALUE env_modification; /* Qfalse or [[k1,v1], ...] */
675 VALUE chdir_dir;
676 };
677
678 /* argv_str contains extra two elements.
679 * The beginning one is for /bin/sh used by exec_with_sh.
680 * The last one for terminating NULL used by execve.
681 * See rb_exec_fillarg() in process.c. */
682 #define ARGVSTR2ARGC(argv_str) (RSTRING_LEN(argv_str) / sizeof(char *) - 2)
683 #define ARGVSTR2ARGV(argv_str) ((char **)RSTRING_PTR(argv_str) + 1)
684
685 rb_pid_t rb_fork_ruby(int *status);
686 void rb_last_status_clear(void);
687
688 /* rational.c */
689 VALUE rb_lcm(VALUE x, VALUE y);
690 VALUE rb_rational_reciprocal(VALUE x);
691
692 /* re.c */
693 VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
694 VALUE rb_reg_check_preprocess(VALUE);
695
696 /* signal.c */
697 int rb_get_next_signal(void);
698 int rb_sigaltstack_size(void);
699
700 /* strftime.c */
701 #ifdef RUBY_ENCODING_H
702 size_t rb_strftime_timespec(char *s, size_t maxsize, const char *format, rb_encoding *enc,
703 const struct vtm *vtm, struct timespec *ts, int gmt);
704 size_t rb_strftime(char *s, size_t maxsize, const char *format, rb_encoding *enc,
705 const struct vtm *vtm, VALUE timev, int gmt);
706 #endif
707
708 /* string.c */
709 VALUE rb_fstring(VALUE);
710 int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
711 int rb_str_symname_p(VALUE);
712 VALUE rb_str_quote_unprintable(VALUE);
713 VALUE rb_id_quote_unprintable(ID);
714 #define QUOTE(str) rb_str_quote_unprintable(str)
715 #define QUOTE_ID(id) rb_id_quote_unprintable(id)
716 void rb_str_fill_terminator(VALUE str, const int termlen);
717 VALUE rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg);
718 #ifdef RUBY_ENCODING_H
719 VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc);
720 #endif
721 #define STR_NOEMBED FL_USER1
722 #define STR_SHARED FL_USER2 /* = ELTS_SHARED */
723 #define STR_ASSOC FL_USER3
724 #define STR_SHARED_P(s) FL_ALL((s), STR_NOEMBED|ELTS_SHARED)
725 #define STR_ASSOC_P(s) FL_ALL((s), STR_NOEMBED|STR_ASSOC)
726 #define STR_NOCAPA (STR_NOEMBED|ELTS_SHARED|STR_ASSOC)
727 #define STR_NOCAPA_P(s) (FL_TEST((s),STR_NOEMBED) && FL_ANY((s),ELTS_SHARED|STR_ASSOC))
728 #define STR_EMBED_P(str) (!FL_TEST((str), STR_NOEMBED))
729 #define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
730 #define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
731
732 /* struct.c */
733 VALUE rb_struct_init_copy(VALUE copy, VALUE s);
734
735 /* time.c */
736 struct timeval rb_time_timeval(VALUE);
737
738 /* thread.c */
739 VALUE rb_obj_is_mutex(VALUE obj);
740 VALUE rb_suppress_tracing(VALUE (*func)(VALUE), VALUE arg);
741 void rb_thread_execute_interrupts(VALUE th);
742 void rb_clear_trace_func(void);
743 VALUE rb_get_coverages(void);
744 VALUE rb_thread_shield_new(void);
745 VALUE rb_thread_shield_wait(VALUE self);
746 VALUE rb_thread_shield_release(VALUE self);
747 VALUE rb_thread_shield_destroy(VALUE self);
748 void rb_mutex_allow_trap(VALUE self, int val);
749 VALUE rb_uninterruptible(VALUE (*b_proc)(ANYARGS), VALUE data);
750 VALUE rb_mutex_owned_p(VALUE self);
751 void ruby_kill(rb_pid_t pid, int sig);
752
753 /* thread_pthread.c, thread_win32.c */
754 void Init_native_thread(void);
755
756 /* vm_insnhelper.h */
757 rb_serial_t rb_next_class_serial(void);
758
759 /* vm.c */
760 VALUE rb_obj_is_thread(VALUE obj);
761 void rb_vm_mark(void *ptr);
762 void Init_BareVM(void);
763 VALUE rb_vm_top_self(void);
764 void rb_thread_recycle_stack_release(VALUE *);
765 void rb_vm_change_state(void);
766 void rb_vm_inc_const_missing_count(void);
767 void rb_thread_mark(void *th);
768 const void **rb_vm_get_insns_address_table(void);
769 VALUE rb_sourcefilename(void);
770 void rb_vm_pop_cfunc_frame(void);
771
772 /* vm_dump.c */
773 void rb_vm_bugreport(void);
774 void rb_print_backtrace(void);
775
776 /* vm_eval.c */
777 void Init_vm_eval(void);
778 VALUE rb_current_realfilepath(void);
779 VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE);
780 typedef void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE);
781 VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv,
782 rb_check_funcall_hook *hook, VALUE arg);
783 VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, int *stateptr);
784
785 /* vm_insnhelper.c */
786 VALUE rb_equal_opt(VALUE obj1, VALUE obj2);
787 int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *);
788 VALUE rb_extract_keywords(VALUE *orighash);
789
790 /* vm_method.c */
791 void Init_eval_method(void);
792 int rb_method_defined_by(VALUE obj, ID mid, VALUE (*cfunc)(ANYARGS));
793
794 /* miniprelude.c, prelude.c */
795 void Init_prelude(void);
796
797 /* vm_backtrace.c */
798 void Init_vm_backtrace(void);
799 VALUE rb_vm_thread_backtrace(int argc, VALUE *argv, VALUE thval);
800 VALUE rb_vm_thread_backtrace_locations(int argc, VALUE *argv, VALUE thval);
801
802 VALUE rb_make_backtrace(void);
803 void rb_backtrace_print_as_bugreport(void);
804 int rb_backtrace_p(VALUE obj);
805 VALUE rb_backtrace_to_str_ary(VALUE obj);
806 VALUE rb_backtrace_to_location_ary(VALUE obj);
807 void rb_backtrace_print_to(VALUE output);
808 VALUE rb_vm_backtrace_object(void);
809
810 RUBY_SYMBOL_EXPORT_BEGIN
811 const char *rb_objspace_data_type_name(VALUE obj);
812
813 /* Temporary. This API will be removed (renamed). */
814 VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd);
815
816 /* bignum.c */
817 VALUE rb_big_mul_normal(VALUE x, VALUE y);
818 VALUE rb_big_mul_balance(VALUE x, VALUE y);
819 VALUE rb_big_mul_karatsuba(VALUE x, VALUE y);
820 VALUE rb_big_mul_toom3(VALUE x, VALUE y);
821 VALUE rb_big_sq_fast(VALUE x);
822 VALUE rb_big_divrem_normal(VALUE x, VALUE y);
823 VALUE rb_big2str_poweroftwo(VALUE x, int base);
824 VALUE rb_big2str_generic(VALUE x, int base);
825 VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck);
826 VALUE rb_str2big_normal(VALUE arg, int base, int badcheck);
827 VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck);
828 #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
829 VALUE rb_big_mul_gmp(VALUE x, VALUE y);
830 VALUE rb_big_divrem_gmp(VALUE x, VALUE y);
831 VALUE rb_big2str_gmp(VALUE x, int base);
832 VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
833 #endif
834
835 /* error.c */
836 int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
837
838 /* file.c */
839 #ifdef __APPLE__
840 VALUE rb_str_normalize_ospath(const char *ptr, long len);
841 #endif
842
843 /* io.c */
844 void rb_maygvl_fd_fix_cloexec(int fd);
845
846 /* numeric.c */
847 VALUE rb_int_positive_pow(long x, unsigned long y);
848
849 /* process.c */
850 int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen);
851 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);
852 VALUE rb_execarg_new(int argc, VALUE *argv, int accept_shell);
853 struct rb_execarg *rb_execarg_get(VALUE execarg_obj); /* dangerous. needs GC guard. */
854 VALUE rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj);
855 int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val);
856 void rb_execarg_fixup(VALUE execarg_obj);
857 int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char* errmsg, size_t errmsg_buflen);
858 VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash);
859 void rb_execarg_setenv(VALUE execarg_obj, VALUE env);
860
861 /* rational.c */
862 VALUE rb_gcd_normal(VALUE self, VALUE other);
863 #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
864 VALUE rb_gcd_gmp(VALUE x, VALUE y);
865 #endif
866
867 /* util.c */
868 extern const signed char ruby_digit36_to_number_table[];
869
870 /* variable.c */
871 void rb_gc_mark_global_tbl(void);
872 void rb_mark_generic_ivar(VALUE);
873 void rb_mark_generic_ivar_tbl(void);
874
875 int rb_st_insert_id_and_value(VALUE obj, st_table *tbl, ID key, VALUE value);
876 st_table *rb_st_copy(VALUE obj, struct st_table *orig_tbl);
877
878 /* gc.c */
879 size_t rb_obj_memsize_of(VALUE);
880 #define RB_OBJ_GC_FLAGS_MAX 5
881 size_t rb_obj_gc_flags(VALUE, ID[], size_t);
882
883 RUBY_SYMBOL_EXPORT_END
884
885 #if defined(__cplusplus)
886 #if 0
887 { /* satisfy cc-mode */
888 #endif
889 } /* extern "C" { */
890 #endif
891
892 #endif /* RUBY_INTERNAL_H */
rb_execarg::fd_dup2
VALUE fd_dup2
Definition: internal.h:669
rb_alloc_func_t
VALUE(* rb_alloc_func_t)(VALUE)
Definition: intern.h:374
method_table_wrapper
Definition: internal.h:282
ruby_float_mod
double ruby_float_mod(double x, double y)
Definition: numeric.c:907
rb_st_insert_id_and_value
int rb_st_insert_id_and_value(VALUE obj, st_table *tbl, ID key, VALUE value)
Definition: variable.c:2618
rb_class_remove_from_super_subclasses
void rb_class_remove_from_super_subclasses(VALUE)
Definition: class.c:80
rb_backtrace_print_to
void rb_backtrace_print_to(VALUE output)
Definition: vm_backtrace.c:803
rb_external_str_with_enc
VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc)
Definition: string.c:695
rb_execarg_setenv
void rb_execarg_setenv(VALUE execarg_obj, VALUE env)
Definition: process.c:2299
new_size
static st_index_t new_size(st_index_t size)
Definition: st.c:184
rb_class_detach_subclasses
void rb_class_detach_subclasses(VALUE)
Definition: class.c:131
rb_vm_bugreport
void rb_vm_bugreport(void)
Definition: vm_dump.c:713
RFloat
Definition: ruby.h:805
rb_method_defined_by
int rb_method_defined_by(VALUE obj, ID mid, VALUE(*cfunc)(ANYARGS))
NORETURN
NORETURN(PRINTF_ARGS(void rb_compile_bug(const char *, int, const char *,...), 3, 4))
rb_math_sqrt
VALUE rb_math_sqrt(VALUE)
rb_vm_inc_const_missing_count
void rb_vm_inc_const_missing_count(void)
Definition: vm.c:111
rb_vm_backtrace_object
VALUE rb_vm_backtrace_object(void)
Definition: vm_backtrace.c:536
rb_parser_get_yydebug
VALUE rb_parser_get_yydebug(VALUE)
Definition: ripper.c:17634
rb_big_mul_balance
VALUE rb_big_mul_balance(VALUE x, VALUE y)
Definition: bignum.c:1668
rb_classext_struct::iv_index_tbl
struct st_table * iv_index_tbl
Definition: internal.h:265
rb_execarg::invoke
union rb_execarg::@123 invoke
rb_insns_name_array
VALUE rb_insns_name_array(void)
Definition: compile.c:5607
rb_reg_compile
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2548
st_table
Definition: st.h:69
ruby_sized_xfree
void void ruby_sized_xfree(void *x, size_t size)
Definition: gc.c:6234
rb_obj_private_methods
VALUE rb_obj_private_methods(int argc, VALUE *argv, VALUE obj)
Definition: class.c:1337
rb_is_global_name
int rb_is_global_name(VALUE name)
Definition: ripper.c:17401
rb_is_instance_name
int rb_is_instance_name(VALUE name)
Definition: ripper.c:17407
ruby_sized_xrealloc
void * ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_ALLOC_SIZE((2))
Definition: gc.c:6200
rb_check_block_call
VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE)
rb_subclass_entry::next
rb_subclass_entry_t * next
Definition: internal.h:250
rb_class_foreach_subclass
void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE))
Definition: class.c:117
ruby_set_inplace_mode
void ruby_set_inplace_mode(const char *)
Definition: io.c:11606
Init_BareVM
void Init_BareVM(void)
Definition: vm.c:2792
rb_execarg::umask_given
unsigned umask_given
Definition: internal.h:654
rb_hash_values
VALUE rb_hash_values(VALUE hash)
Definition: hash.c:1827
rb_check_backtrace
VALUE rb_check_backtrace(VALUE)
Definition: error.c:769
rb_big2str_generic
VALUE rb_big2str_generic(VALUE x, int base)
Definition: bignum.c:4892
rb_str_fill_terminator
void rb_str_fill_terminator(VALUE str, const int termlen)
Definition: string.c:1670
rb_math_exp
VALUE rb_math_exp(VALUE)
rb_class_remove_from_module_subclasses
void rb_class_remove_from_module_subclasses(VALUE)
Definition: class.c:98
rb_get_kwargs
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *)
Definition: class.c:1918
rb_obj_is_thread
VALUE rb_obj_is_thread(VALUE obj)
Definition: vm.c:2155
RBasicRaw
Definition: internal.h:602
rb_reg_check_preprocess
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2325
rb_current_realfilepath
VALUE rb_current_realfilepath(void)
Definition: vm_eval.c:1957
rb_execarg::rlimit_limits
VALUE rlimit_limits
Definition: internal.h:665
rb_execarg_run_options
int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *errmsg, size_t errmsg_buflen)
Definition: process.c:2957
rb_execarg::uid_given
unsigned uid_given
Definition: internal.h:662
rb_classext_struct::origin
VALUE origin
Definition: internal.h:277
Init_newline
void Init_newline(void)
Definition: newline.c:183
rb_backtrace_to_location_ary
VALUE rb_backtrace_to_location_ary(VALUE obj)
Definition: vm_backtrace.c:637
rb_exec_async_signal_safe
int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen)
Definition: process.c:3104
rb_is_method_name
int rb_is_method_name(VALUE name)
Definition: ripper.c:17425
rb_str_quote_unprintable
VALUE rb_str_quote_unprintable(VALUE)
Definition: string.c:8400
rb_struct_init_copy
VALUE rb_struct_init_copy(VALUE copy, VALUE s)
Definition: struct.c:707
rb_big_fdiv
VALUE rb_big_fdiv(VALUE x, VALUE y)
Definition: bignum.c:6321
rb_hash_tbl_raw
struct st_table * rb_hash_tbl_raw(VALUE hash)
Definition: hash.c:351
rb_execarg::unsetenv_others_given
unsigned unsetenv_others_given
Definition: internal.h:655
rb_suppress_tracing
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:388
ruby_debug_printf
void ruby_debug_printf(const char *format,...)
Definition: debug.c:86
rb_local_defined
int rb_local_defined(ID)
Definition: compile.c:5984
rb_execarg::close_others_maxhint
int close_others_maxhint
Definition: internal.h:673
rb_classext_struct::subclasses
rb_subclass_entry_t * subclasses
Definition: internal.h:268
ruby_get_inplace_mode
const char * ruby_get_inplace_mode(void)
Definition: io.c:11600
rb_ary_set_len
void rb_ary_set_len(VALUE, long)
Definition: array.c:1592
RBasicRaw::klass
VALUE klass
Definition: internal.h:604
rb_gc_mark_parser
void rb_gc_mark_parser(void)
Definition: ripper.c:16607
rb_obj_equal
VALUE rb_obj_equal(VALUE obj1, VALUE obj2)
Definition: object.c:142
ruby_mimmalloc
void * ruby_mimmalloc(size_t size)
Definition: gc.c:6251
rb_lcm
VALUE rb_lcm(VALUE x, VALUE y)
Definition: rational.c:1730
rb_fork_ruby
rb_pid_t rb_fork_ruby(int *status)
rb_async_bug_errno
void rb_async_bug_errno(const char *mesg, int errno_arg)
Definition: error.c:371
rb_str_locktmp_ensure
VALUE rb_str_locktmp_ensure(VALUE str, VALUE(*func)(VALUE), VALUE arg)
Definition: string.c:2001
Init_class_hierarchy
void Init_class_hierarchy(void)
Definition: class.c:535
rb_default_home_dir
VALUE rb_default_home_dir(VALUE result)
Definition: file.c:3018
rb_parser_set_yydebug
VALUE rb_parser_set_yydebug(VALUE, VALUE)
Definition: ripper.c:17649
Init_vm_eval
void Init_vm_eval(void)
Definition: vm_eval.c:1967
rb_dvar_defined
int rb_dvar_defined(ID)
Definition: compile.c:5959
rb_file_expand_path_fast
VALUE rb_file_expand_path_fast(VALUE, VALUE)
Definition: file.c:3428
rb_vm_get_insns_address_table
const void ** rb_vm_get_insns_address_table(void)
Definition: vm_exec.c:118
rb_iseq_first_lineno
VALUE rb_iseq_first_lineno(VALUE iseqval)
Definition: iseq.c:958
RCLASS_M_TBL_WRAPPER
#define RCLASS_M_TBL_WRAPPER(c)
Definition: internal.h:294
Init_vm_backtrace
void Init_vm_backtrace(void)
Definition: vm_backtrace.c:991
ruby_sized_xrealloc2
void * ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_ALLOC_SIZE((2
rb_thread_io_blocking_region
VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd)
Definition: thread.c:1380
rb_math_cos
VALUE rb_math_cos(VALUE)
rb_mutex_allow_trap
void rb_mutex_allow_trap(VALUE self, int val)
Definition: thread.c:4642
rb_catch_protect
VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, int *stateptr)
Definition: vm_eval.c:1835
rb_execarg::env_modification
VALUE env_modification
Definition: internal.h:674
rb_math_sinh
VALUE rb_math_sinh(VALUE)
rb_refinement_module_get_refined_class
VALUE rb_refinement_module_get_refined_class(VALUE module)
Definition: eval.c:1177
st_index_t
st_data_t st_index_t
Definition: st.h:48
method_table_wrapper::tbl
st_table * tbl
Definition: internal.h:283
rb_classext_struct::const_tbl
struct st_table * const_tbl
Definition: internal.h:267
rb_call_inits
void rb_call_inits(void)
Definition: inits.c:18
rb_iseq_base_label
VALUE rb_iseq_base_label(VALUE iseqval)
Definition: iseq.c:940
rb_load_fail
void rb_load_fail(VALUE path, const char *err)
Definition: error.c:2068
rb_classext_struct::parent_subclasses
rb_subclass_entry_t ** parent_subclasses
Definition: internal.h:269
RUBY_ATTR_ALLOC_SIZE
#define RUBY_ATTR_ALLOC_SIZE(params)
Definition: defines.h:118
rb_execarg::envp_str
VALUE envp_str
Definition: internal.h:650
rb_big_mul_karatsuba
VALUE rb_big_mul_karatsuba(VALUE x, VALUE y)
Definition: bignum.c:1849
rb_file_load_ok
int rb_file_load_ok(const char *)
Definition: file.c:5391
rb_equal_opt
VALUE rb_equal_opt(VALUE obj1, VALUE obj2)
Definition: vm_insnhelper.c:901
rb_iseq_path
VALUE rb_iseq_path(VALUE iseqval)
Definition: iseq.c:857
rb_insns_name
const char * rb_insns_name(int i)
Definition: compile.c:5601
__sFILE
Definition: vsnprintf.c:175
output
static unsigned char * output
Definition: nkf.c:32
rb_execarg::unsetenv_others_do
unsigned unsetenv_others_do
Definition: internal.h:656
rb_big_mul_normal
VALUE rb_big_mul_normal(VALUE x, VALUE y)
Definition: bignum.c:1540
rb_extract_keywords
VALUE rb_extract_keywords(VALUE *orighash)
Definition: class.c:1903
ruby_register_rollback_func_for_ensure
void ruby_register_rollback_func_for_ensure(VALUE(*ensure_func)(ANYARGS), VALUE(*rollback_func)(ANYARGS))
Definition: cont.c:947
rb_vm_change_state
void rb_vm_change_state(void)
rb_iseq_absolute_path
VALUE rb_iseq_absolute_path(VALUE iseqval)
Definition: iseq.c:881
rb_gc_mark_encodings
void rb_gc_mark_encodings(void)
Definition: encoding.c:236
rb_str2big_poweroftwo
VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck)
Definition: bignum.c:4161
rb_math_log
VALUE rb_math_log(int argc, VALUE *argv)
RCLASS_SUPER
static VALUE RCLASS_SUPER(VALUE klass)
Definition: internal.h:313
rb_block_call_func
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
Definition: ruby.h:1513
rb_vm_thread_backtrace
VALUE rb_vm_thread_backtrace(int argc, VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:906
rb_str_symname_p
int rb_str_symname_p(VALUE)
Definition: string.c:8381
uint64_t
unsigned long long uint64_t
Definition: sha2.h:102
rb_execarg::gid
rb_gid_t gid
Definition: internal.h:668
rb_get_path_check_convert
VALUE rb_get_path_check_convert(VALUE, VALUE, int)
Definition: file.c:198
rb_execarg_get
struct rb_execarg * rb_execarg_get(VALUE execarg_obj)
Definition: process.c:2272
Init_ext
void Init_ext(void)
Definition: dmyext.c:2
rb_classext_struct::refined_class
VALUE refined_class
Definition: internal.h:278
rb_strftime_timespec
size_t rb_strftime_timespec(char *s, size_t maxsize, const char *format, rb_encoding *enc, const struct vtm *vtm, struct timespec *ts, int gmt)
Definition: strftime.c:837
rb_compile_bug
void rb_compile_bug(const char *file, int line, const char *fmt,...)
Definition: error.c:395
rb_subclass_entry
Definition: internal.h:248
ruby_error_print
void ruby_error_print(void)
Definition: eval_error.c:206
rb_vm_mark
void rb_vm_mark(void *ptr)
Definition: vm.c:1762
rb_mark_generic_ivar_tbl
void rb_mark_generic_ivar_tbl(void)
Definition: variable.c:1022
val
#define val
rb_special_singleton_class
VALUE rb_special_singleton_class(VALUE)
Definition: class.c:1535
rb_get_coverages
VALUE rb_get_coverages(void)
Definition: thread.c:5287
vtm
Definition: timev.h:4
rb_realpath_internal
VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict)
Definition: file.c:3620
rb_num_negative_p
int rb_num_negative_p(VALUE)
Definition: numeric.c:197
rb_thread_shield_release
VALUE rb_thread_shield_release(VALUE self)
Definition: thread.c:4734
rb_ary_last
VALUE rb_ary_last(int, VALUE *, VALUE)
Definition: array.c:1329
rb_id_quote_unprintable
VALUE rb_id_quote_unprintable(ID)
Definition: string.c:8421
rb_execarg_extract_options
VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash)
Definition: process.c:1959
ruby_num_interval_step_size
VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl)
Definition: numeric.c:1813
rb_check_funcall_hook
void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE)
Definition: internal.h:780
rb_execarg::uid
rb_uid_t uid
Definition: internal.h:667
RCLASS_SET_SUPER
static VALUE RCLASS_SET_SUPER(VALUE klass, VALUE super)
Definition: internal.h:319
rb_execarg::command_name
VALUE command_name
Definition: internal.h:643
rb_execarg::pgroup_pgid
rb_pid_t pgroup_pgid
Definition: internal.h:664
rb_execarg::command_abspath
VALUE command_abspath
Definition: internal.h:644
rb_class_subclass_add
void rb_class_subclass_add(VALUE super, VALUE klass)
Definition: class.c:40
rb_fork_async_signal_safe
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)
rb_obj_is_mutex
VALUE rb_obj_is_mutex(VALUE obj)
Definition: thread.c:4216
rb_file_expand_path_internal
VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE)
Definition: file.c:3054
FLONUM_P
#define FLONUM_P(x)
Definition: ruby.h:367
Init_File
void Init_File(void)
Definition: file.c:5614
argc
int argc
Definition: ruby.c:131
rb_gc_mark_symbols
void rb_gc_mark_symbols(int full_mark)
Definition: ripper.c:16779
rb_io_flush_raw
VALUE rb_io_flush_raw(VALUE, int)
Definition: io.c:1466
rb_proc_location
VALUE rb_proc_location(VALUE self)
Definition: proc.c:928
rb_file_const
void rb_file_const(const char *, VALUE)
Definition: file.c:5275
RCLASS_M_TBL_INIT
static void RCLASS_M_TBL_INIT(VALUE c)
Definition: internal.h:302
rb_iseq_klass
VALUE rb_iseq_klass(VALUE iseqval)
Definition: iseq.c:966
rb_builtin_class_name
const char * rb_builtin_class_name(VALUE x)
Definition: error.c:451
rb_obj_protected_methods
VALUE rb_obj_protected_methods(int argc, VALUE *argv, VALUE obj)
Definition: class.c:1322
err
int err
Definition: win32.c:114
rb_int_pred
VALUE rb_int_pred(VALUE num)
Definition: numeric.c:2499
ruby_float_step
int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl)
Definition: numeric.c:1782
rb_gc_resurrect
void rb_gc_resurrect(VALUE ptr)
Definition: gc.c:3612
rb_float_new_in_heap
VALUE rb_float_new_in_heap(double)
Definition: numeric.c:637
rb_backtrace_p
int rb_backtrace_p(VALUE obj)
Definition: vm_backtrace.c:417
rb_float_new_inline
static VALUE rb_float_new_inline(double d)
Definition: internal.h:565
ALLOC
#define ALLOC(type)
Definition: ruby.h:1334
rb_obj_basic_to_s_p
int rb_obj_basic_to_s_p(VALUE)
Definition: class.c:1716
rb_invcmp
VALUE rb_invcmp(VALUE, VALUE)
Definition: compar.c:42
rb_backtrace_to_str_ary
VALUE rb_backtrace_to_str_ary(VALUE obj)
Definition: vm_backtrace.c:590
rb_iseq_clone
VALUE rb_iseq_clone(VALUE iseqval, VALUE newcbase)
Definition: iseq.c:1922
rb_int_succ
VALUE rb_int_succ(VALUE num)
Definition: numeric.c:2474
rb_execarg::close_others_given
unsigned close_others_given
Definition: internal.h:657
rb_get_load_path
VALUE rb_get_load_path(void)
Definition: load.c:32
rb_check_funcall_with_hook
VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv, rb_check_funcall_hook *hook, VALUE arg)
Definition: vm_eval.c:428
timeval
Definition: ossl_asn1.c:16
func
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:113
rb_hash_keys
VALUE rb_hash_keys(VALUE hash)
Definition: hash.c:1783
rb_id_encoding
ID rb_id_encoding(void)
Definition: encoding.c:732
rb_last_status_clear
void rb_last_status_clear(void)
Definition: process.c:336
rb_strftime
size_t rb_strftime(char *s, size_t maxsize, const char *format, rb_encoding *enc, const struct vtm *vtm, VALUE timev, int gmt)
Definition: strftime.c:831
rb_classext_struct::iv_tbl
struct st_table * iv_tbl
Definition: internal.h:266
rb_serial_t
unsigned long rb_serial_t
Definition: internal.h:260
chfunc
static int chfunc(void *data, char *errbuf, size_t errbuf_len)
Definition: pty.c:90
rb_get_next_signal
int rb_get_next_signal(void)
Definition: signal.c:685
rb_big_mul_toom3
VALUE rb_big_mul_toom3(VALUE x, VALUE y)
Definition: bignum.c:2246
rb_is_const_name
int rb_is_const_name(VALUE name)
Definition: ripper.c:17389
Init_prelude
void Init_prelude(void)
rb_math_atan2
VALUE rb_math_atan2(VALUE, VALUE)
rb_execarg_fixup
void rb_execarg_fixup(VALUE execarg_obj)
Definition: process.c:2325
rb_print_backtrace
void rb_print_backtrace(void)
Definition: vm_dump.c:685
rb_subclass_entry::klass
VALUE klass
Definition: internal.h:249
RUBY_SYMBOL_EXPORT_END
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:39
rb_mark_end_proc
void rb_mark_end_proc(void)
Definition: eval_jump.c:80
rb_execarg::argv_str
VALUE argv_str
Definition: internal.h:645
rb_thread_execute_interrupts
void rb_thread_execute_interrupts(VALUE th)
Definition: thread.c:2026
rb_thread_shield_destroy
VALUE rb_thread_shield_destroy(VALUE self)
Definition: thread.c:4745
rb_execarg::redirect_fds
VALUE redirect_fds
Definition: internal.h:649
rb_call_end_proc
void rb_call_end_proc(VALUE data)
Definition: eval_jump.c:11
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
rb_execarg::close_others_do
unsigned close_others_do
Definition: internal.h:658
rb_vm_pop_cfunc_frame
void rb_vm_pop_cfunc_frame(void)
Definition: vm.c:281
ID
unsigned long ID
Definition: ruby.h:89
rb_execarg
Definition: internal.h:636
rb_block_arity
int rb_block_arity(void)
Definition: proc.c:860
ruby_digit36_to_number_table
const signed char ruby_digit36_to_number_table[]
Definition: util.c:58
rb_execarg::new_pgroup_given
unsigned new_pgroup_given
Definition: internal.h:660
mode_t
#define mode_t
Definition: win32.h:116
options
static int options(unsigned char *cp)
Definition: nkf.c:6357
Init_heap
void Init_heap(void)
Definition: gc.c:1661
rb_obj_public_methods
VALUE rb_obj_public_methods(int argc, VALUE *argv, VALUE obj)
Definition: class.c:1352
rb_integer_float_eq
VALUE rb_integer_float_eq(VALUE x, VALUE y)
Definition: bignum.c:5349
rb_bug_reporter_add
int rb_bug_reporter_add(void(*func)(FILE *, void *), void *data)
Definition: error.c:282
VALUE
unsigned long VALUE
Definition: ruby.h:88
result
static VALUE result
Definition: nkf.c:40
rb_get_backtrace
VALUE rb_get_backtrace(VALUE info)
Definition: eval_error.c:55
rb_obj_copy_ivar
void rb_obj_copy_ivar(VALUE dest, VALUE obj)
Definition: object.c:255
rb_str2big_normal
VALUE rb_str2big_normal(VALUE arg, int base, int badcheck)
Definition: bignum.c:4194
RUBY_SYMBOL_EXPORT_BEGIN
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:38
rb_execarg::argv_buf
VALUE argv_buf
Definition: internal.h:646
Init_native_thread
void Init_native_thread(void)
ruby_mimfree
void ruby_mimfree(void *ptr)
Definition: gc.c:6267
rb_is_class_name
int rb_is_class_name(VALUE name)
Definition: ripper.c:17395
rb_thread_mark
void rb_thread_mark(void *th)
Definition: vm.c:2014
method_table_wrapper::serial
size_t serial
Definition: internal.h:284
rb_math_cosh
VALUE rb_math_cosh(VALUE)
rb_execarg::umask_mask
mode_t umask_mask
Definition: internal.h:666
rb_execarg::pgroup_given
unsigned pgroup_given
Definition: internal.h:653
rb_sigaltstack_size
int rb_sigaltstack_size(void)
rb_deprecated_classext_struct::conflict
char conflict[sizeof(VALUE)*3]
Definition: internal.h:242
st_init_numtable
st_table * st_init_numtable(void)
Definition: st.c:272
rb_uninterruptible
VALUE rb_uninterruptible(VALUE(*b_proc)(ANYARGS), VALUE data)
Definition: thread.c:5307
rb_fstring
VALUE rb_fstring(VALUE)
Definition: string.c:201
rb_blocking_function_t
VALUE rb_blocking_function_t(void *)
Definition: intern.h:865
rb_execarg::fd_dup2_child
VALUE fd_dup2_child
Definition: internal.h:672
rb_class_detach_module_subclasses
void rb_class_detach_module_subclasses(VALUE)
Definition: class.c:137
rb_deprecated_classext_struct
Definition: classext.h:10
CHAR_BIT
#define CHAR_BIT
Definition: ruby.h:198
rb_execarg::fd_open
VALUE fd_open
Definition: internal.h:671
nlz_int
static int nlz_int(unsigned int x)
Definition: internal.h:116
rb_write_error_str
void rb_write_error_str(VALUE mesg)
Definition: io.c:7163
rb_thread_recycle_stack_release
void rb_thread_recycle_stack_release(VALUE *)
Definition: vm.c:1992
rb_execarg::cmd
struct rb_execarg::@123::@125 cmd
size
int size
Definition: encoding.c:49
rb_thread_shield_new
VALUE rb_thread_shield_new(void)
Definition: thread.c:4698
rb_str_buf_cat_escaped_char
int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p)
Definition: string.c:4747
rb_make_backtrace
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:817
rb_mark_generic_ivar
void rb_mark_generic_ivar(VALUE)
Definition: variable.c:992
f
#define f
rb_fiber_reset_root_local_storage
void rb_fiber_reset_root_local_storage(VALUE)
Definition: cont.c:1502
rb_str2big_karatsuba
VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck)
Definition: bignum.c:4233
rb_execarg::dup2_tmpbuf
VALUE dup2_tmpbuf
Definition: internal.h:652
rb_execarg::fd_close
VALUE fd_close
Definition: internal.h:670
rb_execarg::gid_given
unsigned gid_given
Definition: internal.h:663
rb_gc_writebarrier_remember_promoted
void rb_gc_writebarrier_remember_promoted(VALUE obj)
Definition: gc.c:4782
ruby_gc_set_params
void ruby_gc_set_params(int safe_level)
Definition: gc.c:5733
rb_int_positive_pow
VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:3047
rb_execarg::sh
struct rb_execarg::@123::@124 sh
rb_rational_reciprocal
VALUE rb_rational_reciprocal(VALUE x)
Definition: rational.c:1694
rb_ary_delete_same
void rb_ary_delete_same(VALUE, VALUE)
Definition: array.c:2928
ANYARGS
#define ANYARGS
Definition: defines.h:98
rb_execarg::envp_buf
VALUE envp_buf
Definition: internal.h:651
rb_event_flag_t
unsigned long rb_event_flag_t
Definition: ruby.h:1740
rb_obj_memsize_of
size_t rb_obj_memsize_of(VALUE)
Definition: gc.c:2548
rb_execarg_init
VALUE rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj)
Definition: process.c:2280
rb_execarg::chdir_given
unsigned chdir_given
Definition: internal.h:659
rb_big_sq_fast
VALUE rb_big_sq_fast(VALUE x)
Definition: bignum.c:1609
rb_gcd_normal
VALUE rb_gcd_normal(VALUE self, VALUE other)
Definition: rational.c:356
key
uint8_t key[16]
Definition: random.c:1250
rb_singleton_class_get
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
Definition: class.c:1597
rb_st_copy
st_table * rb_st_copy(VALUE obj, struct st_table *orig_tbl)
Definition: variable.c:2633
rb_execarg::use_shell
int use_shell
Definition: internal.h:637
rb_classext_struct::module_subclasses
rb_subclass_entry_t ** module_subclasses
In the case that this is an ICLASS, module_subclasses points to the link in the module's subclasses l...
Definition: internal.h:275
rb_execarg::chdir_dir
VALUE chdir_dir
Definition: internal.h:675
rb_obj_methods
VALUE rb_obj_methods(int argc, VALUE *argv, VALUE obj)
Definition: class.c:1294
rb_is_local_name
int rb_is_local_name(VALUE name)
Definition: ripper.c:17419
timespec
Definition: missing.h:50
rb_iseq_label
VALUE rb_iseq_label(VALUE iseqval)
Definition: iseq.c:912
rb_get_expanded_load_path
VALUE rb_get_expanded_load_path(void)
Definition: load.c:109
hash
static unsigned int hash(const char *str, unsigned int len)
Definition: lex.c:56
rb_vm_top_self
VALUE rb_vm_top_self(void)
Definition: vm.c:2826
rb_obj_gc_flags
size_t rb_obj_gc_flags(VALUE, ID[], size_t)
rb_iseq_method_name
VALUE rb_iseq_method_name(VALUE self)
Definition: iseq.c:974
ruby_kill
void ruby_kill(rb_pid_t pid, int sig)
Definition: thread.c:5319
rb_thread_shield_wait
VALUE rb_thread_shield_wait(VALUE self)
Definition: thread.c:4714
name
const char * name
Definition: nkf.c:208
rb_execarg_addopt
int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
Definition: process.c:1670
rb_big2str_poweroftwo
VALUE rb_big2str_poweroftwo(VALUE x, int base)
Definition: bignum.c:4809
rb_gc_mark_global_tbl
void rb_gc_mark_global_tbl(void)
Definition: variable.c:562
rb_float_value_inline
static double rb_float_value_inline(VALUE v)
Definition: internal.h:539
rb_classext_struct
Definition: internal.h:264
rb_next_class_serial
rb_serial_t rb_next_class_serial(void)
Definition: vm.c:92
rb_execarg_new
VALUE rb_execarg_new(int argc, VALUE *argv, int accept_shell)
Definition: process.c:2261
rb_time_timeval
struct timeval rb_time_timeval(VALUE)
Definition: time.c:2417
rb_math_sin
VALUE rb_math_sin(VALUE)
rb_classext_struct::allocator
rb_alloc_func_t allocator
Definition: internal.h:279
rb_home_dir_of
VALUE rb_home_dir_of(VALUE user, VALUE result)
Definition: file.c:3001
rb_parse_in_eval
int rb_parse_in_eval(void)
Definition: compile.c:6003
rb_backtrace_print_as_bugreport
void rb_backtrace_print_as_bugreport(void)
Definition: vm_backtrace.c:766
rb_num_to_uint
int rb_num_to_uint(VALUE val, unsigned int *ret)
Definition: numeric.c:132
rb_math_hypot
VALUE rb_math_hypot(VALUE, VALUE)
RBasicRaw::flags
VALUE flags
Definition: internal.h:603
rb_stdio_set_default_encoding
void rb_stdio_set_default_encoding(void)
Definition: io.c:10558
rb_hash_proc
st_index_t rb_hash_proc(st_index_t hash, VALUE proc)
Definition: proc.c:974
rb_get_path_check_to_string
VALUE rb_get_path_check_to_string(VALUE, int)
Definition: file.c:176
rb_classext_struct::class_serial
rb_serial_t class_serial
Definition: internal.h:276
rb_parse_in_main
int rb_parse_in_main(void)
Definition: compile.c:6009
rb_execarg::new_pgroup_flag
unsigned new_pgroup_flag
Definition: internal.h:661
RCLASS
#define RCLASS(obj)
Definition: ruby.h:1118
rb_vm_thread_backtrace_locations
VALUE rb_vm_thread_backtrace_locations(int argc, VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:912
env
#define env
rb_clear_trace_func
void rb_clear_trace_func(void)
Definition: vm_trace.c:225
rb_execarg::shell_script
VALUE shell_script
Definition: internal.h:640
rb_integer_float_cmp
VALUE rb_integer_float_cmp(VALUE x, VALUE y)
Definition: bignum.c:5299
rb_class_search_ancestor
VALUE rb_class_search_ancestor(VALUE klass, VALUE super)
Definition: object.c:672
rb_is_junk_name
int rb_is_junk_name(VALUE name)
Definition: ripper.c:17435
rb_objspace_data_type_name
RUBY_SYMBOL_EXPORT_BEGIN const char * rb_objspace_data_type_name(VALUE obj)
Definition: gc.c:1394
rb_big_uminus
VALUE rb_big_uminus(VALUE x)
Definition: bignum.c:5578
rb_objspace_set_event_hook
void rb_objspace_set_event_hook(const rb_event_flag_t event)
Definition: gc.c:1265
rb_maygvl_fd_fix_cloexec
void rb_maygvl_fd_fix_cloexec(int fd)
Definition: io.c:198
rb_mutex_owned_p
VALUE rb_mutex_owned_p(VALUE self)
Definition: thread.c:4449
RB_OBJ_WRITE
#define RB_OBJ_WRITE(a, slot, b)
Definition: ruby.h:1213
rb_sourcefilename
VALUE rb_sourcefilename(void)
Definition: vm.c:973
rb_builtin_type_name
const char * rb_builtin_type_name(int t)
Definition: error.c:440
rb_obj_is_fiber
VALUE rb_obj_is_fiber(VALUE)
Definition: cont.c:370
rb_big_divrem_normal
VALUE rb_big_divrem_normal(VALUE x, VALUE y)
Definition: bignum.c:2698
argv
char ** argv
Definition: ruby.c:132
rb_block_call_func_t
VALUE(* rb_block_call_func_t)(ANYARGS)
Definition: ruby.h:1518
rb_io_bufread
ssize_t rb_io_bufread(VALUE io, void *buf, size_t size)
Definition: io.c:2094
rb_singleton_class_clone_and_attach
VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
Definition: class.c:377
nlz_long
static int nlz_long(unsigned long x)
Definition: internal.h:146
rb_is_attrset_name
int rb_is_attrset_name(VALUE name)
Definition: ripper.c:17413
OnigEncodingTypeST
Definition: oniguruma.h:158
PRINTF_ARGS
PRINTF_ARGS(void ruby_debug_printf(const char *,...), 1, 2)
Init_eval_method
void Init_eval_method(void)
Definition: vm_method.c:1708