Ruby 2.7.0p0(2019-12-25revision647ee6f091eafcce70ffb75ddf7e121e192ab217)

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 #include "ruby.h"
16
17 #if defined(__cplusplus)
18 extern "C" {
19 #if 0
20 } /* satisfy cc-mode */
21 #endif
22 #endif
23
24 #ifdef HAVE_STDBOOL_H
25 # include <stdbool.h>
26 #else
27 # include "missing/stdbool.h"
28 #endif
29
30 /* The most significant bit of the lower part of half-long integer.
31 * If sizeof(long) == 4, this is 0x8000.
32 * If sizeof(long) == 8, this is 0x80000000.
33 */
34 #define HALF_LONG_MSB ((SIGNED_VALUE)1<<((SIZEOF_LONG*CHAR_BIT-1)/2))
35
36 #define LIKELY(x) RB_LIKELY(x)
37 #define UNLIKELY(x) RB_UNLIKELY(x)
38
39 #ifndef MAYBE_UNUSED
40 # define MAYBE_UNUSED(x) x
41 #endif
42
43 #ifndef WARN_UNUSED_RESULT
44 # define WARN_UNUSED_RESULT(x) x
45 #endif
46
47 #ifndef __has_feature
48 # define __has_feature(x) 0
49 #endif
50
51 #ifndef __has_extension
52 # define __has_extension __has_feature
53 #endif
54
55 #if 0
56 #elif defined(NO_SANITIZE) && __has_feature(memory_sanitizer)
57 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
58 NO_SANITIZE("memory", NO_SANITIZE("address", NOINLINE(x)))
59 #elif defined(NO_SANITIZE)
60 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
61 NO_SANITIZE("address", NOINLINE(x))
62 #elif defined(NO_SANITIZE_ADDRESS)
63 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
64 NO_SANITIZE_ADDRESS(NOINLINE(x))
65 #elif defined(NO_ADDRESS_SAFETY_ANALYSIS)
66 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
67 NO_ADDRESS_SAFETY_ANALYSIS(NOINLINE(x))
68 #else
69 # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) x
70 #endif
71
72 #if defined(NO_SANITIZE) && defined(__GNUC__) &&! defined(__clang__)
73 /* GCC warns about unknown sanitizer, which is annoying. */
74 #undef NO_SANITIZE
75 #define NO_SANITIZE(x, y) \
76 COMPILER_WARNING_PUSH; \
77 COMPILER_WARNING_IGNORED(-Wattributes); \
78 __attribute__((__no_sanitize__(x))) y; \
79 COMPILER_WARNING_POP
80 #endif
81
82 #ifndef NO_SANITIZE
83 # define NO_SANITIZE(x, y) y
84 #endif
85
86 #ifdef HAVE_VALGRIND_MEMCHECK_H
87 # include <valgrind/memcheck.h>
88 # ifndef VALGRIND_MAKE_MEM_DEFINED
89 # define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
90 # endif
91 # ifndef VALGRIND_MAKE_MEM_UNDEFINED
92 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
93 # endif
94 #else
95 # define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
96 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
97 #endif
98
99 #define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
100
101 #ifndef MJIT_HEADER
102
103 #ifdef HAVE_SANITIZER_ASAN_INTERFACE_H
104 # include <sanitizer/asan_interface.h>
105 #endif
106
107 #if !__has_feature(address_sanitizer)
108 # define __asan_poison_memory_region(x, y)
109 # define __asan_unpoison_memory_region(x, y)
110 # define __asan_region_is_poisoned(x, y) 0
111 #endif
112
113 #ifdef HAVE_SANITIZER_MSAN_INTERFACE_H
114 # if __has_feature(memory_sanitizer)
115 # include <sanitizer/msan_interface.h>
116 # endif
117 #endif
118
119 #if !__has_feature(memory_sanitizer)
120 # define __msan_allocated_memory(x, y) ((void)(x), (void)(y))
121 # define __msan_poison(x, y) ((void)(x), (void)(y))
122 # define __msan_unpoison(x, y) ((void)(x), (void)(y))
123 # define __msan_unpoison_string(x) ((void)(x))
124 #endif
125
139 static inline void
140 asan_poison_memory_region(const volatile void *ptr, size_t size)
141 {
142 __msan_poison(ptr, size);
143 __asan_poison_memory_region(ptr, size);
144 }
145
151 static inline void
152 asan_poison_object(VALUE obj)
153 {
154 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
155 asan_poison_memory_region(ptr, SIZEOF_VALUE);
156 }
157
158 #if !__has_feature(address_sanitizer)
159 #define asan_poison_object_if(ptr, obj) ((void)(ptr), (void)(obj))
160 #else
161 #define asan_poison_object_if(ptr, obj) do { \
162 if (ptr) asan_poison_object(obj); \
163 } while (0)
164 #endif
165
173 static inline void *
174 asan_poisoned_object_p(VALUE obj)
175 {
176 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
177 return __asan_region_is_poisoned(ptr, SIZEOF_VALUE);
178 }
179
195 static inline void
196 asan_unpoison_memory_region(const volatile void *ptr, size_t size, bool malloc_p)
197 {
198 __asan_unpoison_memory_region(ptr, size);
199 if (malloc_p) {
200 __msan_allocated_memory(ptr, size);
201 }
202 else {
203 __msan_unpoison(ptr, size);
204 }
205 }
206
213 static inline void
214 asan_unpoison_object(VALUE obj, bool newobj_p)
215 {
216 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
217 asan_unpoison_memory_region(ptr, SIZEOF_VALUE, newobj_p);
218 }
219
220 #endif
221
222 /* Prevent compiler from reordering access */
223 #define ACCESS_ONCE(type,x) (*((volatile type *)&(x)))
224
225 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
226 # define STATIC_ASSERT(name, expr) _Static_assert(expr, #name ": " #expr)
227 #elif GCC_VERSION_SINCE(4, 6, 0) || __has_extension(c_static_assert)
228 # define STATIC_ASSERT(name, expr) RB_GNUC_EXTENSION _Static_assert(expr, #name ": " #expr)
229 #else
230 # define STATIC_ASSERT(name, expr) typedef int static_assert_##name##_check[1 - 2*!(expr)]
231 #endif
232
233 #define SIGNED_INTEGER_TYPE_P(int_type) (0 > ((int_type)0)-1)
234 #define SIGNED_INTEGER_MAX(sint_type) \
235 (sint_type) \
236 ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) | \
237 ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) - 1))
238 #define SIGNED_INTEGER_MIN(sint_type) (-SIGNED_INTEGER_MAX(sint_type)-1)
239 #define UNSIGNED_INTEGER_MAX(uint_type) (~(uint_type)0)
240
241 #if SIGNEDNESS_OF_TIME_T < 0 /* signed */
242 # define TIMET_MAX SIGNED_INTEGER_MAX(time_t)
243 # define TIMET_MIN SIGNED_INTEGER_MIN(time_t)
244 #elif SIGNEDNESS_OF_TIME_T > 0 /* unsigned */
245 # define TIMET_MAX UNSIGNED_INTEGER_MAX(time_t)
246 # define TIMET_MIN ((time_t)0)
247 #endif
248 #define TIMET_MAX_PLUS_ONE (2*(double)(TIMET_MAX/2+1))
249
250 #ifdef HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW_P
251 #define MUL_OVERFLOW_P(a, b) \
252 __builtin_mul_overflow_p((a), (b), (__typeof__(a * b))0)
253 #elif defined HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW
254 #define MUL_OVERFLOW_P(a, b) \
255 RB_GNUC_EXTENSION_BLOCK(__typeof__(a) c; __builtin_mul_overflow((a), (b), &c))
256 #endif
257
258 #define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
259 (a) == 0 ? 0 : \
260 (a) == -1 ? (b) < -(max) : \
261 (a) > 0 ? \
262 ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
263 ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
264
265 #ifdef HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW_P
266 /* __builtin_mul_overflow_p can take bitfield */
267 /* and GCC permits bitfields for integers other than int */
268 #define MUL_OVERFLOW_FIXNUM_P(a, b) RB_GNUC_EXTENSION_BLOCK( \
269 struct { long fixnum : SIZEOF_LONG * CHAR_BIT - 1; } c; \
270 __builtin_mul_overflow_p((a), (b), c.fixnum); \
271 )
272 #else
273 #define MUL_OVERFLOW_FIXNUM_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
274 #endif
275
276 #ifdef MUL_OVERFLOW_P
277 #define MUL_OVERFLOW_LONG_LONG_P(a, b) MUL_OVERFLOW_P(a, b)
278 #define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_P(a, b)
279 #define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_P(a, b)
280 #else
281 #define MUL_OVERFLOW_LONG_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LLONG_MIN, LLONG_MAX)
282 #define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
283 #define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
284 #endif
285
286 #ifndef swap16
287 # ifdef HAVE_BUILTIN___BUILTIN_BSWAP16
288 # define swap16(x) __builtin_bswap16(x)
289 # endif
290 #endif
291
292 #ifndef swap16
293 # define swap16(x) ((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
294 #endif
295
296 #ifndef swap32
297 # ifdef HAVE_BUILTIN___BUILTIN_BSWAP32
298 # define swap32(x) __builtin_bswap32(x)
299 # endif
300 #endif
301
302 #ifndef swap32
303 # define swap32(x) ((uint32_t)((((x)&0xFF)<<24) \
304 |(((x)>>24)&0xFF) \
305 |(((x)&0x0000FF00)<<8) \
306 |(((x)&0x00FF0000)>>8) ))
307 #endif
308
309 #ifndef swap64
310 # ifdef HAVE_BUILTIN___BUILTIN_BSWAP64
311 # define swap64(x) __builtin_bswap64(x)
312 # endif
313 #endif
314
315 #ifndef swap64
316 # ifdef HAVE_INT64_T
317 # define byte_in_64bit(n) ((uint64_t)0xff << (n))
318 # define swap64(x) ((uint64_t)((((x)&byte_in_64bit(0))<<56) \
319 |(((x)>>56)&0xFF) \
320 |(((x)&byte_in_64bit(8))<<40) \
321 |(((x)&byte_in_64bit(48))>>40) \
322 |(((x)&byte_in_64bit(16))<<24) \
323 |(((x)&byte_in_64bit(40))>>24) \
324 |(((x)&byte_in_64bit(24))<<8) \
325 |(((x)&byte_in_64bit(32))>>8)))
326 # endif
327 #endif
328
329 static inline unsigned int
330 nlz_int(unsigned int x)
331 {
332 #if defined(HAVE_BUILTIN___BUILTIN_CLZ)
333 if (x == 0) return SIZEOF_INT * CHAR_BIT;
334 return (unsigned int)__builtin_clz(x);
335 #else
336 unsigned int y;
337 # if 64 < SIZEOF_INT * CHAR_BIT
338 unsigned int n = 128;
339 # elif 32 < SIZEOF_INT * CHAR_BIT
340 unsigned int n = 64;
341 # else
342 unsigned int n = 32;
343 # endif
344 # if 64 < SIZEOF_INT * CHAR_BIT
345 y = x >> 64; if (y) {n -= 64; x = y;}
346 # endif
347 # if 32 < SIZEOF_INT * CHAR_BIT
348 y = x >> 32; if (y) {n -= 32; x = y;}
349 # endif
350 y = x >> 16; if (y) {n -= 16; x = y;}
351 y = x >> 8; if (y) {n -= 8; x = y;}
352 y = x >> 4; if (y) {n -= 4; x = y;}
353 y = x >> 2; if (y) {n -= 2; x = y;}
354 y = x >> 1; if (y) {return n - 2;}
355 return (unsigned int)(n - x);
356 #endif
357 }
358
359 static inline unsigned int
360 nlz_long(unsigned long x)
361 {
362 #if defined(HAVE_BUILTIN___BUILTIN_CLZL)
363 if (x == 0) return SIZEOF_LONG * CHAR_BIT;
364 return (unsigned int)__builtin_clzl(x);
365 #else
366 unsigned long y;
367 # if 64 < SIZEOF_LONG * CHAR_BIT
368 unsigned int n = 128;
369 # elif 32 < SIZEOF_LONG * CHAR_BIT
370 unsigned int n = 64;
371 # else
372 unsigned int n = 32;
373 # endif
374 # if 64 < SIZEOF_LONG * CHAR_BIT
375 y = x >> 64; if (y) {n -= 64; x = y;}
376 # endif
377 # if 32 < SIZEOF_LONG * CHAR_BIT
378 y = x >> 32; if (y) {n -= 32; x = y;}
379 # endif
380 y = x >> 16; if (y) {n -= 16; x = y;}
381 y = x >> 8; if (y) {n -= 8; x = y;}
382 y = x >> 4; if (y) {n -= 4; x = y;}
383 y = x >> 2; if (y) {n -= 2; x = y;}
384 y = x >> 1; if (y) {return n - 2;}
385 return (unsigned int)(n - x);
386 #endif
387 }
388
389 #ifdef HAVE_LONG_LONG
390 static inline unsigned int
391 nlz_long_long(unsigned LONG_LONG x)
392 {
393 #if defined(HAVE_BUILTIN___BUILTIN_CLZLL)
394 if (x == 0) return SIZEOF_LONG_LONG * CHAR_BIT;
395 return (unsigned int)__builtin_clzll(x);
396 #else
397 unsigned LONG_LONG y;
398 # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
399 unsigned int n = 128;
400 # elif 32 < SIZEOF_LONG_LONG * CHAR_BIT
401 unsigned int n = 64;
402 # else
403 unsigned int n = 32;
404 # endif
405 # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
406 y = x >> 64; if (y) {n -= 64; x = y;}
407 # endif
408 # if 32 < SIZEOF_LONG_LONG * CHAR_BIT
409 y = x >> 32; if (y) {n -= 32; x = y;}
410 # endif
411 y = x >> 16; if (y) {n -= 16; x = y;}
412 y = x >> 8; if (y) {n -= 8; x = y;}
413 y = x >> 4; if (y) {n -= 4; x = y;}
414 y = x >> 2; if (y) {n -= 2; x = y;}
415 y = x >> 1; if (y) {return n - 2;}
416 return (unsigned int)(n - x);
417 #endif
418 }
419 #endif
420
421 #ifdef HAVE_UINT128_T
422 static inline unsigned int
423 nlz_int128(uint128_t x)
424 {
425 uint128_t y;
426 unsigned int n = 128;
427 y = x >> 64; if (y) {n -= 64; x = y;}
428 y = x >> 32; if (y) {n -= 32; x = y;}
429 y = x >> 16; if (y) {n -= 16; x = y;}
430 y = x >> 8; if (y) {n -= 8; x = y;}
431 y = x >> 4; if (y) {n -= 4; x = y;}
432 y = x >> 2; if (y) {n -= 2; x = y;}
433 y = x >> 1; if (y) {return n - 2;}
434 return (unsigned int)(n - x);
435 }
436 #endif
437
438 static inline unsigned int
439 nlz_intptr(uintptr_t x)
440 {
441 #if SIZEOF_UINTPTR_T == SIZEOF_INT
442 return nlz_int(x);
443 #elif SIZEOF_UINTPTR_T == SIZEOF_LONG
444 return nlz_long(x);
445 #elif SIZEOF_UINTPTR_T == SIZEOF_LONG_LONG
446 return nlz_long_long(x);
447 #else
448 #error no known integer type corresponds uintptr_t
449 return /* sane compiler */ ~0;
450 #endif
451 }
452
453 static inline unsigned int
454 rb_popcount32(uint32_t x)
455 {
456 #ifdef HAVE_BUILTIN___BUILTIN_POPCOUNT
457 return (unsigned int)__builtin_popcount(x);
458 #else
459 x = (x & 0x55555555) + (x >> 1 & 0x55555555);
460 x = (x & 0x33333333) + (x >> 2 & 0x33333333);
461 x = (x & 0x0f0f0f0f) + (x >> 4 & 0x0f0f0f0f);
462 x = (x & 0x001f001f) + (x >> 8 & 0x001f001f);
463 return (x & 0x0000003f) + (x >>16 & 0x0000003f);
464 #endif
465 }
466
467 static inline int
468 rb_popcount64(uint64_t x)
469 {
470 #ifdef HAVE_BUILTIN___BUILTIN_POPCOUNT
471 return __builtin_popcountll(x);
472 #else
473 x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
474 x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
475 x = (x & 0x0707070707070707) + (x >> 4 & 0x0707070707070707);
476 x = (x & 0x001f001f001f001f) + (x >> 8 & 0x001f001f001f001f);
477 x = (x & 0x0000003f0000003f) + (x >>16 & 0x0000003f0000003f);
478 return (x & 0x7f) + (x >>32 & 0x7f);
479 #endif
480 }
481
482 static inline int
483 rb_popcount_intptr(uintptr_t x)
484 {
485 #if SIZEOF_VOIDP == 8
486 return rb_popcount64(x);
487 #elif SIZEOF_VOIDP == 4
488 return rb_popcount32(x);
489 #endif
490 }
491
492 static inline int
493 ntz_int32(uint32_t x)
494 {
495 #ifdef HAVE_BUILTIN___BUILTIN_CTZ
496 return __builtin_ctz(x);
497 #else
498 return rb_popcount32((~x) & (x-1));
499 #endif
500 }
501
502 static inline int
503 ntz_int64(uint64_t x)
504 {
505 #ifdef HAVE_BUILTIN___BUILTIN_CTZLL
506 return __builtin_ctzll(x);
507 #else
508 return rb_popcount64((~x) & (x-1));
509 #endif
510 }
511
512 static inline int
513 ntz_intptr(uintptr_t x)
514 {
515 #if SIZEOF_VOIDP == 8
516 return ntz_int64(x);
517 #elif SIZEOF_VOIDP == 4
518 return ntz_int32(x);
519 #endif
520 }
521
522 #if HAVE_LONG_LONG && SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG
523 # define DLONG LONG_LONG
524 # define DL2NUM(x) LL2NUM(x)
525 #elif defined(HAVE_INT128_T)
526 # define DLONG int128_t
527 # define DL2NUM(x) (RB_FIXABLE(x) ? LONG2FIX(x) : rb_int128t2big(x))
528 VALUE rb_int128t2big(int128_t n);
529 #endif
530
531 static inline long
532 rb_overflowed_fix_to_int(long x)
533 {
534 return (long)((unsigned long)(x >> 1) ^ (1LU << (SIZEOF_LONG * CHAR_BIT - 1)));
535 }
536
537 static inline VALUE
538 rb_fix_plus_fix(VALUE x, VALUE y)
539 {
540 #ifdef HAVE_BUILTIN___BUILTIN_ADD_OVERFLOW
541 long lz;
542 /* NOTE
543 * (1) `LONG2FIX(FIX2LONG(x)+FIX2LONG(y))`
544 + = `((lx*2+1)/2 + (ly*2+1)/2)*2+1`
545 + = `lx*2 + ly*2 + 1`
546 + = `(lx*2+1) + (ly*2+1) - 1`
547 + = `x + y - 1`
548 * (2) Fixnum's LSB is always 1.
549 * It means you can always run `x - 1` without overflow.
550 * (3) Of course `z = x + (y-1)` may overflow.
551 * At that time true value is
552 * * positive: 0b0 1xxx...1, and z = 0b1xxx...1
553 * * nevative: 0b1 0xxx...1, and z = 0b0xxx...1
554 * To convert this true value to long,
555 * (a) Use arithmetic shift
556 * * positive: 0b11xxx...
557 * * negative: 0b00xxx...
558 * (b) invert MSB
559 * * positive: 0b01xxx...
560 * * negative: 0b10xxx...
561 */
562 if (__builtin_add_overflow((long)x, (long)y-1, &lz)) {
563 return rb_int2big(rb_overflowed_fix_to_int(lz));
564 }
565 else {
566 return (VALUE)lz;
567 }
568 #else
569 long lz = FIX2LONG(x) + FIX2LONG(y);
570 return LONG2NUM(lz);
571 #endif
572 }
573
574 static inline VALUE
575 rb_fix_minus_fix(VALUE x, VALUE y)
576 {
577 #ifdef HAVE_BUILTIN___BUILTIN_SUB_OVERFLOW
578 long lz;
579 if (__builtin_sub_overflow((long)x, (long)y-1, &lz)) {
580 return rb_int2big(rb_overflowed_fix_to_int(lz));
581 }
582 else {
583 return (VALUE)lz;
584 }
585 #else
586 long lz = FIX2LONG(x) - FIX2LONG(y);
587 return LONG2NUM(lz);
588 #endif
589 }
590
591 /* arguments must be Fixnum */
592 static inline VALUE
593 rb_fix_mul_fix(VALUE x, VALUE y)
594 {
595 long lx = FIX2LONG(x);
596 long ly = FIX2LONG(y);
597 #ifdef DLONG
598 return DL2NUM((DLONG)lx * (DLONG)ly);
599 #else
600 if (MUL_OVERFLOW_FIXNUM_P(lx, ly)) {
601 return rb_big_mul(rb_int2big(lx), rb_int2big(ly));
602 }
603 else {
604 return LONG2FIX(lx * ly);
605 }
606 #endif
607 }
608
609 /*
610 * This behaves different from C99 for negative arguments.
611 * Note that div may overflow fixnum.
612 */
613 static inline void
614 rb_fix_divmod_fix(VALUE a, VALUE b, VALUE *divp, VALUE *modp)
615 {
616 /* assume / and % comply C99.
617 * ldiv(3) won't be inlined by GCC and clang.
618 * I expect / and % are compiled as single idiv.
619 */
620 long x = FIX2LONG(a);
621 long y = FIX2LONG(b);
622 long div, mod;
623 if (x == FIXNUM_MIN && y == -1) {
624 if (divp) *divp = LONG2NUM(-FIXNUM_MIN);
625 if (modp) *modp = LONG2FIX(0);
626 return;
627 }
628 div = x / y;
629 mod = x % y;
630 if (y > 0 ? mod < 0 : mod > 0) {
631 mod += y;
632 div -= 1;
633 }
634 if (divp) *divp = LONG2FIX(div);
635 if (modp) *modp = LONG2FIX(mod);
636 }
637
638 /* div() for Ruby
639 * This behaves different from C99 for negative arguments.
640 */
641 static inline VALUE
642 rb_fix_div_fix(VALUE x, VALUE y)
643 {
644 VALUE div;
645 rb_fix_divmod_fix(x, y, &div, NULL);
646 return div;
647 }
648
649 /* mod() for Ruby
650 * This behaves different from C99 for negative arguments.
651 */
652 static inline VALUE
653 rb_fix_mod_fix(VALUE x, VALUE y)
654 {
655 VALUE mod;
656 rb_fix_divmod_fix(x, y, NULL, &mod);
657 return mod;
658 }
659
660 #if defined(HAVE_UINT128_T) && defined(HAVE_LONG_LONG)
661 # define bit_length(x) \
662 (unsigned int) \
663 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
664 sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
665 sizeof(x) <= SIZEOF_LONG_LONG ? SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)) : \
666 SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
667 #elif defined(HAVE_UINT128_T)
668 # define bit_length(x) \
669 (unsigned int) \
670 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
671 sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
672 SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
673 #elif defined(HAVE_LONG_LONG)
674 # define bit_length(x) \
675 (unsigned int) \
676 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
677 sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
678 SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)))
679 #else
680 # define bit_length(x) \
681 (unsigned int) \
682 (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
683 SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)))
684 #endif
685
686 #ifndef BDIGIT
687 # if SIZEOF_INT*2 <= SIZEOF_LONG_LONG
688 # define BDIGIT unsigned int
689 # define SIZEOF_BDIGIT SIZEOF_INT
690 # define BDIGIT_DBL unsigned LONG_LONG
691 # define BDIGIT_DBL_SIGNED LONG_LONG
692 # define PRI_BDIGIT_PREFIX ""
693 # define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX
694 # elif SIZEOF_INT*2 <= SIZEOF_LONG
695 # define BDIGIT unsigned int
696 # define SIZEOF_BDIGIT SIZEOF_INT
697 # define BDIGIT_DBL unsigned long
698 # define BDIGIT_DBL_SIGNED long
699 # define PRI_BDIGIT_PREFIX ""
700 # define PRI_BDIGIT_DBL_PREFIX "l"
701 # elif SIZEOF_SHORT*2 <= SIZEOF_LONG
702 # define BDIGIT unsigned short
703 # define SIZEOF_BDIGIT SIZEOF_SHORT
704 # define BDIGIT_DBL unsigned long
705 # define BDIGIT_DBL_SIGNED long
706 # define PRI_BDIGIT_PREFIX "h"
707 # define PRI_BDIGIT_DBL_PREFIX "l"
708 # else
709 # define BDIGIT unsigned short
710 # define SIZEOF_BDIGIT (SIZEOF_LONG/2)
711 # define SIZEOF_ACTUAL_BDIGIT SIZEOF_LONG
712 # define BDIGIT_DBL unsigned long
713 # define BDIGIT_DBL_SIGNED long
714 # define PRI_BDIGIT_PREFIX "h"
715 # define PRI_BDIGIT_DBL_PREFIX "l"
716 # endif
717 #endif
718 #ifndef SIZEOF_ACTUAL_BDIGIT
719 # define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGIT
720 #endif
721
722 #ifdef PRI_BDIGIT_PREFIX
723 # define PRIdBDIGIT PRI_BDIGIT_PREFIX"d"
724 # define PRIiBDIGIT PRI_BDIGIT_PREFIX"i"
725 # define PRIoBDIGIT PRI_BDIGIT_PREFIX"o"
726 # define PRIuBDIGIT PRI_BDIGIT_PREFIX"u"
727 # define PRIxBDIGIT PRI_BDIGIT_PREFIX"x"
728 # define PRIXBDIGIT PRI_BDIGIT_PREFIX"X"
729 #endif
730
731 #ifdef PRI_BDIGIT_DBL_PREFIX
732 # define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d"
733 # define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i"
734 # define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o"
735 # define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u"
736 # define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x"
737 # define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X"
738 #endif
739
740 #define BIGNUM_EMBED_LEN_NUMBITS 3
741 #ifndef BIGNUM_EMBED_LEN_MAX
742 # if (SIZEOF_VALUE*RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT) < (1 << BIGNUM_EMBED_LEN_NUMBITS)-1
743 # define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT)
744 # else
745 # define BIGNUM_EMBED_LEN_MAX ((1 << BIGNUM_EMBED_LEN_NUMBITS)-1)
746 # endif
747 #endif
748
749 struct RBignum {
750 struct RBasic basic;
751 union {
752 struct {
753 size_t len;
754 BDIGIT *digits;
755 } heap;
756 BDIGIT ary[BIGNUM_EMBED_LEN_MAX];
757 } as;
758 };
759 #define BIGNUM_SIGN_BIT ((VALUE)FL_USER1)
760 /* sign: positive:1, negative:0 */
761 #define BIGNUM_SIGN(b) ((RBASIC(b)->flags & BIGNUM_SIGN_BIT) != 0)
762 #define BIGNUM_SET_SIGN(b,sign) \
763 ((sign) ? (RBASIC(b)->flags |= BIGNUM_SIGN_BIT) \
764 : (RBASIC(b)->flags &= ~BIGNUM_SIGN_BIT))
765 #define BIGNUM_POSITIVE_P(b) BIGNUM_SIGN(b)
766 #define BIGNUM_NEGATIVE_P(b) (!BIGNUM_SIGN(b))
767 #define BIGNUM_NEGATE(b) (RBASIC(b)->flags ^= BIGNUM_SIGN_BIT)
768
769 #define BIGNUM_EMBED_FLAG ((VALUE)FL_USER2)
770 #define BIGNUM_EMBED_LEN_MASK \
771 (~(~(VALUE)0U << BIGNUM_EMBED_LEN_NUMBITS) << BIGNUM_EMBED_LEN_SHIFT)
772 #define BIGNUM_EMBED_LEN_SHIFT \
773 (FL_USHIFT+3) /* bit offset of BIGNUM_EMBED_LEN_MASK */
774 #define BIGNUM_LEN(b) \
775 ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
776 (size_t)((RBASIC(b)->flags >> BIGNUM_EMBED_LEN_SHIFT) & \
777 (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT)) : \
778 RBIGNUM(b)->as.heap.len)
779 /* LSB:BIGNUM_DIGITS(b)[0], MSB:BIGNUM_DIGITS(b)[BIGNUM_LEN(b)-1] */
780 #define BIGNUM_DIGITS(b) \
781 ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
782 RBIGNUM(b)->as.ary : \
783 RBIGNUM(b)->as.heap.digits)
784 #define BIGNUM_LENINT(b) rb_long2int(BIGNUM_LEN(b))
785
786 #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
787
788 struct RRational {
789 struct RBasic basic;
790 VALUE num;
791 VALUE den;
792 };
793
794 #define RRATIONAL(obj) (R_CAST(RRational)(obj))
795 #define RRATIONAL_SET_NUM(rat, n) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->num,(n))
796 #define RRATIONAL_SET_DEN(rat, d) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->den,(d))
797
798 struct RFloat {
799 struct RBasic basic;
800 double float_value;
801 };
802
803 #define RFLOAT(obj) (R_CAST(RFloat)(obj))
804
805 struct RComplex {
806 struct RBasic basic;
807 VALUE real;
808 VALUE imag;
809 };
810
811 #define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
812
813 /* shortcut macro for internal only */
814 #define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r))
815 #define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i))
816
817 enum ruby_rhash_flags {
818 RHASH_PASS_AS_KEYWORDS = FL_USER1, /* FL 1 */
819 RHASH_PROC_DEFAULT = FL_USER2, /* FL 2 */
820 RHASH_ST_TABLE_FLAG = FL_USER3, /* FL 3 */
821 #define RHASH_AR_TABLE_MAX_SIZE SIZEOF_VALUE
822 RHASH_AR_TABLE_SIZE_MASK = (FL_USER4|FL_USER5|FL_USER6|FL_USER7), /* FL 4..7 */
823 RHASH_AR_TABLE_SIZE_SHIFT = (FL_USHIFT+4),
824 RHASH_AR_TABLE_BOUND_MASK = (FL_USER8|FL_USER9|FL_USER10|FL_USER11), /* FL 8..11 */
825 RHASH_AR_TABLE_BOUND_SHIFT = (FL_USHIFT+8),
826
827 // we can not put it in "enum" because it can exceed "int" range.
828 #define RHASH_LEV_MASK (FL_USER13 | FL_USER14 | FL_USER15 | /* FL 13..19 */ \
829 FL_USER16 | FL_USER17 | FL_USER18 | FL_USER19)
830
831 #if USE_TRANSIENT_HEAP
832 RHASH_TRANSIENT_FLAG = FL_USER12, /* FL 12 */
833 #endif
834
835 RHASH_LEV_SHIFT = (FL_USHIFT + 13),
836 RHASH_LEV_MAX = 127, /* 7 bits */
837
838 RHASH_ENUM_END
839 };
840
841 #define RHASH_AR_TABLE_SIZE_RAW(h) \
842 ((unsigned int)((RBASIC(h)->flags & RHASH_AR_TABLE_SIZE_MASK) >> RHASH_AR_TABLE_SIZE_SHIFT))
843
844 void rb_hash_st_table_set(VALUE hash, st_table *st);
845
846 #if 0 /* for debug */
847 int rb_hash_ar_table_p(VALUE hash);
848 struct ar_table_struct *rb_hash_ar_table(VALUE hash);
849 st_table *rb_hash_st_table(VALUE hash);
850 #define RHASH_AR_TABLE_P(hash) rb_hash_ar_table_p(hash)
851 #define RHASH_AR_TABLE(h) rb_hash_ar_table(h)
852 #define RHASH_ST_TABLE(h) rb_hash_st_table(h)
853 #else
854 #define RHASH_AR_TABLE_P(hash) (!FL_TEST_RAW((hash), RHASH_ST_TABLE_FLAG))
855 #define RHASH_AR_TABLE(hash) (RHASH(hash)->as.ar)
856 #define RHASH_ST_TABLE(hash) (RHASH(hash)->as.st)
857 #endif
858
859 #define RHASH(obj) (R_CAST(RHash)(obj))
860 #define RHASH_ST_SIZE(h) (RHASH_ST_TABLE(h)->num_entries)
861 #define RHASH_ST_TABLE_P(h) (!RHASH_AR_TABLE_P(h))
862 #define RHASH_ST_CLEAR(h) (FL_UNSET_RAW(h, RHASH_ST_TABLE_FLAG), RHASH(h)->as.ar = NULL)
863
864 #define RHASH_AR_TABLE_SIZE_MASK (VALUE)RHASH_AR_TABLE_SIZE_MASK
865 #define RHASH_AR_TABLE_SIZE_SHIFT RHASH_AR_TABLE_SIZE_SHIFT
866 #define RHASH_AR_TABLE_BOUND_MASK (VALUE)RHASH_AR_TABLE_BOUND_MASK
867 #define RHASH_AR_TABLE_BOUND_SHIFT RHASH_AR_TABLE_BOUND_SHIFT
868
869 #if USE_TRANSIENT_HEAP
870 #define RHASH_TRANSIENT_P(hash) FL_TEST_RAW((hash), RHASH_TRANSIENT_FLAG)
871 #define RHASH_SET_TRANSIENT_FLAG(h) FL_SET_RAW(h, RHASH_TRANSIENT_FLAG)
872 #define RHASH_UNSET_TRANSIENT_FLAG(h) FL_UNSET_RAW(h, RHASH_TRANSIENT_FLAG)
873 #else
874 #define RHASH_TRANSIENT_P(hash) 0
875 #define RHASH_SET_TRANSIENT_FLAG(h) ((void)0)
876 #define RHASH_UNSET_TRANSIENT_FLAG(h) ((void)0)
877 #endif
878
879 #if SIZEOF_VALUE / RHASH_AR_TABLE_MAX_SIZE == 2
880 typedef uint16_t ar_hint_t;
881 #elif SIZEOF_VALUE / RHASH_AR_TABLE_MAX_SIZE == 1
882 typedef unsigned char ar_hint_t;
883 #else
884 #error unsupported
885 #endif
886
887 struct RHash {
888 struct RBasic basic;
889 union {
890 st_table *st;
891 struct ar_table_struct *ar; /* possibly 0 */
892 } as;
893 const VALUE ifnone;
894 union {
895 ar_hint_t ary[RHASH_AR_TABLE_MAX_SIZE];
896 VALUE word;
897 } ar_hint;
898 };
899
900 #ifdef RHASH_IFNONE
901 # undef RHASH_IFNONE
902 # undef RHASH_SIZE
903
904 # define RHASH_IFNONE(h) (RHASH(h)->ifnone)
905 # define RHASH_SIZE(h) (RHASH_AR_TABLE_P(h) ? RHASH_AR_TABLE_SIZE_RAW(h) : RHASH_ST_SIZE(h))
906 #endif /* ifdef RHASH_IFNONE */
907
908 struct RMoved {
909 VALUE flags;
910 VALUE destination;
911 VALUE next;
912 };
913
914 /* missing/setproctitle.c */
915 #ifndef HAVE_SETPROCTITLE
916 extern void ruby_init_setproctitle(int argc, char *argv[]);
917 #endif
918
919 #define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX
920 #define RSTRUCT_EMBED_LEN_MASK RSTRUCT_EMBED_LEN_MASK
921 #define RSTRUCT_EMBED_LEN_SHIFT RSTRUCT_EMBED_LEN_SHIFT
922
923 enum {
924 RSTRUCT_EMBED_LEN_MAX = RVALUE_EMBED_LEN_MAX,
925 RSTRUCT_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER1),
926 RSTRUCT_EMBED_LEN_SHIFT = (RUBY_FL_USHIFT+1),
927 RSTRUCT_TRANSIENT_FLAG = FL_USER3,
928
929 RSTRUCT_ENUM_END
930 };
931
932 #if USE_TRANSIENT_HEAP
933 #define RSTRUCT_TRANSIENT_P(st) FL_TEST_RAW((obj), RSTRUCT_TRANSIENT_FLAG)
934 #define RSTRUCT_TRANSIENT_SET(st) FL_SET_RAW((st), RSTRUCT_TRANSIENT_FLAG)
935 #define RSTRUCT_TRANSIENT_UNSET(st) FL_UNSET_RAW((st), RSTRUCT_TRANSIENT_FLAG)
936 #else
937 #define RSTRUCT_TRANSIENT_P(st) 0
938 #define RSTRUCT_TRANSIENT_SET(st) ((void)0)
939 #define RSTRUCT_TRANSIENT_UNSET(st) ((void)0)
940 #endif
941
942 struct RStruct {
943 struct RBasic basic;
944 union {
945 struct {
946 long len;
947 const VALUE *ptr;
948 } heap;
949 const VALUE ary[RSTRUCT_EMBED_LEN_MAX];
950 } as;
951 };
952
953 #undef RSTRUCT_LEN
954 #undef RSTRUCT_PTR
955 #undef RSTRUCT_SET
956 #undef RSTRUCT_GET
957 #define RSTRUCT_EMBED_LEN(st) \
958 (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
959 (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT))
960 #define RSTRUCT_LEN(st) rb_struct_len(st)
961 #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
962 #define RSTRUCT_CONST_PTR(st) rb_struct_const_ptr(st)
963 #define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(STRUCT, st)))
964 #define RSTRUCT_SET(st, idx, v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v))
965 #define RSTRUCT_GET(st, idx) (RSTRUCT_CONST_PTR(st)[idx])
966 #define RSTRUCT(obj) (R_CAST(RStruct)(obj))
967
968 static inline long
969 rb_struct_len(VALUE st)
970 {
971 return (RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ?
972 RSTRUCT_EMBED_LEN(st) : RSTRUCT(st)->as.heap.len;
973 }
974
975 static inline const VALUE *
976 rb_struct_const_ptr(VALUE st)
977 {
978 return FIX_CONST_VALUE_PTR((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ?
979 RSTRUCT(st)->as.ary : RSTRUCT(st)->as.heap.ptr);
980 }
981
982 static inline const VALUE *
983 rb_struct_const_heap_ptr(VALUE st)
984 {
985 /* TODO: check embed on debug mode */
986 return RSTRUCT(st)->as.heap.ptr;
987 }
988
989 /* class.c */
990
991 struct rb_deprecated_classext_struct {
992 char conflict[sizeof(VALUE) * 3];
993 };
994
995 struct rb_subclass_entry;
996 typedef struct rb_subclass_entry rb_subclass_entry_t;
997
998 struct rb_subclass_entry {
999 VALUE klass;
1000 rb_subclass_entry_t *next;
1001 };
1002
1003 #if defined(HAVE_LONG_LONG)
1004 typedef unsigned LONG_LONG rb_serial_t;
1005 #define SERIALT2NUM ULL2NUM
1006 #define PRI_SERIALT_PREFIX PRI_LL_PREFIX
1007 #define SIZEOF_SERIAL_T SIZEOF_LONG_LONG
1008 #elif defined(HAVE_UINT64_T)
1009 typedef uint64_t rb_serial_t;
1010 #define SERIALT2NUM SIZET2NUM
1011 #define PRI_SERIALT_PREFIX PRI_64_PREFIX
1012 #define SIZEOF_SERIAL_T SIZEOF_UINT64_T
1013 #else
1014 typedef unsigned long rb_serial_t;
1015 #define SERIALT2NUM ULONG2NUM
1016 #define PRI_SERIALT_PREFIX PRI_LONG_PREFIX
1017 #define SIZEOF_SERIAL_T SIZEOF_LONG
1018 #endif
1019
1020 struct rb_classext_struct {
1021 struct st_table *iv_index_tbl;
1022 struct st_table *iv_tbl;
1023 #if SIZEOF_SERIAL_T == SIZEOF_VALUE /* otherwise m_tbl is in struct RClass */
1024 struct rb_id_table *m_tbl;
1025 #endif
1026 struct rb_id_table *const_tbl;
1027 struct rb_id_table *callable_m_tbl;
1028 rb_subclass_entry_t *subclasses;
1029 rb_subclass_entry_t **parent_subclasses;
1035 rb_subclass_entry_t **module_subclasses;
1036 #if SIZEOF_SERIAL_T != SIZEOF_VALUE /* otherwise class_serial is in struct RClass */
1037 rb_serial_t class_serial;
1038 #endif
1039 const VALUE origin_;
1040 const VALUE refined_class;
1041 rb_alloc_func_t allocator;
1042 const VALUE includer;
1043 };
1044
1045 typedef struct rb_classext_struct rb_classext_t;
1046
1047 #undef RClass
1048 struct RClass {
1049 struct RBasic basic;
1050 VALUE super;
1051 rb_classext_t *ptr;
1052 #if SIZEOF_SERIAL_T == SIZEOF_VALUE
1053 /* Class serial is as wide as VALUE. Place it here. */
1054 rb_serial_t class_serial;
1055 #else
1056 /* Class serial does not fit into struct RClass. Place m_tbl instead. */
1057 struct rb_id_table *m_tbl;
1058 #endif
1059 };
1060
1061 void rb_class_subclass_add(VALUE super, VALUE klass);
1062 void rb_class_remove_from_super_subclasses(VALUE);
1063 int rb_singleton_class_internal_p(VALUE sklass);
1064
1065 #define RCLASS_EXT(c) (RCLASS(c)->ptr)
1066 #define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
1067 #define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
1068 #if SIZEOF_SERIAL_T == SIZEOF_VALUE
1069 # define RCLASS_M_TBL(c) (RCLASS_EXT(c)->m_tbl)
1070 #else
1071 # define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
1072 #endif
1073 #define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
1074 #define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
1075 #define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)
1076 #define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
1077 #if SIZEOF_SERIAL_T == SIZEOF_VALUE
1078 # define RCLASS_SERIAL(c) (RCLASS(c)->class_serial)
1079 #else
1080 # define RCLASS_SERIAL(c) (RCLASS_EXT(c)->class_serial)
1081 #endif
1082 #define RCLASS_INCLUDER(c) (RCLASS_EXT(c)->includer)
1083
1084 #define RCLASS_CLONED FL_USER6
1085 #define RICLASS_IS_ORIGIN FL_USER5
1086 #define RCLASS_REFINED_BY_ANY FL_USER7
1087
1088 static inline void
1089 RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
1090 {
1091 RB_OBJ_WRITE(klass, &RCLASS_ORIGIN(klass), origin);
1092 if (klass != origin) FL_SET(origin, RICLASS_IS_ORIGIN);
1093 }
1094
1095 static inline void
1096 RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass)
1097 {
1098 RB_OBJ_WRITE(iclass, &RCLASS_INCLUDER(iclass), klass);
1099 }
1100
1101 #undef RCLASS_SUPER
1102 static inline VALUE
1103 RCLASS_SUPER(VALUE klass)
1104 {
1105 return RCLASS(klass)->super;
1106 }
1107
1108 static inline VALUE
1109 RCLASS_SET_SUPER(VALUE klass, VALUE super)
1110 {
1111 if (super) {
1112 rb_class_remove_from_super_subclasses(klass);
1113 rb_class_subclass_add(super, klass);
1114 }
1115 RB_OBJ_WRITE(klass, &RCLASS(klass)->super, super);
1116 return super;
1117 }
1118 /* IMEMO: Internal memo object */
1119
1120 #ifndef IMEMO_DEBUG
1121 #define IMEMO_DEBUG 0
1122 #endif
1123
1124 struct RIMemo {
1125 VALUE flags;
1126 VALUE v0;
1127 VALUE v1;
1128 VALUE v2;
1129 VALUE v3;
1130 };
1131
1132 enum imemo_type {
1133 imemo_env = 0,
1134 imemo_cref = 1,
1135 imemo_svar = 2,
1136 imemo_throw_data = 3,
1137 imemo_ifunc = 4,
1138 imemo_memo = 5,
1139 imemo_ment = 6,
1140 imemo_iseq = 7,
1141 imemo_tmpbuf = 8,
1142 imemo_ast = 9,
1143 imemo_parser_strterm = 10
1144 };
1145 #define IMEMO_MASK 0x0f
1146
1147 static inline enum imemo_type
1148 imemo_type(VALUE imemo)
1149 {
1150 return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
1151 }
1152
1153 static inline int
1154 imemo_type_p(VALUE imemo, enum imemo_type imemo_type)
1155 {
1156 if (LIKELY(!RB_SPECIAL_CONST_P(imemo))) {
1157 /* fixed at compile time if imemo_type is given. */
1158 const VALUE mask = (IMEMO_MASK << FL_USHIFT) | RUBY_T_MASK;
1159 const VALUE expected_type = (imemo_type << FL_USHIFT) | T_IMEMO;
1160 /* fixed at runtime. */
1161 return expected_type == (RBASIC(imemo)->flags & mask);
1162 }
1163 else {
1164 return 0;
1165 }
1166 }
1167
1168 VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
1169
1170 /* FL_USER0 to FL_USER3 is for type */
1171 #define IMEMO_FL_USHIFT (FL_USHIFT + 4)
1172 #define IMEMO_FL_USER0 FL_USER4
1173 #define IMEMO_FL_USER1 FL_USER5
1174 #define IMEMO_FL_USER2 FL_USER6
1175 #define IMEMO_FL_USER3 FL_USER7
1176 #define IMEMO_FL_USER4 FL_USER8
1177
1178 /* CREF (Class REFerence) is defined in method.h */
1179
1181 struct vm_svar {
1182 VALUE flags;
1183 const VALUE cref_or_me;
1184 const VALUE lastline;
1185 const VALUE backref;
1186 const VALUE others;
1187 };
1188
1189
1190 #define THROW_DATA_CONSUMED IMEMO_FL_USER0
1191
1193 struct vm_throw_data {
1194 VALUE flags;
1195 VALUE reserved;
1196 const VALUE throw_obj;
1197 const struct rb_control_frame_struct *catch_frame;
1198 int throw_state;
1199 };
1200
1201 #define THROW_DATA_P(err) RB_TYPE_P((VALUE)(err), T_IMEMO)
1202
1203 /* IFUNC (Internal FUNCtion) */
1204
1205 struct vm_ifunc_argc {
1206 #if SIZEOF_INT * 2 > SIZEOF_VALUE
1207 signed int min: (SIZEOF_VALUE * CHAR_BIT) / 2;
1208 signed int max: (SIZEOF_VALUE * CHAR_BIT) / 2;
1209 #else
1210 int min, max;
1211 #endif
1212 };
1213
1215 struct vm_ifunc {
1216 VALUE flags;
1217 VALUE reserved;
1218 rb_block_call_func_t func;
1219 const void *data;
1220 struct vm_ifunc_argc argc;
1221 };
1222
1223 #define IFUNC_NEW(a, b, c) ((struct vm_ifunc *)rb_imemo_new(imemo_ifunc, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
1224 struct vm_ifunc *rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc);
1225 static inline struct vm_ifunc *
1226 rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data)
1227 {
1228 return rb_vm_ifunc_new(func, data, 0, UNLIMITED_ARGUMENTS);
1229 }
1230
1231 typedef struct rb_imemo_tmpbuf_struct {
1232 VALUE flags;
1233 VALUE reserved;
1234 VALUE *ptr; /* malloc'ed buffer */
1235 struct rb_imemo_tmpbuf_struct *next; /* next imemo */
1236 size_t cnt; /* buffer size in VALUE */
1237 } rb_imemo_tmpbuf_t;
1238
1239 #define rb_imemo_tmpbuf_auto_free_pointer() rb_imemo_new(imemo_tmpbuf, 0, 0, 0, 0)
1240 rb_imemo_tmpbuf_t *rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt);
1241
1242 #define RB_IMEMO_TMPBUF_PTR(v) \
1243 ((void *)(((const struct rb_imemo_tmpbuf_struct *)(v))->ptr))
1244
1245 static inline void *
1246 rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr)
1247 {
1248 return ((rb_imemo_tmpbuf_t *)v)->ptr = ptr;
1249 }
1250
1251 static inline VALUE
1252 rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str)
1253 {
1254 const void *src;
1255 VALUE imemo;
1256 rb_imemo_tmpbuf_t *tmpbuf;
1257 void *dst;
1258 size_t len;
1259
1260 SafeStringValue(str);
1261 /* create tmpbuf to keep the pointer before xmalloc */
1262 imemo = rb_imemo_tmpbuf_auto_free_pointer();
1263 tmpbuf = (rb_imemo_tmpbuf_t *)imemo;
1264 len = RSTRING_LEN(str);
1265 src = RSTRING_PTR(str);
1266 dst = ruby_xmalloc(len);
1267 memcpy(dst, src, len);
1268 tmpbuf->ptr = dst;
1269 return imemo;
1270 }
1271
1272 void rb_strterm_mark(VALUE obj);
1273
1278 struct MEMO {
1279 VALUE flags;
1280 VALUE reserved;
1281 const VALUE v1;
1282 const VALUE v2;
1283 union {
1284 long cnt;
1285 long state;
1286 const VALUE value;
1287 void (*func)(void);
1288 } u3;
1289 };
1290
1291 #define MEMO_V1_SET(m, v) RB_OBJ_WRITE((m), &(m)->v1, (v))
1292 #define MEMO_V2_SET(m, v) RB_OBJ_WRITE((m), &(m)->v2, (v))
1293
1294 #define MEMO_CAST(m) ((struct MEMO *)m)
1295
1296 #define MEMO_NEW(a, b, c) ((struct MEMO *)rb_imemo_new(imemo_memo, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
1297
1298 #define roomof(x, y) (((x) + (y) - 1) / (y))
1299 #define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
1300 #define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
1301 #define NEW_MEMO_FOR(type, value) \
1302 ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
1303 #define NEW_PARTIAL_MEMO_FOR(type, value, member) \
1304 ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), \
1305 rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), \
1306 MEMO_FOR(type, value))
1307
1308 #define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
1309
1310 #ifdef RUBY_INTEGER_UNIFICATION
1311 # define rb_cFixnum rb_cInteger
1312 # define rb_cBignum rb_cInteger
1313 #endif
1314
1315 enum {
1316 cmp_opt_Fixnum,
1317 cmp_opt_String,
1318 cmp_opt_Float,
1319 cmp_optimizable_count
1320 };
1321
1322 struct cmp_opt_data {
1323 unsigned int opt_methods;
1324 unsigned int opt_inited;
1325 };
1326
1327 #define NEW_CMP_OPT_MEMO(type, value) \
1328 NEW_PARTIAL_MEMO_FOR(type, value, cmp_opt)
1329 #define CMP_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(cmp_opt_,type))
1330 #define CMP_OPTIMIZABLE(data, type) \
1331 (((data).opt_inited & CMP_OPTIMIZABLE_BIT(type)) ? \
1332 ((data).opt_methods & CMP_OPTIMIZABLE_BIT(type)) : \
1333 (((data).opt_inited |= CMP_OPTIMIZABLE_BIT(type)), \
1334 rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && \
1335 ((data).opt_methods |= CMP_OPTIMIZABLE_BIT(type))))
1336
1337 #define OPTIMIZED_CMP(a, b, data) \
1338 ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(data, Fixnum)) ? \
1339 (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : \
1340 (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(data, String)) ? \
1341 rb_str_cmp(a, b) : \
1342 (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b) && CMP_OPTIMIZABLE(data, Float)) ? \
1343 rb_float_cmp(a, b) : \
1344 rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
1345
1346 /* ment is in method.h */
1347
1348 /* global variable */
1349
1350 struct rb_global_entry {
1351 struct rb_global_variable *var;
1352 ID id;
1353 };
1354
1355 struct rb_global_entry *rb_global_entry(ID);
1356 VALUE rb_gvar_get(struct rb_global_entry *);
1357 VALUE rb_gvar_set(struct rb_global_entry *, VALUE);
1358 VALUE rb_gvar_defined(struct rb_global_entry *);
1359
1360 /* array.c */
1361
1362 #ifndef ARRAY_DEBUG
1363 #define ARRAY_DEBUG (0+RUBY_DEBUG)
1364 #endif
1365
1366 #ifdef ARRAY_DEBUG
1367 #define RARRAY_PTR_IN_USE_FLAG FL_USER14
1368 #define ARY_PTR_USING_P(ary) FL_TEST_RAW((ary), RARRAY_PTR_IN_USE_FLAG)
1369 #else
1370
1371 /* disable debug function */
1372 #undef RARRAY_PTR_USE_START_TRANSIENT
1373 #undef RARRAY_PTR_USE_END_TRANSIENT
1374 #define RARRAY_PTR_USE_START_TRANSIENT(a) ((VALUE *)RARRAY_CONST_PTR_TRANSIENT(a))
1375 #define RARRAY_PTR_USE_END_TRANSIENT(a)
1376 #define ARY_PTR_USING_P(ary) 0
1377
1378 #endif
1379
1380 #if USE_TRANSIENT_HEAP
1381 #define RARY_TRANSIENT_SET(ary) FL_SET_RAW((ary), RARRAY_TRANSIENT_FLAG);
1382 #define RARY_TRANSIENT_UNSET(ary) FL_UNSET_RAW((ary), RARRAY_TRANSIENT_FLAG);
1383 #else
1384 #undef RARRAY_TRANSIENT_P
1385 #define RARRAY_TRANSIENT_P(a) 0
1386 #define RARY_TRANSIENT_SET(ary) ((void)0)
1387 #define RARY_TRANSIENT_UNSET(ary) ((void)0)
1388 #endif
1389
1390
1391 VALUE rb_ary_last(int, const VALUE *, VALUE);
1392 void rb_ary_set_len(VALUE, long);
1393 void rb_ary_delete_same(VALUE, VALUE);
1394 VALUE rb_ary_tmp_new_fill(long capa);
1395 VALUE rb_ary_at(VALUE, VALUE);
1396 VALUE rb_ary_aref1(VALUE ary, VALUE i);
1397 size_t rb_ary_memsize(VALUE);
1398 VALUE rb_to_array_type(VALUE obj);
1399 VALUE rb_check_to_array(VALUE ary);
1400 VALUE rb_ary_tmp_new_from_values(VALUE, long, const VALUE *);
1401 VALUE rb_ary_behead(VALUE, long);
1402 #if defined(__GNUC__) && defined(HAVE_VA_ARGS_MACRO)
1403 #define rb_ary_new_from_args(n, ...) \
1404 __extension__ ({ \
1405 const VALUE args_to_new_ary[] = {__VA_ARGS__}; \
1406 if (__builtin_constant_p(n)) { \
1407 STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); \
1408 } \
1409 rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); \
1410 })
1411 #endif
1412
1413 static inline VALUE
1414 rb_ary_entry_internal(VALUE ary, long offset)
1415 {
1416 long len = RARRAY_LEN(ary);
1417 const VALUE *ptr = RARRAY_CONST_PTR_TRANSIENT(ary);
1418 if (len == 0) return Qnil;
1419 if (offset < 0) {
1420 offset += len;
1421 if (offset < 0) return Qnil;
1422 }
1423 else if (len <= offset) {
1424 return Qnil;
1425 }
1426 return ptr[offset];
1427 }
1428
1429 /* MRI debug support */
1430 void rb_obj_info_dump(VALUE obj);
1431 void rb_obj_info_dump_loc(VALUE obj, const char *file, int line, const char *func);
1432 void ruby_debug_breakpoint(void);
1433
1434 // show obj data structure without any side-effect
1435 #define rp(obj) rb_obj_info_dump_loc((VALUE)(obj), __FILE__, __LINE__, __func__)
1436
1437 // same as rp, but add message header
1438 #define rp_m(msg, obj) do { \
1439 fprintf(stderr, "%s", (msg)); \
1440 rb_obj_info_dump((VALUE)obj); \
1441 } while (0)
1442
1443 // `ruby_debug_breakpoint()` does nothing,
1444 // but breakpoint is set in run.gdb, so `make gdb` can stop here.
1445 #define bp() ruby_debug_breakpoint()
1446
1447 /* bignum.c */
1448 extern const char ruby_digitmap[];
1449 double rb_big_fdiv_double(VALUE x, VALUE y);
1450 VALUE rb_big_uminus(VALUE x);
1451 VALUE rb_big_hash(VALUE);
1452 VALUE rb_big_odd_p(VALUE);
1453 VALUE rb_big_even_p(VALUE);
1454 size_t rb_big_size(VALUE);
1455 VALUE rb_integer_float_cmp(VALUE x, VALUE y);
1456 VALUE rb_integer_float_eq(VALUE x, VALUE y);
1457 VALUE rb_str_convert_to_inum(VALUE str, int base, int badcheck, int raise_exception);
1458 VALUE rb_big_comp(VALUE x);
1459 VALUE rb_big_aref(VALUE x, VALUE y);
1460 VALUE rb_big_abs(VALUE x);
1461 VALUE rb_big_size_m(VALUE big);
1462 VALUE rb_big_bit_length(VALUE big);
1463 VALUE rb_big_remainder(VALUE x, VALUE y);
1464 VALUE rb_big_gt(VALUE x, VALUE y);
1465 VALUE rb_big_ge(VALUE x, VALUE y);
1466 VALUE rb_big_lt(VALUE x, VALUE y);
1467 VALUE rb_big_le(VALUE x, VALUE y);
1468 VALUE rb_int_powm(int const argc, VALUE * const argv, VALUE const num);
1469
1470 /* class.c */
1471 VALUE rb_class_boot(VALUE);
1472 VALUE rb_class_inherited(VALUE, VALUE);
1473 VALUE rb_make_metaclass(VALUE, VALUE);
1474 VALUE rb_include_class_new(VALUE, VALUE);
1475 void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE);
1476 void rb_class_detach_subclasses(VALUE);
1477 void rb_class_detach_module_subclasses(VALUE);
1478 void rb_class_remove_from_module_subclasses(VALUE);
1479 VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj);
1480 VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj);
1481 VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj);
1482 VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj);
1483 VALUE rb_special_singleton_class(VALUE);
1484 VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach);
1485 VALUE rb_singleton_class_get(VALUE obj);
1486 void Init_class_hierarchy(void);
1487
1488 int rb_class_has_methods(VALUE c);
1489 void rb_undef_methods_from(VALUE klass, VALUE super);
1490
1491 /* compar.c */
1492 VALUE rb_invcmp(VALUE, VALUE);
1493
1494 /* compile.c */
1495 struct rb_block;
1496 struct rb_iseq_struct;
1497 int rb_dvar_defined(ID, const struct rb_iseq_struct *);
1498 int rb_local_defined(ID, const struct rb_iseq_struct *);
1499 const char * rb_insns_name(int i);
1500 VALUE rb_insns_name_array(void);
1501 int rb_vm_insn_addr2insn(const void *);
1502
1503 /* complex.c */
1504 VALUE rb_dbl_complex_new_polar_pi(double abs, double ang);
1505
1506 struct rb_thread_struct;
1507 /* cont.c */
1508 VALUE rb_obj_is_fiber(VALUE);
1509 void rb_fiber_reset_root_local_storage(struct rb_thread_struct *);
1510 void ruby_register_rollback_func_for_ensure(VALUE (*ensure_func)(VALUE), VALUE (*rollback_func)(VALUE));
1511
1512 /* debug.c */
1513 PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
1514
1515 /* dir.c */
1516 VALUE rb_dir_getwd_ospath(void);
1517
1518 /* dmyext.c */
1519 void Init_enc(void);
1520 void Init_ext(void);
1521
1522 /* encoding.c */
1523 ID rb_id_encoding(void);
1524 #ifdef RUBY_ENCODING_H
1525 rb_encoding *rb_enc_get_from_index(int index);
1526 rb_encoding *rb_enc_check_str(VALUE str1, VALUE str2);
1527 #endif
1528 int rb_encdb_replicate(const char *alias, const char *orig);
1529 int rb_encdb_alias(const char *alias, const char *orig);
1530 int rb_encdb_dummy(const char *name);
1531 void rb_encdb_declare(const char *name);
1532 void rb_enc_set_base(const char *name, const char *orig);
1533 int rb_enc_set_dummy(int index);
1534 void rb_encdb_set_unicode(int index);
1535 PUREFUNC(int rb_data_is_encoding(VALUE obj));
1536
1537 /* enum.c */
1538 extern VALUE rb_cArithSeq;
1539 VALUE rb_f_send(int argc, VALUE *argv, VALUE recv);
1540 VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary);
1541
1542 /* error.c */
1543 extern VALUE rb_eEAGAIN;
1544 extern VALUE rb_eEWOULDBLOCK;
1545 extern VALUE rb_eEINPROGRESS;
1546 void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args);
1547 NORETURN(void rb_async_bug_errno(const char *,int));
1548 const char *rb_builtin_type_name(int t);
1549 const char *rb_builtin_class_name(VALUE x);
1550 PRINTF_ARGS(void rb_warn_deprecated(const char *fmt, const char *suggest, ...), 1, 3);
1551 #ifdef RUBY_ENCODING_H
1552 VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*, va_list);
1553 PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
1554 PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
1555 PRINTF_ARGS(void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt, ...), 3, 4);
1556 #endif
1557
1558 typedef enum {
1559 RB_WARN_CATEGORY_NONE,
1560 RB_WARN_CATEGORY_DEPRECATED,
1561 RB_WARN_CATEGORY_EXPERIMENTAL,
1562 } rb_warning_category_t;
1563 rb_warning_category_t rb_warning_category_from_name(VALUE category);
1564 bool rb_warning_category_enabled_p(rb_warning_category_t category);
1565
1566 #define rb_raise_cstr(etype, mesg) \
1567 rb_exc_raise(rb_exc_new_str(etype, rb_str_new_cstr(mesg)))
1568 #define rb_raise_static(etype, mesg) \
1569 rb_exc_raise(rb_exc_new_str(etype, rb_str_new_static(mesg, rb_strlen_lit(mesg))))
1570
1571 VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
1572 #define rb_name_err_raise_str(mesg, recv, name) \
1573 rb_exc_raise(rb_name_err_new(mesg, recv, name))
1574 #define rb_name_err_raise(mesg, recv, name) \
1575 rb_name_err_raise_str(rb_fstring_cstr(mesg), (recv), (name))
1576 VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv);
1577 VALUE rb_key_err_new(VALUE mesg, VALUE recv, VALUE name);
1578 #define rb_key_err_raise(mesg, recv, name) \
1579 rb_exc_raise(rb_key_err_new(mesg, recv, name))
1580 PRINTF_ARGS(VALUE rb_warning_string(const char *fmt, ...), 1, 2);
1581 NORETURN(void rb_vraise(VALUE, const char *, va_list));
1582
1583 /* eval.c */
1584 VALUE rb_refinement_module_get_refined_class(VALUE module);
1585 extern ID ruby_static_id_signo, ruby_static_id_status;
1586 void rb_class_modify_check(VALUE);
1587 #define id_signo ruby_static_id_signo
1588 #define id_status ruby_static_id_status
1589 NORETURN(VALUE rb_f_raise(int argc, VALUE *argv));
1590
1591 /* eval_error.c */
1592 VALUE rb_get_backtrace(VALUE info);
1593
1594 /* eval_jump.c */
1595 void rb_call_end_proc(VALUE data);
1596 void rb_mark_end_proc(void);
1597
1598 /* file.c */
1599 extern const char ruby_null_device[];
1600 VALUE rb_home_dir_of(VALUE user, VALUE result);
1601 VALUE rb_default_home_dir(VALUE result);
1602 VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
1603 #ifdef RUBY_ENCODING_H
1604 VALUE rb_check_realpath(VALUE basedir, VALUE path, rb_encoding *origenc);
1605 #endif
1606 void rb_file_const(const char*, VALUE);
1607 int rb_file_load_ok(const char *);
1608 VALUE rb_file_expand_path_fast(VALUE, VALUE);
1609 VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE);
1610 VALUE rb_get_path_check_to_string(VALUE);
1611 VALUE rb_get_path_check_convert(VALUE);
1612 void Init_File(void);
1613 int ruby_is_fd_loadable(int fd);
1614
1615 #ifdef RUBY_FUNCTION_NAME_STRING
1616 # if defined __GNUC__ && __GNUC__ >= 4
1617 # pragma GCC visibility push(default)
1618 # endif
1619 NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
1620 NORETURN(void rb_syserr_fail_path_in(const char *func_name, int err, VALUE path));
1621 # if defined __GNUC__ && __GNUC__ >= 4
1622 # pragma GCC visibility pop
1623 # endif
1624 # define rb_sys_fail_path(path) rb_sys_fail_path_in(RUBY_FUNCTION_NAME_STRING, path)
1625 # define rb_syserr_fail_path(err, path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
1626 #else
1627 # define rb_sys_fail_path(path) rb_sys_fail_str(path)
1628 # define rb_syserr_fail_path(err, path) rb_syserr_fail_str((err), (path))
1629 #endif
1630
1631 /* gc.c */
1632 extern VALUE *ruby_initial_gc_stress_ptr;
1633 extern int ruby_disable_gc;
1634 void Init_heap(void);
1635 void *ruby_mimmalloc(size_t size) RUBY_ATTR_MALLOC;
1636 void ruby_mimfree(void *ptr);
1637 void rb_objspace_set_event_hook(const rb_event_flag_t event);
1638 #if USE_RGENGC
1639 void rb_gc_writebarrier_remember(VALUE obj);
1640 #else
1641 #define rb_gc_writebarrier_remember(obj) 0
1642 #endif
1643 void ruby_gc_set_params(void);
1644 void rb_copy_wb_protected_attribute(VALUE dest, VALUE obj);
1645
1646 #if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
1647 #define ruby_sized_xrealloc(ptr, new_size, old_size) ruby_xrealloc(ptr, new_size)
1648 #define ruby_sized_xrealloc2(ptr, new_count, element_size, old_count) ruby_xrealloc2(ptr, new_count, element_size)
1649 #define ruby_sized_xfree(ptr, size) ruby_xfree(ptr)
1650 #define SIZED_REALLOC_N(var,type,n,old_n) REALLOC_N(var, type, n)
1651 #else
1652 RUBY_SYMBOL_EXPORT_BEGIN
1653 void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2));
1654 void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2, 3));
1655 void ruby_sized_xfree(void *x, size_t size);
1656 RUBY_SYMBOL_EXPORT_END
1657 #define SIZED_REALLOC_N(var,type,n,old_n) ((var)=(type*)ruby_sized_xrealloc2((void*)(var), (n), sizeof(type), (old_n)))
1658 #endif
1659
1660 /* optimized version of NEWOBJ() */
1661 #undef NEWOBJF_OF
1662 #undef RB_NEWOBJ_OF
1663 #define RB_NEWOBJ_OF(obj,type,klass,flags) \
1664 type *(obj) = (type*)(((flags) & FL_WB_PROTECTED) ? \
1665 rb_wb_protected_newobj_of(klass, (flags) & ~FL_WB_PROTECTED) : \
1666 rb_wb_unprotected_newobj_of(klass, flags))
1667 #define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags)
1668
1669 #ifdef __has_attribute
1670 #if __has_attribute(alloc_align)
1671 __attribute__((__alloc_align__(1)))
1672 #endif
1673 #endif
1674 void *rb_aligned_malloc(size_t, size_t) RUBY_ATTR_MALLOC RUBY_ATTR_ALLOC_SIZE((2));
1675
1676 size_t rb_size_mul_or_raise(size_t, size_t, VALUE); /* used in compile.c */
1677 size_t rb_size_mul_add_or_raise(size_t, size_t, size_t, VALUE); /* used in iseq.h */
1678 void *rb_xmalloc_mul_add(size_t, size_t, size_t) RUBY_ATTR_MALLOC;
1679 void *rb_xrealloc_mul_add(const void *, size_t, size_t, size_t);
1680 void *rb_xmalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC;
1681 void *rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC;
1682
1683 /* hash.c */
1684 #if RHASH_CONVERT_TABLE_DEBUG
1685 struct st_table *rb_hash_tbl_raw(VALUE hash, const char *file, int line);
1686 #define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h, __FILE__, __LINE__)
1687 #else
1688 struct st_table *rb_hash_tbl_raw(VALUE hash);
1689 #define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h)
1690 #endif
1691
1692 VALUE rb_hash_new_with_size(st_index_t size);
1693 VALUE rb_hash_has_key(VALUE hash, VALUE key);
1694 VALUE rb_hash_default_value(VALUE hash, VALUE key);
1695 VALUE rb_hash_set_default_proc(VALUE hash, VALUE proc);
1696 long rb_dbl_long_hash(double d);
1697 st_table *rb_init_identtable(void);
1698 VALUE rb_hash_compare_by_id_p(VALUE hash);
1699 VALUE rb_to_hash_type(VALUE obj);
1700 VALUE rb_hash_key_str(VALUE);
1701 VALUE rb_hash_keys(VALUE hash);
1702 VALUE rb_hash_values(VALUE hash);
1703 VALUE rb_hash_rehash(VALUE hash);
1704 VALUE rb_hash_resurrect(VALUE hash);
1705 int rb_hash_add_new_element(VALUE hash, VALUE key, VALUE val);
1706 VALUE rb_hash_set_pair(VALUE hash, VALUE pair);
1707
1708 int rb_hash_stlike_lookup(VALUE hash, st_data_t key, st_data_t *pval);
1709 int rb_hash_stlike_delete(VALUE hash, st_data_t *pkey, st_data_t *pval);
1710 RUBY_SYMBOL_EXPORT_BEGIN
1711 int rb_hash_stlike_foreach(VALUE hash, st_foreach_callback_func *func, st_data_t arg);
1712 RUBY_SYMBOL_EXPORT_END
1713 int rb_hash_stlike_foreach_with_replace(VALUE hash, st_foreach_check_callback_func *func, st_update_callback_func *replace, st_data_t arg);
1714 int rb_hash_stlike_update(VALUE hash, st_data_t key, st_update_callback_func func, st_data_t arg);
1715
1716 /* inits.c */
1717 void rb_call_inits(void);
1718
1719 /* io.c */
1720 void ruby_set_inplace_mode(const char *);
1721 void rb_stdio_set_default_encoding(void);
1722 VALUE rb_io_flush_raw(VALUE, int);
1723 #ifdef RUBY_IO_H
1724 size_t rb_io_memsize(const rb_io_t *);
1725 #endif
1726 int rb_stderr_tty_p(void);
1727 void rb_io_fptr_finalize_internal(void *ptr);
1728 #define rb_io_fptr_finalize rb_io_fptr_finalize_internal
1729
1730 /* load.c */
1731 VALUE rb_get_expanded_load_path(void);
1732 int rb_require_internal(VALUE fname);
1733 NORETURN(void rb_load_fail(VALUE, const char*));
1734
1735 /* loadpath.c */
1736 extern const char ruby_exec_prefix[];
1737 extern const char ruby_initial_load_paths[];
1738
1739 /* localeinit.c */
1740 int Init_enc_set_filesystem_encoding(void);
1741
1742 /* math.c */
1743 VALUE rb_math_atan2(VALUE, VALUE);
1744 VALUE rb_math_cos(VALUE);
1745 VALUE rb_math_cosh(VALUE);
1746 VALUE rb_math_exp(VALUE);
1747 VALUE rb_math_hypot(VALUE, VALUE);
1748 VALUE rb_math_log(int argc, const VALUE *argv);
1749 VALUE rb_math_sin(VALUE);
1750 VALUE rb_math_sinh(VALUE);
1751
1752 /* mjit.c */
1753
1754 #if USE_MJIT
1755 extern bool mjit_enabled;
1756 VALUE mjit_pause(bool wait_p);
1757 VALUE mjit_resume(void);
1758 void mjit_finish(bool close_handle_p);
1759 #else
1760 #define mjit_enabled 0
1761 static inline VALUE mjit_pause(bool wait_p){ return Qnil; } // unreachable
1762 static inline VALUE mjit_resume(void){ return Qnil; } // unreachable
1763 static inline void mjit_finish(bool close_handle_p){}
1764 #endif
1765
1766 /* newline.c */
1767 void Init_newline(void);
1768
1769 /* numeric.c */
1770
1771 #define FIXNUM_POSITIVE_P(num) ((SIGNED_VALUE)(num) > (SIGNED_VALUE)INT2FIX(0))
1772 #define FIXNUM_NEGATIVE_P(num) ((SIGNED_VALUE)(num) < 0)
1773 #define FIXNUM_ZERO_P(num) ((num) == INT2FIX(0))
1774
1775 #define INT_NEGATIVE_P(x) (FIXNUM_P(x) ? FIXNUM_NEGATIVE_P(x) : BIGNUM_NEGATIVE_P(x))
1776
1777 #define FLOAT_ZERO_P(x) (RFLOAT_VALUE(x) == 0.0)
1778
1779 #ifndef ROUND_DEFAULT
1780 # define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP
1781 #endif
1782 enum ruby_num_rounding_mode {
1783 RUBY_NUM_ROUND_HALF_UP,
1784 RUBY_NUM_ROUND_HALF_EVEN,
1785 RUBY_NUM_ROUND_HALF_DOWN,
1786 RUBY_NUM_ROUND_DEFAULT = ROUND_DEFAULT
1787 };
1788 #define ROUND_TO(mode, even, up, down) \
1789 ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : \
1790 (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down)
1791 #define ROUND_FUNC(mode, name) \
1792 ROUND_TO(mode, name##_half_even, name##_half_up, name##_half_down)
1793 #define ROUND_CALL(mode, name, args) \
1794 ROUND_TO(mode, name##_half_even args, \
1795 name##_half_up args, name##_half_down args)
1796
1797 int rb_num_to_uint(VALUE val, unsigned int *ret);
1798 VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
1799 double ruby_float_step_size(double beg, double end, double unit, int excl);
1800 int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless);
1801 double ruby_float_mod(double x, double y);
1802 int rb_num_negative_p(VALUE);
1803 VALUE rb_int_succ(VALUE num);
1804 VALUE rb_int_uminus(VALUE num);
1805 VALUE rb_float_uminus(VALUE num);
1806 VALUE rb_int_plus(VALUE x, VALUE y);
1807 VALUE rb_float_plus(VALUE x, VALUE y);
1808 VALUE rb_int_minus(VALUE x, VALUE y);
1809 VALUE rb_int_mul(VALUE x, VALUE y);
1810 VALUE rb_float_mul(VALUE x, VALUE y);
1811 VALUE rb_float_div(VALUE x, VALUE y);
1812 VALUE rb_int_idiv(VALUE x, VALUE y);
1813 VALUE rb_int_modulo(VALUE x, VALUE y);
1814 VALUE rb_int2str(VALUE num, int base);
1815 VALUE rb_fix_plus(VALUE x, VALUE y);
1816 VALUE rb_fix_aref(VALUE fix, VALUE idx);
1817 VALUE rb_int_gt(VALUE x, VALUE y);
1818 int rb_float_cmp(VALUE x, VALUE y);
1819 VALUE rb_float_gt(VALUE x, VALUE y);
1820 VALUE rb_int_ge(VALUE x, VALUE y);
1821 enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts);
1822 double rb_int_fdiv_double(VALUE x, VALUE y);
1823 VALUE rb_int_pow(VALUE x, VALUE y);
1824 VALUE rb_float_pow(VALUE x, VALUE y);
1825 VALUE rb_int_cmp(VALUE x, VALUE y);
1826 VALUE rb_int_equal(VALUE x, VALUE y);
1827 VALUE rb_int_divmod(VALUE x, VALUE y);
1828 VALUE rb_int_and(VALUE x, VALUE y);
1829 VALUE rb_int_lshift(VALUE x, VALUE y);
1830 VALUE rb_int_div(VALUE x, VALUE y);
1831 VALUE rb_int_abs(VALUE num);
1832 VALUE rb_int_odd_p(VALUE num);
1833 int rb_int_positive_p(VALUE num);
1834 int rb_int_negative_p(VALUE num);
1835 VALUE rb_num_pow(VALUE x, VALUE y);
1836 VALUE rb_float_ceil(VALUE num, int ndigits);
1837
1838 static inline VALUE
1839 rb_num_compare_with_zero(VALUE num, ID mid)
1840 {
1841 VALUE zero = INT2FIX(0);
1842 VALUE r = rb_check_funcall(num, mid, 1, &zero);
1843 if (r == Qundef) {
1844 rb_cmperr(num, zero);
1845 }
1846 return r;
1847 }
1848
1849 static inline int
1850 rb_num_positive_int_p(VALUE num)
1851 {
1852 const ID mid = '>';
1853
1854 if (FIXNUM_P(num)) {
1855 if (rb_method_basic_definition_p(rb_cInteger, mid))
1856 return FIXNUM_POSITIVE_P(num);
1857 }
1858 else if (RB_TYPE_P(num, T_BIGNUM)) {
1859 if (rb_method_basic_definition_p(rb_cInteger, mid))
1860 return BIGNUM_POSITIVE_P(num);
1861 }
1862 return RTEST(rb_num_compare_with_zero(num, mid));
1863 }
1864
1865
1866 static inline int
1867 rb_num_negative_int_p(VALUE num)
1868 {
1869 const ID mid = '<';
1870
1871 if (FIXNUM_P(num)) {
1872 if (rb_method_basic_definition_p(rb_cInteger, mid))
1873 return FIXNUM_NEGATIVE_P(num);
1874 }
1875 else if (RB_TYPE_P(num, T_BIGNUM)) {
1876 if (rb_method_basic_definition_p(rb_cInteger, mid))
1877 return BIGNUM_NEGATIVE_P(num);
1878 }
1879 return RTEST(rb_num_compare_with_zero(num, mid));
1880 }
1881
1882
1883 VALUE rb_float_abs(VALUE flt);
1884 VALUE rb_float_equal(VALUE x, VALUE y);
1885 VALUE rb_float_eql(VALUE x, VALUE y);
1886 VALUE rb_flo_div_flo(VALUE x, VALUE y);
1887
1888 #if USE_FLONUM
1889 #define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
1890 #define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
1891 #endif
1892
1893 static inline double
1894 rb_float_flonum_value(VALUE v)
1895 {
1896 #if USE_FLONUM
1897 if (v != (VALUE)0x8000000000000002) { /* LIKELY */
1898 union {
1899 double d;
1900 VALUE v;
1901 } t;
1902
1903 VALUE b63 = (v >> 63);
1904 /* e: xx1... -> 011... */
1905 /* xx0... -> 100... */
1906 /* ^b63 */
1907 t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~(VALUE)0x03), 3);
1908 return t.d;
1909 }
1910 #endif
1911 return 0.0;
1912 }
1913
1914 static inline double
1915 rb_float_noflonum_value(VALUE v)
1916 {
1917 return ((struct RFloat *)v)->float_value;
1918 }
1919
1920 static inline double
1921 rb_float_value_inline(VALUE v)
1922 {
1923 if (FLONUM_P(v)) {
1924 return rb_float_flonum_value(v);
1925 }
1926 return rb_float_noflonum_value(v);
1927 }
1928
1929 static inline VALUE
1930 rb_float_new_inline(double d)
1931 {
1932 #if USE_FLONUM
1933 union {
1934 double d;
1935 VALUE v;
1936 } t;
1937 int bits;
1938
1939 t.d = d;
1940 bits = (int)((VALUE)(t.v >> 60) & 0x7);
1941 /* bits contains 3 bits of b62..b60. */
1942 /* bits - 3 = */
1943 /* b011 -> b000 */
1944 /* b100 -> b001 */
1945
1946 if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
1947 !((bits-3) & ~0x01)) {
1948 return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
1949 }
1950 else if (t.v == (VALUE)0) {
1951 /* +0.0 */
1952 return 0x8000000000000002;
1953 }
1954 /* out of range */
1955 #endif
1956 return rb_float_new_in_heap(d);
1957 }
1958
1959 #define rb_float_value(v) rb_float_value_inline(v)
1960 #define rb_float_new(d) rb_float_new_inline(d)
1961
1962 /* object.c */
1963 void rb_obj_copy_ivar(VALUE dest, VALUE obj);
1964 CONSTFUNC(VALUE rb_obj_equal(VALUE obj1, VALUE obj2));
1965 CONSTFUNC(VALUE rb_obj_not(VALUE obj));
1966 VALUE rb_class_search_ancestor(VALUE klass, VALUE super);
1967 NORETURN(void rb_undefined_alloc(VALUE klass));
1968 double rb_num_to_dbl(VALUE val);
1969 VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound);
1970 VALUE rb_immutable_obj_clone(int, VALUE *, VALUE);
1971 VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
1972 VALUE rb_convert_type_with_id(VALUE,int,const char*,ID);
1973 VALUE rb_check_convert_type_with_id(VALUE,int,const char*,ID);
1974 int rb_bool_expected(VALUE, const char *);
1975
1976 struct RBasicRaw {
1977 VALUE flags;
1978 VALUE klass;
1979 };
1980
1981 #define RBASIC_CLEAR_CLASS(obj) memset(&(((struct RBasicRaw *)((VALUE)(obj)))->klass), 0, sizeof(VALUE))
1982 #define RBASIC_SET_CLASS_RAW(obj, cls) memcpy(&((struct RBasicRaw *)((VALUE)(obj)))->klass, &(cls), sizeof(VALUE))
1983 #define RBASIC_SET_CLASS(obj, cls) do { \
1984 VALUE _obj_ = (obj); \
1985 RB_OBJ_WRITE(_obj_, &((struct RBasicRaw *)(_obj_))->klass, cls); \
1986 } while (0)
1987
1988 /* parse.y */
1989 #ifndef USE_SYMBOL_GC
1990 #define USE_SYMBOL_GC 1
1991 #endif
1992 VALUE rb_parser_set_yydebug(VALUE, VALUE);
1993 RUBY_SYMBOL_EXPORT_BEGIN
1994 VALUE rb_parser_set_context(VALUE, const struct rb_iseq_struct *, int);
1995 RUBY_SYMBOL_EXPORT_END
1996 void *rb_parser_load_file(VALUE parser, VALUE name);
1997 int rb_is_const_name(VALUE name);
1998 int rb_is_class_name(VALUE name);
1999 int rb_is_instance_name(VALUE name);
2000 int rb_is_local_name(VALUE name);
2001 PUREFUNC(int rb_is_const_sym(VALUE sym));
2002 PUREFUNC(int rb_is_attrset_sym(VALUE sym));
2003 ID rb_make_internal_id(void);
2004 void rb_gc_free_dsymbol(VALUE);
2005
2006 /* proc.c */
2007 VALUE rb_proc_location(VALUE self);
2008 st_index_t rb_hash_proc(st_index_t hash, VALUE proc);
2009 int rb_block_arity(void);
2010 int rb_block_min_max_arity(int *max);
2011 VALUE rb_func_proc_new(rb_block_call_func_t func, VALUE val);
2012 VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc);
2013 VALUE rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_info);
2014
2015 /* process.c */
2016 #define RB_MAX_GROUPS (65536)
2017
2018 struct waitpid_state;
2019 struct rb_execarg {
2020 union {
2021 struct {
2022 VALUE shell_script;
2023 } sh;
2024 struct {
2025 VALUE command_name;
2026 VALUE command_abspath; /* full path string or nil */
2027 VALUE argv_str;
2028 VALUE argv_buf;
2029 } cmd;
2030 } invoke;
2031 VALUE redirect_fds;
2032 VALUE envp_str;
2033 VALUE envp_buf;
2034 VALUE dup2_tmpbuf;
2035 unsigned use_shell : 1;
2036 unsigned pgroup_given : 1;
2037 unsigned umask_given : 1;
2038 unsigned unsetenv_others_given : 1;
2039 unsigned unsetenv_others_do : 1;
2040 unsigned close_others_given : 1;
2041 unsigned close_others_do : 1;
2042 unsigned chdir_given : 1;
2043 unsigned new_pgroup_given : 1;
2044 unsigned new_pgroup_flag : 1;
2045 unsigned uid_given : 1;
2046 unsigned gid_given : 1;
2047 unsigned exception : 1;
2048 unsigned exception_given : 1;
2049 struct waitpid_state *waitpid_state; /* for async process management */
2050 rb_pid_t pgroup_pgid; /* asis(-1), new pgroup(0), specified pgroup (0<V). */
2051 VALUE rlimit_limits; /* Qfalse or [[rtype, softlim, hardlim], ...] */
2052 mode_t umask_mask;
2053 rb_uid_t uid;
2054 rb_gid_t gid;
2055 int close_others_maxhint;
2056 VALUE fd_dup2;
2057 VALUE fd_close;
2058 VALUE fd_open;
2059 VALUE fd_dup2_child;
2060 VALUE env_modification; /* Qfalse or [[k1,v1], ...] */
2061 VALUE path_env;
2062 VALUE chdir_dir;
2063 };
2064
2065 /* argv_str contains extra two elements.
2066 * The beginning one is for /bin/sh used by exec_with_sh.
2067 * The last one for terminating NULL used by execve.
2068 * See rb_exec_fillarg() in process.c. */
2069 #define ARGVSTR2ARGV(argv_str) ((char **)RB_IMEMO_TMPBUF_PTR(argv_str) + 1)
2070
2071 static inline size_t
2072 ARGVSTR2ARGC(VALUE argv_str)
2073 {
2074 size_t i = 0;
2075 char *const *p = ARGVSTR2ARGV(argv_str);
2076 while (p[i++])
2077 ;
2078 return i - 1;
2079 }
2080
2081 rb_pid_t rb_fork_ruby(int *status);
2082 void rb_last_status_clear(void);
2083
2084 /* range.c */
2085 #define RANGE_BEG(r) (RSTRUCT(r)->as.ary[0])
2086 #define RANGE_END(r) (RSTRUCT(r)->as.ary[1])
2087 #define RANGE_EXCL(r) (RSTRUCT(r)->as.ary[2])
2088
2089 /* rational.c */
2090 VALUE rb_rational_canonicalize(VALUE x);
2091 VALUE rb_rational_uminus(VALUE self);
2092 VALUE rb_rational_plus(VALUE self, VALUE other);
2093 VALUE rb_rational_mul(VALUE self, VALUE other);
2094 VALUE rb_lcm(VALUE x, VALUE y);
2095 VALUE rb_rational_reciprocal(VALUE x);
2096 VALUE rb_cstr_to_rat(const char *, int);
2097 VALUE rb_rational_abs(VALUE self);
2098 VALUE rb_rational_cmp(VALUE self, VALUE other);
2099 VALUE rb_rational_pow(VALUE self, VALUE other);
2100 VALUE rb_numeric_quo(VALUE x, VALUE y);
2101 VALUE rb_float_numerator(VALUE x);
2102 VALUE rb_float_denominator(VALUE x);
2103
2104 /* re.c */
2105 VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
2106 VALUE rb_reg_check_preprocess(VALUE);
2107 long rb_reg_search0(VALUE, VALUE, long, int, int);
2108 VALUE rb_reg_match_p(VALUE re, VALUE str, long pos);
2109 bool rb_reg_start_with_p(VALUE re, VALUE str);
2110 void rb_backref_set_string(VALUE string, long pos, long len);
2111 void rb_match_unbusy(VALUE);
2112 int rb_match_count(VALUE match);
2113 int rb_match_nth_defined(int nth, VALUE match);
2114 VALUE rb_reg_new_ary(VALUE ary, int options);
2115
2116 /* signal.c */
2117 extern int ruby_enable_coredump;
2118 int rb_get_next_signal(void);
2119
2120 /* string.c */
2121 VALUE rb_fstring(VALUE);
2122 VALUE rb_fstring_new(const char *ptr, long len);
2123 #define rb_fstring_lit(str) rb_fstring_new((str), rb_strlen_lit(str))
2124 #define rb_fstring_literal(str) rb_fstring_lit(str)
2125 VALUE rb_fstring_cstr(const char *str);
2126 #ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
2127 # define rb_fstring_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
2128 (__builtin_constant_p(str)) ? \
2129 rb_fstring_new((str), (long)strlen(str)) : \
2130 rb_fstring_cstr(str) \
2131 )
2132 #endif
2133 #ifdef RUBY_ENCODING_H
2134 VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);
2135 #define rb_fstring_enc_lit(str, enc) rb_fstring_enc_new((str), rb_strlen_lit(str), (enc))
2136 #define rb_fstring_enc_literal(str, enc) rb_fstring_enc_lit(str, enc)
2137 #endif
2138 int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
2139 int rb_str_symname_p(VALUE);
2140 VALUE rb_str_quote_unprintable(VALUE);
2141 VALUE rb_id_quote_unprintable(ID);
2142 #define QUOTE(str) rb_str_quote_unprintable(str)
2143 #define QUOTE_ID(id) rb_id_quote_unprintable(id)
2144 char *rb_str_fill_terminator(VALUE str, const int termlen);
2145 void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen);
2146 VALUE rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg);
2147 VALUE rb_str_chomp_string(VALUE str, VALUE chomp);
2148 #ifdef RUBY_ENCODING_H
2149 VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc);
2150 VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
2151 rb_encoding *from, int ecflags, VALUE ecopts);
2152 VALUE rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl);
2153 VALUE rb_str_initialize(VALUE str, const char *ptr, long len, rb_encoding *enc);
2154 #endif
2155 #define STR_NOEMBED FL_USER1
2156 #define STR_SHARED FL_USER2 /* = ELTS_SHARED */
2157 #define STR_EMBED_P(str) (!FL_TEST_RAW((str), STR_NOEMBED))
2158 #define STR_SHARED_P(s) FL_ALL_RAW((s), STR_NOEMBED|ELTS_SHARED)
2159 #define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
2160 #define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
2161 size_t rb_str_memsize(VALUE);
2162 VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc);
2163 VALUE rb_sym_to_proc(VALUE sym);
2164 char *rb_str_to_cstr(VALUE str);
2165 VALUE rb_str_eql(VALUE str1, VALUE str2);
2166 VALUE rb_obj_as_string_result(VALUE str, VALUE obj);
2167 const char *ruby_escaped_char(int c);
2168 VALUE rb_str_opt_plus(VALUE, VALUE);
2169
2170 /* expect tail call optimization */
2171 static inline VALUE
2172 rb_str_eql_internal(const VALUE str1, const VALUE str2)
2173 {
2174 const long len = RSTRING_LEN(str1);
2175 const char *ptr1, *ptr2;
2176
2177 if (len != RSTRING_LEN(str2)) return Qfalse;
2178 if (!rb_str_comparable(str1, str2)) return Qfalse;
2179 if ((ptr1 = RSTRING_PTR(str1)) == (ptr2 = RSTRING_PTR(str2)))
2180 return Qtrue;
2181 if (memcmp(ptr1, ptr2, len) == 0)
2182 return Qtrue;
2183 return Qfalse;
2184 }
2185
2186 /* symbol.c */
2187 #ifdef RUBY_ENCODING_H
2188 VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc);
2189 #endif
2190 VALUE rb_sym_intern_ascii(const char *ptr, long len);
2191 VALUE rb_sym_intern_ascii_cstr(const char *ptr);
2192 #ifdef __GNUC__
2193 #define rb_sym_intern_ascii_cstr(ptr) __extension__ ( \
2194 { \
2195 (__builtin_constant_p(ptr)) ? \
2196 rb_sym_intern_ascii((ptr), (long)strlen(ptr)) : \
2197 rb_sym_intern_ascii_cstr(ptr); \
2198 })
2199 #endif
2200 VALUE rb_to_symbol_type(VALUE obj);
2201
2202 /* struct.c */
2203 VALUE rb_struct_init_copy(VALUE copy, VALUE s);
2204 VALUE rb_struct_lookup(VALUE s, VALUE idx);
2205 VALUE rb_struct_s_keyword_init(VALUE klass);
2206
2207 /* time.c */
2208 struct timeval rb_time_timeval(VALUE);
2209
2210 /* thread.c */
2211 #define COVERAGE_INDEX_LINES 0
2212 #define COVERAGE_INDEX_BRANCHES 1
2213 #define COVERAGE_TARGET_LINES 1
2214 #define COVERAGE_TARGET_BRANCHES 2
2215 #define COVERAGE_TARGET_METHODS 4
2216 #define COVERAGE_TARGET_ONESHOT_LINES 8
2217
2218 VALUE rb_obj_is_mutex(VALUE obj);
2219 VALUE rb_suppress_tracing(VALUE (*func)(VALUE), VALUE arg);
2220 void rb_thread_execute_interrupts(VALUE th);
2221 VALUE rb_get_coverages(void);
2222 int rb_get_coverage_mode(void);
2223 VALUE rb_default_coverage(int);
2224 VALUE rb_thread_shield_new(void);
2225 VALUE rb_thread_shield_wait(VALUE self);
2226 VALUE rb_thread_shield_release(VALUE self);
2227 VALUE rb_thread_shield_destroy(VALUE self);
2228 int rb_thread_to_be_killed(VALUE thread);
2229 void rb_mutex_allow_trap(VALUE self, int val);
2230 VALUE rb_uninterruptible(VALUE (*b_proc)(VALUE), VALUE data);
2231 VALUE rb_mutex_owned_p(VALUE self);
2232
2233 /* transcode.c */
2234 extern VALUE rb_cEncodingConverter;
2235 #ifdef RUBY_ENCODING_H
2236 size_t rb_econv_memsize(rb_econv_t *);
2237 #endif
2238
2239 /* us_ascii.c */
2240 #ifdef RUBY_ENCODING_H
2241 extern rb_encoding OnigEncodingUS_ASCII;
2242 #endif
2243
2244 /* util.c */
2245 char *ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve);
2246 char *ruby_hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rve);
2247
2248 /* utf_8.c */
2249 #ifdef RUBY_ENCODING_H
2250 extern rb_encoding OnigEncodingUTF_8;
2251 #endif
2252
2253 /* variable.c */
2254 #if USE_TRANSIENT_HEAP
2255 #define ROBJECT_TRANSIENT_FLAG FL_USER13
2256 #define ROBJ_TRANSIENT_P(obj) FL_TEST_RAW((obj), ROBJECT_TRANSIENT_FLAG)
2257 #define ROBJ_TRANSIENT_SET(obj) FL_SET_RAW((obj), ROBJECT_TRANSIENT_FLAG)
2258 #define ROBJ_TRANSIENT_UNSET(obj) FL_UNSET_RAW((obj), ROBJECT_TRANSIENT_FLAG)
2259 #else
2260 #define ROBJ_TRANSIENT_P(obj) 0
2261 #define ROBJ_TRANSIENT_SET(obj) ((void)0)
2262 #define ROBJ_TRANSIENT_UNSET(obj) ((void)0)
2263 #endif
2264 void rb_gc_mark_global_tbl(void);
2265 size_t rb_generic_ivar_memsize(VALUE);
2266 VALUE rb_search_class_path(VALUE);
2267 VALUE rb_attr_delete(VALUE, ID);
2268 VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef);
2269 void rb_autoload_str(VALUE mod, ID id, VALUE file);
2270 VALUE rb_autoload_at_p(VALUE, ID, int);
2271 void rb_deprecate_constant(VALUE mod, const char *name);
2272 NORETURN(VALUE rb_mod_const_missing(VALUE,VALUE));
2273 rb_gvar_getter_t *rb_gvar_getter_function_of(const struct rb_global_entry *);
2274 rb_gvar_setter_t *rb_gvar_setter_function_of(const struct rb_global_entry *);
2275 bool rb_gvar_is_traced(const struct rb_global_entry *);
2276 void rb_gvar_readonly_setter(VALUE v, ID id, VALUE *_);
2277
2278 /* vm_insnhelper.h */
2279 rb_serial_t rb_next_class_serial(void);
2280
2281 /* vm.c */
2282 VALUE rb_obj_is_thread(VALUE obj);
2283 void rb_vm_mark(void *ptr);
2284 void Init_BareVM(void);
2285 void Init_vm_objects(void);
2286 PUREFUNC(VALUE rb_vm_top_self(void));
2287 void rb_vm_inc_const_missing_count(void);
2288 const void **rb_vm_get_insns_address_table(void);
2289 VALUE rb_source_location(int *pline);
2290 const char *rb_source_location_cstr(int *pline);
2291 MJIT_STATIC void rb_vm_pop_cfunc_frame(void);
2292 int rb_vm_add_root_module(ID id, VALUE module);
2293 void rb_vm_check_redefinition_by_prepend(VALUE klass);
2294 int rb_vm_check_optimizable_mid(VALUE mid);
2295 VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements);
2296 MJIT_STATIC VALUE ruby_vm_special_exception_copy(VALUE);
2297 PUREFUNC(st_table *rb_vm_fstring_table(void));
2298
2299
2300 /* vm_dump.c */
2301 void rb_print_backtrace(void);
2302
2303 /* vm_eval.c */
2304 void Init_vm_eval(void);
2305 VALUE rb_adjust_argv_kw_splat(int *, const VALUE **, int *);
2306 VALUE rb_current_realfilepath(void);
2307 VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE);
2308 typedef void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE);
2309 VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv,
2310 rb_check_funcall_hook *hook, VALUE arg);
2311 VALUE rb_check_funcall_with_hook_kw(VALUE recv, ID mid, int argc, const VALUE *argv,
2312 rb_check_funcall_hook *hook, VALUE arg, int kw_splat);
2313 const char *rb_type_str(enum ruby_value_type type);
2314 VALUE rb_check_funcall_default(VALUE, ID, int, const VALUE *, VALUE);
2315 VALUE rb_yield_1(VALUE val);
2316 VALUE rb_yield_force_blockarg(VALUE values);
2317 VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv,
2318 rb_block_call_func_t bl_proc, int min_argc, int max_argc,
2319 VALUE data2);
2320
2321 /* vm_insnhelper.c */
2322 VALUE rb_equal_opt(VALUE obj1, VALUE obj2);
2323 VALUE rb_eql_opt(VALUE obj1, VALUE obj2);
2324 void Init_vm_stack_canary(void);
2325
2326 /* vm_method.c */
2327 void Init_eval_method(void);
2328
2329 enum method_missing_reason {
2330 MISSING_NOENTRY = 0x00,
2331 MISSING_PRIVATE = 0x01,
2332 MISSING_PROTECTED = 0x02,
2333 MISSING_FCALL = 0x04,
2334 MISSING_VCALL = 0x08,
2335 MISSING_SUPER = 0x10,
2336 MISSING_MISSING = 0x20,
2337 MISSING_NONE = 0x40
2338 };
2339 struct rb_callable_method_entry_struct;
2340 struct rb_method_definition_struct;
2341 struct rb_execution_context_struct;
2342 struct rb_control_frame_struct;
2343 struct rb_calling_info;
2344 struct rb_call_data;
2345 /* I have several reasons to chose 64 here:
2346 *
2347 * - A cache line must be a power-of-two size.
2348 * - Setting this to anything less than or equal to 32 boosts nothing.
2349 * - I have never seen an architecture that has 128 byte L1 cache line.
2350 * - I know Intel Core and Sparc T4 at least uses 64.
2351 * - I know jemalloc internally has this exact same `#define CACHE_LINE 64`.
2352 * https://github.com/jemalloc/jemalloc/blob/dev/include/jemalloc/internal/jemalloc_internal_types.h
2353 */
2354 #define CACHELINE 64
2355 struct rb_call_cache {
2356 /* inline cache: keys */
2357 rb_serial_t method_state;
2358 rb_serial_t class_serial[
2359 (CACHELINE
2360 - sizeof(rb_serial_t) /* method_state */
2361 - sizeof(struct rb_callable_method_entry_struct *) /* me */
2362 - sizeof(uintptr_t) /* method_serial */
2363 - sizeof(enum method_missing_reason) /* aux */
2364 - sizeof(VALUE (*)( /* call */
2365 struct rb_execution_context_struct *e,
2366 struct rb_control_frame_struct *,
2367 struct rb_calling_info *,
2368 const struct rb_call_data *)))
2369 / sizeof(rb_serial_t)
2370 ];
2371
2372 /* inline cache: values */
2373 const struct rb_callable_method_entry_struct *me;
2374 uintptr_t method_serial; /* me->def->method_serial */
2375
2376 VALUE (*call)(struct rb_execution_context_struct *ec,
2377 struct rb_control_frame_struct *cfp,
2378 struct rb_calling_info *calling,
2379 struct rb_call_data *cd);
2380
2381 union {
2382 unsigned int index; /* used by ivar */
2383 enum method_missing_reason method_missing_reason; /* used by method_missing */
2384 } aux;
2385 };
2386 STATIC_ASSERT(cachelined, sizeof(struct rb_call_cache) <= CACHELINE);
2387 struct rb_call_info {
2388 /* fixed at compile time */
2389 ID mid;
2390 unsigned int flag;
2391 int orig_argc;
2392 };
2393 struct rb_call_data {
2394 struct rb_call_cache cc;
2395 struct rb_call_info ci;
2396 };
2397 RUBY_FUNC_EXPORTED
2398 RUBY_FUNC_NONNULL(1, VALUE rb_funcallv_with_cc(struct rb_call_data*, VALUE, ID, int, const VALUE*));
2399 RUBY_FUNC_EXPORTED
2400 RUBY_FUNC_NONNULL(1, bool rb_method_basic_definition_p_with_cc(struct rb_call_data *, VALUE, ID));
2401
2402 #ifdef __GNUC__
2403 # define rb_funcallv(recv, mid, argc, argv) \
2404 __extension__({ \
2405 static struct rb_call_data rb_funcallv_data; \
2406 rb_funcallv_with_cc(&rb_funcallv_data, recv, mid, argc, argv); \
2407 })
2408 # define rb_method_basic_definition_p(klass, mid) \
2409 __extension__({ \
2410 static struct rb_call_data rb_mbdp; \
2411 (klass == Qfalse) ? /* hidden object cannot be overridden */ true : \
2412 rb_method_basic_definition_p_with_cc(&rb_mbdp, klass, mid); \
2413 })
2414 #endif
2415
2416 /* vm_backtrace.c */
2417 void Init_vm_backtrace(void);
2418 VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval);
2419 VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval);
2420
2421 VALUE rb_make_backtrace(void);
2422 void rb_backtrace_print_as_bugreport(void);
2423 int rb_backtrace_p(VALUE obj);
2424 VALUE rb_backtrace_to_str_ary(VALUE obj);
2425 VALUE rb_backtrace_to_location_ary(VALUE obj);
2426 void rb_backtrace_each(VALUE (*iter)(VALUE recv, VALUE str), VALUE output);
2427
2428 RUBY_SYMBOL_EXPORT_BEGIN
2429 const char *rb_objspace_data_type_name(VALUE obj);
2430
2431 /* Temporary. This API will be removed (renamed). */
2432 VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd);
2433
2434 /* array.c (export) */
2435 void rb_ary_detransient(VALUE a);
2436 VALUE *rb_ary_ptr_use_start(VALUE ary);
2437 void rb_ary_ptr_use_end(VALUE ary);
2438
2439 /* bignum.c (export) */
2440 VALUE rb_big_mul_normal(VALUE x, VALUE y);
2441 VALUE rb_big_mul_balance(VALUE x, VALUE y);
2442 VALUE rb_big_mul_karatsuba(VALUE x, VALUE y);
2443 VALUE rb_big_mul_toom3(VALUE x, VALUE y);
2444 VALUE rb_big_sq_fast(VALUE x);
2445 VALUE rb_big_divrem_normal(VALUE x, VALUE y);
2446 VALUE rb_big2str_poweroftwo(VALUE x, int base);
2447 VALUE rb_big2str_generic(VALUE x, int base);
2448 VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck);
2449 VALUE rb_str2big_normal(VALUE arg, int base, int badcheck);
2450 VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck);
2451 #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
2452 VALUE rb_big_mul_gmp(VALUE x, VALUE y);
2453 VALUE rb_big_divrem_gmp(VALUE x, VALUE y);
2454 VALUE rb_big2str_gmp(VALUE x, int base);
2455 VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
2456 #endif
2457 enum rb_int_parse_flags {
2458 RB_INT_PARSE_SIGN = 0x01,
2459 RB_INT_PARSE_UNDERSCORE = 0x02,
2460 RB_INT_PARSE_PREFIX = 0x04,
2461 RB_INT_PARSE_ALL = 0x07,
2462 RB_INT_PARSE_DEFAULT = 0x07
2463 };
2464 VALUE rb_int_parse_cstr(const char *str, ssize_t len, char **endp, size_t *ndigits, int base, int flags);
2465
2466 /* enumerator.c (export) */
2467 VALUE rb_arith_seq_new(VALUE obj, VALUE meth, int argc, VALUE const *argv,
2468 rb_enumerator_size_func *size_fn,
2469 VALUE beg, VALUE end, VALUE step, int excl);
2470
2471 /* error.c (export) */
2472 int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
2473 NORETURN(void rb_unexpected_type(VALUE,int));
2474 #undef Check_Type
2475 #define Check_Type(v, t) \
2476 (!RB_TYPE_P((VALUE)(v), (t)) || \
2477 ((t) == RUBY_T_DATA && RTYPEDDATA_P(v)) ? \
2478 rb_unexpected_type((VALUE)(v), (t)) : (void)0)
2479
2480 static inline int
2481 rb_typeddata_is_instance_of_inline(VALUE obj, const rb_data_type_t *data_type)
2482 {
2483 return RB_TYPE_P(obj, T_DATA) && RTYPEDDATA_P(obj) && (RTYPEDDATA_TYPE(obj) == data_type);
2484 }
2485 #define rb_typeddata_is_instance_of rb_typeddata_is_instance_of_inline
2486
2487 /* file.c (export) */
2488 #if defined HAVE_READLINK && defined RUBY_ENCODING_H
2489 VALUE rb_readlink(VALUE path, rb_encoding *enc);
2490 #endif
2491 #ifdef __APPLE__
2492 VALUE rb_str_normalize_ospath(const char *ptr, long len);
2493 #endif
2494
2495 /* hash.c (export) */
2496 VALUE rb_hash_delete_entry(VALUE hash, VALUE key);
2497 VALUE rb_ident_hash_new(void);
2498
2499 /* io.c (export) */
2500 void rb_maygvl_fd_fix_cloexec(int fd);
2501 int rb_gc_for_fd(int err);
2502 void rb_write_error_str(VALUE mesg);
2503
2504 /* numeric.c (export) */
2505 VALUE rb_int_positive_pow(long x, unsigned long y);
2506
2507 /* object.c (export) */
2508 int rb_opts_exception_p(VALUE opts, int default_value);
2509
2510 /* process.c (export) */
2511 int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen);
2512 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);
2513 VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell, int allow_exc_opt);
2514 struct rb_execarg *rb_execarg_get(VALUE execarg_obj); /* dangerous. needs GC guard. */
2515 int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val);
2516 void rb_execarg_parent_start(VALUE execarg_obj);
2517 void rb_execarg_parent_end(VALUE execarg_obj);
2518 int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char* errmsg, size_t errmsg_buflen);
2519 VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash);
2520 void rb_execarg_setenv(VALUE execarg_obj, VALUE env);
2521
2522 /* rational.c (export) */
2523 VALUE rb_gcd(VALUE x, VALUE y);
2524 VALUE rb_gcd_normal(VALUE self, VALUE other);
2525 #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
2526 VALUE rb_gcd_gmp(VALUE x, VALUE y);
2527 #endif
2528
2529 /* signal.c (export) */
2530 int rb_grantpt(int fd);
2531
2532 /* string.c (export) */
2533 VALUE rb_str_tmp_frozen_acquire(VALUE str);
2534 void rb_str_tmp_frozen_release(VALUE str, VALUE tmp);
2535 #ifdef RUBY_ENCODING_H
2536 /* internal use */
2537 VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
2538 #endif
2539 VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
2540 VALUE rb_str_upto_endless_each(VALUE, int (*each)(VALUE, VALUE), VALUE);
2541
2542 /* thread.c (export) */
2543 int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
2544
2545 /* time.c (export) */
2546 void ruby_reset_leap_second_info(void);
2547
2548 /* util.c (export) */
2549 extern const signed char ruby_digit36_to_number_table[];
2550 extern const char ruby_hexdigits[];
2551 extern unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow);
2552
2553 /* variable.c (export) */
2554 void rb_mark_generic_ivar(VALUE);
2555 void rb_mv_generic_ivar(VALUE src, VALUE dst);
2556 VALUE rb_const_missing(VALUE klass, VALUE name);
2557 int rb_class_ivar_set(VALUE klass, ID vid, VALUE value);
2558 void rb_iv_tbl_copy(VALUE dst, VALUE src);
2559
2560 /* gc.c (export) */
2561 VALUE rb_wb_protected_newobj_of(VALUE, VALUE);
2562 VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE);
2563
2564 size_t rb_obj_memsize_of(VALUE);
2565 void rb_gc_verify_internal_consistency(void);
2566
2567 #define RB_OBJ_GC_FLAGS_MAX 6
2568 size_t rb_obj_gc_flags(VALUE, ID[], size_t);
2569 void rb_gc_mark_values(long n, const VALUE *values);
2570 void rb_gc_mark_vm_stack_values(long n, const VALUE *values);
2571
2572 #if IMEMO_DEBUG
2573 VALUE rb_imemo_new_debug(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0, const char *file, int line);
2574 #define rb_imemo_new(type, v1, v2, v3, v0) rb_imemo_new_debug(type, v1, v2, v3, v0, __FILE__, __LINE__)
2575 #else
2576 VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
2577 #endif
2578
2579 /* random.c */
2580 int ruby_fill_random_bytes(void *, size_t, int);
2581
2582 RUBY_SYMBOL_EXPORT_END
2583
2584 #define RUBY_DTRACE_CREATE_HOOK(name, arg) \
2585 RUBY_DTRACE_HOOK(name##_CREATE, arg)
2586 #define RUBY_DTRACE_HOOK(name, arg) \
2587 do { \
2588 if (UNLIKELY(RUBY_DTRACE_##name##_ENABLED())) { \
2589 int dtrace_line; \
2590 const char *dtrace_file = rb_source_location_cstr(&dtrace_line); \
2591 if (!dtrace_file) dtrace_file = ""; \
2592 RUBY_DTRACE_##name(arg, dtrace_file, dtrace_line); \
2593 } \
2594 } while (0)
2595
2596 #define RB_OBJ_BUILTIN_TYPE(obj) rb_obj_builtin_type(obj)
2597 #define OBJ_BUILTIN_TYPE(obj) RB_OBJ_BUILTIN_TYPE(obj)
2598 #ifdef __GNUC__
2599 #define rb_obj_builtin_type(obj) \
2600 __extension__({ \
2601 VALUE arg_obj = (obj); \
2602 RB_SPECIAL_CONST_P(arg_obj) ? -1 : \
2603 RB_BUILTIN_TYPE(arg_obj); \
2604 })
2605 #else
2606 static inline int
2607 rb_obj_builtin_type(VALUE obj)
2608 {
2609 return RB_SPECIAL_CONST_P(obj) ? -1 :
2610 RB_BUILTIN_TYPE(obj);
2611 }
2612 #endif
2613
2614 /* A macro for defining a flexible array, like: VALUE ary[FLEX_ARY_LEN]; */
2615 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
2616 # define FLEX_ARY_LEN /* VALUE ary[]; */
2617 #elif defined(__GNUC__) && !defined(__STRICT_ANSI__)
2618 # define FLEX_ARY_LEN 0 /* VALUE ary[0]; */
2619 #else
2620 # define FLEX_ARY_LEN 1 /* VALUE ary[1]; */
2621 #endif
2622
2623 /*
2624 * For declaring bitfields out of non-unsigned int types:
2625 * struct date {
2626 * BITFIELD(enum months, month, 4);
2627 * ...
2628 * };
2629 */
2630 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)
2631 # define BITFIELD(type, name, size) type name : size
2632 #else
2633 # define BITFIELD(type, name, size) unsigned int name : size
2634 #endif
2635
2636 #if defined(_MSC_VER)
2637 # define COMPILER_WARNING_PUSH __pragma(warning(push))
2638 # define COMPILER_WARNING_POP __pragma(warning(pop))
2639 # define COMPILER_WARNING_ERROR(flag) __pragma(warning(error: flag)))
2640 # define COMPILER_WARNING_IGNORED(flag) __pragma(warning(suppress: flag)))
2641
2642 #elif defined(__clang__) /* clang 2.6 already had this feature */
2643 # define COMPILER_WARNING_PUSH _Pragma("clang diagnostic push")
2644 # define COMPILER_WARNING_POP _Pragma("clang diagnostic pop")
2645 # define COMPILER_WARNING_SPECIFIER(kind, msg) \
2646 clang diagnostic kind # msg
2647 # define COMPILER_WARNING_ERROR(flag) \
2648 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(error, flag))
2649 # define COMPILER_WARNING_IGNORED(flag) \
2650 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(ignored, flag))
2651
2652 #elif GCC_VERSION_SINCE(4, 6, 0)
2653 /* https://gcc.gnu.org/onlinedocs/gcc-4.6.4/gcc/Diagnostic-Pragmas.html */
2654 # define COMPILER_WARNING_PUSH _Pragma("GCC diagnostic push")
2655 # define COMPILER_WARNING_POP _Pragma("GCC diagnostic pop")
2656 # define COMPILER_WARNING_SPECIFIER(kind, msg) \
2657 GCC diagnostic kind # msg
2658 # define COMPILER_WARNING_ERROR(flag) \
2659 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(error, flag))
2660 # define COMPILER_WARNING_IGNORED(flag) \
2661 COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(ignored, flag))
2662
2663 #else /* other compilers to follow? */
2664 # define COMPILER_WARNING_PUSH /* nop */
2665 # define COMPILER_WARNING_POP /* nop */
2666 # define COMPILER_WARNING_ERROR(flag) /* nop */
2667 # define COMPILER_WARNING_IGNORED(flag) /* nop */
2668 #endif
2669
2670 #define COMPILER_WARNING_PRAGMA(str) COMPILER_WARNING_PRAGMA_(str)
2671 #define COMPILER_WARNING_PRAGMA_(str) _Pragma(#str)
2672
2673 #if defined(USE_UNALIGNED_MEMBER_ACCESS) && USE_UNALIGNED_MEMBER_ACCESS && \
2674 (defined(__clang__) || GCC_VERSION_SINCE(9, 0, 0))
2675 # define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ \
2676 COMPILER_WARNING_PUSH; \
2677 COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); \
2678 typeof(expr) unaligned_member_access_result = (expr); \
2679 COMPILER_WARNING_POP; \
2680 unaligned_member_access_result; \
2681 })
2682 #else
2683 # define UNALIGNED_MEMBER_ACCESS(expr) expr
2684 #endif
2685 #define UNALIGNED_MEMBER_PTR(ptr, mem) UNALIGNED_MEMBER_ACCESS(&(ptr)->mem)
2686
2687 #undef RB_OBJ_WRITE
2688 #define RB_OBJ_WRITE(a, slot, b) UNALIGNED_MEMBER_ACCESS(rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__))
2689
2690 #if defined(__cplusplus)
2691 #if 0
2692 { /* satisfy cc-mode */
2693 #endif
2694 } /* extern "C" { */
2695 #endif
2696
2697 #endif /* RUBY_INTERNAL_H */
rb_hash_stlike_lookup
int rb_hash_stlike_lookup(VALUE hash, st_data_t key, st_data_t *pval)
Definition: hash.c:1944
rb_eEAGAIN
VALUE rb_eEAGAIN
Definition: error.c:54
rb_readlink
VALUE rb_readlink(VALUE path, rb_encoding *resultenc)
Definition: file.c:618
rb_is_const_name
int rb_is_const_name(VALUE name)
Definition: symbol.c:1050
rb_rational_cmp
VALUE rb_rational_cmp(VALUE self, VALUE other)
Definition: rational.c:1097
rb_math_exp
VALUE rb_math_exp(VALUE)
rb_dir_getwd_ospath
VALUE rb_dir_getwd_ospath(void)
Definition: dir.c:1117
FLONUM_P
#define FLONUM_P(x)
Definition: ruby.h:430
rb_to_hash_type
VALUE rb_to_hash_type(VALUE obj)
Definition: hash.c:1818
Init_class_hierarchy
void Init_class_hierarchy(void)
Definition: class.c:549
RIMemo::v1
VALUE v1
Definition: internal.h:1127
rb_str_symname_p
int rb_str_symname_p(VALUE)
Definition: string.c:10695
__attribute__
unsigned int UINT8 __attribute__((__mode__(__QI__)))
Definition: ffi_common.h:110
rb_subclass_entry::next
rb_subclass_entry_t * next
Definition: internal.h:1000
rb_hash_stlike_foreach_with_replace
RUBY_SYMBOL_EXPORT_END int rb_hash_stlike_foreach_with_replace(VALUE hash, st_foreach_check_callback_func *func, st_update_callback_func *replace, st_data_t arg)
Definition: hash.c:1431
ID
unsigned long ID
Definition: ruby.h:103
rb_check_funcall
VALUE rb_check_funcall(VALUE, ID, int, const VALUE *)
Definition: vm_eval.c:505
RUBY_SYMBOL_EXPORT_END
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:49
rb_imemo_tmpbuf_parser_heap
rb_imemo_tmpbuf_t * rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt)
Definition: gc.c:2326
rb_execarg_parent_end
void rb_execarg_parent_end(VALUE execarg_obj)
Definition: process.c:2855
RHASH_PROC_DEFAULT
@ RHASH_PROC_DEFAULT
Definition: internal.h:819
rb_hash_set_pair
VALUE rb_hash_set_pair(VALUE hash, VALUE pair)
Definition: hash.c:3257
rb_deprecated_classext_struct::conflict
char conflict[sizeof(VALUE) *3]
Definition: internal.h:992
rb_fix_aref
VALUE rb_fix_aref(VALUE fix, VALUE idx)
Definition: numeric.c:4642
ruby_reset_leap_second_info
void ruby_reset_leap_second_info(void)
Definition: time.c:1193
rb_f_raise
VALUE rb_f_raise(int argc, VALUE *argv)
Definition: eval.c:726
void
void
Definition: rb_mjit_min_header-2.7.0.h:13273
ruby_dtoa
char * ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve)
rb_fstring
VALUE rb_fstring(VALUE)
Definition: string.c:312
rb_method_basic_definition_p
#define rb_method_basic_definition_p(klass, mid)
Definition: rb_mjit_min_header-2.7.0.h:7900
MISSING_SUPER
@ MISSING_SUPER
Definition: internal.h:2335
rb_check_convert_type_with_id
VALUE rb_check_convert_type_with_id(VALUE, int, const char *, ID)
Definition: object.c:2957
rb_dvar_defined
int rb_dvar_defined(ID, const struct rb_iseq_struct *)
rb_block_arity
int rb_block_arity(void)
Definition: proc.c:1144
rb_reg_start_with_p
bool rb_reg_start_with_p(VALUE re, VALUE str)
Definition: re.c:1618
abs
int abs(int)
rb_id_encoding
ID rb_id_encoding(void)
Definition: encoding.c:759
FIX_CONST_VALUE_PTR
#define FIX_CONST_VALUE_PTR(x)
Definition: ruby.h:2178
rb_execarg::fd_dup2_child
VALUE fd_dup2_child
Definition: internal.h:2059
RHASH_AR_TABLE_MAX_SIZE
#define RHASH_AR_TABLE_MAX_SIZE
Definition: internal.h:821
st_update_callback_func
int st_update_callback_func(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
Definition: st.h:131
rb_suppress_tracing
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:409
rb_gc_for_fd
int rb_gc_for_fd(int err)
Definition: io.c:953
rb_mark_generic_ivar
void rb_mark_generic_ivar(VALUE)
Definition: variable.c:973
rb_lambda_call
VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv, rb_block_call_func_t bl_proc, int min_argc, int max_argc, VALUE data2)
Definition: vm_eval.c:1501
rb_execarg::chdir_dir
VALUE chdir_dir
Definition: internal.h:2062
rb_class_inherited
VALUE rb_class_inherited(VALUE, VALUE)
Calls Class::inherited.
Definition: class.c:623
rb_obj_not_equal
VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2)
Definition: object.c:187
rb_big_ge
VALUE rb_big_ge(VALUE x, VALUE y)
Definition: bignum.c:5495
Init_enc_set_filesystem_encoding
int Init_enc_set_filesystem_encoding(void)
Definition: localeinit.c:119
rb_class_modify_check
void rb_class_modify_check(VALUE)
Asserts that klass is not a frozen class.
Definition: eval.c:437
rb_execarg::env_modification
VALUE env_modification
Definition: internal.h:2060
rb_big_lt
VALUE rb_big_lt(VALUE x, VALUE y)
Definition: bignum.c:5501
rb_hash_default_value
VALUE rb_hash_default_value(VALUE hash, VALUE key)
Definition: hash.c:1917
rb_hash_set_default_proc
VALUE rb_hash_set_default_proc(VALUE hash, VALUE proc)
Definition: hash.c:2169
env
#define env
rb_opts_exception_p
int rb_opts_exception_p(VALUE opts, int default_value)
Definition: object.c:3125
rb_struct_lookup
VALUE rb_struct_lookup(VALUE s, VALUE idx)
Definition: struct.c:1104
rb_mutex_owned_p
VALUE rb_mutex_owned_p(VALUE self)
Definition: thread_sync.c:345
rb_iseq_struct
Definition: vm_core.h:456
ruby_value_type
ruby_value_type
Definition: ruby.h:486
ruby_static_id_signo
ID ruby_static_id_signo
Definition: eval.c:36
rb_class_has_methods
int rb_class_has_methods(VALUE c)
Definition: class.c:2201
rb_gvar_defined
VALUE rb_gvar_defined(struct rb_global_entry *)
Definition: variable.c:695
MEMO::flags
VALUE flags
Definition: internal.h:1279
RFloat
Definition: internal.h:798
rb_hash_st_table
st_table * rb_hash_st_table(VALUE hash)
Definition: hash.c:551
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:3385
rb_reg_match_p
VALUE rb_reg_match_p(VALUE re, VALUE str, long pos)
Definition: re.c:3339
path
VALUE path
Definition: rb_mjit_min_header-2.7.0.h:7351
rb_execarg_parent_start
void rb_execarg_parent_start(VALUE execarg_obj)
Definition: process.c:2816
rb_big_hash
VALUE rb_big_hash(VALUE)
Definition: bignum.c:6726
RBignum::len
size_t len
Definition: internal.h:753
rb_sym_intern
VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc)
Definition: symbol.c:1024
RBignum::basic
struct RBasic basic
Definition: internal.h:750
rb_classext_struct::subclasses
rb_subclass_entry_t * subclasses
Definition: internal.h:1028
rb_dbl_complex_new_polar_pi
VALUE rb_dbl_complex_new_polar_pi(double abs, double ang)
Definition: complex.c:667
rb_vm_thread_backtrace_locations
VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:966
rb_match_count
int rb_match_count(VALUE match)
Definition: re.c:1299
CONSTFUNC
CONSTFUNC(VALUE rb_obj_equal(VALUE obj1, VALUE obj2))
rb_backtrace_each
void rb_backtrace_each(VALUE(*iter)(VALUE recv, VALUE str), VALUE output)
Definition: vm_backtrace.c:855
rb_vm_inc_const_missing_count
void rb_vm_inc_const_missing_count(void)
Definition: vm.c:386
obj2
VALUE obj2
Definition: rb_mjit_min_header-2.7.0.h:7583
FL_USER3
#define FL_USER3
Definition: ruby.h:1294
rb_gc_mark_values
void rb_gc_mark_values(long n, const VALUE *values)
Definition: gc.c:4715
RComplex::basic
struct RBasic basic
Definition: internal.h:806
rb_big_aref
VALUE rb_big_aref(VALUE x, VALUE y)
Definition: bignum.c:6681
rb_bug_reporter_add
int rb_bug_reporter_add(void(*func)(FILE *, void *), void *data)
Definition: error.c:455
rb_type_str
const char * rb_type_str(enum ruby_value_type type)
Definition: vm_eval.c:572
rb_global_entry::var
struct rb_global_variable * var
Definition: internal.h:1351
imemo_memo
@ imemo_memo
Definition: internal.h:1138
RUBY_FL_USHIFT
@ RUBY_FL_USHIFT
Definition: ruby.h:853
ar_hint_t
unsigned char ar_hint_t
Definition: rb_mjit_min_header-2.7.0.h:6887
IMEMO_MASK
#define IMEMO_MASK
Definition: internal.h:1145
rb_immutable_obj_clone
VALUE rb_immutable_obj_clone(int, VALUE *, VALUE)
Definition: object.c:346
rb_func_lambda_new
VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc)
Definition: proc.c:735
rb_equal_opt
VALUE rb_equal_opt(VALUE obj1, VALUE obj2)
Definition: rb_mjit_min_header-2.7.0.h:13438
RB_BUILTIN_TYPE
#define RB_BUILTIN_TYPE(x)
Definition: ruby.h:550
rb_int_abs
VALUE rb_int_abs(VALUE num)
Definition: numeric.c:4855
rb_singleton_class_internal_p
int rb_singleton_class_internal_p(VALUE sklass)
Definition: class.c:455
rb_file_expand_path_fast
VALUE rb_file_expand_path_fast(VALUE, VALUE)
Definition: file.c:4025
ruby_float_mod
double ruby_float_mod(double x, double y)
Definition: numeric.c:1207
rb_classext_struct::iv_tbl
struct st_table * iv_tbl
Definition: internal.h:1022
rb_num_get_rounding_option
enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts)
Definition: numeric.c:200
rb_ary_last
VALUE rb_ary_last(int, const VALUE *, VALUE)
Definition: array.c:1677
rb_int_positive_pow
VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:4033
vm_ifunc_argc::max
int max
Definition: internal.h:1210
vm_ifunc_argc::min
int min
Definition: internal.h:1210
rb_search_class_path
VALUE rb_search_class_path(VALUE)
Definition: variable.c:175
ruby_mimmalloc
void * ruby_mimmalloc(size_t size) RUBY_ATTR_MALLOC
Definition: gc.c:10187
__asan_unpoison_memory_region
#define __asan_unpoison_memory_region(x, y)
Definition: internal.h:109
rb_num_to_uint
int rb_num_to_uint(VALUE val, unsigned int *ret)
Definition: numeric.c:244
CACHELINE
#define CACHELINE
Definition: internal.h:2354
rb_vm_check_optimizable_mid
int rb_vm_check_optimizable_mid(VALUE mid)
Definition: vm.c:1581
RRational::num
VALUE num
Definition: internal.h:790
MEMO::v1
const VALUE v1
Definition: internal.h:1281
INT2FIX
#define INT2FIX(i)
Definition: ruby.h:263
rb_make_internal_id
ID rb_make_internal_id(void)
Definition: symbol.c:810
RB_INT_PARSE_ALL
@ RB_INT_PARSE_ALL
Definition: internal.h:2461
rb_ary_memsize
size_t rb_ary_memsize(VALUE)
Definition: array.c:816
rb_execarg::gid
rb_gid_t gid
Definition: internal.h:2054
rb_float_gt
VALUE rb_float_gt(VALUE x, VALUE y)
Definition: numeric.c:1503
rb_int128t2big
VALUE rb_int128t2big(__int128 n)
rb_call_cache::me
const struct rb_callable_method_entry_struct * me
Definition: internal.h:2373
rb_to_symbol_type
VALUE rb_to_symbol_type(VALUE obj)
Definition: symbol.c:1044
vm_ifunc::data
const void * data
Definition: internal.h:1219
ruby_xmalloc
void * ruby_xmalloc(size_t size)
Definition: gc.c:11950
rb_int2str
VALUE rb_int2str(VALUE num, int base)
Definition: numeric.c:3562
RHash::ifnone
const VALUE ifnone
Definition: internal.h:893
rb_struct_s_keyword_init
VALUE rb_struct_s_keyword_init(VALUE klass)
Definition: struct.c:52
rb_execarg::unsetenv_others_do
unsigned unsetenv_others_do
Definition: internal.h:2039
vm_ifunc::func
rb_block_call_func_t func
Definition: internal.h:1218
rb_class_remove_from_module_subclasses
void rb_class_remove_from_module_subclasses(VALUE)
Definition: class.c:94
rb_warning_category_enabled_p
bool rb_warning_category_enabled_p(rb_warning_category_t category)
Definition: error.c:164
RUBY_ATTR_ALLOC_SIZE
#define RUBY_ATTR_ALLOC_SIZE(params)
Definition: defines.h:226
RSTRING_PTR
#define RSTRING_PTR(str)
Definition: ruby.h:1009
rb_file_load_ok
int rb_file_load_ok(const char *)
Definition: file.c:6222
rb_class_ivar_set
int rb_class_ivar_set(VALUE klass, ID vid, VALUE value)
Definition: variable.c:3316
rb_file_expand_path_internal
VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE)
Definition: file.c:3646
__asan_poison_memory_region
#define __asan_poison_memory_region(x, y)
Definition: internal.h:108
cmp_opt_Float
@ cmp_opt_Float
Definition: internal.h:1318
div
void div_t div(int __numer, int __denom)
rb_call_cache::method_missing_reason
enum method_missing_reason method_missing_reason
Definition: internal.h:2383
RTYPEDDATA_TYPE
#define RTYPEDDATA_TYPE(v)
Definition: ruby.h:1178
rb_big_mul_karatsuba
VALUE rb_big_mul_karatsuba(VALUE x, VALUE y)
Definition: bignum.c:1870
LONG_LONG
#define LONG_LONG
Definition: rb_mjit_min_header-2.7.0.h:3939
rb_iv_tbl_copy
void rb_iv_tbl_copy(VALUE dst, VALUE src)
Definition: variable.c:3332
rb_int2big
VALUE rb_int2big(intptr_t n)
Definition: bignum.c:3180
rb_float_equal
VALUE rb_float_equal(VALUE x, VALUE y)
Definition: numeric.c:1383
vm_throw_data::catch_frame
const struct rb_control_frame_struct * catch_frame
Definition: internal.h:1197
RFloat::basic
struct RBasic basic
Definition: internal.h:799
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_block_to_s
VALUE rb_block_to_s(VALUE self, const struct rb_block *block, const char *additional_info)
Definition: proc.c:1360
RCLASS_INCLUDER
#define RCLASS_INCLUDER(c)
Definition: internal.h:1082
FL_USER10
#define FL_USER10
Definition: ruby.h:1301
rb_backref_set_string
void rb_backref_set_string(VALUE string, long pos, long len)
Definition: re.c:1340
rb_str2big_poweroftwo
VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck)
Definition: bignum.c:4274
rb_rational_uminus
VALUE rb_rational_uminus(VALUE self)
Definition: rational.c:624
rb_gvar_readonly_setter
void rb_gvar_readonly_setter(VALUE v, ID id, VALUE *_)
Definition: variable.c:412
VALUE
unsigned long VALUE
Definition: ruby.h:102
index
int index
Definition: rb_mjit_min_header-2.7.0.h:11246
rb_math_sin
VALUE rb_math_sin(VALUE)
rb_key_err_new
VALUE rb_key_err_new(VALUE mesg, VALUE recv, VALUE name)
Definition: error.c:1907
rb_to_array_type
VALUE rb_to_array_type(VALUE obj)
Definition: array.c:902
rb_hash_st_table_set
void rb_hash_st_table_set(VALUE hash, st_table *st)
Definition: hash.c:558
RB_TYPE_P
#define RB_TYPE_P(obj, type)
Definition: ruby.h:560
rb_fiber_reset_root_local_storage
void rb_fiber_reset_root_local_storage(struct rb_thread_struct *)
Definition: cont.c:2120
rb_rational_plus
VALUE rb_rational_plus(VALUE self, VALUE other)
Definition: rational.c:737
rb_big_fdiv_double
double rb_big_fdiv_double(VALUE x, VALUE y)
Definition: bignum.c:6209
rb_hash_add_new_element
int rb_hash_add_new_element(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:4472
Init_ext
void Init_ext(void)
Definition: dmyext.c:2
rb_callable_method_entry_struct
Definition: method.h:59
rb_str_memsize
size_t rb_str_memsize(VALUE)
Definition: string.c:1371
rb_str_to_cstr
char * rb_str_to_cstr(VALUE str)
Definition: string.c:2284
SIZEOF_INT
#define SIZEOF_INT
Definition: rb_mjit_min_header-2.7.0.h:83
rb_obj_info_dump_loc
void rb_obj_info_dump_loc(VALUE obj, const char *file, int line, const char *func)
Definition: gc.c:11668
RStruct::basic
struct RBasic basic
Definition: internal.h:943
rb_name_err_new
VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method)
Definition: error.c:1592
rb_execarg::pgroup_given
unsigned pgroup_given
Definition: internal.h:2036
imemo_iseq
@ imemo_iseq
Definition: internal.h:1140
rb_call_cache::call
VALUE(* call)(struct rb_execution_context_struct *ec, struct rb_control_frame_struct *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)
Definition: internal.h:2376
rb_math_log
VALUE rb_math_log(int argc, const VALUE *argv)
Definition: math.c:459
rb_obj_gc_flags
size_t rb_obj_gc_flags(VALUE, ID[], size_t)
RUBY_NUM_ROUND_HALF_EVEN
@ RUBY_NUM_ROUND_HALF_EVEN
Definition: internal.h:1784
imemo_env
@ imemo_env
Definition: internal.h:1133
rb_refinement_module_get_refined_class
VALUE rb_refinement_module_get_refined_class(VALUE module)
Definition: eval.c:1480
int
__inline__ int
Definition: rb_mjit_min_header-2.7.0.h:2839
RRational
Definition: internal.h:788
RUBY_NUM_ROUND_HALF_DOWN
@ RUBY_NUM_ROUND_HALF_DOWN
Definition: internal.h:1785
rb_bool_expected
int rb_bool_expected(VALUE, const char *)
Definition: object.c:3112
rb_execarg::waitpid_state
struct waitpid_state * waitpid_state
Definition: internal.h:2049
rb_execarg::new_pgroup_given
unsigned new_pgroup_given
Definition: internal.h:2043
rb_objspace_set_event_hook
void rb_objspace_set_event_hook(const rb_event_flag_t event)
Definition: gc.c:2080
rb_num_negative_p
int rb_num_negative_p(VALUE)
Definition: numeric.c:313
FL_USER11
#define FL_USER11
Definition: ruby.h:1302
rb_parser_set_yydebug
VALUE rb_parser_set_yydebug(VALUE, VALUE)
Definition: ripper.c:19329
alias
const char * alias
Definition: nkf.c:1159
rb_int_ge
VALUE rb_int_ge(VALUE x, VALUE y)
Definition: numeric.c:4292
rb_ary_delete_same
void rb_ary_delete_same(VALUE, VALUE)
Definition: array.c:3396
rb_execarg::gid_given
unsigned gid_given
Definition: internal.h:2046
rb_is_local_name
int rb_is_local_name(VALUE name)
Definition: symbol.c:1068
uint64_t
unsigned long long uint64_t
Definition: sha2.h:102
rb_proc_location
VALUE rb_proc_location(VALUE self)
Definition: proc.c:1256
RIMemo::v0
VALUE v0
Definition: internal.h:1126
rb_float_pow
VALUE rb_float_pow(VALUE x, VALUE y)
Definition: numeric.c:1298
MAYBE_UNUSED
#define MAYBE_UNUSED(x)
Definition: internal.h:40
rb_big_even_p
VALUE rb_big_even_p(VALUE)
Definition: bignum.c:6840
rb_id_table
Definition: id_table.c:40
RSTRUCT_EMBED_LEN
#define RSTRUCT_EMBED_LEN(st)
Definition: internal.h:957
rb_ary_ptr_use_start
VALUE * rb_ary_ptr_use_start(VALUE ary)
Definition: array.c:226
DL2NUM
#define DL2NUM(x)
Definition: rb_mjit_min_header-2.7.0.h:6720
ruby_thread_has_gvl_p
int ruby_thread_has_gvl_p(void)
Definition: thread.c:1705
rb_int_pow
VALUE rb_int_pow(VALUE x, VALUE y)
Definition: numeric.c:4106
RB_INT_PARSE_PREFIX
@ RB_INT_PARSE_PREFIX
Definition: internal.h:2460
RB_WARN_CATEGORY_NONE
@ RB_WARN_CATEGORY_NONE
Definition: internal.h:1559
rb_is_attrset_sym
int rb_is_attrset_sym(VALUE sym)
Definition: symbol.c:902
rb_class_detach_module_subclasses
void rb_class_detach_module_subclasses(VALUE)
Definition: class.c:145
rb_gvar_is_traced
bool rb_gvar_is_traced(const struct rb_global_entry *)
Definition: variable.c:714
vm_svar::backref
const VALUE backref
Definition: internal.h:1185
PUREFUNC
PUREFUNC(int rb_data_is_encoding(VALUE obj))
rb_gvar_getter_t
VALUE rb_gvar_getter_t(ID id, VALUE *data)
Definition: ruby.h:1782
Qundef
#define Qundef
Definition: ruby.h:470
imemo
union @11::@13 imemo
rb_econv_t
Definition: transcode.c:110
CHAR_BIT
#define CHAR_BIT
Definition: ruby.h:227
MEMO::reserved
VALUE reserved
Definition: internal.h:1280
RHASH_ST_TABLE_FLAG
@ RHASH_ST_TABLE_FLAG
Definition: internal.h:820
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:1694
rb_obj_copy_ivar
void rb_obj_copy_ivar(VALUE dest, VALUE obj)
Definition: object.c:247
rb_get_path_check_to_string
VALUE rb_get_path_check_to_string(VALUE)
Definition: file.c:196
rb_hash_stlike_update
int rb_hash_stlike_update(VALUE hash, st_data_t key, st_update_callback_func func, st_data_t arg)
Definition: hash.c:1624
rb_call_cache::method_serial
uintptr_t method_serial
Definition: internal.h:2374
rb_calling_info
Definition: vm_core.h:250
ptr
struct RIMemo * ptr
Definition: debug.c:74
rb_int_and
VALUE rb_int_and(VALUE x, VALUE y)
Definition: numeric.c:4467
rb_call_cache::method_state
rb_serial_t method_state
Definition: internal.h:2357
vm_ifunc
IFUNC (Internal FUNCtion)
Definition: internal.h:1215
rb_enc_set_base
void rb_enc_set_base(const char *name, const char *orig)
Definition: encoding.c:382
SIZEOF_LONG_LONG
#define SIZEOF_LONG_LONG
Definition: rb_mjit_min_header-2.7.0.h:86
rb_class_subclass_add
void rb_class_subclass_add(VALUE super, VALUE klass)
Definition: class.c:36
T_DATA
#define T_DATA
Definition: ruby.h:538
cmp_opt_data::opt_inited
unsigned int opt_inited
Definition: internal.h:1324
stdbool.h
Qfalse
#define Qfalse
Definition: ruby.h:467
rb_encdb_alias
int rb_encdb_alias(const char *alias, const char *orig)
Definition: encoding.c:565
rb_float_abs
VALUE rb_float_abs(VALUE flt)
Definition: numeric.c:1698
rb_hash_stlike_delete
int rb_hash_stlike_delete(VALUE hash, st_data_t *pkey, st_data_t *pval)
Definition: hash.c:2237
rb_eql_opt
VALUE rb_eql_opt(VALUE obj1, VALUE obj2)
Definition: rb_mjit_min_header-2.7.0.h:13444
rb_execarg::unsetenv_others_given
unsigned unsetenv_others_given
Definition: internal.h:2038
uintptr_t
unsigned int uintptr_t
Definition: win32.h:106
mjit_finish
void mjit_finish(_Bool close_handle_p)
rb_int_lshift
VALUE rb_int_lshift(VALUE x, VALUE y)
Definition: numeric.c:4583
RHash::st
st_table * st
Definition: internal.h:890
__asan_region_is_poisoned
#define __asan_region_is_poisoned(x, y)
Definition: internal.h:110
rb_execarg::argv_buf
VALUE argv_buf
Definition: internal.h:2028
ssize_t
_ssize_t ssize_t
Definition: rb_mjit_min_header-2.7.0.h:1329
rb_gvar_setter_t
void rb_gvar_setter_t(VALUE val, ID id, VALUE *data)
Definition: ruby.h:1783
rb_external_str_with_enc
VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc)
Definition: string.c:1074
rb_str_eql
VALUE rb_str_eql(VALUE str1, VALUE str2)
Definition: string.c:3287
RFloat::float_value
double float_value
Definition: internal.h:800
ruby_digit36_to_number_table
const signed char ruby_digit36_to_number_table[]
Definition: escape.c:6
rb_numeric_quo
VALUE rb_numeric_quo(VALUE x, VALUE y)
Definition: rational.c:2014
rb_ivar_lookup
VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
Definition: variable.c:1035
rb_rational_reciprocal
VALUE rb_rational_reciprocal(VALUE x)
Definition: rational.c:1875
rb_enumerator_size_func
VALUE rb_enumerator_size_func(VALUE, VALUE, VALUE)
Definition: intern.h:256
rb_cInteger
RUBY_EXTERN VALUE rb_cInteger
Definition: ruby.h:2031
rb_stderr_tty_p
int rb_stderr_tty_p(void)
Definition: io.c:7958
rb_match_nth_defined
int rb_match_nth_defined(int nth, VALUE match)
Definition: re.c:1309
rb_enc_set_dummy
int rb_enc_set_dummy(int index)
Definition: encoding.c:393
RSTRUCT_ENUM_END
@ RSTRUCT_ENUM_END
Definition: internal.h:929
rb_parser_load_file
RUBY_SYMBOL_EXPORT_END void * rb_parser_load_file(VALUE parser, VALUE name)
Definition: ruby.c:2193
rb_vm_insn_addr2insn
int rb_vm_insn_addr2insn(const void *)
Definition: iseq.c:3111
RIMemo::flags
VALUE flags
Definition: internal.h:1125
NULL
#define NULL
Definition: _sdbm.c:101
RIMemo
Definition: internal.h:1124
MUL_OVERFLOW_FIXNUM_P
#define MUL_OVERFLOW_FIXNUM_P(a, b)
Definition: internal.h:273
rb_print_backtrace
void rb_print_backtrace(void)
Definition: vm_dump.c:750
rb_check_realpath
VALUE rb_check_realpath(VALUE basedir, VALUE path, rb_encoding *enc)
Definition: file.c:4417
rb_execarg::pgroup_pgid
rb_pid_t pgroup_pgid
Definition: internal.h:2050
vm_ifunc::argc
struct vm_ifunc_argc argc
Definition: internal.h:1220
uint32_t
unsigned int uint32_t
Definition: sha2.h:101
SafeStringValue
#define SafeStringValue(v)
Definition: ruby.h:607
imemo_svar
@ imemo_svar
special variable
Definition: internal.h:1135
rb_require_internal
int rb_require_internal(VALUE fname)
Definition: load.c:1067
rb_ary_aref1
VALUE rb_ary_aref1(VALUE ary, VALUE i)
Definition: array.c:1595
vm_svar::others
const VALUE others
Definition: internal.h:1186
rb_float_new_in_heap
VALUE rb_float_new_in_heap(double)
Definition: numeric.c:895
rb_class_remove_from_super_subclasses
void rb_class_remove_from_super_subclasses(VALUE)
Definition: class.c:76
RVALUE
Definition: gc.c:566
rb_execarg::cmd
struct rb_execarg::@110::@112 cmd
rb_obj_info_dump
void rb_obj_info_dump(VALUE obj)
Definition: gc.c:11661
RUBY_BIT_ROTR
#define RUBY_BIT_ROTR(v, n)
Definition: internal.h:1890
ruby_static_id_status
ID ruby_static_id_status
Definition: internal.h:1585
rb_classext_struct::const_tbl
struct rb_id_table * const_tbl
Definition: internal.h:1026
MISSING_NONE
@ MISSING_NONE
Definition: internal.h:2337
Init_heap
void Init_heap(void)
Definition: gc.c:2909
rb_local_defined
int rb_local_defined(ID, const struct rb_iseq_struct *)
rb_hash_ar_table_p
int rb_hash_ar_table_p(VALUE hash)
Definition: hash.c:532
RUBY_T_MASK
@ RUBY_T_MASK
Definition: ruby.h:518
rb_int_powm
VALUE rb_int_powm(int const argc, VALUE *const argv, VALUE const num)
Definition: bignum.c:7112
rb_str_cat_conv_enc_opts
VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len, rb_encoding *from, int ecflags, VALUE ecopts)
Definition: string.c:943
FL_SET
#define FL_SET(x, f)
Definition: ruby.h:1359
ruby_is_fd_loadable
int ruby_is_fd_loadable(int fd)
Definition: file.c:6195
RSTRUCT_EMBED_LEN_MAX
#define RSTRUCT_EMBED_LEN_MAX
Definition: internal.h:919
FIX2LONG
#define FIX2LONG(x)
Definition: ruby.h:394
rb_execarg::close_others_maxhint
int close_others_maxhint
Definition: internal.h:2055
rb_int_idiv
VALUE rb_int_idiv(VALUE x, VALUE y)
Definition: numeric.c:3843
Init_vm_eval
void Init_vm_eval(void)
Definition: vm_eval.c:2470
rb_blocking_function_t
VALUE rb_blocking_function_t(void *)
Definition: intern.h:941
ruby_initial_load_paths
const char ruby_initial_load_paths[]
Definition: loadpath.c:62
rb_copy_wb_protected_attribute
void rb_copy_wb_protected_attribute(VALUE dest, VALUE obj)
Definition: gc.c:6938
RB_WARN_CATEGORY_EXPERIMENTAL
@ RB_WARN_CATEGORY_EXPERIMENTAL
Definition: internal.h:1561
rb_call_info::orig_argc
int orig_argc
Definition: internal.h:2391
RB_INT_PARSE_DEFAULT
@ RB_INT_PARSE_DEFAULT
Definition: internal.h:2462
rb_math_hypot
VALUE rb_math_hypot(VALUE, VALUE)
rb_autoload_at_p
VALUE rb_autoload_at_p(VALUE, ID, int)
Definition: variable.c:2287
imemo_throw_data
@ imemo_throw_data
Definition: internal.h:1136
rb_big_sq_fast
VALUE rb_big_sq_fast(VALUE x)
Definition: bignum.c:1630
MEMO
MEMO.
Definition: internal.h:1278
rb_int_uminus
VALUE rb_int_uminus(VALUE num)
Definition: numeric.c:3479
rb_gcd_normal
VALUE rb_gcd_normal(VALUE self, VALUE other)
Definition: rational.c:344
rb_write_error_str
void rb_write_error_str(VALUE mesg)
Definition: io.c:7936
rb_backtrace_to_location_ary
VALUE rb_backtrace_to_location_ary(VALUE obj)
Definition: vm_backtrace.c:686
RUBY_FUNC_EXPORTED
#define RUBY_FUNC_EXPORTED
Definition: defines.h:391
rb_reg_search0
long rb_reg_search0(VALUE, VALUE, long, int, int)
Definition: re.c:1530
MISSING_MISSING
@ MISSING_MISSING
Definition: internal.h:2336
waitpid_state
Definition: process.c:943
v
int VALUE v
Definition: rb_mjit_min_header-2.7.0.h:12332
rb_strterm_mark
void rb_strterm_mark(VALUE obj)
Definition: ripper.c:765
rb_str_locktmp_ensure
VALUE rb_str_locktmp_ensure(VALUE str, VALUE(*func)(VALUE), VALUE arg)
Definition: string.c:2685
rb_get_expanded_load_path
VALUE rb_get_expanded_load_path(void)
Definition: load.c:92
imemo_ast
@ imemo_ast
Definition: internal.h:1142
rb_float_denominator
VALUE rb_float_denominator(VALUE x)
Definition: rational.c:2104
rb_big2str_generic
VALUE rb_big2str_generic(VALUE x, int base)
Definition: bignum.c:5004
UNLIMITED_ARGUMENTS
#define UNLIMITED_ARGUMENTS
Definition: intern.h:57
rb_call_cache::index
unsigned int index
Definition: internal.h:2382
rb_str_fill_terminator
char * rb_str_fill_terminator(VALUE str, const int termlen)
Definition: string.c:2306
RBignum::as
union RBignum::@103 as
rb_file_const
void rb_file_const(const char *, VALUE)
Definition: file.c:6083
rb_reg_compile
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2952
rb_str_opt_plus
VALUE rb_str_opt_plus(VALUE, VALUE)
Definition: string.c:1925
RCLASS_ORIGIN
#define RCLASS_ORIGIN(c)
Definition: internal.h:1075
rb_imemo_tmpbuf_struct::cnt
size_t cnt
Definition: internal.h:1236
RRational::basic
struct RBasic basic
Definition: internal.h:789
MEMO::u3
union MEMO::@109 u3
rb_str_tmp_frozen_acquire
VALUE rb_str_tmp_frozen_acquire(VALUE str)
Definition: string.c:1210
RClass::super
VALUE super
Definition: internal.h:1050
rb_call_cache
Definition: internal.h:2355
BDIGIT
#define BDIGIT
Definition: internal.h:688
FL_USER5
#define FL_USER5
Definition: ruby.h:1296
rb_execarg::fd_open
VALUE fd_open
Definition: internal.h:2058
Init_BareVM
void Init_BareVM(void)
Definition: vm.c:3301
rb_time_timeval
struct timeval rb_time_timeval(VALUE)
Definition: time.c:2675
RUBY_NUM_ROUND_HALF_UP
@ RUBY_NUM_ROUND_HALF_UP
Definition: internal.h:1783
rb_mark_end_proc
void rb_mark_end_proc(void)
Definition: eval_jump.c:78
rb_home_dir_of
VALUE rb_home_dir_of(VALUE user, VALUE result)
Definition: file.c:3536
rb_int_odd_p
VALUE rb_int_odd_p(VALUE num)
Definition: numeric.c:3222
imemo_parser_strterm
@ imemo_parser_strterm
Definition: internal.h:1143
rb_int_succ
VALUE rb_int_succ(VALUE num)
Definition: numeric.c:3321
LONG2NUM
#define LONG2NUM(x)
Definition: ruby.h:1644
SIZEOF_LONG
#define SIZEOF_LONG
Definition: rb_mjit_min_header-2.7.0.h:85
obj
const VALUE VALUE obj
Definition: rb_mjit_min_header-2.7.0.h:5742
rb_int_fdiv_double
double rb_int_fdiv_double(VALUE x, VALUE y)
Definition: numeric.c:3728
RStruct::ptr
const VALUE * ptr
Definition: internal.h:947
BIGNUM_POSITIVE_P
#define BIGNUM_POSITIVE_P(b)
Definition: internal.h:765
MISSING_PROTECTED
@ MISSING_PROTECTED
Definition: internal.h:2332
rb_ary_detransient
void rb_ary_detransient(VALUE a)
Definition: array.c:408
rb_special_singleton_class
VALUE rb_special_singleton_class(VALUE)
Definition: class.c:1621
rb_big_divrem_normal
VALUE rb_big_divrem_normal(VALUE x, VALUE y)
Definition: bignum.c:2714
rb_fstring_enc_new
VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc)
Definition: string.c:403
SIZEOF_VALUE
#define SIZEOF_VALUE
Definition: ruby.h:105
rb_fix_plus
VALUE rb_fix_plus(VALUE x, VALUE y)
Definition: numeric.c:3604
rb_big_size
size_t rb_big_size(VALUE)
Definition: bignum.c:6778
rb_sym_intern_ascii
VALUE rb_sym_intern_ascii(const char *ptr, long len)
Definition: symbol.c:1032
RUBY_FUNC_NONNULL
RUBY_FUNC_EXPORTED RUBY_FUNC_NONNULL(1, VALUE rb_funcallv_with_cc(struct rb_call_data *, VALUE, ID, int, const VALUE *))
RICLASS_IS_ORIGIN
#define RICLASS_IS_ORIGIN
Definition: internal.h:1085
rb_classext_struct::includer
const VALUE includer
Definition: internal.h:1042
rb_int_negative_p
int rb_int_negative_p(VALUE num)
Definition: numeric.c:307
rb_global_entry::id
ID id
Definition: internal.h:1352
rb_vraise
void rb_vraise(VALUE exc, const char *fmt, va_list ap)
Definition: error.c:2663
rb_load_fail
void rb_load_fail(VALUE path, const char *err)
Definition: error.c:2965
memcpy
void * memcpy(void *__restrict, const void *__restrict, size_t)
rb_const_missing
VALUE rb_const_missing(VALUE klass, VALUE name)
Definition: variable.c:1694
rb_yield_refine_block
VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements)
Definition: vm_eval.c:1883
st_foreach_check_callback_func
int st_foreach_check_callback_func(st_data_t, st_data_t, st_data_t, int)
Definition: st.h:138
imemo_type
imemo_type
Definition: internal.h:1132
vm_throw_data::throw_obj
const VALUE throw_obj
Definition: internal.h:1196
vm_svar
SVAR (Special VARiable)
Definition: internal.h:1181
uint16_t
__uint16_t uint16_t
Definition: rb_mjit_min_header-2.7.0.h:1172
rb_execarg::command_abspath
VALUE command_abspath
Definition: internal.h:2026
rb_thread_shield_new
VALUE rb_thread_shield_new(void)
Definition: thread.c:4790
rb_thread_shield_wait
VALUE rb_thread_shield_wait(VALUE self)
Definition: thread.c:4806
rb_float_numerator
VALUE rb_float_numerator(VALUE x)
Definition: rational.c:2081
rb_hash_tbl_raw
struct st_table * rb_hash_tbl_raw(VALUE hash)
Definition: hash.c:1567
rb_str_upto_endless_each
VALUE rb_str_upto_endless_each(VALUE, int(*each)(VALUE, VALUE), VALUE)
Definition: string.c:4345
rb_str_buf_cat_escaped_char
int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p)
Definition: string.c:5815
rb_execarg::fd_dup2
VALUE fd_dup2
Definition: internal.h:2056
DLONG
#define DLONG
Definition: rb_mjit_min_header-2.7.0.h:6719
rb_deprecated_classext_struct
Definition: classext.h:10
rb_backtrace_to_str_ary
VALUE rb_backtrace_to_str_ary(VALUE obj)
Definition: vm_backtrace.c:620
rb_vm_pop_cfunc_frame
MJIT_STATIC void rb_vm_pop_cfunc_frame(void)
Definition: rb_mjit_min_header-2.7.0.h:17268
rb_int_mul
VALUE rb_int_mul(VALUE x, VALUE y)
Definition: numeric.c:3699
rb_sys_enc_warning
void rb_sys_enc_warning(rb_encoding *enc, const char *fmt,...)
Definition: error.c:2943
rb_cEncodingConverter
VALUE rb_cEncodingConverter
Definition: transcode.c:24
rb_gvar_setter_function_of
rb_gvar_setter_t * rb_gvar_setter_function_of(const struct rb_global_entry *)
Definition: variable.c:708
rb_undef_methods_from
void rb_undef_methods_from(VALUE klass, VALUE super)
Definition: class.c:1589
rb_imemo_tmpbuf_struct::ptr
VALUE * ptr
Definition: internal.h:1234
rb_thread_execute_interrupts
void rb_thread_execute_interrupts(VALUE th)
Definition: thread.c:2284
rb_float_plus
VALUE rb_float_plus(VALUE x, VALUE y)
Definition: numeric.c:1024
rb_execarg::umask_mask
mode_t umask_mask
Definition: internal.h:2052
rb_encoding
const typedef OnigEncodingType rb_encoding
Definition: encoding.h:115
rb_parser_set_context
RUBY_SYMBOL_EXPORT_BEGIN VALUE rb_parser_set_context(VALUE, const struct rb_iseq_struct *, int)
Definition: ripper.c:19234
rb_ident_hash_new
VALUE rb_ident_hash_new(void)
Definition: hash.c:4203
rb_is_class_name
int rb_is_class_name(VALUE name)
Definition: symbol.c:1056
RHASH_ENUM_END
@ RHASH_ENUM_END
Definition: internal.h:838
vm_svar::lastline
const VALUE lastline
Definition: internal.h:1184
rb_execarg::new_pgroup_flag
unsigned new_pgroup_flag
Definition: internal.h:2044
rb_int_div
VALUE rb_int_div(VALUE x, VALUE y)
Definition: numeric.c:3816
rb_fstring_cstr
VALUE rb_fstring_cstr(const char *str)
Definition: string.c:410
rb_obj_is_fiber
VALUE rb_obj_is_fiber(VALUE)
Definition: cont.c:1041
rb_sym_to_proc
VALUE rb_sym_to_proc(VALUE sym)
Definition: proc.c:1312
MISSING_VCALL
@ MISSING_VCALL
Definition: internal.h:2334
rb_nomethod_err_new
VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv)
Definition: error.c:1673
rb_obj_protected_methods
VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1380
cmp_optimizable_count
@ cmp_optimizable_count
Definition: internal.h:1319
rb_obj_is_thread
VALUE rb_obj_is_thread(VALUE obj)
Definition: vm.c:2655
ruby_scan_digits
unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow)
Definition: util.c:97
rb_thread_io_blocking_region
VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd)
Definition: thread.c:1595
rb_math_sinh
VALUE rb_math_sinh(VALUE)
rb_setup_fake_str
VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc)
Definition: string.c:385
rb_obj_dig
VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound)
Definition: object.c:3791
rb_vm_get_insns_address_table
const void ** rb_vm_get_insns_address_table(void)
Definition: vm_exec.c:126
rb_convert_type_with_id
VALUE rb_convert_type_with_id(VALUE, int, const char *, ID)
Definition: object.c:2914
__msan_allocated_memory
#define __msan_allocated_memory(x, y)
Definition: internal.h:120
rb_execarg::dup2_tmpbuf
VALUE dup2_tmpbuf
Definition: internal.h:2034
st_foreach_callback_func
int st_foreach_callback_func(st_data_t, st_data_t, st_data_t)
Definition: st.h:137
rb_global_entry
struct rb_global_entry * rb_global_entry(ID)
Definition: variable.c:326
FL_USER2
#define FL_USER2
Definition: ruby.h:1293
rb_int_parse_cstr
VALUE rb_int_parse_cstr(const char *str, ssize_t len, char **endp, size_t *ndigits, int base, int flags)
Definition: bignum.c:4041
RSTRUCT_EMBED_LEN_MASK
#define RSTRUCT_EMBED_LEN_MASK
Definition: internal.h:920
rb_io_memsize
RUBY_FUNC_EXPORTED size_t rb_io_memsize(const rb_io_t *fptr)
Definition: io.c:4760
rb_serial_t
unsigned long rb_serial_t
Definition: internal.h:1014
i
uint32_t i
Definition: rb_mjit_min_header-2.7.0.h:5464
rb_yield_1
VALUE rb_yield_1(VALUE val)
Definition: vm_eval.c:1231
rb_gvar_set
VALUE rb_gvar_set(struct rb_global_entry *, VALUE)
Definition: variable.c:654
rb_execarg_new
VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell, int allow_exc_opt)
Definition: process.c:2633
rb_vm_top_self
VALUE rb_vm_top_self(void)
Definition: vm.c:3345
NORETURN
NORETURN(void rb_async_bug_errno(const char *, int))
ROUND_DEFAULT
#define ROUND_DEFAULT
Definition: internal.h:1780
rb_lcm
VALUE rb_lcm(VALUE x, VALUE y)
Definition: rational.c:1913
ruby_sized_xrealloc
RUBY_SYMBOL_EXPORT_BEGIN void * ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2))
Definition: gc.c:10107
rb_insns_name
const char * rb_insns_name(int i)
Definition: compile.c:8761
rb_sym_proc_call
VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc)
Definition: string.c:10816
FL_USER1
#define FL_USER1
Definition: ruby.h:1292
rb_str2big_gmp
VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck)
rb_vm_ifunc_new
struct vm_ifunc * rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc)
Definition: proc.c:699
rb_match_unbusy
void rb_match_unbusy(VALUE)
Definition: re.c:1293
sym
#define sym(x)
Definition: date_core.c:3716
rb_builtin_type_name
const char * rb_builtin_type_name(int t)
Definition: error.c:761
mask
enum @11::@13::@14 mask
cmp_opt_String
@ cmp_opt_String
Definition: internal.h:1317
RMoved::flags
VALUE flags
Definition: internal.h:909
RCLASS
#define RCLASS(obj)
Definition: ruby.h:1269
rb_f_send
VALUE rb_f_send(int argc, VALUE *argv, VALUE recv)
Definition: vm_eval.c:1188
rb_imemo_tmpbuf_struct::next
struct rb_imemo_tmpbuf_struct * next
Definition: internal.h:1235
rb_check_funcall_hook
void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE)
Definition: internal.h:2308
rb_big_comp
VALUE rb_big_comp(VALUE x)
Definition: bignum.c:5564
long
#define long
Definition: rb_mjit_min_header-2.7.0.h:2880
vm_svar::cref_or_me
const VALUE cref_or_me
class reference or rb_method_entry_t
Definition: internal.h:1183
rb_execarg::shell_script
VALUE shell_script
Definition: internal.h:2022
rb_hash_rehash
VALUE rb_hash_rehash(VALUE hash)
Definition: hash.c:1885
RBasicRaw::klass
VALUE klass
Definition: internal.h:1978
rb_enc_check_str
rb_encoding * rb_enc_check_str(VALUE str1, VALUE str2)
Definition: encoding.c:880
rb_hash_keys
VALUE rb_hash_keys(VALUE hash)
Definition: hash.c:3334
rb_big_uminus
VALUE rb_big_uminus(VALUE x)
Definition: bignum.c:5554
rb_execarg::uid_given
unsigned uid_given
Definition: internal.h:2045
rb_execarg_get
struct rb_execarg * rb_execarg_get(VALUE execarg_obj)
Definition: process.c:2608
RUBY_BIT_ROTL
#define RUBY_BIT_ROTL(v, n)
Definition: internal.h:1889
st_index_t
st_data_t st_index_t
Definition: st.h:50
MISSING_FCALL
@ MISSING_FCALL
Definition: internal.h:2333
rb_encdb_declare
void rb_encdb_declare(const char *name)
Definition: encoding.c:350
RComplex::real
VALUE real
Definition: internal.h:807
Init_vm_backtrace
void Init_vm_backtrace(void)
Definition: vm_backtrace.c:1045
rb_include_class_new
VALUE rb_include_class_new(VALUE, VALUE)
Definition: class.c:825
rb_obj_public_methods
VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1410
rb_vm_add_root_module
int rb_vm_add_root_module(ID id, VALUE module)
Definition: vm.c:2312
ruby.h
vm_throw_data
THROW_DATA.
Definition: internal.h:1193
vm_throw_data::flags
VALUE flags
Definition: internal.h:1194
rb_integer_float_cmp
VALUE rb_integer_float_cmp(VALUE x, VALUE y)
Definition: bignum.c:5325
rb_make_backtrace
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:872
RMoved::next
VALUE next
Definition: internal.h:911
cnt
rb_atomic_t cnt[RUBY_NSIG]
Definition: signal.c:503
rb_enc_str_scrub
VALUE rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl)
Definition: string.c:10255
RIMemo::v2
VALUE v2
Definition: internal.h:1128
rb_classext_struct::refined_class
const VALUE refined_class
Definition: internal.h:1040
RUBY_ATTR_RETURNS_NONNULL
#define RUBY_ATTR_RETURNS_NONNULL
Definition: defines.h:244
rb_io_fptr_finalize_internal
void rb_io_fptr_finalize_internal(void *ptr)
Definition: io.c:4730
min_argc
const rb_iseq_t const int const int min_argc
Definition: rb_mjit_min_header-2.7.0.h:13505
rb_io_flush_raw
VALUE rb_io_flush_raw(VALUE, int)
Definition: io.c:1864
rb_encdb_set_unicode
void rb_encdb_set_unicode(int index)
Definition: encoding.c:576
rb_call_data::cc
struct rb_call_cache cc
Definition: internal.h:2394
rb_big_remainder
VALUE rb_big_remainder(VALUE x, VALUE y)
Definition: bignum.c:6119
rb_source_location_cstr
const char * rb_source_location_cstr(int *pline)
Definition: vm.c:1376
RHASH_PASS_AS_KEYWORDS
@ RHASH_PASS_AS_KEYWORDS
Definition: internal.h:818
RRational::den
VALUE den
Definition: internal.h:791
rb_obj_is_mutex
VALUE rb_obj_is_mutex(VALUE obj)
Definition: thread_sync.c:131
RSTRUCT_EMBED_LEN_SHIFT
#define RSTRUCT_EMBED_LEN_SHIFT
Definition: internal.h:921
rb_int_parse_flags
rb_int_parse_flags
Definition: internal.h:2457
RSTRUCT_TRANSIENT_FLAG
@ RSTRUCT_TRANSIENT_FLAG
Definition: internal.h:927
rb_call_info::mid
ID mid
Definition: internal.h:2389
rb_backtrace_print_as_bugreport
void rb_backtrace_print_as_bugreport(void)
Definition: vm_backtrace.c:813
rb_get_coverages
VALUE rb_get_coverages(void)
Definition: thread.c:5477
rb_aligned_malloc
void * rb_aligned_malloc(size_t, size_t) RUBY_ATTR_MALLOC RUBY_ATTR_ALLOC_SIZE((2))
Definition: gc.c:9610
rb_enc_get_from_index
rb_encoding * rb_enc_get_from_index(int index)
Definition: encoding.c:618
rb_ary_behead
VALUE rb_ary_behead(VALUE, long)
Definition: array.c:1369
rb_gc_mark_global_tbl
void rb_gc_mark_global_tbl(void)
Definition: variable.c:434
rb_big_mul_gmp
VALUE rb_big_mul_gmp(VALUE x, VALUE y)
rb_call_inits
void rb_call_inits(void)
Definition: inits.c:19
RClass::basic
struct RBasic basic
Definition: internal.h:1049
MEMO::cnt
long cnt
Definition: internal.h:1284
rb_size_mul_or_raise
size_t rb_size_mul_or_raise(size_t, size_t, VALUE)
Definition: gc.c:192
rb_wb_unprotected_newobj_of
VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE)
Definition: gc.c:2272
ruby_sized_xrealloc2
void * ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_RETURNS_NONNULL RUBY_ATTR_ALLOC_SIZE((2
rb_gc_writebarrier_remember
void rb_gc_writebarrier_remember(VALUE obj)
Definition: gc.c:6875
rb_execarg::envp_str
VALUE envp_str
Definition: internal.h:2032
mjit_enabled
#define mjit_enabled
Definition: internal.h:1760
mod
#define mod(x, y)
Definition: date_strftime.c:28
rb_control_frame_struct
Definition: vm_core.h:760
rb_call_cache::class_serial
rb_serial_t class_serial[(CACHELINE - sizeof(rb_serial_t) - sizeof(struct rb_callable_method_entry_struct *) - sizeof(uintptr_t) - sizeof(enum method_missing_reason) - sizeof(VALUE(*)(struct rb_execution_context_struct *e, struct rb_control_frame_struct *, struct rb_calling_info *, const struct rb_call_data *)))/sizeof(rb_serial_t)]
Definition: internal.h:2370
rb_mv_generic_ivar
void rb_mv_generic_ivar(VALUE src, VALUE dst)
Definition: variable.c:983
FL_USHIFT
#define FL_USHIFT
Definition: ruby.h:1289
rb_uninterruptible
VALUE rb_uninterruptible(VALUE(*b_proc)(VALUE), VALUE data)
Definition: thread.c:5554
rb_async_bug_errno
void rb_async_bug_errno(const char *mesg, int errno_arg)
Definition: error.c:688
rb_class_boot
VALUE rb_class_boot(VALUE)
A utility function that wraps class_alloc.
Definition: class.c:201
size
int size
Definition: encoding.c:58
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:1035
rb_vm_mark
void rb_vm_mark(void *ptr)
Definition: vm.c:2243
uint128_t
#define uint128_t
Definition: rb_mjit_min_header-2.7.0.h:235
FIXNUM_P
#define FIXNUM_P(f)
Definition: ruby.h:396
rb_big_mul_toom3
VALUE rb_big_mul_toom3(VALUE x, VALUE y)
Definition: bignum.c:2267
RString
Definition: ruby.h:988
rb_arith_seq_new
VALUE rb_arith_seq_new(VALUE obj, VALUE meth, int argc, VALUE const *argv, rb_enumerator_size_func *size_fn, VALUE beg, VALUE end, VALUE step, int excl)
Definition: enumerator.c:3308
RCLASS_SUPER
#define RCLASS_SUPER(c)
Definition: classext.h:16
ruby_initial_gc_stress_ptr
VALUE * ruby_initial_gc_stress_ptr
Definition: gc.c:905
RHASH_AR_TABLE_BOUND_MASK
#define RHASH_AR_TABLE_BOUND_MASK
Definition: internal.h:866
rb_struct_init_copy
VALUE rb_struct_init_copy(VALUE copy, VALUE s)
Definition: struct.c:977
rb_eEWOULDBLOCK
VALUE rb_eEWOULDBLOCK
Definition: error.c:55
RClass::ptr
rb_classext_t * ptr
Definition: internal.h:1051
rb_classext_struct::allocator
rb_alloc_func_t allocator
Definition: internal.h:1041
OnigEncodingUTF_8
const ONIG_EXTERN OnigEncodingType OnigEncodingUTF_8
Definition: onigmo.h:201
cmp_opt_data
Definition: internal.h:1322
rb_int_modulo
VALUE rb_int_modulo(VALUE x, VALUE y)
Definition: numeric.c:3886
rb_gc_free_dsymbol
void rb_gc_free_dsymbol(VALUE)
Definition: symbol.c:678
rb_check_to_array
VALUE rb_check_to_array(VALUE ary)
Definition: array.c:915
rb_execarg_extract_options
VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash)
Definition: process.c:2279
rb_hash_stlike_foreach
RUBY_SYMBOL_EXPORT_BEGIN int rb_hash_stlike_foreach(VALUE hash, st_foreach_callback_func *func, st_data_t arg)
Definition: hash.c:1420
RHash::as
union RHash::@105 as
ruby_num_rounding_mode
ruby_num_rounding_mode
Definition: internal.h:1782
RBasicRaw::flags
VALUE flags
Definition: internal.h:1977
rb_gid_t
#define rb_gid_t
Definition: rb_mjit_min_header-2.7.0.h:111
rb_thread_shield_destroy
VALUE rb_thread_shield_destroy(VALUE self)
Definition: thread.c:4846
rb_id_quote_unprintable
VALUE rb_id_quote_unprintable(ID)
Definition: string.c:10735
RHash::basic
struct RBasic basic
Definition: internal.h:888
RBignum::heap
struct RBignum::@103::@104 heap
rb_execarg::use_shell
unsigned use_shell
Definition: internal.h:2035
memcmp
int memcmp(const void *s1, const void *s2, size_t len)
Definition: memcmp.c:7
rb_syntax_error_append
VALUE rb_syntax_error_append(VALUE exc, VALUE file, int line, int column, rb_encoding *enc, const char *fmt, va_list args)
Definition: error.c:104
Init_newline
void Init_newline(void)
rb_call_end_proc
void rb_call_end_proc(VALUE data)
Definition: eval_jump.c:11
calling
rb_control_frame_t struct rb_calling_info * calling
Definition: rb_mjit_min_header-2.7.0.h:14544
rb_big_le
VALUE rb_big_le(VALUE x, VALUE y)
Definition: bignum.c:5507
rb_fstring_new
VALUE rb_fstring_new(const char *ptr, long len)
Definition: string.c:396
RHash::ar_hint
union RHash::@106 ar_hint
RBignum::digits
BDIGIT * digits
Definition: internal.h:754
rb_class_search_ancestor
VALUE rb_class_search_ancestor(VALUE klass, VALUE super)
Definition: object.c:713
FL_USER7
#define FL_USER7
Definition: ruby.h:1298
rb_obj_as_string_result
VALUE rb_obj_as_string_result(VALUE str, VALUE obj)
Definition: string.c:1452
rb_hash_resurrect
VALUE rb_hash_resurrect(VALUE hash)
Definition: hash.c:1548
key
key
Definition: openssl_missing.h:181
RStruct::as
union RStruct::@107 as
rb_hash_new_with_size
VALUE rb_hash_new_with_size(st_index_t size)
Definition: hash.c:1507
FL_USER4
#define FL_USER4
Definition: ruby.h:1295
rb_execarg::close_others_given
unsigned close_others_given
Definition: internal.h:2040
rb_float_div
VALUE rb_float_div(VALUE x, VALUE y)
Definition: numeric.c:1126
FL_USER9
#define FL_USER9
Definition: ruby.h:1300
RUBY_NUM_ROUND_DEFAULT
@ RUBY_NUM_ROUND_DEFAULT
Definition: internal.h:1786
vm_ifunc::flags
VALUE flags
Definition: internal.h:1216
mjit_pause
VALUE mjit_pause(_Bool wait_p)
rb_gvar_get
VALUE rb_gvar_get(struct rb_global_entry *)
Definition: variable.c:619
rb_execarg::umask_given
unsigned umask_given
Definition: internal.h:2037
rb_report_bug_valist
void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args)
Definition: error.c:710
ruby_debug_printf
void ruby_debug_printf(const char *format,...)
Definition: debug.c:85
RHash
Definition: internal.h:887
BIGNUM_EMBED_LEN_MAX
#define BIGNUM_EMBED_LEN_MAX
Definition: internal.h:743
src
__inline__ const void *__restrict src
Definition: rb_mjit_min_header-2.7.0.h:2836
fmt
const VALUE int int int int int int VALUE char * fmt
Definition: rb_mjit_min_header-2.7.0.h:6462
RHash::ar
struct ar_table_struct * ar
Definition: internal.h:891
rb_gvar_getter_function_of
rb_gvar_getter_t * rb_gvar_getter_function_of(const struct rb_global_entry *)
Definition: variable.c:702
ruby_mimfree
void ruby_mimfree(void *ptr)
Definition: gc.c:10217
rb_big_gt
VALUE rb_big_gt(VALUE x, VALUE y)
Definition: bignum.c:5489
RMoved
Definition: internal.h:908
rb_hash_key_str
VALUE rb_hash_key_str(VALUE)
Definition: hash.c:2729
RARRAY_LEN
#define RARRAY_LEN(a)
Definition: ruby.h:1070
rb_check_block_call
VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE)
Definition: vm_eval.c:1528
imemo_ment
@ imemo_ment
Definition: internal.h:1139
ruby_register_rollback_func_for_ensure
void ruby_register_rollback_func_for_ensure(VALUE(*ensure_func)(VALUE), VALUE(*rollback_func)(VALUE))
FIXNUM_POSITIVE_P
#define FIXNUM_POSITIVE_P(num)
Definition: internal.h:1771
rb_reg_new_ary
VALUE rb_reg_new_ary(VALUE ary, int options)
Definition: re.c:2926
rb_big_bit_length
VALUE rb_big_bit_length(VALUE big)
Definition: bignum.c:6790
rb_cArithSeq
VALUE rb_cArithSeq
Definition: enumerator.c:180
rb_current_realfilepath
VALUE rb_current_realfilepath(void)
Definition: vm_eval.c:2460
rb_int_divmod
VALUE rb_int_divmod(VALUE x, VALUE y)
Definition: numeric.c:3963
rb_obj_builtin_type
#define rb_obj_builtin_type(obj)
Definition: rb_mjit_min_header-2.7.0.h:8006
rb_big_mul_normal
VALUE rb_big_mul_normal(VALUE x, VALUE y)
Definition: bignum.c:1561
RHASH_AR_TABLE_BOUND_SHIFT
#define RHASH_AR_TABLE_BOUND_SHIFT
Definition: internal.h:867
rb_int_equal
VALUE rb_int_equal(VALUE x, VALUE y)
Definition: numeric.c:4163
rb_event_flag_t
uint32_t rb_event_flag_t
Definition: ruby.h:2278
ruby_num_interval_step_size
VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl)
Definition: numeric.c:2555
rb_execarg::rlimit_limits
VALUE rlimit_limits
Definition: internal.h:2051
rb_float_mul
VALUE rb_float_mul(VALUE x, VALUE y)
Definition: numeric.c:1072
rb_ary_at
VALUE rb_ary_at(VALUE, VALUE)
Definition: array.c:1629
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4322
n
const char size_t n
Definition: rb_mjit_min_header-2.7.0.h:5456
rb_func_proc_new
VALUE rb_func_proc_new(rb_block_call_func_t func, VALUE val)
Definition: proc.c:728
rb_hash_delete_entry
VALUE rb_hash_delete_entry(VALUE hash, VALUE key)
Definition: hash.c:2253
T_BIGNUM
#define T_BIGNUM
Definition: ruby.h:533
rb_rational_pow
VALUE rb_rational_pow(VALUE self, VALUE other)
Definition: rational.c:1002
rb_vm_fstring_table
st_table * rb_vm_fstring_table(void)
Definition: vm.c:3390
rb_classext_struct::callable_m_tbl
struct rb_id_table * callable_m_tbl
Definition: internal.h:1027
RStruct::len
long len
Definition: internal.h:946
rb_backtrace_p
int rb_backtrace_p(VALUE obj)
Definition: vm_backtrace.c:446
rb_block_call_func_t
rb_block_call_func * rb_block_call_func_t
Definition: ruby.h:1967
arg
VALUE arg
Definition: rb_mjit_min_header-2.7.0.h:5601
RStruct::heap
struct RStruct::@107::@108 heap
argv
char ** argv
Definition: ruby.c:223
rb_rational_abs
VALUE rb_rational_abs(VALUE self)
Definition: rational.c:1255
f
#define f
rb_big_mul_balance
VALUE rb_big_mul_balance(VALUE x, VALUE y)
Definition: bignum.c:1689
rb_method_basic_definition_p_with_cc
bool rb_method_basic_definition_p_with_cc(struct rb_call_data *cd, VALUE klass, ID mid)
Definition: vm_method.c:2057
STATIC_ASSERT
#define STATIC_ASSERT(name, expr)
Definition: internal.h:230
rb_imemo_tmpbuf_t
struct rb_imemo_tmpbuf_struct rb_imemo_tmpbuf_t
RBignum
Definition: internal.h:749
RUBY_SYMBOL_EXPORT_BEGIN
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:48
BIGNUM_NEGATIVE_P
#define BIGNUM_NEGATIVE_P(b)
Definition: internal.h:766
rb_ary_tmp_new_fill
VALUE rb_ary_tmp_new_fill(long capa)
Definition: array.c:776
rb_thread_struct::args
VALUE args
Definition: vm_core.h:966
rb_warn_deprecated
void rb_warn_deprecated(const char *fmt, const char *suggest,...)
Definition: error.c:364
rb_realpath_internal
VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict)
Definition: file.c:4409
rb_cmperr
void rb_cmperr(VALUE x, VALUE y)
Definition: compar.c:25
rb_next_class_serial
rb_serial_t rb_next_class_serial(void)
Definition: vm.c:358
rb_syserr_enc_warning
void rb_syserr_enc_warning(int err, rb_encoding *enc, const char *fmt,...)
Definition: error.c:2955
rb_execarg_setenv
void rb_execarg_setenv(VALUE execarg_obj, VALUE env)
Definition: process.c:2646
klass
VALUE klass
Definition: rb_mjit_min_header-2.7.0.h:13254
rb_math_cos
VALUE rb_math_cos(VALUE)
rb_execarg::sh
struct rb_execarg::@110::@111 sh
st_data_t
unsigned long st_data_t
Definition: rb_mjit_min_header-2.7.0.h:5363
rb_int_positive_p
int rb_int_positive_p(VALUE num)
Definition: numeric.c:301
rb_subclass_entry::klass
VALUE klass
Definition: internal.h:999
timeval
Definition: missing.h:53
rb_gc_mark_vm_stack_values
void rb_gc_mark_vm_stack_values(long n, const VALUE *values)
Definition: gc.c:4739
ruby_rhash_flags
ruby_rhash_flags
Definition: internal.h:817
str
char str[HTML_ESCAPE_MAX_LEN+1]
Definition: escape.c:18
ruby_float_step
int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl, int allow_endless)
Definition: numeric.c:2524
rb_class_foreach_subclass
void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE, VALUE), VALUE)
Definition: class.c:113
ruby_float_step_size
double ruby_float_step_size(double beg, double end, double unit, int excl)
Definition: numeric.c:2495
rb_execarg
Definition: internal.h:2019
FIXNUM_MIN
#define FIXNUM_MIN
Definition: ruby.h:260
rb_num_pow
VALUE rb_num_pow(VALUE x, VALUE y)
Definition: numeric.c:4118
Init_enc
void Init_enc(void)
Definition: dmyenc.c:5
RMoved::destination
VALUE destination
Definition: internal.h:910
MEMO::v2
const VALUE v2
Definition: internal.h:1282
rb_invcmp
VALUE rb_invcmp(VALUE, VALUE)
Definition: compar.c:47
vm_throw_data::reserved
VALUE reserved
Definition: internal.h:1195
rb_math_atan2
VALUE rb_math_atan2(VALUE, VALUE)
MJIT_STATIC
#define MJIT_STATIC
Definition: intern.h:47
rb_last_status_clear
void rb_last_status_clear(void)
Definition: process.c:554
rb_is_const_sym
int rb_is_const_sym(VALUE sym)
Definition: symbol.c:896
ARGVSTR2ARGV
#define ARGVSTR2ARGV(argv_str)
Definition: internal.h:2069
rb_execarg::fd_close
VALUE fd_close
Definition: internal.h:2057
rb_big_mul
VALUE rb_big_mul(VALUE x, VALUE y)
Definition: bignum.c:5933
ruby_escaped_char
const char * ruby_escaped_char(int c)
Definition: string.c:5848
rb_default_home_dir
VALUE rb_default_home_dir(VALUE result)
Definition: file.c:3576
rb_wb_protected_newobj_of
VALUE rb_wb_protected_newobj_of(VALUE, VALUE)
Definition: gc.c:2279
rb_gcd_gmp
VALUE rb_gcd_gmp(VALUE x, VALUE y)
rb_float_eql
VALUE rb_float_eql(VALUE x, VALUE y)
Definition: numeric.c:1654
rb_execarg::redirect_fds
VALUE redirect_fds
Definition: internal.h:2031
rb_big_size_m
VALUE rb_big_size_m(VALUE big)
Definition: bignum.c:6784
RComplex
Definition: internal.h:805
RUBY_ATTR_MALLOC
#define RUBY_ATTR_MALLOC
Definition: defines.h:235
Init_vm_objects
void Init_vm_objects(void)
Definition: vm.c:3324
rb_autoload_str
void rb_autoload_str(VALUE mod, ID id, VALUE file)
Definition: variable.c:1933
rb_cstr_to_rat
VALUE rb_cstr_to_rat(const char *, int)
Definition: rational.c:2541
rb_alloc_func_t
VALUE(* rb_alloc_func_t)(VALUE)
Definition: intern.h:427
ruby_debug_breakpoint
void ruby_debug_breakpoint(void)
Definition: debug.c:135
rb_execarg::argv_str
VALUE argv_str
Definition: internal.h:2027
rb_ary_set_len
void rb_ary_set_len(VALUE, long)
Definition: array.c:1932
ruby_init_setproctitle
void ruby_init_setproctitle(int argc, char *argv[])
ruby_hexdigits
const char ruby_hexdigits[]
Definition: escape.c:5
Init_eval_method
void Init_eval_method(void)
Definition: vm_method.c:2281
rb_flo_div_flo
VALUE rb_flo_div_flo(VALUE x, VALUE y)
Definition: numeric.c:1110
rb_warning_string
VALUE rb_warning_string(const char *fmt,...)
Definition: error.c:344
rb_str_tmp_frozen_release
void rb_str_tmp_frozen_release(VALUE str, VALUE tmp)
Definition: string.c:1217
ruby_exec_prefix
const char ruby_exec_prefix[]
Definition: loadpath.c:59
argc
int argc
Definition: ruby.c:222
RHash::word
VALUE word
Definition: internal.h:896
rb_str_initialize
VALUE rb_str_initialize(VALUE str, const char *ptr, long len, rb_encoding *enc)
Definition: string.c:964
st
enum ruby_tag_type st
Definition: rb_mjit_min_header-2.7.0.h:11111
RB_INT_PARSE_SIGN
@ RB_INT_PARSE_SIGN
Definition: internal.h:2458
rb_enc_warn
void rb_enc_warn(rb_encoding *enc, const char *fmt,...)
Definition: error.c:323
T_IMEMO
#define T_IMEMO
Definition: ruby.h:543
RHash::ary
ar_hint_t ary[RHASH_AR_TABLE_MAX_SIZE]
Definition: internal.h:895
rb_check_funcall_default
VALUE rb_check_funcall_default(VALUE, ID, int, const VALUE *, VALUE)
Definition: vm_eval.c:533
rb_call_cache::aux
union rb_call_cache::@113 aux
rb_init_identtable
st_table * rb_init_identtable(void)
Definition: hash.c:4211
ruby_enable_coredump
int ruby_enable_coredump
Definition: signal.c:1481
err
int err
Definition: win32.c:135
RHASH_LEV_SHIFT
@ RHASH_LEV_SHIFT
Definition: internal.h:835
rb_thread_to_be_killed
int rb_thread_to_be_killed(VALUE thread)
Definition: thread.c:2472
rb_adjust_argv_kw_splat
VALUE rb_adjust_argv_kw_splat(int *, const VALUE **, int *)
Definition: vm_eval.c:237
rb_get_next_signal
int rb_get_next_signal(void)
Definition: signal.c:756
rb_execarg_addopt
int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
Definition: process.c:2013
rb_call_info::flag
unsigned int flag
Definition: internal.h:2390
rb_get_coverage_mode
int rb_get_coverage_mode(void)
Definition: thread.c:5483
rb_data_type_struct
Definition: ruby.h:1148
rb_make_metaclass
VALUE rb_make_metaclass(VALUE, VALUE)
Definition: class.c:580
__msan_poison
#define __msan_poison(x, y)
Definition: internal.h:121
rb_global_variable
Definition: variable.c:301
rb_execarg::envp_buf
VALUE envp_buf
Definition: internal.h:2033
ruby_null_device
const char ruby_null_device[]
Definition: file.c:6389
rb_execarg::invoke
union rb_execarg::@110 invoke
rb_int_gt
VALUE rb_int_gt(VALUE x, VALUE y)
Definition: numeric.c:4252
rb_thread_shield_release
VALUE rb_thread_shield_release(VALUE self)
Definition: thread.c:4835
rb_call_data::ci
struct rb_call_info ci
Definition: internal.h:2395
rb_execarg::close_others_do
unsigned close_others_do
Definition: internal.h:2041
MEMO::value
const VALUE value
Definition: internal.h:1286
RBASIC
#define RBASIC(obj)
Definition: ruby.h:1267
rb_execarg::path_env
VALUE path_env
Definition: internal.h:2061
rb_obj_private_methods
VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1395
rb_xrealloc_mul_add
void * rb_xrealloc_mul_add(const void *, size_t, size_t, size_t)
Definition: gc.c:10163
FIXNUM_NEGATIVE_P
#define FIXNUM_NEGATIVE_P(num)
Definition: internal.h:1772
MISSING_NOENTRY
@ MISSING_NOENTRY
Definition: internal.h:2330
rb_nmin_run
VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary)
Definition: enum.c:1568
FL_USER8
#define FL_USER8
Definition: ruby.h:1299
rb_deprecate_constant
void rb_deprecate_constant(VALUE mod, const char *name)
Definition: variable.c:2947
rb_method_definition_struct
Definition: method.h:163
rb_rational_canonicalize
VALUE rb_rational_canonicalize(VALUE x)
Definition: rational.c:2034
vm_svar::flags
VALUE flags
Definition: internal.h:1182
imemo_cref
@ imemo_cref
class reference
Definition: internal.h:1134
__msan_unpoison
#define __msan_unpoison(x, y)
Definition: internal.h:122
rb_vm_thread_backtrace
VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:960
rb_encdb_dummy
int rb_encdb_dummy(const char *name)
Definition: encoding.c:472
_
#define _(args)
Definition: dln.h:28
ruby_fill_random_bytes
int ruby_fill_random_bytes(void *, size_t, int)
Definition: random.c:434
rb_hash_values
VALUE rb_hash_values(VALUE hash)
Definition: hash.c:3381
ar_table_struct
Definition: hash.c:349
rb_singleton_class_clone_and_attach
VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
Definition: class.c:376
rb_imemo_tmpbuf_auto_free_pointer
#define rb_imemo_tmpbuf_auto_free_pointer()
Definition: internal.h:1239
Qtrue
#define Qtrue
Definition: ruby.h:468
rb_str_convert_to_inum
VALUE rb_str_convert_to_inum(VALUE str, int base, int badcheck, int raise_exception)
Definition: bignum.c:4246
rb_get_backtrace
VALUE rb_get_backtrace(VALUE info)
Definition: error.c:1229
rb_hash_compare_by_id_p
VALUE rb_hash_compare_by_id_p(VALUE hash)
Definition: hash.c:4192
rb_xmalloc_mul_add
void * rb_xmalloc_mul_add(size_t, size_t, size_t) RUBY_ATTR_MALLOC
Definition: gc.c:10156
rb_ary_tmp_new_from_values
VALUE rb_ary_tmp_new_from_values(VALUE, long, const VALUE *)
Definition: array.c:748
rb_ary_ptr_use_end
void rb_ary_ptr_use_end(VALUE ary)
Definition: array.c:235
len
uint8_t len
Definition: escape.c:17
rb_gc_verify_internal_consistency
void rb_gc_verify_internal_consistency(void)
Definition: gc.c:6202
rb_hash_ar_table
ar_table * rb_hash_ar_table(VALUE hash)
Definition: hash.c:544
rb_sym_intern_ascii_cstr
VALUE rb_sym_intern_ascii_cstr(const char *ptr)
Definition: symbol.c:1038
rb_get_path_check_convert
VALUE rb_get_path_check_convert(VALUE)
Definition: file.c:211
rb_eEINPROGRESS
VALUE rb_eEINPROGRESS
Definition: error.c:56
rb_integer_float_eq
VALUE rb_integer_float_eq(VALUE x, VALUE y)
Definition: bignum.c:5386
rb_subclass_entry
Definition: internal.h:998
rb_str_change_terminator_length
void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen)
Definition: string.c:2230
rb_size_mul_add_or_raise
size_t rb_size_mul_add_or_raise(size_t, size_t, size_t, VALUE)
Definition: gc.c:219
rb_int_cmp
VALUE rb_int_cmp(VALUE x, VALUE y)
Definition: numeric.c:4212
RStruct
Definition: internal.h:942
rb_dbl_long_hash
long rb_dbl_long_hash(double d)
Definition: hash.c:160
RBignum::ary
BDIGIT ary[BIGNUM_EMBED_LEN_MAX]
Definition: internal.h:756
rb_hash_proc
st_index_t rb_hash_proc(st_index_t hash, VALUE proc)
Definition: proc.c:1302
rb_execarg::uid
rb_uid_t uid
Definition: internal.h:2053
int128_t
#define int128_t
Definition: rb_mjit_min_header-2.7.0.h:232
rb_mutex_allow_trap
void rb_mutex_allow_trap(VALUE self, int val)
Definition: thread_sync.c:545
rb_vm_check_redefinition_by_prepend
void rb_vm_check_redefinition_by_prepend(VALUE klass)
Definition: vm.c:1631
LONG2FIX
#define LONG2FIX(i)
Definition: ruby.h:265
RTYPEDDATA_P
#define RTYPEDDATA_P(v)
Definition: ruby.h:1177
waitpid_state::status
int status
Definition: process.c:949
RBasicRaw
Definition: internal.h:1976
rb_class_detach_subclasses
void rb_class_detach_subclasses(VALUE)
Definition: class.c:133
rb_classext_struct::iv_index_tbl
struct st_table * iv_index_tbl
Definition: internal.h:1021
imemo_tmpbuf
@ imemo_tmpbuf
Definition: internal.h:1141
rb_data_is_encoding
int rb_data_is_encoding(VALUE obj)
Definition: encoding.c:89
LIKELY
#define LIKELY(x)
Definition: internal.h:36
RClass::class_serial
rb_serial_t class_serial
Definition: internal.h:1054
rb_block
Definition: vm_core.h:751
rb_pid_t
#define rb_pid_t
Definition: rb_mjit_min_header-2.7.0.h:99
RB_OBJ_WRITE
#define RB_OBJ_WRITE(a, slot, b)
Definition: internal.h:2688
rb_execarg::exception_given
unsigned exception_given
Definition: internal.h:2047
rb_execarg::chdir_given
unsigned chdir_given
Definition: internal.h:2042
va_list
__gnuc_va_list va_list
Definition: rb_mjit_min_header-2.7.0.h:836
rb_attr_delete
VALUE rb_attr_delete(VALUE, ID)
Definition: variable.c:1126
rb_float_uminus
VALUE rb_float_uminus(VALUE num)
Definition: numeric.c:1011
rb_econv_memsize
size_t rb_econv_memsize(rb_econv_t *ec)
Definition: transcode.c:1702
rb_obj_memsize_of
size_t rb_obj_memsize_of(VALUE)
Definition: gc.c:3934
rb_generic_ivar_memsize
size_t rb_generic_ivar_memsize(VALUE)
Definition: variable.c:1010
rb_yield_force_blockarg
VALUE rb_yield_force_blockarg(VALUE values)
Definition: vm_eval.c:1309
ruby_digitmap
const char ruby_digitmap[]
Definition: bignum.c:38
rb_uid_t
#define rb_uid_t
Definition: rb_mjit_min_header-2.7.0.h:105
rb_call_info
Definition: internal.h:2387
RComplex::imag
VALUE imag
Definition: internal.h:808
rb_rational_mul
VALUE rb_rational_mul(VALUE self, VALUE other)
Definition: rational.c:874
rb_builtin_class_name
const char * rb_builtin_class_name(VALUE x)
Definition: error.c:797
RARRAY_CONST_PTR_TRANSIENT
#define RARRAY_CONST_PTR_TRANSIENT(a)
Definition: ruby.h:1073
ruby_vm_special_exception_copy
MJIT_STATIC VALUE ruby_vm_special_exception_copy(VALUE)
Definition: rb_mjit_min_header-2.7.0.h:12219
RHASH_AR_TABLE_SIZE_SHIFT
#define RHASH_AR_TABLE_SIZE_SHIFT
Definition: internal.h:865
RHASH_AR_TABLE_SIZE_MASK
#define RHASH_AR_TABLE_SIZE_MASK
Definition: internal.h:864
rb_big_divrem_gmp
VALUE rb_big_divrem_gmp(VALUE x, VALUE y)
RB_WARN_CATEGORY_DEPRECATED
@ RB_WARN_CATEGORY_DEPRECATED
Definition: internal.h:1560
FL_USER12
#define FL_USER12
Definition: ruby.h:1303
vm_ifunc_argc
Definition: internal.h:1205
rb_num_to_dbl
double rb_num_to_dbl(VALUE val)
Definition: object.c:3576
ruby_hdtoa
char * ruby_hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rve)
rb_imemo_tmpbuf_struct
Definition: internal.h:1231
rb_insns_name_array
VALUE rb_insns_name_array(void)
Definition: compile.c:8767
rb_str2big_karatsuba
VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck)
Definition: bignum.c:4352
Qnil
#define Qnil
Definition: ruby.h:469
rb_big2str_gmp
VALUE rb_big2str_gmp(VALUE x, int base)
rb_stdio_set_default_encoding
void rb_stdio_set_default_encoding(void)
Definition: io.c:11758
rb_imemo_tmpbuf_struct::flags
VALUE flags
Definition: internal.h:1232
method_missing_reason
method_missing_reason
Definition: internal.h:2329
Init_File
void Init_File(void)
Definition: file.c:6435
waitpid_state::options
int options
Definition: process.c:950
rb_math_cosh
VALUE rb_math_cosh(VALUE)
mjit_resume
VALUE mjit_resume(void)
ruby_disable_gc
int ruby_disable_gc
Definition: gc.c:1001
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:3516
Init_vm_stack_canary
void Init_vm_stack_canary(void)
Definition: rb_mjit_min_header-2.7.0.h:16989
rb_float_ceil
VALUE rb_float_ceil(VALUE num, int ndigits)
Definition: numeric.c:2017
rb_imemo_tmpbuf_struct::reserved
VALUE reserved
Definition: internal.h:1233
rb_execarg::command_name
VALUE command_name
Definition: internal.h:2025
ruby_sized_xfree
void void ruby_sized_xfree(void *x, size_t size)
Definition: gc.c:10142
RIMemo::v3
VALUE v3
Definition: internal.h:1129
rb_imemo_new
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
Definition: gc.c:2306
mode_t
__mode_t mode_t
Definition: rb_mjit_min_header-2.7.0.h:1331
rb_objspace_data_type_name
const RUBY_SYMBOL_EXPORT_BEGIN char * rb_objspace_data_type_name(VALUE obj)
Definition: gc.c:2430
vm_ifunc::reserved
VALUE reserved
Definition: internal.h:1217
vm_throw_data::throw_state
int throw_state
Definition: internal.h:1198
rb_io_t
Definition: io.h:66
cmp_opt_data::opt_methods
unsigned int opt_methods
Definition: internal.h:1323
rb_warning_category_from_name
rb_warning_category_t rb_warning_category_from_name(VALUE category)
Definition: error.c:140
rb_str_chomp_string
VALUE rb_str_chomp_string(VALUE str, VALUE chomp)
Definition: string.c:8921
rb_classext_struct
Definition: internal.h:1020
rb_is_instance_name
int rb_is_instance_name(VALUE name)
Definition: symbol.c:1062
rb_int_plus
VALUE rb_int_plus(VALUE x, VALUE y)
Definition: numeric.c:3610
cmp_opt_Fixnum
@ cmp_opt_Fixnum
Definition: internal.h:1316
rb_encdb_replicate
int rb_encdb_replicate(const char *alias, const char *orig)
Definition: encoding.c:450
rb_thread_struct
Definition: vm_core.h:910
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:565
rb_call_data
Definition: internal.h:2393
MEMO::state
long state
Definition: internal.h:1285
rb_classext_struct::origin_
const VALUE origin_
Definition: internal.h:1039
RSTRING_LEN
#define RSTRING_LEN(str)
Definition: ruby.h:1005
RHASH_TRANSIENT_FLAG
@ RHASH_TRANSIENT_FLAG
Definition: internal.h:832
rb_gcd
VALUE rb_gcd(VALUE x, VALUE y)
Definition: rational.c:1894
rb_obj_methods
VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1361
rb_classext_struct::parent_subclasses
rb_subclass_entry_t ** parent_subclasses
Definition: internal.h:1029
st_table
Definition: st.h:79
ruby_set_inplace_mode
void ruby_set_inplace_mode(const char *)
Definition: io.c:12857
rb_mod_const_missing
VALUE rb_mod_const_missing(VALUE klass, VALUE name)
Definition: variable.c:1739
rb_classext_struct::m_tbl
struct rb_id_table * m_tbl
Definition: internal.h:1024
rb_grantpt
int rb_grantpt(int fd)
Definition: signal.c:1597
FL_USER6
#define FL_USER6
Definition: ruby.h:1297
rb_default_coverage
VALUE rb_default_coverage(int)
Definition: thread.c:5519
MEMO::func
void(* func)(void)
Definition: internal.h:1287
rb_reg_check_preprocess
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2706
ruby_gc_set_params
void ruby_gc_set_params(void)
Definition: gc.c:9401
rb_warning_category_t
rb_warning_category_t
Definition: internal.h:1558
max_argc
const rb_iseq_t const int const int const int max_argc
Definition: rb_mjit_min_header-2.7.0.h:13505
RTEST
#define RTEST(v)
Definition: ruby.h:481
imemo_ifunc
@ imemo_ifunc
iterator function
Definition: internal.h:1137
ruby::backward::cxxanyargs::type
VALUE type(ANYARGS)
ANYARGS-ed function type.
Definition: cxxanyargs.hpp:39
rb_str2big_normal
VALUE rb_str2big_normal(VALUE arg, int base, int badcheck)
Definition: bignum.c:4310
RB_SPECIAL_CONST_P
#define RB_SPECIAL_CONST_P(x)
Definition: ruby.h:1312
rb_str_quote_unprintable
VALUE rb_str_quote_unprintable(VALUE)
Definition: string.c:10714
rb_maygvl_fd_fix_cloexec
void rb_maygvl_fd_fix_cloexec(int fd)
Definition: io.c:245
rb_unexpected_type
void rb_unexpected_type(VALUE x, int t)
Definition: error.c:852
rb_str_comparable
int rb_str_comparable(VALUE, VALUE)
Definition: string.c:3203
rb_big_abs
VALUE rb_big_abs(VALUE x)
Definition: bignum.c:6762
__sFILE
Definition: vsnprintf.c:169
rb_block_min_max_arity
int rb_block_min_max_arity(int *max)
Definition: proc.c:1178
rb_global_entry
Definition: internal.h:1350
rb_xcalloc_mul_add_mul
void * rb_xcalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC
Definition: gc.c:10177
RB_INT_PARSE_UNDERSCORE
@ RB_INT_PARSE_UNDERSCORE
Definition: internal.h:2459
rb_hash_has_key
VALUE rb_hash_has_key(VALUE hash, VALUE key)
Definition: hash.c:3432
rb_xmalloc_mul_add_mul
void * rb_xmalloc_mul_add_mul(size_t, size_t, size_t, size_t) RUBY_ATTR_MALLOC
Definition: gc.c:10170
RSTRUCT
#define RSTRUCT(obj)
Definition: internal.h:966
rb_check_funcall_with_hook_kw
VALUE rb_check_funcall_with_hook_kw(VALUE recv, ID mid, int argc, const VALUE *argv, rb_check_funcall_hook *hook, VALUE arg, int kw_splat)
Definition: vm_eval.c:539
rb_float_cmp
int rb_float_cmp(VALUE x, VALUE y)
Definition: numeric.c:1487
RVALUE_EMBED_LEN_MAX
@ RVALUE_EMBED_LEN_MAX
Definition: ruby.h:910
rb_int_minus
VALUE rb_int_minus(VALUE x, VALUE y)
Definition: numeric.c:3649
rb_big2str_poweroftwo
VALUE rb_big2str_poweroftwo(VALUE x, int base)
Definition: bignum.c:4921
RClass
Definition: internal.h:1048
cfp
rb_control_frame_t * cfp
Definition: rb_mjit_min_header-2.7.0.h:14544
RStruct::ary
const VALUE ary[RSTRUCT_EMBED_LEN_MAX]
Definition: internal.h:949
MISSING_PRIVATE
@ MISSING_PRIVATE
Definition: internal.h:2331
rb_source_location
VALUE rb_source_location(int *pline)
Definition: vm.c:1360
RHASH_LEV_MAX
@ RHASH_LEV_MAX
Definition: internal.h:836
name
const char * name
Definition: nkf.c:208
rb_execution_context_struct
Definition: vm_core.h:843
rb_fork_ruby
rb_pid_t rb_fork_ruby(int *status)
rb_str_upto_each
VALUE rb_str_upto_each(VALUE, VALUE, int, int(*each)(VALUE, VALUE), VALUE)
Definition: string.c:4263
PRINTF_ARGS
PRINTF_ARGS(void ruby_debug_printf(const char *,...), 1, 2)
rb_big_odd_p
VALUE rb_big_odd_p(VALUE)
Definition: bignum.c:6831