Ruby  2.4.2p198(2017-09-14revision59899)
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 #include "ruby/encoding.h"
17 #include "ruby/io.h"
18 
19 #if defined(__cplusplus)
20 extern "C" {
21 #if 0
22 } /* satisfy cc-mode */
23 #endif
24 #endif
25 
26 #define LIKELY(x) RB_LIKELY(x)
27 #define UNLIKELY(x) RB_UNLIKELY(x)
28 
29 #ifndef MAYBE_UNUSED
30 # define MAYBE_UNUSED(x) x
31 #endif
32 
33 #ifndef WARN_UNUSED_RESULT
34 # define WARN_UNUSED_RESULT(x) x
35 #endif
36 
37 #ifdef HAVE_VALGRIND_MEMCHECK_H
38 # include <valgrind/memcheck.h>
39 # ifndef VALGRIND_MAKE_MEM_DEFINED
40 # define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
41 # endif
42 # ifndef VALGRIND_MAKE_MEM_UNDEFINED
43 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
44 # endif
45 #else
46 # define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
47 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
48 #endif
49 
50 #define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
51 
52 #ifndef __has_feature
53 # define __has_feature(x) 0
54 #endif
55 
56 #ifndef __has_extension
57 # define __has_extension __has_feature
58 #endif
59 
60 #if GCC_VERSION_SINCE(4, 6, 0) || __has_extension(c_static_assert)
61 # define STATIC_ASSERT(name, expr) _Static_assert(expr, #name ": " #expr)
62 #else
63 # define STATIC_ASSERT(name, expr) typedef int static_assert_##name##_check[1 - 2*!(expr)]
64 #endif
65 
66 #define SIGNED_INTEGER_TYPE_P(int_type) (0 > ((int_type)0)-1)
67 #define SIGNED_INTEGER_MAX(sint_type) \
68  (sint_type) \
69  ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) | \
70  ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) - 1))
71 #define SIGNED_INTEGER_MIN(sint_type) (-SIGNED_INTEGER_MAX(sint_type)-1)
72 #define UNSIGNED_INTEGER_MAX(uint_type) (~(uint_type)0)
73 
74 #if SIGNEDNESS_OF_TIME_T < 0 /* signed */
75 # define TIMET_MAX SIGNED_INTEGER_MAX(time_t)
76 # define TIMET_MIN SIGNED_INTEGER_MIN(time_t)
77 #elif SIGNEDNESS_OF_TIME_T > 0 /* unsigned */
78 # define TIMET_MAX UNSIGNED_INTEGER_MAX(time_t)
79 # define TIMET_MIN ((time_t)0)
80 #endif
81 #define TIMET_MAX_PLUS_ONE (2*(double)(TIMET_MAX/2+1))
82 
83 #define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
84  (a) == 0 ? 0 : \
85  (a) == -1 ? (b) < -(max) : \
86  (a) > 0 ? \
87  ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
88  ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
89 #define MUL_OVERFLOW_FIXNUM_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
90 #define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
91 #define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
92 
93 #ifndef swap16
94 # ifdef HAVE_BUILTIN___BUILTIN_BSWAP16
95 # define swap16(x) __builtin_bswap16(x)
96 # endif
97 #endif
98 
99 #ifndef swap16
100 # define swap16(x) ((uint16_t)((((x)&0xFF)<<8) | (((x)>>8)&0xFF)))
101 #endif
102 
103 #ifndef swap32
104 # ifdef HAVE_BUILTIN___BUILTIN_BSWAP32
105 # define swap32(x) __builtin_bswap32(x)
106 # endif
107 #endif
108 
109 #ifndef swap32
110 # define swap32(x) ((uint32_t)((((x)&0xFF)<<24) \
111  |(((x)>>24)&0xFF) \
112  |(((x)&0x0000FF00)<<8) \
113  |(((x)&0x00FF0000)>>8) ))
114 #endif
115 
116 #ifndef swap64
117 # ifdef HAVE_BUILTIN___BUILTIN_BSWAP64
118 # define swap64(x) __builtin_bswap64(x)
119 # endif
120 #endif
121 
122 #ifndef swap64
123 # ifdef HAVE_INT64_T
124 # define byte_in_64bit(n) ((uint64_t)0xff << (n))
125 # define swap64(x) ((uint64_t)((((x)&byte_in_64bit(0))<<56) \
126  |(((x)>>56)&0xFF) \
127  |(((x)&byte_in_64bit(8))<<40) \
128  |(((x)&byte_in_64bit(48))>>40) \
129  |(((x)&byte_in_64bit(16))<<24) \
130  |(((x)&byte_in_64bit(40))>>24) \
131  |(((x)&byte_in_64bit(24))<<8) \
132  |(((x)&byte_in_64bit(32))>>8)))
133 # endif
134 #endif
135 
136 static inline unsigned int
137 nlz_int(unsigned int x)
138 {
139 #if defined(HAVE_BUILTIN___BUILTIN_CLZ)
140  if (x == 0) return SIZEOF_INT * CHAR_BIT;
141  return (unsigned int)__builtin_clz(x);
142 #else
143  unsigned int y;
144 # if 64 < SIZEOF_INT * CHAR_BIT
145  unsigned int n = 128;
146 # elif 32 < SIZEOF_INT * CHAR_BIT
147  unsigned int n = 64;
148 # else
149  unsigned int n = 32;
150 # endif
151 # if 64 < SIZEOF_INT * CHAR_BIT
152  y = x >> 64; if (y) {n -= 64; x = y;}
153 # endif
154 # if 32 < SIZEOF_INT * CHAR_BIT
155  y = x >> 32; if (y) {n -= 32; x = y;}
156 # endif
157  y = x >> 16; if (y) {n -= 16; x = y;}
158  y = x >> 8; if (y) {n -= 8; x = y;}
159  y = x >> 4; if (y) {n -= 4; x = y;}
160  y = x >> 2; if (y) {n -= 2; x = y;}
161  y = x >> 1; if (y) {return n - 2;}
162  return (unsigned int)(n - x);
163 #endif
164 }
165 
166 static inline unsigned int
167 nlz_long(unsigned long x)
168 {
169 #if defined(HAVE_BUILTIN___BUILTIN_CLZL)
170  if (x == 0) return SIZEOF_LONG * CHAR_BIT;
171  return (unsigned int)__builtin_clzl(x);
172 #else
173  unsigned long y;
174 # if 64 < SIZEOF_LONG * CHAR_BIT
175  unsigned int n = 128;
176 # elif 32 < SIZEOF_LONG * CHAR_BIT
177  unsigned int n = 64;
178 # else
179  unsigned int n = 32;
180 # endif
181 # if 64 < SIZEOF_LONG * CHAR_BIT
182  y = x >> 64; if (y) {n -= 64; x = y;}
183 # endif
184 # if 32 < SIZEOF_LONG * CHAR_BIT
185  y = x >> 32; if (y) {n -= 32; x = y;}
186 # endif
187  y = x >> 16; if (y) {n -= 16; x = y;}
188  y = x >> 8; if (y) {n -= 8; x = y;}
189  y = x >> 4; if (y) {n -= 4; x = y;}
190  y = x >> 2; if (y) {n -= 2; x = y;}
191  y = x >> 1; if (y) {return n - 2;}
192  return (unsigned int)(n - x);
193 #endif
194 }
195 
196 #ifdef HAVE_LONG_LONG
197 static inline unsigned int
198 nlz_long_long(unsigned LONG_LONG x)
199 {
200 #if defined(HAVE_BUILTIN___BUILTIN_CLZLL)
201  if (x == 0) return SIZEOF_LONG_LONG * CHAR_BIT;
202  return (unsigned int)__builtin_clzll(x);
203 #else
204  unsigned LONG_LONG y;
205 # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
206  unsigned int n = 128;
207 # elif 32 < SIZEOF_LONG_LONG * CHAR_BIT
208  unsigned int n = 64;
209 # else
210  unsigned int n = 32;
211 # endif
212 # if 64 < SIZEOF_LONG_LONG * CHAR_BIT
213  y = x >> 64; if (y) {n -= 64; x = y;}
214 # endif
215 # if 32 < SIZEOF_LONG_LONG * CHAR_BIT
216  y = x >> 32; if (y) {n -= 32; x = y;}
217 # endif
218  y = x >> 16; if (y) {n -= 16; x = y;}
219  y = x >> 8; if (y) {n -= 8; x = y;}
220  y = x >> 4; if (y) {n -= 4; x = y;}
221  y = x >> 2; if (y) {n -= 2; x = y;}
222  y = x >> 1; if (y) {return n - 2;}
223  return (unsigned int)(n - x);
224 #endif
225 }
226 #endif
227 
228 #ifdef HAVE_UINT128_T
229 static inline unsigned int
230 nlz_int128(uint128_t x)
231 {
232  uint128_t y;
233  unsigned int n = 128;
234  y = x >> 64; if (y) {n -= 64; x = y;}
235  y = x >> 32; if (y) {n -= 32; x = y;}
236  y = x >> 16; if (y) {n -= 16; x = y;}
237  y = x >> 8; if (y) {n -= 8; x = y;}
238  y = x >> 4; if (y) {n -= 4; x = y;}
239  y = x >> 2; if (y) {n -= 2; x = y;}
240  y = x >> 1; if (y) {return n - 2;}
241  return (unsigned int)(n - x);
242 }
243 #endif
244 
245 static inline unsigned int
247 {
248 #if SIZEOF_VOIDP == 8
249  return nlz_long_long(x);
250 #elif SIZEOF_VOIDP == 4
251  return nlz_int(x);
252 #endif
253 }
254 
255 static inline unsigned int
257 {
258 #ifdef HAVE_BUILTIN___BUILTIN_POPCOUNT
259  return (unsigned int)__builtin_popcount(x);
260 #else
261  x = (x & 0x55555555) + (x >> 1 & 0x55555555);
262  x = (x & 0x33333333) + (x >> 2 & 0x33333333);
263  x = (x & 0x0f0f0f0f) + (x >> 4 & 0x0f0f0f0f);
264  x = (x & 0x001f001f) + (x >> 8 & 0x001f001f);
265  return (x & 0x0000003f) + (x >>16 & 0x0000003f);
266 #endif
267 }
268 
269 static inline int
271 {
272 #ifdef HAVE_BUILTIN___BUILTIN_POPCOUNT
273  return __builtin_popcountll(x);
274 #else
275  x = (x & 0x5555555555555555) + (x >> 1 & 0x5555555555555555);
276  x = (x & 0x3333333333333333) + (x >> 2 & 0x3333333333333333);
277  x = (x & 0x0707070707070707) + (x >> 4 & 0x0707070707070707);
278  x = (x & 0x001f001f001f001f) + (x >> 8 & 0x001f001f001f001f);
279  x = (x & 0x0000003f0000003f) + (x >>16 & 0x0000003f0000003f);
280  return (x & 0x7f) + (x >>32 & 0x7f);
281 #endif
282 }
283 
284 static inline int
286 {
287 #if SIZEOF_VOIDP == 8
288  return rb_popcount64(x);
289 #elif SIZEOF_VOIDP == 4
290  return rb_popcount32(x);
291 #endif
292 }
293 
294 static inline int
296 {
297 #ifdef HAVE_BUILTIN___BUILTIN_CTZ
298  return __builtin_ctz(x);
299 #else
300  return rb_popcount32((~x) & (x-1));
301 #endif
302 }
303 
304 static inline int
306 {
307 #ifdef HAVE_BUILTIN___BUILTIN_CTZLL
308  return __builtin_ctzll(x);
309 #else
310  return rb_popcount64((~x) & (x-1));
311 #endif
312 }
313 
314 static inline int
316 {
317 #if SIZEOF_VOIDP == 8
318  return ntz_int64(x);
319 #elif SIZEOF_VOIDP == 4
320  return ntz_int32(x);
321 #endif
322 }
323 
324 #if HAVE_LONG_LONG && SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG
325 # define DLONG LONG_LONG
326 # define DL2NUM(x) LL2NUM(x)
327 #elif defined(HAVE_INT128_T)
328 # define DLONG int128_t
329 # define DL2NUM(x) (RB_FIXABLE(x) ? LONG2FIX(x) : rb_int128t2big(x))
330 VALUE rb_int128t2big(int128_t n);
331 #endif
332 
333 
334 /* arguments must be Fixnum */
335 static inline VALUE
337 {
338  long lx = FIX2LONG(x);
339  long ly = FIX2LONG(y);
340 #ifdef DLONG
341  return DL2NUM((DLONG)lx * (DLONG)ly);
342 #else
343  if (MUL_OVERFLOW_FIXNUM_P(lx, ly)) {
344  return rb_big_mul(rb_int2big(lx), rb_int2big(ly));
345  }
346  else {
347  return LONG2FIX(lx * ly);
348  }
349 #endif
350 }
351 
352 /*
353  * This behaves different from C99 for negative arguments.
354  * Note that div may overflow fixnum.
355  */
356 static inline void
358 {
359  /* assume / and % comply C99.
360  * ldiv(3) won't be inlined by GCC and clang.
361  * I expect / and % are compiled as single idiv.
362  */
363  long x = FIX2LONG(a);
364  long y = FIX2LONG(b);
365  long div, mod;
366  if (x == FIXNUM_MIN && y == -1) {
367  if (divp) *divp = LONG2NUM(-FIXNUM_MIN);
368  if (modp) *modp = LONG2FIX(0);
369  return;
370  }
371  div = x / y;
372  mod = x % y;
373  if (y > 0 ? mod < 0 : mod > 0) {
374  mod += y;
375  div -= 1;
376  }
377  if (divp) *divp = LONG2FIX(div);
378  if (modp) *modp = LONG2FIX(mod);
379 }
380 
381 /* div() for Ruby
382  * This behaves different from C99 for negative arguments.
383  */
384 static inline VALUE
386 {
387  VALUE div;
388  rb_fix_divmod_fix(x, y, &div, NULL);
389  return div;
390 }
391 
392 /* mod() for Ruby
393  * This behaves different from C99 for negative arguments.
394  */
395 static inline VALUE
397 {
398  VALUE mod;
399  rb_fix_divmod_fix(x, y, NULL, &mod);
400  return mod;
401 }
402 
403 #if defined(HAVE_UINT128_T)
404 # define bit_length(x) \
405  (unsigned int) \
406  (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
407  sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
408  sizeof(x) <= SIZEOF_LONG_LONG ? SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)) : \
409  SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
410 #elif defined(HAVE_LONG_LONG)
411 # define bit_length(x) \
412  (unsigned int) \
413  (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
414  sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : \
415  SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)))
416 #else
417 # define bit_length(x) \
418  (unsigned int) \
419  (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : \
420  SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)))
421 #endif
422 
423 #ifndef BDIGIT
424 # if SIZEOF_INT*2 <= SIZEOF_LONG_LONG
425 # define BDIGIT unsigned int
426 # define SIZEOF_BDIGIT SIZEOF_INT
427 # define BDIGIT_DBL unsigned LONG_LONG
428 # define BDIGIT_DBL_SIGNED LONG_LONG
429 # define PRI_BDIGIT_PREFIX ""
430 # define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX
431 # elif SIZEOF_INT*2 <= SIZEOF_LONG
432 # define BDIGIT unsigned int
433 # define SIZEOF_BDIGIT SIZEOF_INT
434 # define BDIGIT_DBL unsigned long
435 # define BDIGIT_DBL_SIGNED long
436 # define PRI_BDIGIT_PREFIX ""
437 # define PRI_BDIGIT_DBL_PREFIX "l"
438 # elif SIZEOF_SHORT*2 <= SIZEOF_LONG
439 # define BDIGIT unsigned short
440 # define SIZEOF_BDIGIT SIZEOF_SHORT
441 # define BDIGIT_DBL unsigned long
442 # define BDIGIT_DBL_SIGNED long
443 # define PRI_BDIGIT_PREFIX "h"
444 # define PRI_BDIGIT_DBL_PREFIX "l"
445 # else
446 # define BDIGIT unsigned short
447 # define SIZEOF_BDIGIT (SIZEOF_LONG/2)
448 # define SIZEOF_ACTUAL_BDIGIT SIZEOF_LONG
449 # define BDIGIT_DBL unsigned long
450 # define BDIGIT_DBL_SIGNED long
451 # define PRI_BDIGIT_PREFIX "h"
452 # define PRI_BDIGIT_DBL_PREFIX "l"
453 # endif
454 #endif
455 #ifndef SIZEOF_ACTUAL_BDIGIT
456 # define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGIT
457 #endif
458 
459 #ifdef PRI_BDIGIT_PREFIX
460 # define PRIdBDIGIT PRI_BDIGIT_PREFIX"d"
461 # define PRIiBDIGIT PRI_BDIGIT_PREFIX"i"
462 # define PRIoBDIGIT PRI_BDIGIT_PREFIX"o"
463 # define PRIuBDIGIT PRI_BDIGIT_PREFIX"u"
464 # define PRIxBDIGIT PRI_BDIGIT_PREFIX"x"
465 # define PRIXBDIGIT PRI_BDIGIT_PREFIX"X"
466 #endif
467 
468 #ifdef PRI_BDIGIT_DBL_PREFIX
469 # define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d"
470 # define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i"
471 # define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o"
472 # define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u"
473 # define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x"
474 # define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X"
475 #endif
476 
477 #define BIGNUM_EMBED_LEN_NUMBITS 3
478 #ifndef BIGNUM_EMBED_LEN_MAX
479 # if (SIZEOF_VALUE*3/SIZEOF_ACTUAL_BDIGIT) < (1 << BIGNUM_EMBED_LEN_NUMBITS)-1
480 # define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*3/SIZEOF_ACTUAL_BDIGIT)
481 # else
482 # define BIGNUM_EMBED_LEN_MAX ((1 << BIGNUM_EMBED_LEN_NUMBITS)-1)
483 # endif
484 #endif
485 
486 struct RBignum {
487  struct RBasic basic;
488  union {
489  struct {
490  size_t len;
492  } heap;
494  } as;
495 };
496 #define BIGNUM_SIGN_BIT ((VALUE)FL_USER1)
497 /* sign: positive:1, negative:0 */
498 #define BIGNUM_SIGN(b) ((RBASIC(b)->flags & BIGNUM_SIGN_BIT) != 0)
499 #define BIGNUM_SET_SIGN(b,sign) \
500  ((sign) ? (RBASIC(b)->flags |= BIGNUM_SIGN_BIT) \
501  : (RBASIC(b)->flags &= ~BIGNUM_SIGN_BIT))
502 #define BIGNUM_POSITIVE_P(b) BIGNUM_SIGN(b)
503 #define BIGNUM_NEGATIVE_P(b) (!BIGNUM_SIGN(b))
504 #define BIGNUM_NEGATE(b) (RBASIC(b)->flags ^= BIGNUM_SIGN_BIT)
505 
506 #define BIGNUM_EMBED_FLAG ((VALUE)FL_USER2)
507 #define BIGNUM_EMBED_LEN_MASK ((VALUE)(FL_USER5|FL_USER4|FL_USER3))
508 #define BIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+BIGNUM_EMBED_LEN_NUMBITS)
509 #define BIGNUM_LEN(b) \
510  ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
511  (size_t)((RBASIC(b)->flags >> BIGNUM_EMBED_LEN_SHIFT) & \
512  (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT)) : \
513  RBIGNUM(b)->as.heap.len)
514 /* LSB:BIGNUM_DIGITS(b)[0], MSB:BIGNUM_DIGITS(b)[BIGNUM_LEN(b)-1] */
515 #define BIGNUM_DIGITS(b) \
516  ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? \
517  RBIGNUM(b)->as.ary : \
518  RBIGNUM(b)->as.heap.digits)
519 #define BIGNUM_LENINT(b) rb_long2int(BIGNUM_LEN(b))
520 
521 #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
522 
523 struct RRational {
524  struct RBasic basic;
525  const VALUE num;
526  const VALUE den;
527 };
528 
529 #define RRATIONAL(obj) (R_CAST(RRational)(obj))
530 #define RRATIONAL_SET_NUM(rat, n) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->num,(n))
531 #define RRATIONAL_SET_DEN(rat, d) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->den,(d))
532 
533 struct RFloat {
534  struct RBasic basic;
535  double float_value;
536 };
537 
538 #define RFLOAT(obj) (R_CAST(RFloat)(obj))
539 
540 struct RComplex {
541  struct RBasic basic;
542  const VALUE real;
543  const VALUE imag;
544 };
545 
546 #define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
547 
548 #ifdef RCOMPLEX_SET_REAL /* shortcut macro for internal only */
549 #undef RCOMPLEX_SET_REAL
550 #undef RCOMPLEX_SET_IMAG
551 #define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r))
552 #define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i))
553 #endif
554 
555 struct RHash {
556  struct RBasic basic;
557  struct st_table *ntbl; /* possibly 0 */
558  int iter_lev;
559  const VALUE ifnone;
560 };
561 
562 #define RHASH(obj) (R_CAST(RHash)(obj))
563 
564 #ifdef RHASH_ITER_LEV
565 #undef RHASH_ITER_LEV
566 #undef RHASH_IFNONE
567 #undef RHASH_SIZE
568 #define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
569 #define RHASH_IFNONE(h) (RHASH(h)->ifnone)
570 #define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : (st_index_t)0)
571 #endif
572 
573 /* missing/setproctitle.c */
574 #ifndef HAVE_SETPROCTITLE
575 extern void ruby_init_setproctitle(int argc, char *argv[]);
576 #endif
577 
578 #define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX
579 #define RSTRUCT_EMBED_LEN_MASK RSTRUCT_EMBED_LEN_MASK
580 #define RSTRUCT_EMBED_LEN_SHIFT RSTRUCT_EMBED_LEN_SHIFT
581 enum {
583  RSTRUCT_EMBED_LEN_MASK = (RUBY_FL_USER2|RUBY_FL_USER1),
585 
587 };
588 
589 struct RStruct {
590  struct RBasic basic;
591  union {
592  struct {
593  long len;
594  const VALUE *ptr;
595  } heap;
597  } as;
598 };
599 
600 #undef RSTRUCT_LEN
601 #undef RSTRUCT_PTR
602 #undef RSTRUCT_SET
603 #undef RSTRUCT_GET
604 #define RSTRUCT_EMBED_LEN(st) \
605  (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
606  (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT))
607 #define RSTRUCT_LEN(st) rb_struct_len(st)
608 #define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
609 #define RSTRUCT_CONST_PTR(st) rb_struct_const_ptr(st)
610 #define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(STRUCT, st)))
611 #define RSTRUCT_SET(st, idx, v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v))
612 #define RSTRUCT_GET(st, idx) (RSTRUCT_CONST_PTR(st)[idx])
613 #define RSTRUCT(obj) (R_CAST(RStruct)(obj))
614 
615 static inline long
617 {
618  return (RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ?
619  RSTRUCT_EMBED_LEN(st) : RSTRUCT(st)->as.heap.len;
620 }
621 
622 static inline const VALUE *
624 {
625  return FIX_CONST_VALUE_PTR((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ?
626  RSTRUCT(st)->as.ary : RSTRUCT(st)->as.heap.ptr);
627 }
628 
629 /* class.c */
630 
632  char conflict[sizeof(VALUE) * 3];
633 };
634 
635 struct rb_subclass_entry;
637 
641 };
642 
643 #if defined(HAVE_LONG_LONG)
644 typedef unsigned LONG_LONG rb_serial_t;
645 #define SERIALT2NUM ULL2NUM
646 #elif defined(HAVE_UINT64_T)
647 typedef uint64_t rb_serial_t;
648 #define SERIALT2NUM SIZET2NUM
649 #else
650 typedef unsigned long rb_serial_t;
651 #define SERIALT2NUM ULONG2NUM
652 #endif
653 
656  struct st_table *iv_tbl;
657  struct rb_id_table *const_tbl;
658  struct rb_id_table *callable_m_tbl;
667  rb_serial_t class_serial;
668  const VALUE origin_;
671 };
672 
674 
675 #undef RClass
676 struct RClass {
677  struct RBasic basic;
680  struct rb_id_table *m_tbl;
681 };
682 
683 void rb_class_subclass_add(VALUE super, VALUE klass);
686 
687 #define RCLASS_EXT(c) (RCLASS(c)->ptr)
688 #define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
689 #define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
690 #define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
691 #define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
692 #define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
693 #define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)
694 #define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
695 #define RCLASS_SERIAL(c) (RCLASS_EXT(c)->class_serial)
696 
697 #define RICLASS_IS_ORIGIN FL_USER5
698 
699 static inline void
701 {
702  RB_OBJ_WRITE(klass, &RCLASS_ORIGIN(klass), origin);
703  if (klass != origin) FL_SET(origin, RICLASS_IS_ORIGIN);
704 }
705 
706 #undef RCLASS_SUPER
707 static inline VALUE
709 {
710  return RCLASS(klass)->super;
711 }
712 
713 static inline VALUE
715 {
716  if (super) {
718  rb_class_subclass_add(super, klass);
719  }
720  RB_OBJ_WRITE(klass, &RCLASS(klass)->super, super);
721  return super;
722 }
723 /* IMEMO: Internal memo object */
724 
725 #ifndef IMEMO_DEBUG
726 #define IMEMO_DEBUG 0
727 #endif
728 
729 struct RIMemo {
735 };
736 
746  imemo_mask = 0x07
747 };
748 
749 static inline enum imemo_type
751 {
752  return (RBASIC(imemo)->flags >> FL_USHIFT) & imemo_mask;
753 }
754 
755 /* FL_USER0 to FL_USER2 is for type */
756 #define IMEMO_FL_USHIFT (FL_USHIFT + 3)
757 #define IMEMO_FL_USER0 FL_USER3
758 #define IMEMO_FL_USER1 FL_USER4
759 #define IMEMO_FL_USER2 FL_USER5
760 #define IMEMO_FL_USER3 FL_USER6
761 #define IMEMO_FL_USER4 FL_USER7
762 
763 /* CREF in method.h */
764 
765 /* SVAR */
766 
767 struct vm_svar {
771  const VALUE backref;
772  const VALUE others;
773 };
774 
775 /* THROW_DATA */
776 
777 #define THROW_DATA_CONSUMED IMEMO_FL_USER0
778 
785 };
786 
787 #define THROW_DATA_P(err) RB_TYPE_P(((VALUE)err), T_IMEMO)
788 
789 /* IFUNC */
790 
792 #if SIZEOF_INT * 2 > SIZEOF_VALUE
793  int min: (SIZEOF_VALUE * CHAR_BIT) / 2;
794  int max: (SIZEOF_VALUE * CHAR_BIT) / 2;
795 #else
796  int min, max;
797 #endif
798 };
799 
800 struct vm_ifunc {
804  const void *data;
806 };
807 
808 #define IFUNC_NEW(a, b, c) ((struct vm_ifunc *)rb_imemo_new(imemo_ifunc, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
809 struct vm_ifunc *rb_vm_ifunc_new(VALUE (*func)(ANYARGS), const void *data, int min_argc, int max_argc);
810 static inline struct vm_ifunc *
812 {
813  return rb_vm_ifunc_new(func, data, 0, UNLIMITED_ARGUMENTS);
814 }
815 
816 /* MEMO */
817 
818 struct MEMO {
821  const VALUE v1;
822  const VALUE v2;
823  union {
824  long cnt;
825  long state;
826  const VALUE value;
828  } u3;
829 };
830 
831 #define MEMO_V1_SET(m, v) RB_OBJ_WRITE((m), &(m)->v1, (v))
832 #define MEMO_V2_SET(m, v) RB_OBJ_WRITE((m), &(m)->v2, (v))
833 
834 #define MEMO_CAST(m) ((struct MEMO *)m)
835 
836 #define MEMO_NEW(a, b, c) ((struct MEMO *)rb_imemo_new(imemo_memo, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
837 
838 #define roomof(x, y) (((x) + (y) - 1) / (y))
839 #define type_roomof(x, y) roomof(sizeof(x), sizeof(y))
840 #define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
841 #define NEW_MEMO_FOR(type, value) \
842  ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
843 #define NEW_PARTIAL_MEMO_FOR(type, value, member) \
844  ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), \
845  rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), \
846  MEMO_FOR(type, value))
847 
848 #define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
849 
850 #ifdef RUBY_INTEGER_UNIFICATION
851 # define rb_cFixnum rb_cInteger
852 # define rb_cBignum rb_cInteger
853 #endif
854 
855 enum {
859 };
860 
861 struct cmp_opt_data {
862  unsigned int opt_methods;
863  unsigned int opt_inited;
864 };
865 
866 #define NEW_CMP_OPT_MEMO(type, value) \
867  NEW_PARTIAL_MEMO_FOR(type, value, cmp_opt)
868 #define CMP_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(cmp_opt_,type))
869 #define CMP_OPTIMIZABLE(data, type) \
870  (((data).opt_inited & CMP_OPTIMIZABLE_BIT(type)) ? \
871  ((data).opt_methods & CMP_OPTIMIZABLE_BIT(type)) : \
872  (((data).opt_inited |= CMP_OPTIMIZABLE_BIT(type)), \
873  rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && \
874  ((data).opt_methods |= CMP_OPTIMIZABLE_BIT(type))))
875 
876 #define OPTIMIZED_CMP(a, b, data) \
877  ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(data, Fixnum)) ? \
878  (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : \
879  (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(data, String)) ? \
880  rb_str_cmp(a, b) : \
881  rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
882 
883 /* ment is in method.h */
884 
885 /* global variable */
886 
890 };
891 
896 
897 struct vtm; /* defined by timev.h */
898 
899 /* array.c */
900 VALUE rb_ary_last(int, const VALUE *, VALUE);
901 void rb_ary_set_len(VALUE, long);
903 VALUE rb_ary_tmp_new_fill(long capa);
905 size_t rb_ary_memsize(VALUE);
906 #ifdef __GNUC__
907 #define rb_ary_new_from_args(n, ...) \
908  __extension__ ({ \
909  const VALUE args_to_new_ary[] = {__VA_ARGS__}; \
910  if (__builtin_constant_p(n)) { \
911  STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); \
912  } \
913  rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); \
914  })
915 #endif
916 
917 /* bignum.c */
918 extern const char ruby_digitmap[];
919 double rb_big_fdiv_double(VALUE x, VALUE y);
924 size_t rb_big_size(VALUE);
927 VALUE rb_cstr_parse_inum(const char *str, ssize_t len, char **endp, int base);
934 VALUE rb_big_gt(VALUE x, VALUE y);
935 VALUE rb_big_ge(VALUE x, VALUE y);
936 VALUE rb_big_lt(VALUE x, VALUE y);
937 VALUE rb_big_le(VALUE x, VALUE y);
938 
939 /* class.c */
944 void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE);
948 VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj);
949 VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj);
950 VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj);
951 VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj);
956 void Init_class_hierarchy(void);
957 
959 void rb_undef_methods_from(VALUE klass, VALUE super);
960 
961 /* compar.c */
963 
964 /* compile.c */
965 struct rb_block;
966 int rb_dvar_defined(ID, const struct rb_block *);
967 int rb_local_defined(ID, const struct rb_block *);
968 CONSTFUNC(const char * rb_insns_name(int i));
970 
971 /* complex.c */
976 
977 /* cont.c */
980 void ruby_register_rollback_func_for_ensure(VALUE (*ensure_func)(ANYARGS), VALUE (*rollback_func)(ANYARGS));
981 
982 /* debug.c */
983 PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
984 
985 /* dmyext.c */
986 void Init_enc(void);
987 void Init_ext(void);
988 
989 /* encoding.c */
990 ID rb_id_encoding(void);
991 CONSTFUNC(void rb_gc_mark_encodings(void));
994 int rb_encdb_replicate(const char *alias, const char *orig);
995 int rb_encdb_alias(const char *alias, const char *orig);
996 int rb_encdb_dummy(const char *name);
997 void rb_encdb_declare(const char *name);
998 void rb_enc_set_base(const char *name, const char *orig);
999 int rb_enc_set_dummy(int index);
1000 void rb_encdb_set_unicode(int index);
1002 
1003 /* enum.c */
1004 VALUE rb_f_send(int argc, VALUE *argv, VALUE recv);
1005 VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary);
1006 
1007 /* error.c */
1008 extern VALUE rb_eEAGAIN;
1009 extern VALUE rb_eEWOULDBLOCK;
1010 extern VALUE rb_eEINPROGRESS;
1011 void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args);
1012 PRINTF_ARGS(void rb_compile_error_str(VALUE file, int line, void *enc, const char *fmt, ...), 4, 5);
1013 VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding*, const char*, va_list);
1015 NORETURN(void rb_async_bug_errno(const char *,int));
1016 const char *rb_builtin_type_name(int t);
1017 const char *rb_builtin_class_name(VALUE x);
1018 PRINTF_ARGS(void rb_enc_warn(rb_encoding *enc, const char *fmt, ...), 2, 3);
1019 PRINTF_ARGS(void rb_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
1020 PRINTF_ARGS(void rb_sys_enc_warning(rb_encoding *enc, const char *fmt, ...), 2, 3);
1021 VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method);
1022 #define rb_name_err_raise_str(mesg, recv, name) \
1023  rb_exc_raise(rb_name_err_new(mesg, recv, name))
1024 #define rb_name_err_raise(mesg, recv, name) \
1025  rb_name_err_raise_str(rb_fstring_cstr(mesg), (recv), (name))
1026 NORETURN(void ruby_only_for_internal_use(const char *));
1027 #define ONLY_FOR_INTERNAL_USE(func) ruby_only_for_internal_use(func)
1028 
1029 /* eval.c */
1031 
1032 /* eval_error.c */
1033 void ruby_error_print(void);
1035 
1036 /* eval_jump.c */
1037 void rb_call_end_proc(VALUE data);
1038 void rb_mark_end_proc(void);
1039 
1040 /* file.c */
1043 VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
1044 void rb_file_const(const char*, VALUE);
1045 int rb_file_load_ok(const char *);
1050 void Init_File(void);
1051 int ruby_is_fd_loadable(int fd);
1052 
1053 #ifdef RUBY_FUNCTION_NAME_STRING
1054 # if defined __GNUC__ && __GNUC__ >= 4
1055 # pragma GCC visibility push(default)
1056 # endif
1057 NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
1058 NORETURN(void rb_syserr_fail_path_in(const char *func_name, int err, VALUE path));
1059 # if defined __GNUC__ && __GNUC__ >= 4
1060 # pragma GCC visibility pop
1061 # endif
1062 # define rb_sys_fail_path(path) rb_sys_fail_path_in(RUBY_FUNCTION_NAME_STRING, path)
1063 # define rb_syserr_fail_path(err, path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
1064 #else
1065 # define rb_sys_fail_path(path) rb_sys_fail_str(path)
1066 # define rb_syserr_fail_path(err, path) rb_syserr_fail_str((err), (path))
1067 #endif
1068 
1069 /* gc.c */
1071 extern int ruby_disable_gc;
1072 void Init_heap(void);
1073 void *ruby_mimmalloc(size_t size);
1074 void ruby_mimfree(void *ptr);
1076 #if USE_RGENGC
1078 #else
1079 #define rb_gc_writebarrier_remember(obj) 0
1080 #endif
1081 void ruby_gc_set_params(int safe_level);
1083 
1084 #if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
1085 #define ruby_sized_xrealloc(ptr, new_size, old_size) ruby_xrealloc(ptr, new_size)
1086 #define ruby_sized_xrealloc2(ptr, new_count, element_size, old_count) ruby_xrealloc(ptr, new_count, element_size)
1087 #define ruby_sized_xfree(ptr, size) ruby_xfree(ptr)
1088 #define SIZED_REALLOC_N(var,type,n,old_n) REALLOC_N(var, type, n)
1089 #else
1090 void *ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_ALLOC_SIZE((2));
1091 void *ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_ALLOC_SIZE((2, 3));
1092 void ruby_sized_xfree(void *x, size_t size);
1093 #define SIZED_REALLOC_N(var,type,n,old_n) ((var)=(type*)ruby_sized_xrealloc((char*)(var), (n) * sizeof(type), (old_n) * sizeof(type)))
1094 #endif
1095 
1096 void rb_gc_resurrect(VALUE ptr);
1097 
1098 /* optimized version of NEWOBJ() */
1099 #undef NEWOBJF_OF
1100 #undef RB_NEWOBJ_OF
1101 #define RB_NEWOBJ_OF(obj,type,klass,flags) \
1102  type *(obj) = (type*)(((flags) & FL_WB_PROTECTED) ? \
1103  rb_wb_protected_newobj_of(klass, (flags) & ~FL_WB_PROTECTED) : \
1104  rb_wb_unprotected_newobj_of(klass, flags))
1105 #define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags)
1106 
1107 /* hash.c */
1112 long rb_objid_hash(st_index_t index);
1113 long rb_dbl_long_hash(double d);
1117 
1118 #define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h)
1123 #define HASH_DELETED FL_USER1
1124 #define HASH_PROC_DEFAULT FL_USER2
1125 
1126 /* inits.c */
1127 void rb_call_inits(void);
1128 
1129 /* io.c */
1130 const char *ruby_get_inplace_mode(void);
1131 void ruby_set_inplace_mode(const char *);
1132 ssize_t rb_io_bufread(VALUE io, void *buf, size_t size);
1135 size_t rb_io_memsize(const rb_io_t *);
1136 
1137 /* load.c */
1138 VALUE rb_get_load_path(void);
1140 int rb_require_internal(VALUE fname, int safe);
1141 NORETURN(void rb_load_fail(VALUE, const char*));
1142 
1143 /* loadpath.c */
1144 extern const char ruby_exec_prefix[];
1145 extern const char ruby_initial_load_paths[];
1146 
1147 /* localeinit.c */
1149 
1150 /* math.c */
1156 VALUE rb_math_log(int argc, const VALUE *argv);
1160 
1161 /* newline.c */
1162 void Init_newline(void);
1163 
1164 /* numeric.c */
1165 
1166 #define FIXNUM_POSITIVE_P(num) ((SIGNED_VALUE)(num) > (SIGNED_VALUE)INT2FIX(0))
1167 #define FIXNUM_NEGATIVE_P(num) ((SIGNED_VALUE)(num) < 0)
1168 #define FIXNUM_ZERO_P(num) ((num) == INT2FIX(0))
1169 
1170 #define INT_NEGATIVE_P(x) (FIXNUM_P(x) ? FIXNUM_NEGATIVE_P(x) : BIGNUM_NEGATIVE_P(x))
1171 
1172 #ifndef ROUND_DEFAULT
1173 # define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP
1174 #endif
1180 };
1181 #define ROUND_TO(mode, even, up, down) \
1182  ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : \
1183  (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down)
1184 #define ROUND_FUNC(mode, name) \
1185  ROUND_TO(mode, name##_half_even, name##_half_up, name##_half_down)
1186 #define ROUND_CALL(mode, name, args) \
1187  ROUND_TO(mode, name##_half_even args, \
1188  name##_half_up args, name##_half_down args)
1189 
1190 int rb_num_to_uint(VALUE val, unsigned int *ret);
1191 VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
1192 int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl);
1193 double ruby_float_mod(double x, double y);
1195 VALUE rb_int_succ(VALUE num);
1196 VALUE rb_int_pred(VALUE num);
1201 VALUE rb_int_mul(VALUE x, VALUE y);
1204 VALUE rb_int_round(VALUE num, int ndigits, enum ruby_num_rounding_mode mode);
1205 VALUE rb_int2str(VALUE num, int base);
1206 VALUE rb_dbl_hash(double d);
1208 VALUE rb_int_gt(VALUE x, VALUE y);
1210 VALUE rb_int_ge(VALUE x, VALUE y);
1212 double rb_int_fdiv_double(VALUE x, VALUE y);
1213 VALUE rb_int_pow(VALUE x, VALUE y);
1215 VALUE rb_int_cmp(VALUE x, VALUE y);
1218 VALUE rb_int_and(VALUE x, VALUE y);
1220 VALUE rb_int_div(VALUE x, VALUE y);
1221 VALUE rb_int_abs(VALUE num);
1222 VALUE rb_float_abs(VALUE flt);
1223 
1224 #if USE_FLONUM
1225 #define RUBY_BIT_ROTL(v, n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
1226 #define RUBY_BIT_ROTR(v, n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
1227 #endif
1228 
1229 static inline double
1231 {
1232 #if USE_FLONUM
1233  if (v != (VALUE)0x8000000000000002) { /* LIKELY */
1234  union {
1235  double d;
1236  VALUE v;
1237  } t;
1238 
1239  VALUE b63 = (v >> 63);
1240  /* e: xx1... -> 011... */
1241  /* xx0... -> 100... */
1242  /* ^b63 */
1243  t.v = RUBY_BIT_ROTR((2 - b63) | (v & ~(VALUE)0x03), 3);
1244  return t.d;
1245  }
1246 #endif
1247  return 0.0;
1248 }
1249 
1250 static inline double
1252 {
1253  return ((struct RFloat *)v)->float_value;
1254 }
1255 
1256 static inline double
1258 {
1259  if (FLONUM_P(v)) {
1260  return rb_float_flonum_value(v);
1261  }
1262  return rb_float_noflonum_value(v);
1263 }
1264 
1265 static inline VALUE
1267 {
1268 #if USE_FLONUM
1269  union {
1270  double d;
1271  VALUE v;
1272  } t;
1273  int bits;
1274 
1275  t.d = d;
1276  bits = (int)((VALUE)(t.v >> 60) & 0x7);
1277  /* bits contains 3 bits of b62..b60. */
1278  /* bits - 3 = */
1279  /* b011 -> b000 */
1280  /* b100 -> b001 */
1281 
1282  if (t.v != 0x3000000000000000 /* 1.72723e-77 */ &&
1283  !((bits-3) & ~0x01)) {
1284  return (RUBY_BIT_ROTL(t.v, 3) & ~(VALUE)0x01) | 0x02;
1285  }
1286  else if (t.v == (VALUE)0) {
1287  /* +0.0 */
1288  return 0x8000000000000002;
1289  }
1290  /* out of range */
1291 #endif
1292  return rb_float_new_in_heap(d);
1293 }
1294 
1295 #define rb_float_value(v) rb_float_value_inline(v)
1296 #define rb_float_new(d) rb_float_new_inline(d)
1297 
1298 /* object.c */
1299 void rb_obj_copy_ivar(VALUE dest, VALUE obj);
1300 CONSTFUNC(VALUE rb_obj_equal(VALUE obj1, VALUE obj2));
1303 NORETURN(void rb_undefined_alloc(VALUE klass));
1304 double rb_num_to_dbl(VALUE val);
1305 VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound);
1306 
1307 struct RBasicRaw {
1310 };
1311 
1312 #define RBASIC_CLEAR_CLASS(obj) memset(&(((struct RBasicRaw *)((VALUE)(obj)))->klass), 0, sizeof(VALUE))
1313 #define RBASIC_SET_CLASS_RAW(obj, cls) memcpy(&((struct RBasicRaw *)((VALUE)(obj)))->klass, &(cls), sizeof(VALUE))
1314 #define RBASIC_SET_CLASS(obj, cls) do { \
1315  VALUE _obj_ = (obj); \
1316  RB_OBJ_WRITE(_obj_, &((struct RBasicRaw *)(_obj_))->klass, cls); \
1317 } while (0)
1318 
1319 /* parse.y */
1320 #ifndef USE_SYMBOL_GC
1321 #define USE_SYMBOL_GC 1
1322 #endif
1325 VALUE rb_parser_set_context(VALUE, const struct rb_block *, int);
1326 void *rb_parser_load_file(VALUE parser, VALUE name);
1341 PUREFUNC(int rb_is_method_sym(VALUE sym));
1343 ID rb_make_internal_id(void);
1345 ID rb_id_attrget(ID id);
1346 
1347 /* proc.c */
1350 int rb_block_arity(void);
1351 int rb_block_min_max_arity(int *max);
1353 VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc);
1354 
1355 /* process.c */
1356 #define RB_MAX_GROUPS (65536)
1357 
1358 struct rb_execarg {
1359  union {
1360  struct {
1362  } sh;
1363  struct {
1365  VALUE command_abspath; /* full path string or nil */
1368  } cmd;
1369  } invoke;
1374  unsigned use_shell : 1;
1375  unsigned pgroup_given : 1;
1376  unsigned umask_given : 1;
1378  unsigned unsetenv_others_do : 1;
1379  unsigned close_others_given : 1;
1380  unsigned close_others_do : 1;
1381  unsigned chdir_given : 1;
1382  unsigned new_pgroup_given : 1;
1383  unsigned new_pgroup_flag : 1;
1384  unsigned uid_given : 1;
1385  unsigned gid_given : 1;
1386  rb_pid_t pgroup_pgid; /* asis(-1), new pgroup(0), specified pgroup (0<V). */
1387  VALUE rlimit_limits; /* Qfalse or [[rtype, softlim, hardlim], ...] */
1389  rb_uid_t uid;
1390  rb_gid_t gid;
1396  VALUE env_modification; /* Qfalse or [[k1,v1], ...] */
1399 };
1400 
1401 /* argv_str contains extra two elements.
1402  * The beginning one is for /bin/sh used by exec_with_sh.
1403  * The last one for terminating NULL used by execve.
1404  * See rb_exec_fillarg() in process.c. */
1405 #define ARGVSTR2ARGC(argv_str) (RSTRING_LEN(argv_str) / sizeof(char *) - 2)
1406 #define ARGVSTR2ARGV(argv_str) ((char **)RSTRING_PTR(argv_str) + 1)
1407 
1408 rb_pid_t rb_fork_ruby(int *status);
1409 void rb_last_status_clear(void);
1410 
1411 /* rational.c */
1413 VALUE rb_rational_plus(VALUE self, VALUE other);
1414 VALUE rb_lcm(VALUE x, VALUE y);
1416 VALUE rb_cstr_to_rat(const char *, int);
1418 VALUE rb_rational_cmp(VALUE self, VALUE other);
1419 
1420 /* re.c */
1421 VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
1423 long rb_reg_search0(VALUE, VALUE, long, int, int);
1424 VALUE rb_reg_match_p(VALUE re, VALUE str, long pos);
1425 void rb_backref_set_string(VALUE string, long pos, long len);
1427 int rb_match_nth_defined(int nth, VALUE match);
1428 
1429 /* signal.c */
1430 extern int ruby_enable_coredump;
1431 int rb_get_next_signal(void);
1432 int rb_sigaltstack_size(void);
1433 
1434 /* strftime.c */
1435 #ifdef RUBY_ENCODING_H
1436 VALUE rb_strftime_timespec(const char *format, size_t format_len, rb_encoding *enc,
1437  const struct vtm *vtm, struct timespec *ts, int gmt);
1438 VALUE rb_strftime(const char *format, size_t format_len, rb_encoding *enc,
1439  const struct vtm *vtm, VALUE timev, int gmt);
1440 #endif
1441 
1442 /* string.c */
1444 VALUE rb_fstring_new(const char *ptr, long len);
1445 #define rb_fstring_lit(str) rb_fstring_new((str), rb_strlen_lit(str))
1446 #define rb_fstring_literal(str) rb_fstring_lit(str)
1447 VALUE rb_fstring_cstr(const char *str);
1448 #ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
1449 # define rb_fstring_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
1450  (__builtin_constant_p(str)) ? \
1451  rb_fstring_new((str), (long)strlen(str)) : \
1452  rb_fstring_cstr(str) \
1453 )
1454 #endif
1455 #ifdef RUBY_ENCODING_H
1456 VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);
1457 #define rb_fstring_enc_lit(str, enc) rb_fstring_enc_new((str), rb_strlen_lit(str), (enc))
1458 #define rb_fstring_enc_literal(str, enc) rb_fstring_enc_lit(str, enc)
1459 VALUE rb_fstring_enc_cstr(const char *ptr, rb_encoding *enc);
1460 # ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
1461 # define rb_fstring_enc_cstr(str, enc) RB_GNUC_EXTENSION_BLOCK( \
1462  (__builtin_constant_p(str)) ? \
1463  rb_fstring_enc_new((str), (long)strlen(str), (enc)) : \
1464  rb_fstring_enc_cstr(str, enc) \
1465 )
1466 # endif
1467 #endif
1468 int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
1469 int rb_str_symname_p(VALUE);
1472 #define QUOTE(str) rb_str_quote_unprintable(str)
1473 #define QUOTE_ID(id) rb_id_quote_unprintable(id)
1474 char *rb_str_fill_terminator(VALUE str, const int termlen);
1475 void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen);
1478 void rb_str_tmp_frozen_release(VALUE str, VALUE tmp);
1479 VALUE rb_str_chomp_string(VALUE str, VALUE chomp);
1480 #ifdef RUBY_ENCODING_H
1482 VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
1483  rb_encoding *from, int ecflags, VALUE ecopts);
1484 VALUE rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl);
1485 #endif
1486 #define STR_NOEMBED FL_USER1
1487 #define STR_SHARED FL_USER2 /* = ELTS_SHARED */
1488 #define STR_EMBED_P(str) (!FL_TEST_RAW((str), STR_NOEMBED))
1489 #define STR_SHARED_P(s) FL_ALL_RAW((s), STR_NOEMBED|ELTS_SHARED)
1490 #define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
1491 #define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
1492 size_t rb_str_memsize(VALUE);
1493 VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, VALUE passed_proc);
1495 
1496 /* symbol.c */
1497 #ifdef RUBY_ENCODING_H
1498 VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc);
1499 VALUE rb_sym_intern_cstr(const char *ptr, rb_encoding *enc);
1500 #ifdef __GNUC__
1501 #define rb_sym_intern_cstr(ptr, enc) __extension__ ( \
1502 { \
1503  (__builtin_constant_p(ptr)) ? \
1504  rb_sym_intern((ptr), (long)strlen(ptr), (enc)) : \
1505  rb_sym_intern_cstr((ptr), (enc)); \
1506 })
1507 #endif
1508 #endif
1509 VALUE rb_sym_intern_ascii(const char *ptr, long len);
1510 VALUE rb_sym_intern_ascii_cstr(const char *ptr);
1511 #ifdef __GNUC__
1512 #define rb_sym_intern_ascii_cstr(ptr) __extension__ ( \
1513 { \
1514  (__builtin_constant_p(ptr)) ? \
1515  rb_sym_intern_ascii((ptr), (long)strlen(ptr)) : \
1516  rb_sym_intern_ascii_cstr(ptr); \
1517 })
1518 #endif
1519 
1520 /* struct.c */
1523 
1524 /* time.c */
1525 struct timeval rb_time_timeval(VALUE);
1526 
1527 /* thread.c */
1531 void rb_clear_trace_func(void);
1532 VALUE rb_get_coverages(void);
1537 int rb_thread_to_be_killed(VALUE thread);
1538 void rb_mutex_allow_trap(VALUE self, int val);
1539 VALUE rb_uninterruptible(VALUE (*b_proc)(ANYARGS), VALUE data);
1541 void ruby_kill(rb_pid_t pid, int sig);
1542 
1543 /* thread_pthread.c, thread_win32.c */
1544 void Init_native_thread(void);
1545 int rb_divert_reserved_fd(int fd);
1546 
1547 /* transcode.c */
1549 size_t rb_econv_memsize(rb_econv_t *);
1550 
1551 /* us_ascii.c */
1553 
1554 /* util.c */
1555 char *ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve);
1556 char *ruby_hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rve);
1557 
1558 /* utf_8.c */
1560 
1561 /* variable.c */
1562 void rb_gc_mark_global_tbl(void);
1566 VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef);
1567 void rb_autoload_str(VALUE mod, ID id, VALUE file);
1568 void rb_deprecate_constant(VALUE mod, const char *name);
1569 
1570 /* version.c */
1571 extern const char ruby_engine[];
1572 
1573 /* vm_insnhelper.h */
1574 rb_serial_t rb_next_class_serial(void);
1575 
1576 /* vm.c */
1578 void rb_vm_mark(void *ptr);
1579 void Init_BareVM(void);
1580 void Init_vm_objects(void);
1583 void rb_vm_change_state(void);
1585 void rb_thread_mark(void *th);
1586 const void **rb_vm_get_insns_address_table(void);
1587 VALUE rb_sourcefilename(void);
1588 VALUE rb_source_location(int *pline);
1589 const char *rb_source_loc(int *pline);
1590 void rb_vm_pop_cfunc_frame(void);
1591 int rb_vm_add_root_module(ID id, VALUE module);
1593 VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements);
1596 
1597 
1598 /* vm_dump.c */
1599 void rb_print_backtrace(void);
1600 
1601 /* vm_eval.c */
1602 void Init_vm_eval(void);
1605 typedef void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE);
1606 VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, const VALUE *argv,
1607  rb_check_funcall_hook *hook, VALUE arg);
1609 VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, int *stateptr);
1611 VALUE rb_yield_lambda(VALUE values);
1612 VALUE rb_lambda_call(VALUE obj, ID mid, int argc, const VALUE *argv,
1613  rb_block_call_func_t bl_proc, int min_argc, int max_argc,
1614  VALUE data2);
1615 
1616 /* vm_insnhelper.c */
1617 VALUE rb_equal_opt(VALUE obj1, VALUE obj2);
1618 
1619 /* vm_method.c */
1620 void Init_eval_method(void);
1621 int rb_method_defined_by(VALUE obj, ID mid, VALUE (*cfunc)(ANYARGS));
1622 
1623 /* miniprelude.c, prelude.c */
1624 void Init_prelude(void);
1625 
1626 /* vm_backtrace.c */
1627 void Init_vm_backtrace(void);
1628 VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval);
1629 VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval);
1630 
1631 VALUE rb_make_backtrace(void);
1633 int rb_backtrace_p(VALUE obj);
1638 
1640 const char *rb_objspace_data_type_name(VALUE obj);
1641 
1642 /* Temporary. This API will be removed (renamed). */
1644 
1645 /* bignum.c (export) */
1652 VALUE rb_big2str_poweroftwo(VALUE x, int base);
1653 VALUE rb_big2str_generic(VALUE x, int base);
1654 VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck);
1655 VALUE rb_str2big_normal(VALUE arg, int base, int badcheck);
1656 VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck);
1657 #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
1658 VALUE rb_big_mul_gmp(VALUE x, VALUE y);
1659 VALUE rb_big_divrem_gmp(VALUE x, VALUE y);
1660 VALUE rb_big2str_gmp(VALUE x, int base);
1661 VALUE rb_str2big_gmp(VALUE arg, int base, int badcheck);
1662 #endif
1663 
1664 /* error.c (export) */
1665 int rb_bug_reporter_add(void (*func)(FILE *, void *), void *data);
1666 NORETURN(void rb_unexpected_type(VALUE,int));
1667 #undef Check_Type
1668 #define Check_Type(v, t) \
1669  (!RB_TYPE_P((VALUE)(v), (t)) || \
1670  ((t) == RUBY_T_DATA && RTYPEDDATA_P(v)) ? \
1671  rb_unexpected_type((VALUE)(v), (t)) : (void)0)
1672 
1673 /* file.c (export) */
1674 #ifdef HAVE_READLINK
1675 VALUE rb_readlink(VALUE path, rb_encoding *enc);
1676 #endif
1677 #ifdef __APPLE__
1678 VALUE rb_str_normalize_ospath(const char *ptr, long len);
1679 #endif
1680 
1681 /* hash.c (export) */
1683 VALUE rb_ident_hash_new(void);
1684 
1685 /* io.c (export) */
1686 void rb_maygvl_fd_fix_cloexec(int fd);
1687 int rb_gc_for_fd(int err);
1688 void rb_write_error_str(VALUE mesg);
1689 
1690 /* numeric.c (export) */
1691 VALUE rb_int_positive_pow(long x, unsigned long y);
1692 
1693 /* process.c (export) */
1694 int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen);
1695 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);
1696 VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell);
1697 struct rb_execarg *rb_execarg_get(VALUE execarg_obj); /* dangerous. needs GC guard. */
1698 VALUE rb_execarg_init(int argc, const VALUE *argv, int accept_shell, VALUE execarg_obj);
1699 int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val);
1700 void rb_execarg_parent_start(VALUE execarg_obj);
1701 void rb_execarg_parent_end(VALUE execarg_obj);
1702 int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char* errmsg, size_t errmsg_buflen);
1703 VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash);
1704 void rb_execarg_setenv(VALUE execarg_obj, VALUE env);
1705 
1706 /* rational.c (export) */
1707 VALUE rb_gcd(VALUE x, VALUE y);
1708 VALUE rb_gcd_normal(VALUE self, VALUE other);
1709 #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
1710 VALUE rb_gcd_gmp(VALUE x, VALUE y);
1711 #endif
1712 
1713 /* string.c (export) */
1714 #ifdef RUBY_ENCODING_H
1715 /* internal use */
1716 VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
1717 #endif
1718 
1719 /* thread.c (export) */
1720 int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
1721 
1722 /* util.c (export) */
1723 extern const signed char ruby_digit36_to_number_table[];
1724 extern const char ruby_hexdigits[];
1725 extern unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow);
1726 
1727 /* variable.c (export) */
1730 int rb_class_ivar_set(VALUE klass, ID vid, VALUE value);
1731 st_table *rb_st_copy(VALUE obj, struct st_table *orig_tbl);
1732 
1733 /* gc.c (export) */
1736 
1737 size_t rb_obj_memsize_of(VALUE);
1739 
1740 #define RB_OBJ_GC_FLAGS_MAX 5
1741 size_t rb_obj_gc_flags(VALUE, ID[], size_t);
1742 void rb_gc_mark_values(long n, const VALUE *values);
1743 
1744 #if IMEMO_DEBUG
1745 VALUE rb_imemo_new_debug(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0, const char *file, int line);
1746 #define rb_imemo_new(type, v1, v2, v3, v0) rb_imemo_new_debug(type, v1, v2, v3, v0, __FILE__, __LINE__)
1747 #else
1748 VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0);
1749 #endif
1750 
1752 
1753 #define RUBY_DTRACE_CREATE_HOOK(name, arg) \
1754  RUBY_DTRACE_HOOK(name##_CREATE, arg)
1755 #define RUBY_DTRACE_HOOK(name, arg) \
1756 do { \
1757  if (UNLIKELY(RUBY_DTRACE_##name##_ENABLED())) { \
1758  int dtrace_line; \
1759  const char *dtrace_file = rb_source_loc(&dtrace_line); \
1760  if (!dtrace_file) dtrace_file = ""; \
1761  RUBY_DTRACE_##name(arg, dtrace_file, dtrace_line); \
1762  } \
1763 } while (0)
1764 
1765 #define RB_OBJ_BUILTIN_TYPE(obj) rb_obj_builtin_type(obj)
1766 #define OBJ_BUILTIN_TYPE(obj) RB_OBJ_BUILTIN_TYPE(obj)
1767 #ifdef __GNUC__
1768 #define rb_obj_builtin_type(obj) \
1769 __extension__({ \
1770  VALUE arg_obj = (obj); \
1771  RB_SPECIAL_CONST_P(arg_obj) ? -1 : \
1772  RB_BUILTIN_TYPE(arg_obj); \
1773  })
1774 #else
1775 static inline int
1777 {
1778  return RB_SPECIAL_CONST_P(obj) ? -1 :
1779  RB_BUILTIN_TYPE(obj);
1780 }
1781 #endif
1782 
1783 #if defined(__cplusplus)
1784 #if 0
1785 { /* satisfy cc-mode */
1786 #endif
1787 } /* extern "C" { */
1788 #endif
1789 
1790 #endif /* RUBY_INTERNAL_H */
VALUE fd_dup2
Definition: internal.h:1392
VALUE rb_int_plus(VALUE x, VALUE y)
Definition: numeric.c:3514
#define RSTRUCT_EMBED_LEN(st)
Definition: internal.h:604
VALUE rb_rational_cmp(VALUE self, VALUE other)
Definition: rational.c:1080
double ruby_float_mod(double x, double y)
Definition: numeric.c:1221
void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args)
Definition: error.c:558
void rb_class_remove_from_super_subclasses(VALUE)
Definition: class.c:76
st_table * rb_init_identtable_with_size(st_index_t size)
Definition: hash.c:2822
void rb_backtrace_print_to(VALUE output)
Definition: vm_backtrace.c:797
VALUE rb_int_cmp(VALUE x, VALUE y)
Definition: numeric.c:4102
static unsigned int nlz_long(unsigned long x)
Definition: internal.h:167
VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc)
Definition: string.c:1007
void rb_execarg_setenv(VALUE execarg_obj, VALUE env)
Definition: process.c:2293
double rb_big_fdiv_double(VALUE x, VALUE y)
Definition: bignum.c:6139
const VALUE num
Definition: internal.h:525
void rb_class_detach_subclasses(VALUE)
Definition: class.c:133
long len
Definition: internal.h:593
VALUE rb_int_uminus(VALUE num)
Definition: numeric.c:3374
int rb_method_defined_by(VALUE obj, ID mid, VALUE(*cfunc)(ANYARGS))
VALUE rb_math_sqrt(VALUE)
Definition: math.c:620
void rb_vm_inc_const_missing_count(void)
Definition: vm.c:323
VALUE rb_vm_backtrace_object(void)
Definition: vm_backtrace.c:530
VALUE rb_parser_get_yydebug(VALUE)
Definition: ripper.c:17824
VALUE rb_big_mul_balance(VALUE x, VALUE y)
Definition: bignum.c:1668
VALUE rb_eEWOULDBLOCK
Definition: error.c:47
struct st_table * iv_index_tbl
Definition: internal.h:655
VALUE(* rb_block_call_func_t)(ANYARGS)
Definition: ruby.h:1837
VALUE rb_syntax_error_append(VALUE, VALUE, int, int, rb_encoding *, const char *, va_list)
Definition: error.c:104
rb_encoding * rb_enc_get_from_index(int index)
Definition: encoding.c:628
VALUE rb_sym_intern(const char *ptr, long len, rb_encoding *enc)
Definition: symbol.c:1030
int rb_encdb_alias(const char *alias, const char *orig)
Definition: encoding.c:572
VALUE rb_insns_name_array(void)
Definition: compile.c:6518
VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline)
Definition: re.c:2850
VALUE rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl)
Definition: string.c:9239
const VALUE v2
Definition: internal.h:822
VALUE rb_gvar_get(struct rb_global_entry *)
Definition: variable.c:791
VALUE rb_big_remainder(VALUE x, VALUE y)
Definition: bignum.c:6050
BDIGIT * digits
Definition: internal.h:491
Definition: st.h:79
void rb_gc_free_dsymbol(VALUE)
Definition: symbol.c:629
void void ruby_sized_xfree(void *x, size_t size)
Definition: gc.c:8009
CONSTFUNC(const char *rb_insns_name(int i))
VALUE throw_state
Definition: internal.h:784
int rb_block_min_max_arity(int *max)
Definition: proc.c:1075
int rb_is_global_name(VALUE name)
Definition: symbol.c:1096
VALUE rb_execarg_init(int argc, const VALUE *argv, int accept_shell, VALUE execarg_obj)
Definition: process.c:2276
int rb_is_instance_name(VALUE name)
Definition: symbol.c:1102
void * ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size) RUBY_ATTR_ALLOC_SIZE((2))
Definition: gc.c:7975
const char ruby_exec_prefix[]
Definition: loadpath.c:59
VALUE rb_cstr_to_rat(const char *, int)
Definition: rational.c:2560
VALUE rb_check_block_call(VALUE, ID, int, const VALUE *, rb_block_call_func_t, VALUE)
static int max(int a, int b)
Definition: strftime.c:142
void rb_str_tmp_frozen_release(VALUE str, VALUE tmp)
Definition: string.c:1148
static unsigned int hash(str, len) register const char *str
rb_subclass_entry_t * next
Definition: internal.h:640
void rb_gc_mark_values(long n, const VALUE *values)
Definition: gc.c:4024
VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc)
Definition: string.c:367
#define FIX_CONST_VALUE_PTR(x)
Definition: ruby.h:2038
#define FL_USHIFT
Definition: ruby.h:1225
void ruby_set_inplace_mode(const char *)
Definition: io.c:12054
void Init_BareVM(void)
Definition: vm.c:3107
unsigned umask_given
Definition: internal.h:1376
VALUE rb_hash_values(VALUE hash)
Definition: hash.c:2061
VALUE rb_check_backtrace(VALUE)
Definition: error.c:1006
const VALUE cref_or_me
Definition: internal.h:769
VALUE rb_big2str_generic(VALUE x, int base)
Definition: bignum.c:4954
VALUE rb_math_exp(VALUE)
VALUE rb_fstring_cstr(const char *str)
Definition: string.c:387
int rb_is_attrset_sym(VALUE sym)
Definition: symbol.c:894
static int ntz_int64(uint64_t x)
Definition: internal.h:305
static int ntz_intptr(uintptr_t x)
Definition: internal.h:315
void rb_class_remove_from_module_subclasses(VALUE)
Definition: class.c:94
int ruby_disable_gc
Definition: gc.c:814
struct vm_ifunc * rb_vm_ifunc_new(VALUE(*func)(ANYARGS), const void *data, int min_argc, int max_argc)
Definition: proc.c:647
struct rb_id_table * const_tbl
Definition: internal.h:657
VALUE rb_obj_is_thread(VALUE obj)
Definition: vm.c:2487
VALUE rb_reg_check_preprocess(VALUE)
Definition: re.c:2603
VALUE rb_current_realfilepath(void)
Definition: vm_eval.c:2199
VALUE rb_int_round(VALUE num, int ndigits, enum ruby_num_rounding_mode mode)
Definition: numeric.c:2097
VALUE rlimit_limits
Definition: internal.h:1387
#define RSTRUCT_EMBED_LEN_SHIFT
Definition: internal.h:580
int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char *errmsg, size_t errmsg_buflen)
Definition: process.c:3021
unsigned uid_given
Definition: internal.h:1384
Definition: io.h:62
void Init_newline(void)
VALUE rb_backtrace_to_location_ary(VALUE obj)
Definition: vm_backtrace.c:631
size_t rb_big_size(VALUE)
Definition: bignum.c:6701
int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen)
Definition: process.c:3150
int rb_is_method_name(VALUE name)
Definition: symbol.c:1120
VALUE rb_str_quote_unprintable(VALUE)
Definition: string.c:9619
VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc)
Definition: string.c:380
VALUE rb_struct_init_copy(VALUE copy, VALUE s)
Definition: struct.c:809
VALUE rb_int_equal(VALUE x, VALUE y)
Definition: numeric.c:4052
VALUE rb_float_abs(VALUE flt)
Definition: numeric.c:1704
struct st_table * rb_hash_tbl_raw(VALUE hash)
Definition: hash.c:490
unsigned unsetenv_others_given
Definition: internal.h:1377
VALUE rb_suppress_tracing(VALUE(*func)(VALUE), VALUE arg)
Definition: vm_trace.c:387
#define FIXNUM_MIN
Definition: ruby.h:229
void ruby_debug_printf(const char *format,...)
Definition: debug.c:54
VALUE * ruby_initial_gc_stress_ptr
Definition: gc.c:720
VALUE rb_big_size_m(VALUE big)
Definition: bignum.c:6707
int close_others_maxhint
Definition: internal.h:1391
rb_subclass_entry_t * subclasses
Definition: internal.h:659
const char * ruby_get_inplace_mode(void)
Definition: io.c:12048
VALUE reserved
Definition: internal.h:802
VALUE rb_eEAGAIN
Definition: error.c:46
VALUE flags
Definition: internal.h:819
void rb_ary_set_len(VALUE, long)
Definition: array.c:1627
VALUE rb_yield_lambda(VALUE values)
Definition: vm_eval.c:1072
VALUE rb_strftime_timespec(const char *format, size_t format_len, rb_encoding *enc, const struct vtm *vtm, struct timespec *ts, int gmt)
Definition: strftime.c:923
VALUE rb_complex_abs(VALUE x)
Definition: complex.c:1464
VALUE klass
Definition: internal.h:1309
SSL_METHOD *(* func)(void)
Definition: ossl_ssl.c:54
VALUE v0
Definition: internal.h:731
#define RB_SPECIAL_CONST_P(x)
Definition: ruby.h:1248
void * ruby_mimmalloc(size_t size)
Definition: gc.c:8026
VALUE rb_lcm(VALUE x, VALUE y)
Definition: rational.c:1868
int rb_encdb_replicate(const char *alias, const char *orig)
Definition: encoding.c:454
rb_pid_t rb_fork_ruby(int *status)
VALUE rb_int_minus(VALUE x, VALUE y)
Definition: numeric.c:3561
void rb_async_bug_errno(const char *mesg, int errno_arg)
Definition: error.c:534
VALUE rb_str_locktmp_ensure(VALUE str, VALUE(*func)(VALUE), VALUE arg)
Definition: string.c:2538
void Init_class_hierarchy(void)
Definition: class.c:546
VALUE rb_int_mul(VALUE x, VALUE y)
Definition: numeric.c:3608
int rb_gc_for_fd(int err)
Definition: io.c:876
int rb_is_global_sym(VALUE sym)
Definition: symbol.c:882
VALUE rb_default_home_dir(VALUE result)
Definition: file.c:3238
char * rb_str_fill_terminator(VALUE str, const int termlen)
Definition: string.c:2156
VALUE rb_parser_set_yydebug(VALUE, VALUE)
Definition: ripper.c:17839
static VALUE rb_fix_mul_fix(VALUE x, VALUE y)
Definition: internal.h:336
VALUE rb_strftime(const char *format, size_t format_len, rb_encoding *enc, const struct vtm *vtm, VALUE timev, int gmt)
Definition: strftime.c:913
void Init_vm_eval(void)
Definition: vm_eval.c:2209
void Init_vm_objects(void)
Definition: vm.c:3130
long cnt
Definition: internal.h:824
void rb_vm_check_redefinition_by_prepend(VALUE klass)
Definition: vm.c:1529
VALUE rb_file_expand_path_fast(VALUE, VALUE)
Definition: file.c:3693
const void ** rb_vm_get_insns_address_table(void)
Definition: vm_exec.c:130
int ruby_thread_has_gvl_p(void)
Definition: thread.c:1541
VALUE rb_readlink(VALUE path, rb_encoding *resultenc)
Definition: file.c:599
size_t rb_io_memsize(const rb_io_t *)
Definition: io.c:4414
VALUE rb_execarg_new(int argc, const VALUE *argv, int accept_shell)
Definition: process.c:2257
#define RUBY_BIT_ROTL(v, n)
Definition: internal.h:1225
static long rb_struct_len(VALUE st)
Definition: internal.h:616
void Init_vm_backtrace(void)
Definition: vm_backtrace.c:985
void * ruby_sized_xrealloc2(void *ptr, size_t new_count, size_t element_size, size_t old_count) RUBY_ATTR_ALLOC_SIZE((2
VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd)
Definition: thread.c:1434
VALUE rb_math_cos(VALUE)
void rb_mutex_allow_trap(VALUE self, int val)
Definition: thread_sync.c:511
VALUE rb_int_divmod(VALUE x, VALUE y)
Definition: numeric.c:3881
VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, int *stateptr)
Definition: vm_eval.c:2041
VALUE rb_int_gt(VALUE x, VALUE y)
Definition: numeric.c:4142
VALUE env_modification
Definition: internal.h:1396
VALUE rb_math_sinh(VALUE)
VALUE rb_attr_delete(VALUE, ID)
Definition: variable.c:1315
const char * alias
Definition: nkf.c:1151
VALUE rb_refinement_module_get_refined_class(VALUE module)
Definition: eval.c:1238
size_t rb_ary_memsize(VALUE)
Definition: array.c:555
VALUE rb_big_le(VALUE x, VALUE y)
Definition: bignum.c:5434
unsigned long ruby_scan_digits(const char *str, ssize_t len, int base, size_t *retlen, int *overflow)
Definition: util.c:84
VALUE flags
Definition: internal.h:730
st_data_t st_index_t
Definition: st.h:50
ID id
Definition: internal.h:889
void rb_enc_set_base(const char *name, const char *orig)
Definition: encoding.c:389
VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method)
Definition: error.c:1367
double float_value
Definition: internal.h:535
static VALUE rb_fix_div_fix(VALUE x, VALUE y)
Definition: internal.h:385
void rb_call_inits(void)
Definition: inits.c:17
const VALUE backref
Definition: internal.h:771
int rb_hash_add_new_element(VALUE hash, VALUE key, VALUE val)
Definition: hash.c:3034
double rb_int_fdiv_double(VALUE x, VALUE y)
Definition: numeric.c:3637
void rb_load_fail(VALUE path, const char *err)
Definition: error.c:2438
const char * rb_source_loc(int *pline)
Definition: vm.c:1291
rb_subclass_entry_t ** parent_subclasses
Definition: internal.h:660
#define RUBY_ATTR_ALLOC_SIZE(params)
Definition: defines.h:193
rb_encoding OnigEncodingUS_ASCII
#define RSTRUCT(obj)
Definition: internal.h:613
VALUE envp_str
Definition: internal.h:1371
VALUE rb_big_mul_karatsuba(VALUE x, VALUE y)
Definition: bignum.c:1849
int rb_file_load_ok(const char *)
Definition: file.c:5724
int rb_match_count(VALUE match)
Definition: re.c:1266
enum ruby_num_rounding_mode rb_num_get_rounding_option(VALUE opts)
Definition: numeric.c:198
VALUE rb_equal_opt(VALUE obj1, VALUE obj2)
int rb_local_defined(ID, const struct rb_block *)
Definition: compile.c:7049
static double rb_float_flonum_value(VALUE v)
Definition: internal.h:1230
#define RSTRUCT_EMBED_LEN_MAX
Definition: internal.h:578
#define sym(x)
Definition: date_core.c:3721
#define BIGNUM_EMBED_LEN_MAX
Definition: internal.h:480
VALUE rb_fstring_enc_cstr(const char *ptr, rb_encoding *enc)
Definition: string.c:393
VALUE rb_ary_tmp_new_fill(long capa)
Definition: array.c:538
static int rb_obj_builtin_type(VALUE obj)
Definition: internal.h:1776
static unsigned char * output
Definition: nkf.c:32
unsigned unsetenv_others_do
Definition: internal.h:1378
const VALUE den
Definition: internal.h:526
int rb_is_junk_sym(VALUE sym)
Definition: symbol.c:906
VALUE rb_big_mul_normal(VALUE x, VALUE y)
Definition: bignum.c:1540
VALUE rb_gvar_set(struct rb_global_entry *, VALUE)
Definition: variable.c:824
VALUE rb_wb_unprotected_newobj_of(VALUE, VALUE)
Definition: gc.c:1933
void rb_encdb_set_unicode(int index)
Definition: encoding.c:583
void ruby_register_rollback_func_for_ensure(VALUE(*ensure_func)(ANYARGS), VALUE(*rollback_func)(ANYARGS))
Definition: cont.c:977
void rb_vm_change_state(void)
unsigned int opt_inited
Definition: internal.h:863
void * rb_parser_load_file(VALUE parser, VALUE name)
Definition: ruby.c:2007
#define RUBY_BIT_ROTR(v, n)
Definition: internal.h:1226
Definition: ruby.h:961
VALUE rb_parser_set_context(VALUE, const struct rb_block *, int)
Definition: ripper.c:17749
VALUE rb_ary_last(int, const VALUE *, VALUE)
Definition: array.c:1361
VALUE rb_str2big_poweroftwo(VALUE arg, int base, int badcheck)
Definition: bignum.c:4224
VALUE rb_obj_not(VALUE obj)
Definition: object.c:187
static VALUE RCLASS_SUPER(VALUE klass)
Definition: internal.h:708
VALUE rb_block_call_func(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg))
Definition: ruby.h:1832
VALUE rb_int_idiv(VALUE x, VALUE y)
Definition: numeric.c:3756
int rb_str_symname_p(VALUE)
Definition: string.c:9600
unsigned long long uint64_t
Definition: sha2.h:102
VALUE rb_class_inherited(VALUE, VALUE)
Calls Class::inherited.
Definition: class.c:620
struct rb_id_table * callable_m_tbl
Definition: internal.h:658
rb_gid_t gid
Definition: internal.h:1390
VALUE rb_get_path_check_convert(VALUE, VALUE, int)
Definition: file.c:190
struct rb_execarg * rb_execarg_get(VALUE execarg_obj)
Definition: process.c:2268
VALUE rb_ident_hash_new(void)
Definition: hash.c:2808
#define div(x, y)
Definition: date_strftime.c:27
void Init_ext(void)
Definition: dmyext.c:2
int rb_data_is_encoding(VALUE obj)
Definition: encoding.c:90
static unsigned int nlz_int(unsigned int x)
Definition: internal.h:137
VALUE rb_big_bit_length(VALUE big)
Definition: bignum.c:6713
rb_encoding * rb_enc_check_str(VALUE str1, VALUE str2)
Definition: encoding.c:868
VALUE rb_str_chomp_string(VALUE str, VALUE chomp)
Definition: string.c:8136
const char * rb_insns_name(int i)
Definition: compile.c:6512
Definition: internal.h:638
void ruby_error_print(void)
Definition: eval_error.c:185
void rb_vm_mark(void *ptr)
Definition: vm.c:2101
size_t rb_generic_ivar_memsize(VALUE)
Definition: variable.c:1200
VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:906
VALUE rb_big_aref(VALUE x, VALUE y)
Definition: bignum.c:6604
VALUE rb_gvar_defined(struct rb_global_entry *)
Definition: variable.c:859
#define val
Definition: internal.h:887
BDIGIT ary[BIGNUM_EMBED_LEN_MAX]
Definition: internal.h:493
VALUE rb_special_singleton_class(VALUE)
Definition: class.c:1579
VALUE rb_int_ge(VALUE x, VALUE y)
Definition: numeric.c:4182
VALUE rb_get_coverages(void)
Definition: thread.c:5004
VALUE rb_eEINPROGRESS
Definition: error.c:48
const VALUE imag
Definition: internal.h:543
VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict)
Definition: file.c:3873
int rb_num_negative_p(VALUE)
Definition: numeric.c:342
VALUE rb_thread_shield_release(VALUE self)
Definition: thread.c:4455
VALUE rb_hash_set_default_proc(VALUE hash, VALUE proc)
Definition: hash.c:1039
VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, VALUE passed_proc)
Definition: string.c:9716
int rb_class_has_methods(VALUE c)
Definition: class.c:2051
VALUE rb_id_quote_unprintable(ID)
Definition: string.c:9640
VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash)
Definition: process.c:1928
VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl)
Definition: numeric.c:2525
VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1379
int rb_require_internal(VALUE fname, int safe)
Definition: load.c:956
ruby_num_rounding_mode
Definition: internal.h:1175
Definition: ruby.h:854
rb_encoding OnigEncodingUTF_8
Definition: onigmo.h:201
rb_classext_t * ptr
Definition: internal.h:679
#define RCLASS_ORIGIN(c)
Definition: internal.h:693
void rb_check_funcall_hook(int, VALUE, ID, int, const VALUE *, VALUE)
Definition: internal.h:1605
rb_uid_t uid
Definition: internal.h:1389
static VALUE RCLASS_SET_SUPER(VALUE klass, VALUE super)
Definition: internal.h:714
const VALUE real
Definition: internal.h:542
int rb_match_nth_defined(int nth, VALUE match)
Definition: re.c:1276
VALUE rb_sym_intern_ascii(const char *ptr, long len)
Definition: symbol.c:1044
VALUE flags
Definition: internal.h:780
VALUE command_name
Definition: internal.h:1364
const VALUE others
Definition: internal.h:772
rb_pid_t pgroup_pgid
Definition: internal.h:1386
VALUE rb_int2str(VALUE num, int base)
Definition: numeric.c:3458
VALUE command_abspath
Definition: internal.h:1365
VALUE rb_complex_sqrt(VALUE x)
void rb_class_subclass_add(VALUE super, VALUE klass)
Definition: class.c:36
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)
void rb_encdb_declare(const char *name)
Definition: encoding.c:357
void rb_unexpected_type(VALUE x, int t)
Definition: error.c:700
VALUE rb_obj_is_mutex(VALUE obj)
Definition: thread_sync.c:83
VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE)
Definition: file.c:3308
VALUE rb_cstr_parse_inum(const char *str, ssize_t len, char **endp, int base)
Definition: bignum.c:4018
Definition: internal.h:818
VALUE rb_int_and(VALUE x, VALUE y)
Definition: numeric.c:4358
const VALUE throw_obj
Definition: internal.h:782
st_table * rb_vm_fstring_table(void)
Definition: vm.c:3196
#define FLONUM_P(x)
Definition: ruby.h:399
int rb_dvar_defined(ID, const struct rb_block *)
Definition: compile.c:7024
void Init_File(void)
Definition: file.c:5953
int argc
Definition: ruby.c:183
VALUE rb_io_flush_raw(VALUE, int)
Definition: io.c:1551
VALUE rb_int_lshift(VALUE x, VALUE y)
Definition: numeric.c:4473
VALUE rb_struct_lookup(VALUE s, VALUE idx)
Definition: struct.c:936
static const VALUE * rb_struct_const_ptr(VALUE st)
Definition: internal.h:623
VALUE rb_proc_location(VALUE self)
Definition: proc.c:1147
void rb_file_const(const char *, VALUE)
Definition: file.c:5585
int rb_is_class_sym(VALUE sym)
Definition: symbol.c:876
void rb_undefined_alloc(VALUE klass)
Definition: object.c:1816
const char * rb_builtin_class_name(VALUE x)
Definition: error.c:645
VALUE rb_hash_compare_by_id_p(VALUE hash)
Definition: hash.c:2797
int err
Definition: win32.c:135
VALUE rb_int_pred(VALUE num)
Definition: numeric.c:3240
int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl)
Definition: numeric.c:2494
char * ruby_dtoa(double d_, int mode, int ndigits, int *decpt, int *sign, char **rve)
Definition: util.c:3136
void rb_gc_resurrect(VALUE ptr)
VALUE rb_int_abs(VALUE num)
Definition: numeric.c:4644
VALUE rb_float_new_in_heap(double)
Definition: numeric.c:941
int rb_backtrace_p(VALUE obj)
Definition: vm_backtrace.c:410
VALUE rb_obj_equal(VALUE obj1, VALUE obj2)
Definition: object.c:139
static VALUE rb_float_new_inline(double d)
Definition: internal.h:1266
int rb_obj_basic_to_s_p(VALUE)
Definition: class.c:1777
VALUE rb_yield_refine_block(VALUE refinement, VALUE refinements)
Definition: vm_eval.c:1635
VALUE rb_invcmp(VALUE, VALUE)
Definition: compar.c:46
void rb_copy_wb_protected_attribute(VALUE dest, VALUE obj)
Definition: gc.c:6031
struct st_table * ntbl
Definition: internal.h:557
int rb_is_local_sym(VALUE sym)
Definition: symbol.c:900
size_t len
Definition: internal.h:490
VALUE rb_int_modulo(VALUE x, VALUE y)
Definition: numeric.c:3799
union RBignum::@134 as
VALUE rb_float_gt(VALUE x, VALUE y)
Definition: numeric.c:1513
VALUE rb_backtrace_to_str_ary(VALUE obj)
Definition: vm_backtrace.c:584
VALUE rb_int_succ(VALUE num)
Definition: numeric.c:3215
VALUE rb_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval)
Definition: vm_backtrace.c:900
VALUE v2
Definition: internal.h:733
unsigned close_others_given
Definition: internal.h:1379
VALUE rb_get_load_path(void)
Definition: load.c:30
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:465
VALUE rb_hash_keys(VALUE hash)
Definition: hash.c:2017
long rb_reg_search0(VALUE, VALUE, long, int, int)
Definition: re.c:1497
static int ntz_int32(uint32_t x)
Definition: internal.h:295
void rb_deprecate_constant(VALUE mod, const char *name)
Definition: variable.c:2792
#define MUL_OVERFLOW_FIXNUM_P(a, b)
Definition: internal.h:89
ID rb_id_encoding(void)
Definition: encoding.c:753
void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE, VALUE), VALUE)
Definition: class.c:113
void rb_last_status_clear(void)
Definition: process.c:494
int rb_encdb_dummy(const char *name)
Definition: encoding.c:476
struct st_table * iv_tbl
Definition: internal.h:656
VALUE rb_hash_has_key(VALUE hash, VALUE key)
Definition: hash.c:2105
unsigned long rb_serial_t
Definition: internal.h:650
VALUE rb_complex_plus(VALUE, VALUE)
Definition: complex.c:673
static int chfunc(void *data, char *errbuf, size_t errbuf_len)
Definition: pty.c:91
int rb_get_next_signal(void)
Definition: signal.c:739
void rb_execarg_parent_start(VALUE execarg_obj)
Definition: process.c:2457
VALUE rb_big_mul_toom3(VALUE x, VALUE y)
Definition: bignum.c:2246
int rb_is_const_name(VALUE name)
Definition: symbol.c:1084
void Init_prelude(void)
VALUE reserved
Definition: internal.h:781
#define RICLASS_IS_ORIGIN
Definition: internal.h:697
VALUE rb_math_atan2(VALUE, VALUE)
VALUE rb_include_class_new(VALUE, VALUE)
Definition: class.c:818
void rb_print_backtrace(void)
Definition: vm_dump.c:679
VALUE rb_const_missing(VALUE klass, VALUE name)
Definition: variable.c:1794
VALUE klass
Definition: internal.h:639
#define RUBY_SYMBOL_EXPORT_END
Definition: missing.h:49
void rb_mark_end_proc(void)
Definition: eval_jump.c:80
VALUE argv_str
Definition: internal.h:1366
char * ruby_hdtoa(double d, const char *xdigs, int ndigits, int *decpt, int *sign, char **rve)
Definition: util.c:3891
static unsigned int nlz_intptr(uintptr_t x)
Definition: internal.h:246
size_t rb_str_memsize(VALUE)
Definition: string.c:1294
void rb_thread_execute_interrupts(VALUE th)
Definition: thread.c:2098
VALUE rb_thread_shield_destroy(VALUE self)
Definition: thread.c:4466
VALUE redirect_fds
Definition: internal.h:1370
void rb_call_end_proc(VALUE data)
Definition: eval_jump.c:11
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4309
unsigned close_others_do
Definition: internal.h:1380
void rb_vm_pop_cfunc_frame(void)
Definition: vm.c:523
VALUE rb_fix_plus(VALUE x, VALUE y)
Definition: numeric.c:3508
PUREFUNC(int rb_data_is_encoding(VALUE obj))
unsigned long ID
Definition: ruby.h:86
int rb_block_arity(void)
Definition: proc.c:1041
long state
Definition: internal.h:825
VALUE path_env
Definition: internal.h:1397
const signed char ruby_digit36_to_number_table[]
Definition: escape.c:6
const char ruby_digitmap[]
Definition: bignum.c:37
unsigned int uintptr_t
Definition: win32.h:106
unsigned new_pgroup_given
Definition: internal.h:1382
VALUE rb_sym_to_proc(VALUE sym)
Definition: proc.c:1203
#define mode_t
Definition: win32.h:119
static int options(unsigned char *cp)
Definition: nkf.c:6358
void Init_heap(void)
Definition: gc.c:2323
VALUE rb_big_hash(VALUE)
Definition: bignum.c:6649
VALUE rb_integer_float_eq(VALUE x, VALUE y)
Definition: bignum.c:5314
int rb_bug_reporter_add(void(*func)(FILE *, void *), void *data)
Definition: error.c:314
size_t rb_econv_memsize(rb_econv_t *)
Definition: transcode.c:1716
unsigned long VALUE
Definition: ruby.h:85
VALUE rb_big_mul(VALUE x, VALUE y)
Definition: bignum.c:5867
#define RSTRUCT_EMBED_LEN_MASK
Definition: internal.h:579
VALUE rb_vm_top_self(void)
Definition: vm.c:3151
static VALUE result
Definition: nkf.c:40
void rb_undef_methods_from(VALUE klass, VALUE super)
Definition: class.c:1547
#define RBASIC(obj)
Definition: ruby.h:1204
VALUE rb_big_ge(VALUE x, VALUE y)
Definition: bignum.c:5422
VALUE rb_get_backtrace(VALUE info)
Definition: error.c:965
struct RBasic basic
Definition: internal.h:487
void rb_obj_copy_ivar(VALUE dest, VALUE obj)
Definition: object.c:258
VALUE rb_str2big_normal(VALUE arg, int base, int badcheck)
Definition: bignum.c:4260
const char ruby_initial_load_paths[]
Definition: loadpath.c:62
VALUE rb_int_div(VALUE x, VALUE y)
Definition: numeric.c:3729
#define RUBY_SYMBOL_EXPORT_BEGIN
Definition: missing.h:48
VALUE argv_buf
Definition: internal.h:1367
void Init_native_thread(void)
VALUE rb_imemo_new(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0)
Definition: gc.c:1971
VALUE rb_make_metaclass(VALUE, VALUE)
Definition: class.c:577
void ruby_mimfree(void *ptr)
Definition: gc.c:8042
VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1349
int rb_is_class_name(VALUE name)
Definition: symbol.c:1090
void rb_thread_mark(void *th)
Definition: vm.c:2352
void rb_enc_warn(rb_encoding *enc, const char *fmt,...)
Definition: error.c:235
VALUE rb_f_send(int argc, VALUE *argv, VALUE recv)
Definition: vm_eval.c:980
static struct vm_ifunc * rb_vm_ifunc_proc_new(VALUE(*func)(ANYARGS), const void *data)
Definition: internal.h:811
static double rb_float_noflonum_value(VALUE v)
Definition: internal.h:1251
VALUE rb_math_cosh(VALUE)
static VALUE rb_fix_mod_fix(VALUE x, VALUE y)
Definition: internal.h:396
int Init_enc_set_filesystem_encoding(void)
Definition: localeinit.c:98
mode_t umask_mask
Definition: internal.h:1388
unsigned pgroup_given
Definition: internal.h:1375
int rb_sigaltstack_size(void)
VALUE flags
Definition: internal.h:768
VALUE flags
Definition: internal.h:801
VALUE rb_uninterruptible(VALUE(*b_proc)(ANYARGS), VALUE data)
Definition: thread.c:5035
VALUE rb_fstring(VALUE)
Definition: string.c:305
VALUE rb_blocking_function_t(void *)
Definition: intern.h:896
VALUE fd_dup2_child
Definition: internal.h:1395
static int rb_popcount64(uint64_t x)
Definition: internal.h:270
int rb_is_const_sym(VALUE sym)
Definition: symbol.c:870
void rb_class_detach_module_subclasses(VALUE)
Definition: class.c:145
VALUE rb_cEncodingConverter
Definition: transcode.c:23
#define CHAR_BIT
Definition: ruby.h:196
const VALUE origin_
Definition: internal.h:668
VALUE rb_fstring_new(const char *ptr, long len)
Definition: string.c:373
struct rb_global_variable * var
Definition: internal.h:888
VALUE rb_sym_intern_ascii_cstr(const char *ptr)
Definition: symbol.c:1050
static int rb_popcount_intptr(uintptr_t x)
Definition: internal.h:285
void rb_sys_enc_warning(rb_encoding *enc, const char *fmt,...)
Definition: error.c:2418
#define LONG2NUM(x)
Definition: ruby.h:1573
VALUE rb_nmin_run(VALUE obj, VALUE num, int by, int rev, int ary)
Definition: enum.c:1411
unsigned int uint32_t
Definition: sha2.h:101
int rb_thread_to_be_killed(VALUE thread)
Definition: thread.c:2311
VALUE rb_wb_protected_newobj_of(VALUE, VALUE)
Definition: gc.c:1940
VALUE fd_open
Definition: internal.h:1394
void rb_write_error_str(VALUE mesg)
Definition: io.c:7393
VALUE rb_rational_plus(VALUE self, VALUE other)
Definition: rational.c:735
void rb_thread_recycle_stack_release(VALUE *)
Definition: vm.c:2336
VALUE rb_sym_intern_cstr(const char *ptr, rb_encoding *enc)
Definition: symbol.c:1038
int size
Definition: encoding.c:57
VALUE rb_thread_shield_new(void)
Definition: thread.c:4410
ID rb_id_attrget(ID id)
Definition: symbol.c:158
int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p)
Definition: string.c:5555
VALUE reserved
Definition: internal.h:820
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:811
void rb_mark_generic_ivar(VALUE)
Definition: variable.c:1173
VALUE rb_hash_rehash(VALUE hash)
Definition: hash.c:793
#define f
void rb_fiber_reset_root_local_storage(VALUE)
Definition: cont.c:1529
#define UNLIMITED_ARGUMENTS
Definition: intern.h:44
VALUE rb_str2big_karatsuba(VALUE arg, int base, int badcheck)
Definition: bignum.c:4302
int ruby_enable_coredump
Definition: signal.c:1416
const struct rb_control_frame_struct * catch_frame
Definition: internal.h:783
VALUE dup2_tmpbuf
Definition: internal.h:1373
VALUE fd_close
Definition: internal.h:1393
unsigned gid_given
Definition: internal.h:1385
VALUE rb_float_pow(VALUE x, VALUE y)
Definition: numeric.c:1314
const VALUE v1
Definition: internal.h:821
VALUE rb_hash_delete_entry(VALUE hash, VALUE key)
Definition: hash.c:1112
int rb_is_instance_sym(VALUE sym)
Definition: symbol.c:888
void ruby_gc_set_params(int safe_level)
Definition: gc.c:7475
VALUE rb_int_positive_pow(long x, unsigned long y)
Definition: numeric.c:3949
int iter_lev
Definition: internal.h:558
VALUE rb_rational_reciprocal(VALUE x)
Definition: rational.c:1832
#define BDIGIT
Definition: internal.h:425
void rb_ary_delete_same(VALUE, VALUE)
Definition: array.c:3022
#define ANYARGS
Definition: defines.h:173
VALUE envp_buf
Definition: internal.h:1372
VALUE rb_hash_default_value(VALUE hash, VALUE key)
Definition: hash.c:817
int rb_class_ivar_set(VALUE klass, ID vid, VALUE value)
Definition: variable.c:3147
size_t rb_obj_memsize_of(VALUE)
Definition: gc.c:3266
static void rb_fix_divmod_fix(VALUE a, VALUE b, VALUE *divp, VALUE *modp)
Definition: internal.h:357
VALUE v3
Definition: internal.h:734
VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound)
Definition: object.c:3219
void rb_gc_verify_internal_consistency(void)
Definition: gc.c:5298
double rb_num_to_dbl(VALUE val)
Definition: object.c:3034
unsigned chdir_given
Definition: internal.h:1381
VALUE rb_big_sq_fast(VALUE x)
Definition: bignum.c:1609
VALUE rb_gcd_normal(VALUE self, VALUE other)
Definition: rational.c:335
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:1658
VALUE rb_rational_uminus(VALUE self)
Definition: rational.c:629
st_table * rb_init_identtable(void)
Definition: hash.c:2816
#define LONG2FIX(i)
Definition: ruby.h:234
#define SIZEOF_VALUE
Definition: ruby.h:88
unsigned int opt_methods
Definition: internal.h:862
long rb_objid_hash(st_index_t index)
Definition: hash.c:251
VALUE rb_big_lt(VALUE x, VALUE y)
Definition: bignum.c:5428
static void RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
Definition: internal.h:700
st_table * rb_st_copy(VALUE obj, struct st_table *orig_tbl)
Definition: variable.c:3163
rb_subclass_entry_t ** module_subclasses
In the case that this is an ICLASS, module_subclasses points to the link in the module&#39;s subclasses l...
Definition: internal.h:666
VALUE chdir_dir
Definition: internal.h:1398
VALUE rb_int_pow(VALUE x, VALUE y)
Definition: numeric.c:4011
int rb_is_local_name(VALUE name)
Definition: symbol.c:1114
int rb_singleton_class_internal_p(VALUE sklass)
Definition: class.c:450
#define RB_BUILTIN_TYPE(x)
Definition: ruby.h:517
VALUE rb_big_even_p(VALUE)
Definition: bignum.c:6763
VALUE rb_rational_abs(VALUE self)
Definition: rational.c:1267
VALUE rb_func_proc_new(rb_block_call_func_t func, VALUE val)
Definition: proc.c:676
VALUE rb_reg_match_p(VALUE re, VALUE str, long pos)
Definition: re.c:3234
VALUE rb_get_expanded_load_path(void)
Definition: load.c:107
VALUE rb_big_abs(VALUE x)
Definition: bignum.c:6685
VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1330
void rb_backref_set_string(VALUE string, long pos, long len)
Definition: re.c:1308
VALUE rb_ary_at(VALUE, VALUE)
Definition: array.c:1313
VALUE rb_int2big(SIGNED_VALUE n)
Definition: bignum.c:3164
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:1240
size_t rb_obj_gc_flags(VALUE, ID[], size_t)
const VALUE lastline
Definition: internal.h:770
const void * data
Definition: internal.h:804
VALUE rb_gcd(VALUE x, VALUE y)
Definition: rational.c:1850
const VALUE ifnone
Definition: internal.h:559
void ruby_kill(rb_pid_t pid, int sig)
Definition: thread.c:5048
VALUE rb_thread_shield_wait(VALUE self)
Definition: thread.c:4426
VALUE rb_func_lambda_new(rb_block_call_func_t func, VALUE val, int min_argc, int max_argc)
Definition: proc.c:683
VALUE rb_yield_1(VALUE val)
Definition: vm_eval.c:1014
const char * name
Definition: nkf.c:208
#define FL_SET(x, f)
Definition: ruby.h:1290
const VALUE * ptr
Definition: internal.h:594
int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val)
Definition: process.c:1669
NORETURN(void rb_async_bug_errno(const char *, int))
void Init_enc(void)
Definition: dmyenc.c:5
int rb_enc_set_dummy(int index)
Definition: encoding.c:400
void rb_autoload_str(VALUE mod, ID id, VALUE file)
Definition: variable.c:1942
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:914
VALUE rb_big2str_poweroftwo(VALUE x, int base)
Definition: bignum.c:4871
void rb_gc_mark_global_tbl(void)
Definition: variable.c:593
VALUE rb_source_location(int *pline)
Definition: vm.c:1275
imemo_type
Definition: internal.h:737
static double rb_float_value_inline(VALUE v)
Definition: internal.h:1257
uint32_t rb_event_flag_t
Definition: ruby.h:2095
void ruby_only_for_internal_use(const char *func)
Definition: error.c:150
unsigned use_shell
Definition: internal.h:1374
rb_serial_t rb_next_class_serial(void)
Definition: vm.c:305
VALUE rb_dbl_hash(double d)
Definition: numeric.c:1442
void rb_gc_writebarrier_remember(VALUE obj)
Definition: gc.c:5967
#define ROUND_DEFAULT
Definition: internal.h:1173
struct timeval rb_time_timeval(VALUE)
Definition: time.c:2292
VALUE super
Definition: internal.h:678
VALUE rb_math_sin(VALUE)
VALUE rb_str_tmp_frozen_acquire(VALUE str)
Definition: string.c:1135
struct RBignum::@134::@135 heap
rb_alloc_func_t allocator
Definition: internal.h:670
void rb_execarg_parent_end(VALUE execarg_obj)
Definition: process.c:2496
int rb_divert_reserved_fd(int fd)
VALUE rb_home_dir_of(VALUE user, VALUE result)
Definition: file.c:3198
void rb_backtrace_print_as_bugreport(void)
Definition: vm_backtrace.c:760
int rb_num_to_uint(VALUE val, unsigned int *ret)
Definition: numeric.c:242
VALUE rb_math_hypot(VALUE, VALUE)
VALUE rb_big_comp(VALUE x)
Definition: bignum.c:5491
VALUE ruby_vm_special_exception_copy(VALUE)
Definition: vm_insnhelper.c:25
long rb_dbl_long_hash(double d)
Definition: hash.c:149
VALUE flags
Definition: internal.h:1308
void rb_stdio_set_default_encoding(void)
Definition: io.c:10957
st_index_t rb_hash_proc(st_index_t hash, VALUE proc)
Definition: proc.c:1193
VALUE rb_get_path_check_to_string(VALUE, int)
Definition: file.c:168
rb_serial_t class_serial
Definition: internal.h:667
VALUE rb_math_log(int argc, const VALUE *argv)
struct rb_id_table * m_tbl
Definition: internal.h:680
void ruby_init_setproctitle(int argc, char *argv[])
unsigned new_pgroup_flag
Definition: internal.h:1383
const char ruby_hexdigits[]
Definition: escape.c:5
void rb_gc_mark_encodings(void)
Definition: encoding.c:263
#define RCLASS(obj)
Definition: ruby.h:1206
#define mod(x, y)
Definition: date_strftime.c:28
#define env
void rb_clear_trace_func(void)
Definition: vm_trace.c:214
VALUE(* rb_alloc_func_t)(VALUE)
Definition: intern.h:387
int rb_vm_add_root_module(ID id, VALUE module)
Definition: vm.c:2153
#define NULL
Definition: _sdbm.c:102
struct rb_global_entry * rb_global_entry(ID)
Definition: variable.c:481
VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj)
Definition: class.c:1364
VALUE shell_script
Definition: internal.h:1361
VALUE rb_integer_float_cmp(VALUE x, VALUE y)
Definition: bignum.c:5264
#define FIX2LONG(x)
Definition: ruby.h:363
VALUE rb_class_search_ancestor(VALUE klass, VALUE super)
Definition: object.c:710
VALUE rb_check_funcall_default(VALUE, ID, int, const VALUE *, VALUE)
Definition: vm_eval.c:445
int rb_is_junk_name(VALUE name)
Definition: symbol.c:1130
VALUE rb_complex_mul(VALUE, VALUE)
Definition: complex.c:754
VALUE rb_search_class_path(VALUE)
Definition: variable.c:336
RUBY_SYMBOL_EXPORT_BEGIN const char * rb_objspace_data_type_name(VALUE obj)
Definition: gc.c:2042
VALUE rb_big_uminus(VALUE x)
Definition: bignum.c:5481
void rb_objspace_set_event_hook(const rb_event_flag_t event)
Definition: gc.c:1760
static int match(VALUE str, VALUE pat, VALUE hash, int(*cb)(VALUE, VALUE))
Definition: date_parse.c:280
static unsigned int rb_popcount32(uint32_t x)
Definition: internal.h:256
const VALUE value
Definition: internal.h:826
void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen)
Definition: string.c:2103
VALUE rb_class_boot(VALUE)
A utility function that wraps class_alloc.
Definition: class.c:201
VALUE rb_big_gt(VALUE x, VALUE y)
Definition: bignum.c:5416
void rb_maygvl_fd_fix_cloexec(int fd)
Definition: io.c:208
const char ruby_engine[]
Definition: version.c:35
VALUE rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
Definition: variable.c:1225
ID rb_make_internal_id(void)
Definition: symbol.c:768
VALUE rb_mutex_owned_p(VALUE self)
Definition: thread_sync.c:316
#define RB_OBJ_WRITE(a, slot, b)
Definition: ruby.h:1437
VALUE rb_sourcefilename(void)
Definition: vm.c:1233
const char * rb_builtin_type_name(int t)
Definition: error.c:609
VALUE rb_obj_is_fiber(VALUE)
Definition: cont.c:351
VALUE rb_big_divrem_normal(VALUE x, VALUE y)
Definition: bignum.c:2698
char ** argv
Definition: ruby.c:184
VALUE rb_float_uminus(VALUE num)
Definition: numeric.c:1057
VALUE v1
Definition: internal.h:732
ssize_t rb_io_bufread(VALUE io, void *buf, size_t size)
Definition: io.c:2176
VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
Definition: class.c:371
int rb_is_attrset_name(VALUE name)
Definition: symbol.c:1108
int ruby_is_fd_loadable(int fd)
Definition: file.c:5697
PRINTF_ARGS(void ruby_debug_printf(const char *,...), 1, 2)
void Init_eval_method(void)
Definition: vm_method.c:2087
VALUE rb_big_odd_p(VALUE)
Definition: bignum.c:6754