2# pragma GCC system_header
4#define ALWAYS_INLINE(x) __attribute__ ((__always_inline__)) x
29 long long __max_align_ll
__attribute__((__aligned__(__alignof__(
long long))));
30 long double __max_align_ld
__attribute__((__aligned__(__alignof__(
long double))));
64 unsigned char __wchb[4];
271 __asm__(
"bswap %0" :
"=r" (_x) :
"0" (_x));
363static __inline
unsigned short
364__bswap_16 (
unsigned short __x)
366 return (__x >> 8) | (__x << 8);
368static __inline
unsigned int
369__bswap_32 (
unsigned int __x)
371 return (__bswap_16 (__x & 0xffff) << 16) | (__bswap_16 (__x >> 16));
373static __inline
unsigned long long
374__bswap_64 (
unsigned long long __x)
376 return (((
unsigned long long) __bswap_32 (__x & 0xffffffffull)) << 32) | (__bswap_32 (__x >> 32));
392static __inline__
int gnu_dev_major(
dev_t);
393static __inline__
int gnu_dev_minor(
dev_t);
394static __inline__
dev_t gnu_dev_makedev(
int,
int);
396gnu_dev_major(
dev_t dev)
398 return (
int)(((dev) >> 16) & 0xffff);
401gnu_dev_minor(
dev_t dev)
403 return (
int)((dev) & 0xffff);
405static __inline__
dev_t
406gnu_dev_makedev(
int maj,
int min)
408 return (((maj) << 16) | ((min) & 0xffff));
697 int (*__readfn)(
void *__c,
char *
__buf,
699 int (*__writefn)(
void *__c,
const char *
__buf,
702 int (*__closefn)(
void *__c));
704 int (*__readfn)(
void *__c,
char *
__buf,
706 int (*__writefn)(
void *__c,
const char *
__buf,
709 int (*__closefn)(
void *__c));
727static __inline__
int __sgetc_r(
struct _reent *__ptr,
FILE *__p);
728static __inline__
int __sgetc_r(
struct _reent *__ptr,
FILE *__p)
730 int __c = (--(__p)->_r < 0 ?
__srget_r(__ptr, __p) : (
int)(*(__p)->_p++));
731 if ((__p->
_flags & 0x4000) && (__c ==
'\r'))
733 int __c2 = (--(__p)->_r < 0 ?
__srget_r(__ptr, __p) : (
int)(*(__p)->_p++));
741static __inline__
int __sputc_r(
struct _reent *_ptr,
int _c,
FILE *_p) {
742 if ((_p->
_flags & 0x4000) && _c ==
'\n')
743 __sputc_r (_ptr,
'\r', _p);
744 if (--_p->
_w >= 0 || (_p->
_w >= _p->
_lbfsize && (
char)_c !=
'\n'))
745 return (*_p->
_p++ = _c);
750_getchar_unlocked(
void)
754 return (__sgetc_r(_ptr, ((_ptr)->
_stdin)));
757_putchar_unlocked(
int _c)
761 return (__sputc_r(_ptr, _c, ((_ptr)->
_stdout)));
785 if (__builtin_object_size(
__buf, 2 > 1) != (
size_t)-1 && (
size_t)
__len > __builtin_object_size(
__buf, 2 > 1))
__chk_fail();
791 if (__builtin_object_size(
__buf, 2 > 1) != (
size_t)-1 && (
size_t)
__len > __builtin_object_size(
__buf, 2 > 1))
__chk_fail();
796 if (__builtin_object_size(__ptr, 0) != (
size_t)-1 &&
__size *
__n > __builtin_object_size(__ptr, 0))
__chk_fail();
801 if (__builtin_object_size(__ptr, 0) != (
size_t)-1 &&
__size *
__n > __builtin_object_size(__ptr, 0))
__chk_fail();
1004 __extension__
struct
1011 __extension__
struct
1017 __extension__
struct
1088extern const char __attribute__((dllimport)) *sys_sigabbrev[];
1117typedef __attribute__ ((__aligned__ (16))) struct __ucontext {
1119 struct __ucontext *uc_link;
1122 unsigned long int uc_flags;
1266char *
mktemp (
char *)
__attribute__ ((__deprecated__(
"the use of `mktemp' is dangerous; use `mkstemp' instead")));
1303int on_exit (
void (*__func)(
int,
void *),
void *__arg);
1308int setenv (
const char *__string,
const char *__value,
int __overwrite);
1309int _setenv_r (
struct _reent *,
const char *__string,
const char *__value,
int __overwrite);
1313char *
utoa (
unsigned,
char *,
int);
1364 if (
__buf != ((
void *)0))
1365 if (__builtin_object_size(
__buf, 2 > 1) != (
size_t)-1 &&
__n *
sizeof(
wchar_t) > __builtin_object_size(
__buf, 2 > 1))
__chk_fail();
1371 if (
__buf != ((
void *)0))
1378void bcopy(
const void *,
void *,
size_t);
1397int memcmp (
const void *,
const void *,
size_t);
1399void *
memmove (
void *,
const void *,
size_t);
1402char *
strchr (
const char *,
int);
1413char *
strrchr (
const char *,
int);
1415char *
strstr (
const char *,
const char *);
1426void *
memmem (
const void *,
size_t,
const void *,
size_t);
1439size_t strlcat (
char *,
const char *,
size_t);
1440size_t strlcpy (
char *,
const char *,
size_t);
1463extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __memcpy_ichk(
void *
__restrict__,
const void *
__restrict__,
size_t); extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __memcpy_ichk(
void *
__restrict__ dst,
const void *
__restrict__ src,
size_t len) {
return __builtin___memcpy_chk(dst,
src,
len, __builtin_object_size(dst, 0)); }
1464extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __memmove_ichk(
void *,
const void *,
size_t);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __memmove_ichk(
void * dst,
const void *
src,
size_t len) {
return __builtin___memmove_chk(dst,
src,
len, __builtin_object_size(dst, 0)); }
1465extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __mempcpy_ichk(
void *
__restrict__,
const void *
__restrict__,
size_t);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __mempcpy_ichk(
void *
__restrict__ dst,
const void *
__restrict__ src,
size_t len) {
return __builtin___mempcpy_chk(dst,
src,
len, __builtin_object_size(dst, 0)); }
1466extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __memset_ichk(
void *,
int,
size_t);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
void * __memset_ichk(
void * dst,
int src,
size_t len) {
return __builtin___memset_chk(dst,
src,
len, __builtin_object_size(dst, 0)); }
1467extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __stpcpy_ichk(
char *,
const char *);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __stpcpy_ichk(
char *
__restrict__ dst,
const char *
__restrict__ src) {
return __builtin___stpcpy_chk(dst,
src, __builtin_object_size(dst, 0)); }
1468extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __stpncpy_ichk(
char *
__restrict__,
const char *
__restrict__,
size_t);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __stpncpy_ichk(
char *
__restrict__ dst,
const char *
__restrict__ src,
size_t len) {
return __builtin___stpncpy_chk(dst,
src,
len, __builtin_object_size(dst, 0)); }
1469extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strcpy_ichk(
char *,
const char *);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strcpy_ichk(
char *
__restrict__ dst,
const char *
__restrict__ src) {
return __builtin___strcpy_chk(dst,
src, __builtin_object_size(dst, 0)); }
1470extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strcat_ichk(
char *,
const char *);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strcat_ichk(
char *
__restrict__ dst,
const char *
__restrict__ src) {
return __builtin___strcat_chk(dst,
src, __builtin_object_size(dst, 0)); }
1471extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strncpy_ichk(
char *
__restrict__,
const char *
__restrict__,
size_t);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strncpy_ichk(
char *
__restrict__ dst,
const char *
__restrict__ src,
size_t len) {
return __builtin___strncpy_chk(dst,
src,
len, __builtin_object_size(dst, 0)); }
1472extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strncat_ichk(
char *
__restrict__,
const char *
__restrict__,
size_t);
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
char * __strncat_ichk(
char *
__restrict__ dst,
const char *
__restrict__ src,
size_t len) {
return __builtin___strncat_chk(dst,
src,
len, __builtin_object_size(dst, 0)); }
1503char *
crypt (
const char *__key,
const char *__salt);
1506int dup2 (
int __fildes,
int __fildes2);
1507int dup3 (
int __fildes,
int __fildes2,
int flags);
1514int execlp (
const char *__file,
const char *, ...);
1515int execlpe (
const char *__file,
const char *, ...);
1517int execve (
const char *
__path,
char *
const __argv[],
char *
const __envp[]);
1518int execvp (
const char *__file,
char *
const __argv[]);
1519int execvpe (
const char *__file,
char *
const __argv[],
char *
const __envp[]);
1525int fexecve (
int __fd,
char *
const __argv[],
char *
const __envp[]);
1552int iruserok (
unsigned long raddr,
int superuser,
const char *ruser,
const char *luser);
1556int link (
const char *__path1,
const char *__path2);
1557int linkat (
int __dirfd1,
const char *__path1,
int __dirfd2,
const char *__path2,
int __flags);
1572int ruserok (
const char *rhost,
int superuser,
const char *ruser,
const char *luser);
1602int getopt (
int,
char *
const *,
const char *);
1613int symlink (
const char *__name1,
const char *__name2);
1629ssize_t __ssp_real_pread (
int __fd,
void *
__buf,
size_t __len,
off_t __off)
__asm__(
"" "pread");
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
ssize_t pread (
int __fd,
void *
__buf,
size_t __len,
off_t __off) {
if (1)
if (__builtin_object_size(
__buf, 0) != (
size_t)-1 &&
__len > __builtin_object_size(
__buf, 0))
__chk_fail();
return __ssp_real_pread (__fd,
__buf,
__len,
__off); };
1632ssize_t __ssp_real_readlinkat (
int __dirfd1,
const char *
__restrict__ __path,
char *
__restrict__ __buf,
size_t __len)
__asm__(
"" "readlinkat");
extern __inline__
__attribute__((__always_inline__, __gnu_inline__))
ssize_t readlinkat (
int __dirfd1,
const char *
__restrict__ __path,
char *
__restrict__ __buf,
size_t __len) {
if (1)
if (__builtin_object_size(
__buf, 2 > 1) != (
size_t)-1 &&
__len > __builtin_object_size(
__buf, 2 > 1))
__chk_fail();
return __ssp_real_readlinkat (__dirfd1,
__path,
__buf,
__len); };
1640extern double tanh (
double);
1642extern double modf (
double,
double *);
1649extern double cosh (
double);
1650extern double sinh (
double);
1655extern double pow (
double,
double);
1657extern double fmod (
double,
double);
1658extern int finite (
double);
1665extern int isinf (
double);
1666extern int isnan (
double);
1678extern double nan (
const char *);
1682extern double asinh (
double);
1683extern double cbrt (
double);
1684extern double nextafter (
double,
double);
1689extern double tgamma (
double);
1693extern double round (
double);
1698extern double fdim (
double,
double);
1699extern double fmax (
double,
double);
1700extern double fmin (
double,
double);
1701extern double fma (
double,
double,
double);
1704extern double acosh (
double);
1705extern double atanh (
double);
1709extern double erf (
double);
1710extern double erfc (
double);
1711extern double log2 (
double);
1712extern double hypot (
double,
double);
1749extern float fmaf (
float,
float,
float);
1772extern long double cosl (
long double);
1773extern long double sinl (
long double);
1774extern long double tanl (
long double);
1776extern long double frexpl (
long double,
int *);
1777extern long double modfl (
long double,
long double *);
1785extern long double atan2l (
long double,
long double);
1788extern long double expl (
long double);
1790extern long double logl (
long double);
1792extern long double powl (
long double,
long double);
1794extern long double fmodl (
long double,
long double);
1795extern long double hypotl (
long double,
long double);
1797extern long double nanl (
const char *);
1819extern long double remquol (
long double,
long double,
int *);
1820extern long double fdiml (
long double,
long double);
1821extern long double fmaxl (
long double,
long double);
1822extern long double fminl (
long double,
long double);
1823extern long double fmal (
long double,
long double,
long double);
1828extern long double erfl (
long double);
1830extern double drem (
double,
double);
1832extern float dreml (
long double,
long double);
1834extern double lgamma_r (
double,
int *);
1837extern double y0 (
double);
1838extern double y1 (
double);
1839extern double yn (
int,
double);
1840extern double j0 (
double);
1841extern double j1 (
double);
1842extern double jn (
int,
double);
1849extern void sincos (
double,
double *,
double *);
1851extern void sincosl (
long double,
long double *,
long double *);
1890rb_long2int_inline(
long n)
1900 return ((
long)(((
long)(x))>>(
int)(1)));
1902static inline unsigned long
1903rb_fix2ulong(
VALUE x)
1905 return ((
unsigned long)((
long)(((
long)(x))>>(
int)(1))));
1951static inline int rb_type(
VALUE obj);
1976rb_num2long_inline(
VALUE x)
1979 return ((
long)(((
long)(x))>>(
int)(1)));
1983static inline unsigned long
1984rb_num2ulong_inline(
VALUE x)
1987 return ((
unsigned long)((
long)(((
long)(x))>>(
int)(1))));
1994rb_num2int_inline(
VALUE x)
2001unsigned long rb_num2uint(
VALUE);
2002unsigned long rb_fix2uint(
VALUE);
2008rb_num2short_inline(
VALUE x)
2015long long rb_num2ll(
VALUE);
2016unsigned long long rb_num2ull(
VALUE);
2017static inline long long
2018rb_num2ll_inline(
VALUE x)
2021 return ((
long)(((
long)(x))>>(
int)(1)));
2023 return rb_num2ll(x);
2083 struct RBasic
basic;
2105 RUBY_FL_USER5|RUBY_FL_USER6),
2112 struct RBasic
basic;
2134 struct RBasic
basic;
2149 struct RBasic
basic;
2156 struct RBasic
basic;
2160 struct RBasic
basic;
2180 struct RBasic
basic;
2196rb_obj_freeze_inline(
VALUE x)
2206static inline void *rb_data_object_get_warning(
VALUE)
__attribute__((warning(
"untyped Data is unsafe; use TypedData instead")));
2216 return ((
struct RData *)
obj)->data;
2219rb_data_object_get_warning(
VALUE obj)
2278rb_long2num_inline(
long v)
2280 if ((((
v) < (0x7fffffffffffffffL>>1)+1) && ((
v) >= (((
long)(-0x7fffffffffffffffL -1L))>>(
int)(1)))))
2286rb_ulong2num_inline(
unsigned long v)
2288 if (((
v) < (0x7fffffffffffffffL>>1)+1))
2294rb_num2char_inline(
VALUE x)
2299 return (
char)(rb_num2int_inline(x) & 0xff);
2306rb_mul_size_overflow(
size_t a,
size_t b,
size_t max,
size_t *c)
2309 unsigned __int128 c2 = (
unsigned __int128)a * (
unsigned __int128)b;
2310 if (c2 > max)
return 1;
2315rb_alloc_tmp_buffer2(
volatile VALUE *store,
long count,
size_t elsize)
2318 if (elsize ==
sizeof(
VALUE)) {
2324 size_t size, max = 0x7fffffffffffffffL -
sizeof(
VALUE) + 1;
2383__attribute__ ((__error__ (
" argument length doesn't match")))
int rb_varargs_bad_length(
int,
int);
2559 return ((
struct RBasic*)(
obj))->klass;
2726int rb_integer_pack(
VALUE val,
void *words,
size_t numwords,
size_t wordsize,
size_t nails,
int flags);
2823 if ((
argc < min) || (max != (-1) &&
argc > max))
3327rb_array_len(
VALUE a)
3332static inline const VALUE *
3333rb_array_const_ptr_transient(
VALUE a)
3337static inline const VALUE *
3338rb_array_const_ptr(
VALUE a)
3344 return rb_array_const_ptr_transient(a);
3346static inline VALUE *
3347rb_array_ptr_use_start(
VALUE a,
int allow_transient)
3350 if (!allow_transient) {
3356 (
void)allow_transient;
3360rb_array_ptr_use_end(
VALUE a,
int allow_transient)
3364 (
void)allow_transient;
3371static inline int rb_isascii(
int c){
return '\0' <= c && c <=
'\x7f'; }
3372static inline int rb_isupper(
int c){
return 'A' <= c && c <=
'Z'; }
3373static inline int rb_islower(
int c){
return 'a' <= c && c <=
'z'; }
3374static inline int rb_isalpha(
int c){
return rb_isupper(c) || rb_islower(c); }
3375static inline int rb_isdigit(
int c){
return '0' <= c && c <=
'9'; }
3376static inline int rb_isalnum(
int c){
return rb_isalpha(c) || rb_isdigit(c); }
3377static inline int rb_isxdigit(
int c){
return rb_isdigit(c) || (
'A' <= c && c <=
'F') || (
'a' <= c && c <=
'f'); }
3378static inline int rb_isblank(
int c){
return c ==
' ' || c ==
'\t'; }
3379static inline int rb_isspace(
int c){
return c ==
' ' || (
'\t' <= c && c <=
'\r'); }
3380static inline int rb_iscntrl(
int c){
return (
'\0' <= c && c <
' ') || c ==
'\x7f'; }
3381static inline int rb_isprint(
int c){
return ' ' <= c && c <=
'\x7e'; }
3382static inline int rb_ispunct(
int c){
return !rb_isalnum(c); }
3383static inline int rb_isgraph(
int c){
return '!' <= c && c <=
'\x7e'; }
3384static inline int rb_tolower(
int c) {
return rb_isupper(c) ? (c|0x20) : c; }
3385static inline int rb_toupper(
int c) {
return rb_islower(c) ? (c&0x5f) : c; }
3393__attribute__ ((__error__ ("variable argument length doesn't match")))
void rb_scan_args_length_mismatch(
const char*,
int);
3396rb_scan_args_lead_p(
const char *
fmt)
3398 return ((
unsigned char)((
fmt[0])-
'0')<10);
3400__attribute__ ((__always_inline__))
static int rb_scan_args_n_lead(
const char *
fmt);
3402rb_scan_args_n_lead(
const char *
fmt)
3404 return (rb_scan_args_lead_p(
fmt) ?
fmt[0]-
'0' : 0);
3406__attribute__ ((__always_inline__))
static int rb_scan_args_opt_p(
const char *
fmt);
3408rb_scan_args_opt_p(
const char *
fmt)
3410 return (rb_scan_args_lead_p(
fmt) && ((
unsigned char)((
fmt[1])-
'0')<10));
3412__attribute__ ((__always_inline__))
static int rb_scan_args_n_opt(
const char *
fmt);
3414rb_scan_args_n_opt(
const char *
fmt)
3416 return (rb_scan_args_opt_p(
fmt) ?
fmt[1]-
'0' : 0);
3418__attribute__ ((__always_inline__))
static int rb_scan_args_var_idx(
const char *
fmt);
3420rb_scan_args_var_idx(
const char *
fmt)
3422 return (!rb_scan_args_lead_p(
fmt) ? 0 : !((
unsigned char)((
fmt[1])-
'0')<10) ? 1 : 2);
3424__attribute__ ((__always_inline__))
static int rb_scan_args_f_var(
const char *
fmt);
3426rb_scan_args_f_var(
const char *
fmt)
3428 return (
fmt[rb_scan_args_var_idx(
fmt)]==
'*');
3430__attribute__ ((__always_inline__))
static int rb_scan_args_trail_idx(
const char *
fmt);
3432rb_scan_args_trail_idx(
const char *
fmt)
3434 const int idx = rb_scan_args_var_idx(
fmt);
3435 return idx+(
fmt[idx]==
'*');
3437__attribute__ ((__always_inline__))
static int rb_scan_args_n_trail(
const char *
fmt);
3439rb_scan_args_n_trail(
const char *
fmt)
3441 const int idx = rb_scan_args_trail_idx(
fmt);
3442 return (((
unsigned char)((
fmt[idx])-
'0')<10) ?
fmt[idx]-
'0' : 0);
3444__attribute__ ((__always_inline__))
static int rb_scan_args_hash_idx(
const char *
fmt);
3446rb_scan_args_hash_idx(
const char *
fmt)
3448 const int idx = rb_scan_args_trail_idx(
fmt);
3449 return idx+((
unsigned char)((
fmt[idx])-
'0')<10);
3451__attribute__ ((__always_inline__))
static int rb_scan_args_f_hash(
const char *
fmt);
3453rb_scan_args_f_hash(
const char *
fmt)
3455 return (
fmt[rb_scan_args_hash_idx(
fmt)]==
':');
3457__attribute__ ((__always_inline__))
static int rb_scan_args_block_idx(
const char *
fmt);
3459rb_scan_args_block_idx(
const char *
fmt)
3461 const int idx = rb_scan_args_hash_idx(
fmt);
3462 return idx+(
fmt[idx]==
':');
3464__attribute__ ((__always_inline__))
static int rb_scan_args_f_block(
const char *
fmt);
3466rb_scan_args_f_block(
const char *
fmt)
3468 return (
fmt[rb_scan_args_block_idx(
fmt)]==
'&');
3470__attribute__ ((__always_inline__))
int rb_scan_args_set(
int argc,
const VALUE *
argv,
int n_lead,
int n_opt,
int n_trail,
int f_var,
int f_hash,
int f_block,
VALUE *
vars[],
char *
fmt,
int varc);
static inline
3477 int i, argi = 0, vari = 0, last_idx = -1;
3481 int empty_keyword_given = 0;
3482 VALUE tmp_buffer = 0;
3483 if (!keyword_given) {
3486 if (
argc > 0 && !(
f_hash && empty_keyword_given)) {
3489 if (keyword_given) {
3491 rb_warn(
"Keyword flag set when calling rb_scan_args, but last entry is not a hash");
3499 rb_warn(
"The last argument is nil, treating as empty keywords");
3508 if (!(last_hash = hash)) {
3509 if (!keyword_given) {
3510 rb_warn(
"Using the last argument as keyword parameters is deprecated");
3515 rb_warn(
"The last argument is split into positional and keyword parameters");
3516 last_idx =
argc - 1;
3521 else if (
f_hash && keyword_given && n_mand ==
argc) {
3522 rb_warn(
"Passing the keyword argument as the last hash parameter is deprecated");
3525 if (
f_hash && n_mand > 0 && n_mand ==
argc+1 && empty_keyword_given) {
3531 rb_warn(
"Passing the keyword argument as the last hash parameter is deprecated");
3533 if (
argc < n_mand) {
3538 if (var) *var = (argi == last_idx) ? last_hash :
argv[argi];
3544 if (var) *var = (argi == last_idx) ? last_hash :
argv[argi];
3568 if (var) *var = (argi == last_idx) ? last_hash :
argv[argi];
3573 if (var) *var = hash;
3618static inline unsigned int
3619nlz_int(
unsigned int x)
3621 if (x == 0)
return 4 * 8;
3622 return (
unsigned int)__builtin_clz(x);
3624static inline unsigned int
3625nlz_long(
unsigned long x)
3627 if (x == 0)
return 8 * 8;
3628 return (
unsigned int)__builtin_clzl(x);
3630static inline unsigned int
3631nlz_long_long(
unsigned long long x)
3633 if (x == 0)
return 8 * 8;
3634 return (
unsigned int)__builtin_clzll(x);
3636static inline unsigned int
3637nlz_int128(
unsigned __int128 x)
3639 unsigned __int128 y;
3640 unsigned int n = 128;
3641 y = x >> 64;
if (y) {
n -= 64; x = y;}
3642 y = x >> 32;
if (y) {
n -= 32; x = y;}
3643 y = x >> 16;
if (y) {
n -= 16; x = y;}
3644 y = x >> 8;
if (y) {
n -= 8; x = y;}
3645 y = x >> 4;
if (y) {
n -= 4; x = y;}
3646 y = x >> 2;
if (y) {
n -= 2; x = y;}
3647 y = x >> 1;
if (y) {
return n - 2;}
3648 return (
unsigned int)(
n - x);
3650static inline unsigned int
3655static inline unsigned int
3658 return (
unsigned int)__builtin_popcount(x);
3663 return __builtin_popcountll(x);
3668 return rb_popcount64(x);
3673 return __builtin_ctz(x);
3678 return __builtin_ctzll(x);
3683 return ntz_int64(x);
3687rb_overflowed_fix_to_int(
long x)
3689 return (
long)((
unsigned long)(x >> 1) ^ (1L
U << (8 * 8 - 1)));
3695 if (__builtin_add_overflow((
long)x, (
long)y-1, &lz)) {
3696 return rb_int2big(rb_overflowed_fix_to_int(lz));
3706 if (__builtin_sub_overflow((
long)x, (
long)y-1, &lz)) {
3707 return rb_int2big(rb_overflowed_fix_to_int(lz));
3716 long lx = ((
long)(((
long)(x))>>(
int)(1)));
3717 long ly = ((
long)(((
long)(y))>>(
int)(1)));
3718 return (((((__int128)lx * (__int128)ly) < (0x7fffffffffffffffL>>1)+1) && (((__int128)lx * (__int128)ly) >= (((
long)(-0x7fffffffffffffffL -1L))>>(
int)(1)))) ? (((
VALUE)((__int128)lx * (__int128)ly))<<1 |
RUBY_FIXNUM_FLAG) :
rb_int128t2big((__int128)lx * (__int128)ly));
3723 long x = ((
long)(((
long)(a))>>(
int)(1)));
3724 long y = ((
long)(((
long)(b))>>(
int)(1)));
3726 if (x == (((
long)(-0x7fffffffffffffffL -1L))>>(
int)(1)) && y == -1) {
3727 if (divp) *divp = rb_long2num_inline(-(((
long)(-0x7fffffffffffffffL -1L))>>(
int)(1)));
3733 if (y > 0 ? mod < 0 : mod > 0) {
3744 rb_fix_divmod_fix(x, y, &
div, ((
void *)0));
3751 rb_fix_divmod_fix(x, y, ((
void *)0), &
mod);
3834static inline const VALUE *
3839static inline const VALUE *
3840rb_struct_const_heap_ptr(
VALUE st)
3842 return ((
struct RStruct*)(
st))->as.heap.ptr;
3935 return expected_type == (((
struct RBasic*)(
imemo))->flags &
mask);
3981rb_imemo_tmpbuf_set_ptr(
VALUE v,
void *
ptr)
3986rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(
VALUE str)
3999 ((__builtin_object_size(dst, 0) != (
size_t)-1) ? __builtin___memcpy_chk(dst,
src,
len, __builtin_object_size(dst, 0)) : __memcpy_ichk(dst,
src,
len));
4046rb_ary_entry_internal(
VALUE ary,
long offset)
4048 long len = rb_array_len(ary);
4049 const VALUE *
ptr = rb_array_const_ptr_transient(ary);
4055 else if (
len <= offset) {
4294rb_num_compare_with_zero(
VALUE num,
ID mid)
4304rb_num_positive_int_p(
VALUE num)
4313 return ((((
struct RBasic*)(num))->flags & ((
VALUE)((
VALUE)RUBY_FL_USER1))) != 0);
4318rb_num_negative_int_p(
VALUE num)
4323 return ((
long)(num) < 0);
4327 return (!((((
struct RBasic*)(num))->flags & ((
VALUE)((
VALUE)RUBY_FL_USER1))) != 0));
4336rb_float_flonum_value(
VALUE v)
4338 if (
v != (
VALUE)0x8000000000000002) {
4344 t.v = ((((2 - b63) | (
v & ~(
VALUE)0x03)) >> (3)) | (((2 - b63) | (
v & ~(
VALUE)0x03)) << ((
sizeof((2 - b63) | (
v & ~(
VALUE)0x03)) * 8) - 3)));
4350rb_float_noflonum_value(
VALUE v)
4352 return ((
struct RFloat *)
v)->float_value;
4355rb_float_value_inline(
VALUE v)
4358 return rb_float_flonum_value(
v);
4360 return rb_float_noflonum_value(
v);
4363rb_float_new_inline(
double d)
4371 bits = (
int)((
VALUE)(t.v >> 60) & 0x7);
4372 if (t.v != 0x3000000000000000 &&
4373 !((bits-3) & ~0x01)) {
4374 return ((((t.v) << (3)) | ((t.v) >> ((
sizeof(t.v) * 8) - 3))) & ~(
VALUE)0x01) | 0x02;
4376 else if (t.v == (
VALUE)0) {
4377 return 0x8000000000000002;
4448 unsigned exception : 1;
4466ARGVSTR2ARGC(
VALUE argv_str)
4527rb_str_eql_internal(
const VALUE str1,
const VALUE str2)
4530 const char *ptr1, *ptr2;
4561char *
ruby_dtoa(
double d_,
int mode,
int ndigits,
int *decpt,
int *sign,
char **rve);
4562char *
ruby_hdtoa(
double d,
const char *xdigs,
int ndigits,
int *decpt,
int *sign,
char **rve);
4586static void rb_vm_pop_cfunc_frame(
void);
4591static VALUE ruby_vm_special_exception_copy(
VALUE);
4612void Init_vm_stack_canary(
void);
4789 int (*callback)(
void *start,
void *end,
size_t stride,
void *data),
4792 int (*callback)(
void *,
void *,
size_t,
void *),
5287 (
src->flags & (((
VALUE)RUBY_FL_USER4)|((
VALUE)RUBY_FL_USER5)|((
VALUE)RUBY_FL_USER6)));
5389static inline char *container_of_or_null_(
void *member_ptr,
size_t offset)
5391 return member_ptr ? (
char *)member_ptr - offset : ((
void *)0);
5401static inline void list_head_init(
struct list_head *
h)
5403 h->n.next =
h->n.prev = &
h->n;
5405static inline void list_node_init(
struct list_node *
n)
5407 n->next =
n->prev =
n;
5409static inline void list_add_after_(
struct list_head *
h,
5412 const char *abortstr)
5418 (
void)((
void)abortstr,
h);
5420static inline void list_add_(
struct list_head *
h,
5422 const char *abortstr)
5424 list_add_after_(
h, &
h->n,
n, abortstr);
5426static inline void list_add_before_(
struct list_head *
h,
5429 const char *abortstr)
5435 (
void)((
void)abortstr,
h);
5437static inline void list_add_tail_(
struct list_head *
h,
5439 const char *abortstr)
5441 list_add_before_(
h, &
h->n,
n, abortstr);
5443static inline int list_empty_(
const struct list_head *
h,
const char* abortstr)
5445 (
void)((
void)abortstr,
h);
5446 return h->n.next == &
h->n;
5448static inline _Bool list_empty_nocheck(
const struct list_head *
h)
5450 return h->n.next == &
h->n;
5452static inline void list_del_(
struct list_node *
n,
const char* abortstr)
5454 (
void)((
void)abortstr,
n);
5455 n->next->prev =
n->prev;
5456 n->prev->next =
n->next;
5458static inline void list_del_init_(
struct list_node *
n,
const char *abortstr)
5460 list_del_(
n, abortstr);
5465 ((!list_empty_(
h,
"../ruby-2.7.7/ccan/list/list.h" ":" "328")) ? (
void)0 :
__assert_func (
"../ruby-2.7.7/ccan/list/list.h", 328, __func__,
"!list_empty(h)"));
5466 list_del_(
n,
"../ruby-2.7.7/ccan/list/list.h" ":" "329");
5468static inline void list_swap_(
struct list_node *o,
5470 const char* abortstr)
5472 (
void)((
void)abortstr, o);
5477static inline const void *list_top_(
const struct list_head *
h,
size_t off)
5479 if (list_empty_(
h,
"../ruby-2.7.7/ccan/list/list.h" ":" "399"))
5481 return (
const char *)
h->n.next - off;
5483static inline const void *list_pop_(
const struct list_head *
h,
size_t off)
5486 if (list_empty_(
h,
"../ruby-2.7.7/ccan/list/list.h" ":" "425"))
5489 list_del_(
n,
"../ruby-2.7.7/ccan/list/list.h" ":" "428");
5490 return (
const char *)
n - off;
5492static inline const void *list_tail_(
const struct list_head *
h,
size_t off)
5494 if (list_empty_(
h,
"../ruby-2.7.7/ccan/list/list.h" ":" "451"))
5496 return (
const char *)
h->n.prev - off;
5498static inline void list_append_list_(
struct list_head *to,
5500 const char *abortstr)
5504 to->
n.
prev = from_tail;
5505 from_tail->
next = &to->
n;
5506 to_tail->
next = &from->
n;
5507 from->
n.
prev = to_tail;
5508 list_del_(&from->
n,
"../ruby-2.7.7/ccan/list/list.h" ":" "600");
5509 list_head_init(from);
5511static inline void list_prepend_list_(
struct list_head *to,
5513 const char *abortstr)
5519 to_head->
prev = from_tail;
5520 from_tail->
next = to_head;
5521 list_del_(&from->
n,
"../ruby-2.7.7/ccan/list/list.h" ":" "632");
5522 list_head_init(from);
5524static inline void *list_node_to_off_(
struct list_node *node,
size_t off)
5526 return (
void *)((
char *)node - off);
5528static inline struct list_node *list_node_from_off_(
void *
ptr,
size_t off)
5532static inline void *list_entry_or_null(
const struct list_head *
h,
5538 return (
char *)
n - off;
5575int pthread_atfork (
void (*)(
void),
void (*)(
void),
void (*)(
void));
5628 void *(*)(
void *),
void *);
5819pathobj_path(
VALUE pathobj)
5826 return (rb_array_const_ptr_transient(pathobj)[0]);
5830pathobj_realpath(
VALUE pathobj)
5837 return (rb_array_const_ptr_transient(pathobj)[1]);
5876 const struct rb_iseq_param_keyword {
6098rb_thread_ptr(
VALUE thval)
6213 thread_invoke_type_none = 0,
6215 thread_invoke_type_func
6243rb_iseq_new_with_callback_new_callback(
6342static inline void VM_FORCE_WRITE_SPECIAL_CONST(
const VALUE *
ptr,
VALUE special_const_value);
6346 VALUE flags = ep[( 0)];
6348 VM_FORCE_WRITE_SPECIAL_CONST(&ep[( 0)], flags | flag);
6351VM_ENV_FLAGS_UNSET(
const VALUE *ep,
VALUE flag)
6353 VALUE flags = ep[( 0)];
6355 VM_FORCE_WRITE_SPECIAL_CONST(&ep[( 0)], flags & ~flag);
6357static inline unsigned long
6358VM_ENV_FLAGS(
const VALUE *ep,
long flag)
6360 VALUE flags = ep[( 0)];
6362 return flags & flag;
6364static inline unsigned long
6409 return !VM_FRAME_CFRAME_P(
cfp);
6412VM_ENV_LOCAL_P(
const VALUE *ep)
6416static inline const VALUE *
6417VM_ENV_PREV_EP(
const VALUE *ep)
6420 return ((
void *)(((ep[(-1)])) & ~0x03));
6423VM_ENV_BLOCK_HANDLER(
const VALUE *ep)
6429VM_ENV_ESCAPED_P(
const VALUE *ep)
6435VM_ENV_ENVVAL(
const VALUE *ep)
6437 VALUE envval = ep[( 1)];
6443VM_ENV_ENVVAL_PTR(
const VALUE *ep)
6445 return (
const rb_env_t *)VM_ENV_ENVVAL(ep);
6451 env->env_size = env_size;
6461VM_FORCE_WRITE_SPECIAL_CONST(
const VALUE *
ptr,
VALUE special_const_value)
6464 VM_FORCE_WRITE(
ptr, special_const_value);
6470 VM_FORCE_WRITE(&ep[
index],
v);
6472const VALUE *rb_vm_ep_local_ep(
const VALUE *ep);
6485 return !((
void *)(RUBY_VM_END_CONTROL_FRAME(ec)) > (
void *)(
cfp));
6570vm_block_type(
const struct rb_block *block)
6580static inline const struct rb_block *
6581vm_proc_block(
VALUE procval)
6587static inline const VALUE *vm_block_ep(
const struct rb_block *block);
6589vm_proc_iseq(
VALUE procval)
6591 return vm_block_iseq(vm_proc_block(procval));
6593static inline const VALUE *
6594vm_proc_ep(
VALUE procval)
6596 return vm_block_ep(vm_proc_block(procval));
6599vm_block_iseq(
const struct rb_block *block)
6601 switch (vm_block_type(block)) {
6607 __builtin_unreachable();
6610static inline const VALUE *
6611vm_block_ep(
const struct rb_block *block)
6613 switch (vm_block_type(block)) {
6619 __builtin_unreachable();
6623vm_block_self(
const struct rb_block *block)
6625 switch (vm_block_type(block)) {
6630 return vm_block_self(vm_proc_block(block->
as.
proc));
6634 __builtin_unreachable();
6656VM_BH_FROM_PROC(
VALUE procval)
6710rb_vm_living_threads_init(
rb_vm_t *vm)
6728 list_del_(&th->
vmlt_node,
"../ruby-2.7.7/vm_core.h" ":" "1710");
6771rb_current_execution_context(
void)
6776rb_current_thread(
void)
6779 return rb_ec_thread_ptr(ec);
6798 rb_thread_set_current_raw(th);
6876 do {
const rb_event_flag_t flag_arg_ = (0x2000);
rb_hook_list_t *hooks_arg_ = (rb_vm_global_hooks(
ec));
if ((
__builtin_expect(!!((hooks_arg_)->events & (flag_arg_)), 0))) { rb_exec_event_hook_orig(
ec, hooks_arg_, flag_arg_,
ec->
cfp->
self, 0, 0, 0, !((
VALUE)(eval_script) != ((
VALUE)
RUBY_Qnil)) ? (
VALUE)
iseq : __extension__ ({
const VALUE args_to_new_ary[] = {eval_script, (
VALUE)
iseq};
if (__builtin_constant_p(2)) {
_Static_assert(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))) == (2),
"rb_ary_new_from_args" ": " "numberof(args_to_new_ary) == (2)"); }
rb_ary_new_from_values(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))), args_to_new_ary); }), 0); } }
while (0);
6902rb_call_info_kw_arg_bytes(
int keyword_len)
6915static inline VALUE *
6929static inline VALUE *
6984iseq_imemo_alloc(
void)
7059iseq_catch_table_bytes(
int n)
7063 catch_table_entries_max = (0x7fffffff - __builtin_offsetof (
struct iseq_catch_table,
entries)) / catch_table_entry_size
7065 if (
n > catch_table_entries_max)
rb_fatal(
"too large iseq_catch_table - %d",
n);
7067 n * catch_table_entry_size);
7117extern __attribute__((dllimport))
const char *
const _sys_errlist[];
7121extern __attribute__((dllimport))
char *program_invocation_name;
7122extern __attribute__((dllimport))
char *program_invocation_short_name;
7135 __builtin_longjmp(((ec->
tag->
buf)),(1));
7162 ; typeof(rb_obj_write((
VALUE)(cref), (
VALUE *)(&cref->
refinements), (
VALUE)(refs),
"../ruby-2.7.7/eval_intern.h", 220)) unaligned_member_access_result = (rb_obj_write((
VALUE)(cref), (
VALUE *)(&cref->refinements), (
VALUE)(refs), "../
ruby-2.7.7/eval_intern.
h", 220));
7163 ; unaligned_member_access_result; });
7168 return cref->flags & ((
VALUE)RUBY_FL_USER5);
7217static inline const char *
7218rb_char_next(
const char *p)
7227translit_char(
char *p,
int from,
int to)
7230 if ((
unsigned char)*p == from)
7232 p = rb_char_next(p);
7251static inline void rb_builtin_function_check_arity9(
VALUE (*
f)(
rb_execution_context_t *ec,
VALUE self,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE)){}
7252static inline void rb_builtin_function_check_arity10(
VALUE (*
f)(
rb_execution_context_t *ec,
VALUE self,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE)){}
7253static inline void rb_builtin_function_check_arity11(
VALUE (*
f)(
rb_execution_context_t *ec,
VALUE self,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE)){}
7254static inline void rb_builtin_function_check_arity12(
VALUE (*
f)(
rb_execution_context_t *ec,
VALUE self,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE)){}
7255static inline void rb_builtin_function_check_arity13(
VALUE (*
f)(
rb_execution_context_t *ec,
VALUE self,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE)){}
7256static inline void rb_builtin_function_check_arity14(
VALUE (*
f)(
rb_execution_context_t *ec,
VALUE self,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE)){}
7257static inline void rb_builtin_function_check_arity15(
VALUE (*
f)(
rb_execution_context_t *ec,
VALUE self,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE)){}
static inline
7286 while (!VM_ENV_LOCAL_P(ep)) {
7287 ep = VM_ENV_PREV_EP(ep);
7299 while (
cfp < eocfp) {
7300 if (
cfp->
ep == ep) {
7309rb_vm_ep_local_ep(
const VALUE *ep)
7311 return VM_EP_LEP(ep);
7314static inline const VALUE *
7317 return VM_EP_LEP(
cfp->
ep);
7319static inline const VALUE *
7322 return VM_ENV_PREV_EP(
cfp->
ep);
7329 return VM_ENV_BLOCK_HANDLER(ep);
7334 return VM_FRAME_CFRAME_KW_P(
cfp);
7339 return VM_FRAME_CFRAME_EMPTY_KW_P(
cfp);
7344 return VM_CF_BLOCK_HANDLER(
cfp);
7378 int omod_shared = 0;
7385 scope_visi.visi.module_func = module_func;
7386 if (prev_cref != ((
void *)0) && prev_cref != (
void *)1 ) {
7387 refinements = CREF_REFINEMENTS(prev_cref);
7390 CREF_OMOD_SHARED_SET(prev_cref);
7394 if (pushed_by_eval) CREF_PUSHED_BY_EVAL_SET(cref);
7395 if (omod_shared) CREF_OMOD_SHARED_SET(cref);
7401 return vm_cref_new0(
klass, visi, module_func, prev_cref, pushed_by_eval, 0);
7406 return vm_cref_new0(
klass, visi, module_func, prev_cref, pushed_by_eval, 1);
7418 rb_cref_t *next_cref = CREF_NEXT(cref), *new_cref;
7419 int pushed_by_eval = CREF_PUSHED_BY_EVAL(cref);
7424 CREF_REFINEMENTS_SET(new_cref, ref);
7425 CREF_OMOD_SHARED_UNSET(new_cref);
7440rb_vm_cref_new_toplevel(
void)
7442 return vm_cref_new_toplevel(rb_current_execution_context());
7445vm_cref_dump(
const char *mesg,
const rb_cref_t *cref)
7447 fprintf(((
__getreent())->_stderr),
"vm_cref_dump: %s (%p)\n", mesg, (
void *)cref);
7450 cref = CREF_NEXT(cref);
7466 ; unaligned_member_access_result; });
7467 rb_vm_block_ep_update(bindval, &bind->block,
env->ep);
7707 return (body->
type == ISEQ_TYPE_METHOD || body->
type == ISEQ_TYPE_BLOCK)
7749 return func(ec, ec->
cfp);
7777 obj->throw_state =
st;
7784 return obj->throw_obj;
7790 return obj->catch_frame;
7796 return obj->throw_state;
7802 return obj->flags & ((
VALUE)RUBY_FL_USER4);
7814 obj->throw_state =
st;
7821 obj->flags |= ((
VALUE)RUBY_FL_USER4);
8079ruby_vm_special_exception_copy(
VALUE exc)
8093 mesg = ruby_vm_special_exception_copy(mesg);
8100__attribute__ ((__noreturn__))
static void vm_stackoverflow(
void);
8102vm_stackoverflow(
void)
8104 ec_stack_overflow(rb_current_execution_context(), 1);
8115 ec_stack_overflow(ec, 1);
8158 VALUE flags = ep[( 0)];
8161 rb_vm_check_ints(ec);
8168 vm_pop_frame(ec, ec->
cfp, ec->
cfp->
ep);
8171rb_arity_error_new(
int argc,
int min,
int max)
8175 err_mess =
rb_sprintf(
"wrong number of arguments (given %d, expected %d)",
argc, min);
8177 else if (max == (-1)) {
8178 err_mess =
rb_sprintf(
"wrong number of arguments (given %d, expected %d+)",
argc, min);
8181 err_mess =
rb_sprintf(
"wrong number of arguments (given %d, expected %d..%d)",
argc, min, max);
8195 VM_FORCE_WRITE(&ep[
index],
v);
8202 VALUE flags = ep[( 0)];
8204 VM_STACK_ENV_WRITE(ep,
index,
v);
8207 vm_env_write_slowpath(ep,
index,
v);
8226 __builtin_unreachable();
8234 if (lep && (ec == ((
void *)0) || ec->
root_lep != lep)) {
8241 return (
struct vm_svar *)svar;
8247 if (lep && (ec == ((
void *)0) || ec->
root_lep != lep)) {
8248 vm_env_write(lep, (-2), (
VALUE)svar);
8253; typeof(rb_obj_write((
VALUE)(rb_ec_thread_ptr(ec)->
self), (
VALUE *)(&ec->
root_svar), (
VALUE)(svar),
"../ruby-2.7.7/vm_insnhelper.c", 486)) unaligned_member_access_result = (rb_obj_write((
VALUE)(rb_ec_thread_ptr(ec)->self), (
VALUE *)(&ec->
root_svar), (
VALUE)(svar), "../
ruby-2.7.7/vm_insnhelper.c", 486));
8254; unaligned_member_access_result; });
8260 const struct vm_svar *svar = lep_svar(ec, lep);
8264 return svar->lastline;
8266 return svar->backref;
8268 const VALUE ary = svar->others;
8286 struct vm_svar *svar = lep_svar(ec, lep);
8288 lep_svar_write(ec, lep, svar = svar_new((
VALUE)svar));
8294; typeof(rb_obj_write((
VALUE)(svar), (
VALUE *)(&svar->lastline), (
VALUE)(val),
"../ruby-2.7.7/vm_insnhelper.c", 532)) unaligned_member_access_result = (rb_obj_write((
VALUE)(svar), (
VALUE *)(&svar->
lastline), (
VALUE)(val), "../
ruby-2.7.7/vm_insnhelper.c", 532));
8295; unaligned_member_access_result; });
8300; typeof(rb_obj_write((
VALUE)(svar), (
VALUE *)(&svar->backref), (
VALUE)(val),
"../ruby-2.7.7/vm_insnhelper.c", 535)) unaligned_member_access_result = (rb_obj_write((
VALUE)(svar), (
VALUE *)(&svar->
backref), (
VALUE)(val), "../
ruby-2.7.7/vm_insnhelper.c", 535));
8301; unaligned_member_access_result; });
8304 VALUE ary = svar->others;
8309 ; unaligned_member_access_result; });
8320 val = lep_svar_get(ec, lep,
key);
8325 switch (
type >> 1) {
8339 rb_bug(
"unexpected back-ref");
8371 while (!VM_ENV_LOCAL_P(ep)) {
8372 if ((
me = check_method_entry(ep[(-2)], 0)) != ((
void *)0))
return me;
8373 ep = VM_ENV_PREV_EP(ep);
8375 return check_method_entry(ep[(-2)], 1);
8406vm_env_cref(
const VALUE *ep)
8409 while (!VM_ENV_LOCAL_P(ep)) {
8410 if ((cref = check_cref(ep[(-2)], 0)) != ((
void *)0))
return cref;
8411 ep = VM_ENV_PREV_EP(ep);
8413 return check_cref(ep[(-2)], 1);
8431vm_env_cref_by_cref(
const VALUE *ep)
8433 while (!VM_ENV_LOCAL_P(ep)) {
8434 if (is_cref(ep[(-2)], 0))
return 1;
8435 ep = VM_ENV_PREV_EP(ep);
8437 return is_cref(ep[(-2)], 1);
8448 new_cref = vm_cref_dup(cref);
8452 ; typeof(rb_obj_write((
VALUE)(parent), (
VALUE *)(vptr), (
VALUE)(new_cref),
"../ruby-2.7.7/vm_insnhelper.c", 716)) unaligned_member_access_result = (rb_obj_write((
VALUE)(parent), (
VALUE *)(vptr), (
VALUE)(new_cref), "../
ruby-2.7.7/vm_insnhelper.c", 716));
8453 ; unaligned_member_access_result; });
8456 VM_FORCE_WRITE(vptr, (
VALUE)new_cref);
8464 rb_bug(
"cref_replace_with_duplicated_cref_each_frame: unreachable");
8472vm_cref_replace_with_duplicated_cref(
const VALUE *ep)
8474 if (vm_env_cref_by_cref(ep)) {
8477 while (!VM_ENV_LOCAL_P(ep)) {
8479 if ((cref = cref_replace_with_duplicated_cref_each_frame(&ep[(-2)], 0, envval)) != ((
void *)0)) {
8482 ep = VM_ENV_PREV_EP(ep);
8485 return cref_replace_with_duplicated_cref_each_frame(&ep[(-2)], 1, envval);
8488 rb_bug(
"vm_cref_dup: unreachable");
8492vm_get_cref(
const VALUE *ep)
8495 if (cref != ((
void *)0)) {
8499 rb_bug(
"vm_get_cref: unreachable");
8506 if (
cfp == ((
void *)0)) {
8509 return vm_get_cref(
cfp->
ep);
8512vm_get_const_key_cref(
const VALUE *ep)
8514 const rb_cref_t *cref = vm_get_cref(ep);
8521 cref = CREF_NEXT(cref);
8530 if (CREF_CLASS(cref) == old_klass) {
8532 *new_cref_ptr = new_cref;
8535 new_cref = vm_cref_new_use_prev(CREF_CLASS(cref),
METHOD_VISI_UNDEF, 0, cref, 0);
8536 cref = CREF_NEXT(cref);
8537 *new_cref_ptr = new_cref;
8540 *new_cref_ptr = ((
void *)0);
8547 prev_cref = vm_env_cref(ep);
8552 prev_cref = vm_env_cref(
cfp->
ep);
8558vm_get_cbase(
const VALUE *ep)
8560 const rb_cref_t *cref = vm_get_cref(ep);
8563 if ((
klass = CREF_CLASS(cref)) != 0) {
8566 cref = CREF_NEXT(cref);
8571vm_get_const_base(
const VALUE *ep)
8573 const rb_cref_t *cref = vm_get_cref(ep);
8576 if (!CREF_PUSHED_BY_EVAL(cref) &&
8577 (
klass = CREF_CLASS(cref)) != 0) {
8580 cref = CREF_NEXT(cref);
8592vm_ensure_not_refinement_module(
VALUE self)
8595 rb_warn(
"not defined at the refinement, but at the outer class/module");
8612 while (root_cref && CREF_PUSHED_BY_EVAL(root_cref)) {
8613 root_cref = CREF_NEXT(root_cref);
8616 while (cref && CREF_NEXT(cref)) {
8617 if (CREF_PUSHED_BY_EVAL(cref)) {
8621 klass = CREF_CLASS(cref);
8623 cref = CREF_NEXT(cref);
8632 if (am ==
klass)
break;
8634 if (is_defined)
return 1;
8637 goto search_continue;
8651 klass = vm_get_iclass(ec->
cfp, CREF_CLASS(root_cref));
8664 vm_check_if_namespace(orig_klass);
8678 rb_bug(
"vm_get_cvar_base: no cref");
8680 while (CREF_NEXT(cref) &&
8682 CREF_PUSHED_BY_EVAL(cref))) {
8683 cref = CREF_NEXT(cref);
8685 if (!CREF_NEXT(cref)) {
8686 rb_warn(
"class variable access from toplevel");
8688 klass = vm_get_iclass(
cfp, CREF_CLASS(cref));
8749 if (
index < numiv) {
8802 ; unaligned_member_access_result; });
8814 else if (
index >= 0x7fffffff) {
8833 return vm_getivar(
obj,
id, ic, ((
void *)0), 0);
8839 vm_setivar(
obj,
id, val, ic, 0, 0);
8860 const int flag,
const VALUE throwobj)
8871 while (base_iseq->
body->
type != ISEQ_TYPE_BLOCK) {
8873 escape_cfp = ((escape_cfp)+1);
8874 ep = escape_cfp->
ep;
8875 base_iseq = escape_cfp->
iseq;
8878 ep = VM_ENV_PREV_EP(ep);
8880 escape_cfp = rb_vm_search_cf_from_ep(ec, escape_cfp, ep);
8884 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
8889 ep = VM_ENV_PREV_EP(ep);
8890 while (escape_cfp < eocfp) {
8891 if (escape_cfp->
ep == ep) {
8897 for (
i=0;
i < ct->
size;
i++) {
8901 ; typeof(&(ct)->
entries[
i]) unaligned_member_access_result = (&(ct)->
entries[
i]);
8902 ; unaligned_member_access_result; });
8904 entry->
iseq == base_iseq &&
8905 entry->
start < epc && entry->
end >= epc) {
8906 if (entry->
cont == epc) {
8914 escape_cfp = ((escape_cfp)+1);
8923 escape_cfp = rb_vm_search_cf_from_ep(ec,
reg_cfp, ep);
8927 const VALUE *target_lep = VM_EP_LEP(current_ep);
8928 int in_class_frame = 0;
8931 while (escape_cfp < eocfp) {
8932 const VALUE *lep = VM_CF_LEP(escape_cfp);
8936 if (lep == target_lep &&
8937 VM_FRAME_RUBYFRAME_P(escape_cfp) &&
8942 if (lep == target_lep) {
8943 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
8945 if (in_class_frame) {
8949 const VALUE *tep = current_ep;
8950 while (target_lep != tep) {
8951 if (escape_cfp->
ep == tep) {
8954 tep = VM_ENV_PREV_EP(tep);
8958 else if (VM_FRAME_RUBYFRAME_P(escape_cfp)) {
8961 case ISEQ_TYPE_MAIN:
8963 if (in_class_frame)
goto unexpected_return;
8967 case ISEQ_TYPE_EVAL:
8968 case ISEQ_TYPE_CLASS:
8976 if (escape_cfp->
ep == target_lep && escape_cfp->
iseq->
body->
type == ISEQ_TYPE_METHOD) {
8979 escape_cfp = ((escape_cfp)+1);
8986 rb_bug(
"isns(throw): unsupported throw type");
8989 return (
VALUE)THROW_DATA_NEW(throwobj, escape_cfp, state);
8998 return vm_throw_start(ec,
reg_cfp, state, flag, throwobj);
9001 return vm_throw_continue(ec, throwobj);
9007 int is_splat = flag & 0x01;
9008 rb_num_t space_size = num + is_splat;
9019 ptr = rb_array_const_ptr_transient(ary);
9022 if (space_size == 0) {
9024 else if (flag & 0x02) {
9027 for (
i=0;
i<num-
len;
i++) {
9031 for (j=0;
i<num;
i++, j++) {
9041 VALUE *bptr = &base[space_size - 1];
9042 for (
i=0;
i<num;
i++) {
9044 for (;
i<num;
i++) {
9060 (*__extension__ ({
volatile VALUE *rb_gc_guarded_ptr = &(ary);
__asm__(
"" : :
"m"(rb_gc_guarded_ptr)); rb_gc_guarded_ptr; }));
9071 return vm_call_general;
9075 return vm_call_general;
9079 return vm_call_general;
9084 return vm_call_general;
9118 for (;
i > 0;
i--) {
9122 ((__builtin_object_size((&
cc->
aux), 0) != (
size_t)-1) ? __builtin___memset_chk((&
cc->
aux), 0,
sizeof(
cc->
aux)*(
size_t)(1), __builtin_object_size((&
cc->
aux), 0)) : __memset_ichk((&
cc->
aux), 0,
sizeof(
cc->
aux)*(
size_t)(1)));
9143 vm_search_method_fastpath(cd,
klass);
9159 vm_search_method(cd, recv);
9160 return check_cfunc(cd->
cc.
me, func);
9165 if (vm_method_cfunc_is(cd, recv, rb_obj_equal)) {
9183 long z = ((x ^ 2) | (y ^ 2)) & 3;
9189 if (FIXNUM_2_P(recv,
obj)) {
9190 return (((
__builtin_expect(!!((rb_current_vm()->redefined_flag[(
BOP_EQ)]&((1 << 0))) == 0), 1))) != 0) * 2 - 1;
9192 if (FLONUM_2_P(recv,
obj)) {
9193 return (((
__builtin_expect(!!((rb_current_vm()->redefined_flag[(
BOP_EQ)]&((1 << 1))) == 0), 1))) != 0) * 2 - 1;
9196 return (((
__builtin_expect(!!((rb_current_vm()->redefined_flag[(
BOP_EQ)]&((1 << 6))) == 0), 1))) != 0) * 2 - 1;
9205 switch (comparable_by_identity(recv,
obj)) {
9221 return rb_str_eql_internal(recv,
obj);
9225 return opt_equal_fallback(recv,
obj, cd);
9232 switch (comparable_by_identity(recv,
obj)) {
9251 return opt_equal_fallback(recv,
obj, cd);
9260 return opt_eql_func(obj1,
obj2, &cd);
9280 return __extension__({
static struct rb_call_data rb_funcallv_data; rb_funcallv_with_cc(&rb_funcallv_data, pattern,
idEqq, 1, &target); });
9284 rb_bug(
"check_match: unreachable");
9288double_cmp_lt(
double a,
double b)
9294double_cmp_le(
double a,
double b)
9300double_cmp_gt(
double a,
double b)
9306double_cmp_ge(
double a,
double b)
9311static inline VALUE *
9373args_reduce(
struct args_info *args,
int over_argc)
9376 const long len = rb_array_len(args->
rest);
9377 if (
len > over_argc) {
9388 args->
argc -= over_argc;
9391args_check_block_arg0(
struct args_info *args)
9394 if (args->
rest && rb_array_len(args->
rest) == 1) {
9395 VALUE arg0 = (rb_array_const_ptr_transient(args->
rest)[0]);
9398 else if (args->
argc == 1) {
9401 args->
argv[0] = arg0;
9421 ; typeof(rb_obj_write((
VALUE)(_ary), (
VALUE *)(&
ptr[--args->
rest_index]), (
VALUE)(_v),
"../ruby-2.7.7/vm_args.c", 154)) unaligned_member_access_result = (rb_obj_write((
VALUE)(_ary), (
VALUE *)(&
ptr[--args->rest_index]), (
VALUE)(_v), "../
ruby-2.7.7/vm_args.c", 154));
9422 ; unaligned_member_access_result; }); rb_array_ptr_use_end(_ary, 1); }
while (0);
9428 else if (args->
argc > 0) {
9435static inline const VALUE *
9438 return rb_array_const_ptr_transient(args->
rest) + args->
rest_index;
9458 if ((*(
int*)
arg & 3) == 3) {
9464keyword_hash_symbol_other(
VALUE hash)
9466 int symbol_other = 0;
9468 return symbol_other;
9480keyword_hash_split(
VALUE *kw_hash_ptr,
VALUE *rest_hash_ptr)
9486keyword_hash_p(
VALUE *kw_hash_ptr,
VALUE *rest_hash_ptr,
int check_only_symbol)
9490 if (check_only_symbol) {
9491 switch (keyword_hash_symbol_other(*rest_hash_ptr)) {
9500 keyword_hash_split(kw_hash_ptr, rest_hash_ptr);
9504 *kw_hash_ptr = *rest_hash_ptr;
9514args_pop_keyword_hash(
struct args_info *args,
VALUE *kw_hash_ptr,
int check_only_symbol)
9520 *kw_hash_ptr = args->
argv[args->
argc-1];
9521 if (keyword_hash_p(kw_hash_ptr, &rest_hash, check_only_symbol)) {
9523 args->
argv[args->
argc-1] = rest_hash;
9532 long len = rb_array_len(args->
rest);
9534 *kw_hash_ptr = (rb_array_const_ptr_transient(args->
rest)[
len - 1]);
9535 if (keyword_hash_p(kw_hash_ptr, &rest_hash, check_only_symbol)) {
9537 do {
const VALUE _ary = (args->
rest);
const VALUE _v = (rest_hash);
VALUE *
ptr = (
VALUE *)rb_array_ptr_use_start(_ary, 1); __extension__({
9539 ; typeof(rb_obj_write((
VALUE)(_ary), (
VALUE *)(&
ptr[
len - 1]), (
VALUE)(_v),
"../ruby-2.7.7/vm_args.c", 291)) unaligned_member_access_result = (rb_obj_write((
VALUE)(_ary), (
VALUE *)(&
ptr[
len - 1]), (
VALUE)(_v), "../
ruby-2.7.7/vm_args.c", 291));
9540 ; unaligned_member_access_result; }); rb_array_ptr_use_end(_ary, 1); }
while (0);
9556args_kw_argv_to_hash(
struct args_info *args)
9562 const int kw_start = args->
argc - kw_len;
9563 const VALUE *
const kw_argv = args->
argv + kw_start;
9565 args->
argc = kw_start + 1;
9566 for (
i=0;
i<kw_len;
i++) {
9573args_stored_kw_argv_to_hash(
struct args_info *args)
9578 const int passed_keyword_len = kw_arg->
keyword_len;
9580 for (
i=0;
i<passed_keyword_len;
i++) {
9601 const VALUE *
argv = args_rest_argv(args);
9603 locals[
i] =
argv[j];
9613 len = rb_array_len(args->
rest);
9614 ((__builtin_object_size((locals), 0) != (
size_t)-1) ? __builtin___memcpy_chk((locals), (rb_array_const_ptr_transient(args->
rest) +
len -
argc),
sizeof(
VALUE)*(
size_t)(
argc), __builtin_object_size((locals), 0)) : __memcpy_ichk((locals), (rb_array_const_ptr_transient(args->rest) +
len -
argc), sizeof(
VALUE)*(
size_t)(
argc)));
9618args_setup_opt_parameters(
struct args_info *args,
int opt_max,
VALUE *locals)
9621 if (args->
argc >= opt_max) {
9622 args->
argc -= opt_max;
9623 args->
argv += opt_max;
9631 int len = rb_long2int_inline(rb_array_len(args->
rest));
9632 const VALUE *
argv = rb_array_const_ptr_transient(args->
rest);
9637 for (j=
i; j<opt_max; j++) {
9646 *locals = args_rest_array(args);
9649make_unknown_kw_hash(
const VALUE *passed_keywords,
int passed_keyword_len,
const VALUE *kw_argv)
9653 for (
i=0;
i<passed_keyword_len;
i++) {
9661make_rest_kw_hash(
const VALUE *passed_keywords,
int passed_keyword_len,
const VALUE *kw_argv)
9665 for (
i=0;
i<passed_keyword_len;
i++) {
9673args_setup_kw_parameters_lookup(
const ID key,
VALUE *
ptr,
const VALUE *
const passed_keywords,
VALUE *passed_values,
const int passed_keyword_len)
9677 for (
i=0;
i<passed_keyword_len;
i++) {
9678 if (keyname == passed_keywords[
i]) {
9679 *
ptr = passed_values[
i];
9688 VALUE *
const passed_values,
const int passed_keyword_len,
const VALUE *
const passed_keywords,
9689 VALUE *
const locals)
9696 int i, di, found = 0;
9697 int unspecified_bits = 0;
9699 for (
i=0;
i<req_key_num;
i++) {
9700 ID key = acceptable_keywords[
i];
9701 if (args_setup_kw_parameters_lookup(
key, &locals[
i], passed_keywords, passed_values, passed_keyword_len)) {
9709 if (missing) argument_kw_error(ec,
iseq,
"missing", missing);
9710 for (di=0;
i<key_num;
i++, di++) {
9711 if (args_setup_kw_parameters_lookup(acceptable_keywords[
i], &locals[
i], passed_keywords, passed_values, passed_keyword_len)) {
9718 unspecified_bits |= 0x01 << di;
9724 for (j=0; j<(32-1); j++) {
9725 if (unspecified_bits & (0x01 << j)) {
9734 locals[
i] = default_values[di];
9739 const int rest_hash_index = key_num + 1;
9740 locals[rest_hash_index] = make_rest_kw_hash(passed_keywords, passed_keyword_len, passed_values);
9743 if (found != passed_keyword_len) {
9744 VALUE keys = make_unknown_kw_hash(passed_keywords, passed_keyword_len, passed_values);
9745 argument_kw_error(ec,
iseq,
"unknown",
keys);
9751 locals[key_num] = unspecified_bits_value;
9754args_setup_kw_rest_parameter(
VALUE keyword_hash,
VALUE *locals)
9773 int i =
arg->argc++;
9791static st_table *caller_to_callees = 0;
9796 if (!
iseq)
return 0;
9801 if (!caller_to_callees) {
9809 if (val ==
callee)
return 1;
9828 if (rb_warn_check(ec,
iseq))
return;
9831 rb_warn(
"Passing the keyword argument as the last hash parameter is deprecated");
9837 rb_warn(
"Passing the keyword argument for `%""l""i" "\v""' as the last hash parameter is deprecated",
9841 rb_warn(
"Passing the keyword argument as the last hash parameter is deprecated");
9843 rb_compile_warn((!(((
struct RBasic*)((rb_array_const_ptr_transient(loc)[0])))->flags &
RSTRING_NOEMBED) ? ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.ary : ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.heap.ptr), ((
int)
rb_fix2int((
VALUE)((rb_array_const_ptr_transient(loc)[1])))),
9844 "The called method `%""l""i" "\v""' is defined here",
name);
9847 rb_compile_warn((!(((
struct RBasic*)((rb_array_const_ptr_transient(loc)[0])))->flags &
RSTRING_NOEMBED) ? ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.ary : ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.heap.ptr), ((
int)
rb_fix2int((
VALUE)((rb_array_const_ptr_transient(loc)[1])))),
9848 "The called method is defined here");
9855 if (rb_warn_check(ec,
iseq))
return;
9860 rb_warn(
"Splitting the last argument for `%""l""i" "\v""' into positional and keyword parameters is deprecated",
9864 rb_warn(
"Splitting the last argument into positional and keyword parameters is deprecated");
9866 rb_compile_warn((!(((
struct RBasic*)((rb_array_const_ptr_transient(loc)[0])))->flags &
RSTRING_NOEMBED) ? ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.ary : ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.heap.ptr), ((
int)
rb_fix2int((
VALUE)((rb_array_const_ptr_transient(loc)[1])))),
9867 "The called method `%""l""i" "\v""' is defined here",
name);
9870 rb_compile_warn((!(((
struct RBasic*)((rb_array_const_ptr_transient(loc)[0])))->flags &
RSTRING_NOEMBED) ? ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.ary : ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.heap.ptr), ((
int)
rb_fix2int((
VALUE)((rb_array_const_ptr_transient(loc)[1])))),
9871 "The called method is defined here");
9878 if (rb_warn_check(ec,
iseq))
return;
9883 rb_warn(
"Using the last argument for `%""l""i" "\v""' as keyword parameters is deprecated; maybe ** should be added to the call",
9887 rb_warn(
"Using the last argument as keyword parameters is deprecated; maybe ** should be added to the call");
9889 rb_compile_warn((!(((
struct RBasic*)((rb_array_const_ptr_transient(loc)[0])))->flags &
RSTRING_NOEMBED) ? ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.ary : ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.heap.ptr), ((
int)
rb_fix2int((
VALUE)((rb_array_const_ptr_transient(loc)[1])))),
9890 "The called method `%""l""i" "\v""' is defined here",
name);
9893 rb_compile_warn((!(((
struct RBasic*)((rb_array_const_ptr_transient(loc)[0])))->flags &
RSTRING_NOEMBED) ? ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.ary : ((
struct RString*)((rb_array_const_ptr_transient(loc)[0])))->as.heap.ptr), ((
int)
rb_fix2int((
VALUE)((rb_array_const_ptr_transient(loc)[1])))),
9894 "The called method is defined here");
9909 int opt_pc = 0, allow_autosplat = !kw_flag;
9914 int remove_empty_keyword_hash = 1;
9915 VALUE flag_keyword_hash = 0;
9920 ec->
cfp->
sp = &locals[
i];
9923 args->
argv = locals;
9930 args->
argc -= kw_len;
9931 given_argc -= kw_len;
9932 ((__builtin_object_size((args->
kw_argv), 0) != (
size_t)-1) ? __builtin___memcpy_chk((args->
kw_argv), (locals + args->
argc),
sizeof(
VALUE)*(
size_t)(kw_len), __builtin_object_size((args->
kw_argv), 0)) : __memcpy_ichk((args->kw_argv), (locals + args->
argc), sizeof(
VALUE)*(
size_t)(kw_len)));
9936 given_argc = args_kw_argv_to_hash(args);
9941 args->
kw_arg = ((
void *)0);
9945 remove_empty_keyword_hash = 0;
9948 VALUE rest_last = 0;
9952 len = rb_long2int_inline(rb_array_len(args->
rest));
9953 given_argc +=
len - 1;
9954 rest_last = (rb_array_const_ptr_transient(args->
rest)[
len - 1]);
9955 if (!kw_flag &&
len > 0) {
9961 remove_empty_keyword_hash = 0;
9969 if (
len > 0 && ignore_keyword_hash_p(rest_last,
iseq)) {
9971 if (remove_empty_keyword_hash) {
9980 do {
const VALUE _ary = (args->
rest);
const VALUE _v = (rest_last);
VALUE *
ptr = (
VALUE *)rb_array_ptr_use_start(_ary, 1); __extension__({
9982 ; typeof(rb_obj_write((
VALUE)(_ary), (
VALUE *)(&
ptr[
len - 1]), (
VALUE)(_v),
"../ruby-2.7.7/vm_args.c", 826)) unaligned_member_access_result = (rb_obj_write((
VALUE)(_ary), (
VALUE *)(&
ptr[
len - 1]), (
VALUE)(_v), "../
ruby-2.7.7/vm_args.c", 826));
9983 ; unaligned_member_access_result; }); rb_array_ptr_use_end(_ary, 1); }
while (0);
9985 flag_keyword_hash = rest_last;
9992 else if (!remove_empty_keyword_hash && rest_last) {
9993 flag_keyword_hash = rest_last;
10000 if (ignore_keyword_hash_p(last_arg,
iseq)) {
10002 if (remove_empty_keyword_hash) {
10010 args->
argv[args->
argc-1] = last_arg;
10012 flag_keyword_hash = last_arg;
10019 else if (!remove_empty_keyword_hash) {
10020 flag_keyword_hash = args->
argv[args->
argc-1];
10035 if (given_argc == 1 &&
10040 args_check_block_arg0(args)) {
10041 given_argc = rb_long2int_inline(rb_array_len(args->
rest));
10047 args_stored_kw_argv_to_hash(args);
10048 given_argc = args_argc(args);
10065 (kw_splat && given_argc >
max_argc)) &&
10066 args->
kw_argv == ((
void *)0)) {
10072 if (args_pop_keyword_hash(args, &keyword_hash, check_only_symbol)) {
10075 else if (check_only_symbol) {
10084 else if (args_pop_keyword_hash(args, &keyword_hash, 1)) {
10092 else if (given_argc ==
min_argc && kw_flag) {
10098 args_reduce(args, given_argc -
max_argc);
10123 if (args->
kw_argv != ((
void *)0)) {
10131 arg.vals =
arg.keys + kw_len;
10135 args_setup_kw_parameters(ec,
iseq,
arg.vals, kw_len,
arg.keys, klocals);
10139 args_setup_kw_parameters(ec,
iseq, ((
void *)0), 0, ((
void *)0), klocals);
10155 ec->
cfp->
sp = orig_sp;
10167 ec->
cfp->
sp, 0, 0 );
10170 rb_vm_pop_frame(ec);
10185 const ID *keywords = kw->table;
10186 int req_key_num = kw->required_num;
10187 if (req_key_num > 0) {
10188 static const char required[] =
"; required keywords";
10191 rb_str_cat(mesg, required,
sizeof(required) - 1 - (req_key_num == 1));
10197 }
while (--req_key_num);
10201 raise_argument_error(ec,
iseq,
exc);
10217 const VALUE *
ptr = rb_array_const_ptr_transient(
ary);
10218 long len = rb_array_len(
ary),
i;
10220 for (
i = 0;
i <
len;
i++) {
10235 for (
i=0;
i<kw_len;
i++) {
10238 (sp-kw_len)[0] =
h;
10239 cfp->
sp -= kw_len - 1;
10244vm_to_proc(
VALUE proc)
10258 "wrong argument type %s (expected Proc)",
10274 const VALUE symbol = (rb_array_const_ptr_transient(callback_arg)[0]);
10275 const VALUE refinements = (rb_array_const_ptr_transient(callback_arg)[1]);
10292 ec = rb_current_execution_context();
10294 vm_passed_block_handler_set(ec, blockarg);
10339 return vm_to_proc(block_code);
10342 else if (blockiseq != ((
void *)0)) {
10345 return VM_BH_FROM_ISEQ_BLOCK(captured);
10349 return ((VM_EP_LEP(((((
reg_cfp)->
ep)))))[(-1)]);
10368 return vm_call_iseq_setup_tailcall(ec,
cfp,
calling, cd, 0);
10378 return vm_call_iseq_setup_normal(ec,
cfp,
calling,
cc->
me, 0, param, local);
10453 const int opt =
calling->argc - lead_num;
10458 const int delta = opt_num - opt;
10470 const int opt =
calling->argc - lead_num;
10477 VALUE *
const passed_values,
const int passed_keyword_len,
const VALUE *
const passed_keywords,
10478 VALUE *
const locals);
10495 VALUE *
const klocals =
argv + kw_param->bits_start - kw_param->num;
10497 VALUE *
const ci_kws = (
VALUE*)__builtin_alloca_with_align((
sizeof(
VALUE)*(ci_kw_len)), _Alignof(
VALUE) * 8);
10498 ((__builtin_object_size((ci_kws), 0) != (
size_t)-1) ? __builtin___memcpy_chk((ci_kws), (
argv + lead_num),
sizeof(
VALUE)*(
size_t)(ci_kw_len), __builtin_object_size((ci_kws), 0)) : __memcpy_ichk((ci_kws), (
argv + lead_num), sizeof(
VALUE)*(
size_t)(ci_kw_len)));
10499 args_setup_kw_parameters(ec,
iseq, ci_kws, ci_kw_len, ci_keywords, klocals);
10502 return vm_call_iseq_setup_normal(ec,
cfp,
calling,
cc->
me, 0, param, local);
10516 VALUE *
const klocals =
argv + kw_param->bits_start - kw_param->num;
10518 for (
i=0;
i<kw_param->num;
i++) {
10519 klocals[
i] = kw_param->default_values[
i];
10524 return vm_call_iseq_setup_normal(ec,
cfp,
calling,
cc->
me, 0, param, local);
10543 else if (rb_iseq_only_optparam_p(
iseq)) {
10550 const int opt =
argc - lead_num;
10551 if (opt < 0 || opt > opt_num) {
10552 argument_arity_error(ec,
iseq,
argc, lead_num, lead_num + opt_num);
10555 CC_SET_FASTPATH(
cc, vm_call_iseq_setup_normal_opt_start,
10560 CC_SET_FASTPATH(
cc, vm_call_iseq_setup_tailcall_opt_start,
10565 for (
int i=
argc;
i<lead_num + opt_num;
i++) {
10579 VALUE *
const ci_kws = (
VALUE*)__builtin_alloca_with_align((
sizeof(
VALUE)*(ci_kw_len)), _Alignof(
VALUE) * 8);
10580 ((__builtin_object_size((ci_kws), 0) != (
size_t)-1) ? __builtin___memcpy_chk((ci_kws), (
argv + lead_num),
sizeof(
VALUE)*(
size_t)(ci_kw_len), __builtin_object_size((ci_kws), 0)) : __memcpy_ichk((ci_kws), (
argv + lead_num), sizeof(
VALUE)*(
size_t)(ci_kw_len)));
10581 VALUE *
const klocals =
argv + kw_param->bits_start - kw_param->num;
10582 args_setup_kw_parameters(ec,
iseq, ci_kws, ci_kw_len, ci_keywords, klocals);
10583 CC_SET_FASTPATH(
cc, vm_call_iseq_setup_kwparm_kwarg,
10588 else if (
argc == lead_num) {
10589 VALUE *
const klocals =
argv + kw_param->bits_start - kw_param->num;
10590 args_setup_kw_parameters(ec,
iseq, ((
void *)0), 0, ((
void *)0), klocals);
10592 CC_SET_FASTPATH(
cc, vm_call_iseq_setup_kwparm_nokwarg,
10650 VALUE *sp_orig, *sp;
10652 if (VM_BH_FROM_CFP_P(
calling->block_handler,
cfp)) {
10656 if (VM_BH_ISEQ_BLOCK_P(
calling->block_handler)) {
10657 calling->block_handler = VM_BH_FROM_ISEQ_BLOCK(dst_captured);
10660 calling->block_handler = VM_BH_FROM_IFUNC_BLOCK(dst_captured);
10665 sp_orig = sp =
cfp->
sp;
10669 *sp++ = src_argv[
i];
10699 return (*
f)(recv,
argv[0]);
10722 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10728 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10734 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10740 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10746 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10752 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10753 return (*
f)(recv,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9]);
10758 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10759 return (*
f)(recv,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10]);
10764 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10765 return (*
f)(recv,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11]);
10770 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10771 return (*
f)(recv,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11],
argv[12]);
10776 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10777 return (*
f)(recv,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11],
argv[12],
argv[13]);
10782 VALUE(*
f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
10783 return (*
f)(recv,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11],
argv[12],
argv[13],
argv[14]);
10800 return __extension__({
10802 ; typeof(&(
me->
def)->body.cfunc) unaligned_member_access_result = (&(
me->def)->body.cfunc);
10803 ; unaligned_member_access_result; });
10813 int len = cfunc->argc;
10818 int orig_argc =
argc;
10827 vm_push_frame(ec, ((
void *)0), frame_type, recv,
10829 0, ec->cfp->sp, 0, 0);
10832 val = (*cfunc->invoker)(recv,
argc,
reg_cfp->
sp + 1, cfunc->func);
10834 rb_vm_pop_frame(ec);
10843 int empty_kw_splat;
10846 empty_kw_splat =
calling->kw_splat;
10848 if (empty_kw_splat &&
calling->kw_splat) {
10849 empty_kw_splat = 0;
10851 return vm_call_cfunc_with_frame(ec,
reg_cfp,
calling, cd, empty_kw_splat);
10892 return vm_call_bmethod_body(ec,
calling, cd,
argv);
10924 cd.ci_kw.
ci = *orig_ci;
10944 ((__builtin_object_size((&(*(((((
reg_cfp)->sp)))-(
i)-1))), 0) != (
size_t)-1) ? __builtin___memmove_chk((&(*(((((
reg_cfp)->sp)))-(
i)-1))), (&(*(((((
reg_cfp)->sp)))-(
i-1)-1))),
sizeof(
VALUE)*(
size_t)(
i), __builtin_object_size((&(*(((((
reg_cfp)->sp)))-(
i)-1))), 0)) : __memmove_ichk((&(*(((((
reg_cfp)->sp)))-(
i)-1))), (&(*(((((
reg_cfp)->sp)))-(
i-1)-1))), sizeof(
VALUE)*(
size_t)(
i)));
10947 (((
reg_cfp)->sp) -= (((1))));
10961 (((
reg_cfp)->sp) -= (((1))));
10970 return vm_invoke_block_opt_call(ec,
reg_cfp,
calling,
ci, VM_BH_FROM_PROC(procval));
10983 vm_search_method(cd,
calling->recv);
11011 (((
reg_cfp)->sp) += (((1))));
11025 return vm_call_method_nome(ec,
cfp,
calling, cd);
11029 CC_SET_ME(
cc, refined_method_callable_without_refinement(
cc->
me));
11031 return vm_call_method_each_type(ec,
cfp,
calling, cd);
11050 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec,
cfp)) {
11053 }
while (
cfp->
iseq != local_iseq);
11084 ; unaligned_member_access_result; });
11120 for (; cref; cref = CREF_NEXT(cref)) {
11121 const VALUE refinement = find_refinement(CREF_REFINEMENTS(cref),
cc->
me->
owner);
11126 if (
cc->
call == vm_call_super_method) {
11135 CC_SET_ME(
cc, ref_me);
11142 CC_SET_ME(
cc, ((
void *)0));
11147 CC_SET_ME(
cc, refined_method_callable_without_refinement(
cc->
me));
11162 CC_SET_FASTPATH(
cc, vm_call_iseq_setup, 1);
11163 return vm_call_iseq_setup(ec,
cfp,
calling, cd);
11166 CC_SET_FASTPATH(
cc, vm_call_cfunc, 1);
11171 rb_warn_keyword_to_last_hash(ec,
calling,
ci, ((
void *)0));
11179 return vm_call_attrset(ec,
cfp,
calling, cd);
11189 CC_SET_FASTPATH(
cc, vm_call_method_missing, 1);
11190 return vm_call_method_missing(ec,
cfp,
calling, cd);
11192 CC_SET_FASTPATH(
cc, vm_call_bmethod, 1);
11193 return vm_call_bmethod(ec,
cfp,
calling, cd);
11195 CC_SET_ME(
cc, aliased_callable_method_entry(
cc->
me));
11197 return vm_call_method_each_type(ec,
cfp,
calling, cd);
11201 CC_SET_FASTPATH(
cc, vm_call_opt_send, 1);
11202 return vm_call_opt_send(ec,
cfp,
calling, cd);
11204 CC_SET_FASTPATH(
cc, vm_call_opt_call, 1);
11205 return vm_call_opt_call(ec,
cfp,
calling, cd);
11207 CC_SET_FASTPATH(
cc, vm_call_opt_block_call, 1);
11208 return vm_call_opt_block_call(ec,
cfp,
calling, cd);
11210 rb_bug(
"vm_call_method: unsupported optimized method type (%d)",
11218 if (search_refined_method(ec,
cfp,
ci->mid,
cc))
11219 return vm_call_method(ec,
cfp,
calling, cd);
11221 return vm_call_method_nome(ec,
cfp,
calling, cd);
11231 const int stat = ci_missing_reason(
ci);
11239 CC_SET_FASTPATH(
cc, vm_call_method_missing, 1);
11240 return vm_call_method_missing(ec,
cfp,
calling, cd);
11249 if (
cc->
me != ((
void *)0)) {
11252 return vm_call_method_each_type(ec,
cfp,
calling, cd);
11258 CC_SET_FASTPATH(
cc, vm_call_method_missing, 1);
11259 return vm_call_method_missing(ec,
cfp,
calling, cd);
11261 return vm_call_method_each_type(ec,
cfp,
calling, cd);
11266 return vm_call_method_missing(ec,
cfp,
calling, cd);
11273 return vm_call_method_each_type(ec,
cfp,
calling, (
void *)&cd_entry);
11277 return vm_call_method_each_type(ec,
cfp,
calling, &cd_entry);
11281 return vm_call_method_each_type(ec,
cfp,
calling, cd);
11287 return vm_call_method_nome(ec,
cfp,
calling, cd);
11314__attribute__ ((__noreturn__))
static void vm_super_outside(
void);
11316vm_super_outside(
void)
11328 vm_super_outside();
11332 current_defined_class = ((((
struct RClass*)(current_defined_class))->
ptr)->refined_class);
11338 ((((
struct RClass*)(current_defined_class))->
ptr)->includer) : current_defined_class;
11341 "self has wrong type to call super in this context: "
11342 "%""l""i" "\v"" (expected %""l""i" "\v"")",
11348 "implicit argument passing of super from method defined"
11349 " by define_method() is not supported."
11350 " Specify all arguments explicitly.");
11356 CC_SET_FASTPATH(
cc, vm_call_method_missing, 1);
11360 CC_SET_FASTPATH(
cc, vm_call_super_method, 1);
11364block_proc_is_lambda(
const VALUE procval)
11368 (((proc)) = (
rb_proc_t*)(((
struct RData*)(((procval))))->data));
11388 else if (
argc == 0) {
11396 switch (kw_splat) {
11407 ((
VALUE)((captured->
ep)) | (0x01)),
11409 0, ec->
cfp->
sp, 0, 0);
11411 rb_vm_pop_frame(ec);
11423 long len = rb_array_len(ary);
11426 argv[
i] = (rb_array_const_ptr_transient(ary)[
i]);
11431vm_callee_setup_block_arg_arg0_check(
VALUE *
argv)
11488 calling->kw_splat = kw_splat;
11503 (((
reg_cfp)->sp) = (((rsp))));
11504 vm_push_frame(ec,
iseq,
11507 ((
VALUE)((captured->
ep)) | (0x01)), 0,
11533 int kw_splat =
calling->kw_splat;
11536 if (kw_splat && !
calling->kw_splat) {
11540 kw_splat =
calling->kw_splat;
11543 val = vm_yield_with_cfunc(ec, captured, captured->
self,
argc, (((((
reg_cfp)->sp)))-(
argc)), kw_splat,
calling->block_handler, ((
void *)0));
11548vm_proc_to_block_handler(
VALUE procval)
11550 const struct rb_block *block = vm_proc_block(procval);
11551 switch (vm_block_type(block)) {
11553 return VM_BH_FROM_ISEQ_BLOCK(&block->
as.
captured);
11555 return VM_BH_FROM_IFUNC_BLOCK(&block->
as.
captured);
11557 return VM_BH_FROM_SYMBOL(block->
as.
symbol);
11559 return VM_BH_FROM_PROC(block->
as.
proc);
11561 __builtin_unreachable();
11574 return vm_invoke_iseq_block(ec,
reg_cfp,
calling,
ci, is_lambda, captured);
11582 is_lambda = block_proc_is_lambda(VM_BH_TO_PROC(
block_handler));
11588 __builtin_unreachable();
11592vm_make_proc_with_iseq(
const rb_iseq_t *blockiseq)
11598 rb_bug(
"vm_make_proc_with_iseq: unreachable");
11600 captured = VM_CFP_TO_CAPTURED_BLOCK(
cfp);
11602 return rb_vm_make_proc(ec, captured,
rb_cProc);
11611vm_once_clear(
VALUE data)
11686 expr_type = check_respond_to_missing(
obj,
v);
11708 expr_type = check_respond_to_missing(
obj,
v);
11713 if (((VM_EP_LEP(((((
reg_cfp)->ep)))))[(-1)]) != 0) {
11736 rb_bug(
"unimplemented defined? type (VM)");
11739 if (expr_type != 0) {
11751static const VALUE *
11755 const VALUE *ep = reg_ep;
11756 for (
i = 0;
i < lv;
i++) {
11757 ep = ((
VALUE *)((ep)[(-1)] & ~0x03));
11762vm_get_special_object(
const VALUE *
const reg_ep,
11769 return vm_get_cbase(reg_ep);
11771 return vm_get_const_base(reg_ep);
11773 rb_bug(
"putspecialobject insn: unknown value_type %d",
type);
11787 const VALUE ary2 = ary2st;
11791 tmp1 = __extension__ ({
const VALUE args_to_new_ary[] = {ary1};
if (__builtin_constant_p(1)) {
_Static_assert(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))) == (1),
"rb_ary_new_from_args" ": " "numberof(args_to_new_ary) == (1)"); }
rb_ary_new_from_values(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))), args_to_new_ary); });
11794 tmp2 = __extension__ ({
const VALUE args_to_new_ary[] = {ary2};
if (__builtin_constant_p(1)) {
_Static_assert(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))) == (1),
"rb_ary_new_from_args" ": " "numberof(args_to_new_ary) == (1)"); }
rb_ary_new_from_values(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))), args_to_new_ary); });
11796 if (tmp1 == ary1) {
11806 return __extension__ ({
const VALUE args_to_new_ary[] = {ary};
if (__builtin_constant_p(1)) {
_Static_assert(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))) == (1),
"rb_ary_new_from_args" ": " "numberof(args_to_new_ary) == (1)"); }
rb_ary_new_from_values(((
int)(
sizeof(args_to_new_ary) /
sizeof((args_to_new_ary)[0]))), args_to_new_ary); });
11821 const long n = rb_array_len(pattern);
11822 for (
i = 0;
i <
n;
i++) {
11823 VALUE v = (rb_array_const_ptr_transient(pattern)[
i]);
11832 return check_match(ec, pattern, target,
type);
11838 const VALUE kw_bits = *(ep - bits);
11840 unsigned int b = (
unsigned int)((
unsigned long)((
long)(((
long)(kw_bits))>>(
int)(1))));
11841 if ((idx < (32-1)) && (b & (0x01 << idx)))
11877 if ((ns = vm_search_const_defined_class(
cbase,
id)) == 0) {
11880 else if (((flags) & 0x08)) {
11893 else if (((flags) & 0x10)) {
11895 if (tmp != super) {
11897 "superclass mismatch for class %""l""i" "\v""",
11947 rb_str_catf(message,
"\n%""l""i" "\v"":%""l""i" "\v"":"
11948 " previous definition of %""l""i" "\v"" was here",
11959 "superclass must be a Class (%""l""i" "\v"" given)",
11962 vm_check_if_namespace(
cbase);
11964 if ((
klass = vm_const_get_under(
id, flags,
cbase)) != 0) {
11965 if (!vm_check_if_class(
id, flags, super,
klass))
11966 unmatched_redefinition(
"class",
cbase,
id,
klass);
11970 return vm_declare_class(
id, flags,
cbase, super);
11977 vm_check_if_namespace(
cbase);
11978 if ((
mod = vm_const_get_under(
id, flags,
cbase)) != 0) {
11979 if (!vm_check_if_module(
id,
mod))
11980 unmatched_redefinition(
"module",
cbase,
id,
mod);
11984 return vm_declare_module(
id,
cbase);
11988vm_find_or_create_class_by_id(
ID id,
11996 return vm_define_class(
id, flags,
cbase, super);
12000 return vm_define_module(
id, flags,
cbase);
12002 rb_bug(
"unknown defineclass type: %d", (
int)
type);
12009 if (!vm_env_cref_by_cref(
cfp->
ep)) {
12013 return CREF_SCOPE_VISI(vm_ec_cref(ec))->
method_visi;
12020 if (!vm_env_cref_by_cref(
cfp->
ep)) {
12024 return CREF_SCOPE_VISI(vm_ec_cref(ec))->
module_func;
12033 if (!is_singleton) {
12034 klass = CREF_CLASS(cref);
12035 visi = vm_scope_visibility_get(ec);
12045 if (!is_singleton && vm_scope_module_func_check(ec)) {
12051vm_search_method_wrap(
12056 vm_search_method(cd, recv);
12059vm_search_invokeblock(
12087 void (*method_explorer)(
12095 int argc =
ci->orig_argc;
12110 if (((((
reg_cfp)))->
iseq)->body->catch_except_p) {
12125 if (((
__builtin_expect(!!((rb_current_vm()->redefined_flag[(bop)]&((1 << 2))) == 0), 1)))) {
12145 if ((((((
int)(
long)(
v))&
RUBY_FIXNUM_FLAG) && (((
int)(
long)(result))&
RUBY_FIXNUM_FLAG) && (((cmp_opt).
opt_inited & (1U <<
cmp_opt_Fixnum)) ? ((cmp_opt).
opt_methods & (1U <<
cmp_opt_Fixnum)) : (((cmp_opt).
opt_inited |= (1U <<
cmp_opt_Fixnum)), __extension__({
static struct rb_call_data rb_mbdp; (
rb_cInteger == ((
VALUE)
RUBY_Qfalse)) ? 1 :
rb_method_basic_definition_p_with_cc(&rb_mbdp,
rb_cInteger,
idCmp); }) && ((cmp_opt).opt_methods |= (1U <<
cmp_opt_Fixnum))))) ? (((
long)
v > (
long)result) ? 1 : ((
long)
v < (
long)result) ? -1 : 0) : ((( ((
RUBY_T_STRING) ==
RUBY_T_FIXNUM) ? (((
int)(
long)((
v)))&
RUBY_FIXNUM_FLAG) : ((
RUBY_T_STRING) ==
RUBY_T_TRUE) ? (((
v)) == ((
VALUE)
RUBY_Qtrue)) : ((
RUBY_T_STRING) ==
RUBY_T_FALSE) ? (((
v)) == ((
VALUE)
RUBY_Qfalse)) : ((
RUBY_T_STRING) ==
RUBY_T_NIL) ? (((
v)) == ((
VALUE)
RUBY_Qnil)) : ((
RUBY_T_STRING) ==
RUBY_T_UNDEF) ? (((
v)) == ((
VALUE)
RUBY_Qundef)) : ((
RUBY_T_STRING) ==
RUBY_T_SYMBOL) ? ((((
VALUE)((
v))&~((~(
VALUE)0)<<
RUBY_SPECIAL_SHIFT)) ==
RUBY_SYMBOL_FLAG)||(!(((
VALUE)((
v)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((
v)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((
v)))->flags &
RUBY_T_MASK) == (
RUBY_T_SYMBOL))) : ((
RUBY_T_STRING) ==
RUBY_T_FLOAT) ? ( ((((
int)(
long)((
v)))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)((
v)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((
v)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((
v)))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) : (!(((
VALUE)((
v)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((
v)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((
v)))->flags &
RUBY_T_MASK) == (
RUBY_T_STRING))) && rb_class_of((
VALUE)(
v)) ==
rb_cString) && (( ((
RUBY_T_STRING) ==
RUBY_T_FIXNUM) ? (((
int)(
long)((result)))&
RUBY_FIXNUM_FLAG) : ((
RUBY_T_STRING) ==
RUBY_T_TRUE) ? (((result)) == ((
VALUE)
RUBY_Qtrue)) : ((
RUBY_T_STRING) ==
RUBY_T_FALSE) ? (((result)) == ((
VALUE)
RUBY_Qfalse)) : ((
RUBY_T_STRING) ==
RUBY_T_NIL) ? (((result)) == ((
VALUE)
RUBY_Qnil)) : ((
RUBY_T_STRING) ==
RUBY_T_UNDEF) ? (((result)) == ((
VALUE)
RUBY_Qundef)) : ((
RUBY_T_STRING) ==
RUBY_T_SYMBOL) ? ((((
VALUE)((result))&~((~(
VALUE)0)<<
RUBY_SPECIAL_SHIFT)) ==
RUBY_SYMBOL_FLAG)||(!(((
VALUE)((result)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((result)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((result)))->flags &
RUBY_T_MASK) == (
RUBY_T_SYMBOL))) : ((
RUBY_T_STRING) ==
RUBY_T_FLOAT) ? ( ((((
int)(
long)((result)))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)((result)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((result)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((result)))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) : (!(((
VALUE)((result)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((result)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((result)))->flags &
RUBY_T_MASK) == (
RUBY_T_STRING))) && rb_class_of((
VALUE)(result)) ==
rb_cString) && (((cmp_opt).opt_inited & (1U <<
cmp_opt_String)) ? ((cmp_opt).opt_methods & (1U <<
cmp_opt_String)) : (((cmp_opt).opt_inited |= (1U <<
cmp_opt_String)), __extension__({
static struct rb_call_data rb_mbdp; (
rb_cString == ((
VALUE)
RUBY_Qfalse)) ? 1 :
rb_method_basic_definition_p_with_cc(&rb_mbdp,
rb_cString,
idCmp); }) && ((cmp_opt).opt_methods |= (1U <<
cmp_opt_String))))) ?
rb_str_cmp(
v, result) : (( ((((
int)(
long)(
v))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)(
v) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)(
v) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)(
v))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) && ( ((((
int)(
long)(result))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)(result) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)(result) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)(result))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) && (((cmp_opt).opt_inited & (1U <<
cmp_opt_Float)) ? ((cmp_opt).opt_methods & (1U <<
cmp_opt_Float)) : (((cmp_opt).opt_inited |= (1U <<
cmp_opt_Float)), __extension__({
static struct rb_call_data rb_mbdp; (
rb_cFloat == ((
VALUE)
RUBY_Qfalse)) ? 1 :
rb_method_basic_definition_p_with_cc(&rb_mbdp,
rb_cFloat,
idCmp); }) && ((cmp_opt).opt_methods |= (1U <<
cmp_opt_Float))))) ?
rb_float_cmp(
v, result) :
rb_cmpint(__extension__({
static struct rb_call_data rb_funcallv_data; rb_funcallv_with_cc(&rb_funcallv_data,
v,
idCmp, 1, &result); }),
v, result)) > 0) {
12154 return __extension__({
const int rb_funcall_argc = (0);
const VALUE rb_funcall_args[] = {};
const int rb_funcall_nargs = (
int)(
sizeof(rb_funcall_args) /
sizeof(
VALUE)); __extension__({
static struct rb_call_data rb_funcallv_data; rb_funcallv_with_cc(&rb_funcallv_data, ary,
idMax, __builtin_choose_expr(__builtin_constant_p(rb_funcall_argc), (((rb_funcall_argc) == 0 ? (rb_funcall_nargs) <= 1 : (rb_funcall_argc) == (rb_funcall_nargs)) ? (rb_funcall_argc) : rb_varargs_bad_length(rb_funcall_argc, rb_funcall_nargs)), (((rb_funcall_argc) <= (rb_funcall_nargs)) ? (rb_funcall_argc) : (
rb_fatal(
"argc(%d) exceeds actual arguments(%d)", rb_funcall_argc, rb_funcall_nargs), 0))), rb_funcall_nargs ? rb_funcall_args : ((
void *)0)); }); });
12170 if ((((((
int)(
long)(
v))&
RUBY_FIXNUM_FLAG) && (((
int)(
long)(result))&
RUBY_FIXNUM_FLAG) && (((cmp_opt).
opt_inited & (1U <<
cmp_opt_Fixnum)) ? ((cmp_opt).
opt_methods & (1U <<
cmp_opt_Fixnum)) : (((cmp_opt).
opt_inited |= (1U <<
cmp_opt_Fixnum)), __extension__({
static struct rb_call_data rb_mbdp; (
rb_cInteger == ((
VALUE)
RUBY_Qfalse)) ? 1 :
rb_method_basic_definition_p_with_cc(&rb_mbdp,
rb_cInteger,
idCmp); }) && ((cmp_opt).opt_methods |= (1U <<
cmp_opt_Fixnum))))) ? (((
long)
v > (
long)result) ? 1 : ((
long)
v < (
long)result) ? -1 : 0) : ((( ((
RUBY_T_STRING) ==
RUBY_T_FIXNUM) ? (((
int)(
long)((
v)))&
RUBY_FIXNUM_FLAG) : ((
RUBY_T_STRING) ==
RUBY_T_TRUE) ? (((
v)) == ((
VALUE)
RUBY_Qtrue)) : ((
RUBY_T_STRING) ==
RUBY_T_FALSE) ? (((
v)) == ((
VALUE)
RUBY_Qfalse)) : ((
RUBY_T_STRING) ==
RUBY_T_NIL) ? (((
v)) == ((
VALUE)
RUBY_Qnil)) : ((
RUBY_T_STRING) ==
RUBY_T_UNDEF) ? (((
v)) == ((
VALUE)
RUBY_Qundef)) : ((
RUBY_T_STRING) ==
RUBY_T_SYMBOL) ? ((((
VALUE)((
v))&~((~(
VALUE)0)<<
RUBY_SPECIAL_SHIFT)) ==
RUBY_SYMBOL_FLAG)||(!(((
VALUE)((
v)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((
v)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((
v)))->flags &
RUBY_T_MASK) == (
RUBY_T_SYMBOL))) : ((
RUBY_T_STRING) ==
RUBY_T_FLOAT) ? ( ((((
int)(
long)((
v)))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)((
v)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((
v)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((
v)))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) : (!(((
VALUE)((
v)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((
v)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((
v)))->flags &
RUBY_T_MASK) == (
RUBY_T_STRING))) && rb_class_of((
VALUE)(
v)) ==
rb_cString) && (( ((
RUBY_T_STRING) ==
RUBY_T_FIXNUM) ? (((
int)(
long)((result)))&
RUBY_FIXNUM_FLAG) : ((
RUBY_T_STRING) ==
RUBY_T_TRUE) ? (((result)) == ((
VALUE)
RUBY_Qtrue)) : ((
RUBY_T_STRING) ==
RUBY_T_FALSE) ? (((result)) == ((
VALUE)
RUBY_Qfalse)) : ((
RUBY_T_STRING) ==
RUBY_T_NIL) ? (((result)) == ((
VALUE)
RUBY_Qnil)) : ((
RUBY_T_STRING) ==
RUBY_T_UNDEF) ? (((result)) == ((
VALUE)
RUBY_Qundef)) : ((
RUBY_T_STRING) ==
RUBY_T_SYMBOL) ? ((((
VALUE)((result))&~((~(
VALUE)0)<<
RUBY_SPECIAL_SHIFT)) ==
RUBY_SYMBOL_FLAG)||(!(((
VALUE)((result)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((result)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((result)))->flags &
RUBY_T_MASK) == (
RUBY_T_SYMBOL))) : ((
RUBY_T_STRING) ==
RUBY_T_FLOAT) ? ( ((((
int)(
long)((result)))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)((result)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((result)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((result)))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) : (!(((
VALUE)((result)) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)((result)) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)((result)))->flags &
RUBY_T_MASK) == (
RUBY_T_STRING))) && rb_class_of((
VALUE)(result)) ==
rb_cString) && (((cmp_opt).opt_inited & (1U <<
cmp_opt_String)) ? ((cmp_opt).opt_methods & (1U <<
cmp_opt_String)) : (((cmp_opt).opt_inited |= (1U <<
cmp_opt_String)), __extension__({
static struct rb_call_data rb_mbdp; (
rb_cString == ((
VALUE)
RUBY_Qfalse)) ? 1 :
rb_method_basic_definition_p_with_cc(&rb_mbdp,
rb_cString,
idCmp); }) && ((cmp_opt).opt_methods |= (1U <<
cmp_opt_String))))) ?
rb_str_cmp(
v, result) : (( ((((
int)(
long)(
v))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)(
v) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)(
v) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)(
v))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) && ( ((((
int)(
long)(result))&
RUBY_FLONUM_MASK) ==
RUBY_FLONUM_FLAG) || (!(((
VALUE)(result) &
RUBY_IMMEDIATE_MASK) || !!(((
VALUE)(result) & (
VALUE)~((
VALUE)
RUBY_Qnil)) == 0)) && (
int)(((
struct RBasic*)(result))->flags &
RUBY_T_MASK) ==
RUBY_T_FLOAT)) && (((cmp_opt).opt_inited & (1U <<
cmp_opt_Float)) ? ((cmp_opt).opt_methods & (1U <<
cmp_opt_Float)) : (((cmp_opt).opt_inited |= (1U <<
cmp_opt_Float)), __extension__({
static struct rb_call_data rb_mbdp; (
rb_cFloat == ((
VALUE)
RUBY_Qfalse)) ? 1 :
rb_method_basic_definition_p_with_cc(&rb_mbdp,
rb_cFloat,
idCmp); }) && ((cmp_opt).opt_methods |= (1U <<
cmp_opt_Float))))) ?
rb_float_cmp(
v, result) :
rb_cmpint(__extension__({
static struct rb_call_data rb_funcallv_data; rb_funcallv_with_cc(&rb_funcallv_data,
v,
idCmp, 1, &result); }),
v, result)) < 0) {
12179 return __extension__({
const int rb_funcall_argc = (0);
const VALUE rb_funcall_args[] = {};
const int rb_funcall_nargs = (
int)(
sizeof(rb_funcall_args) /
sizeof(
VALUE)); __extension__({
static struct rb_call_data rb_funcallv_data; rb_funcallv_with_cc(&rb_funcallv_data, ary,
idMin, __builtin_choose_expr(__builtin_constant_p(rb_funcall_argc), (((rb_funcall_argc) == 0 ? (rb_funcall_nargs) <= 1 : (rb_funcall_argc) == (rb_funcall_nargs)) ? (rb_funcall_argc) : rb_varargs_bad_length(rb_funcall_argc, rb_funcall_nargs)), (((rb_funcall_argc) <= (rb_funcall_nargs)) ? (rb_funcall_argc) : (
rb_fatal(
"argc(%d) exceeds actual arguments(%d)", rb_funcall_argc, rb_funcall_nargs), 0))), rb_funcall_nargs ? rb_funcall_args : ((
void *)0)); }); });
12183vm_ic_hit_p(
IC ic,
const VALUE *reg_ep)
12186 return (ic->
ic_cref == ((
void *)0) ||
12187 ic->
ic_cref == vm_get_cref(reg_ep));
12197 ic->
ic_cref = vm_get_const_key_cref(reg_ep);
12215; typeof(rb_obj_write((
VALUE)(ec->
cfp->
iseq), (
VALUE *)(&is->
once.
value), (
VALUE)(val),
"../ruby-2.7.7/vm_insnhelper.c", 4160)) unaligned_member_access_result = (rb_obj_write((
VALUE)(ec->
cfp->
iseq), (
VALUE *)(&is->once.value), (
VALUE)(val), "../
ruby-2.7.7/vm_insnhelper.c", 4160));
12216; unaligned_member_access_result; });
12217 is->once.running_thread = RUNNING_THREAD_ONCE_DONE;
12220 else if (is->once.running_thread == th) {
12224 rb_vm_check_ints(ec);
12241 double kval = rb_float_value_inline(
key);
12242 if (!(__builtin_isinf_sign (kval)) &&
modf(kval, &kval) == 0.0) {
12250 return else_offset;
12264 static const char stack_consistency_error[] =
12265 "Stack consistency error (sp: %""t""d"", bp: %""t""d"")";
12266 rb_bug(stack_consistency_error, nsp, nbp);
12272 if (FIXNUM_2_P(recv,
obj) &&
12274 return rb_fix_plus_fix(recv,
obj);
12276 else if (FLONUM_2_P(recv,
obj) &&
12278 return rb_float_new_inline(rb_float_value_inline(recv) + rb_float_value_inline(
obj));
12286 return rb_float_new_inline(rb_float_value_inline(recv) + rb_float_value_inline(
obj));
12306 if (FIXNUM_2_P(recv,
obj) &&
12308 return rb_fix_minus_fix(recv,
obj);
12310 else if (FLONUM_2_P(recv,
obj) &&
12312 return rb_float_new_inline(rb_float_value_inline(recv) - rb_float_value_inline(
obj));
12320 return rb_float_new_inline(rb_float_value_inline(recv) - rb_float_value_inline(
obj));
12330 if (FIXNUM_2_P(recv,
obj) &&
12332 return rb_fix_mul_fix(recv,
obj);
12334 else if (FLONUM_2_P(recv,
obj) &&
12336 return rb_float_new_inline(rb_float_value_inline(recv) * rb_float_value_inline(
obj));
12344 return rb_float_new_inline(rb_float_value_inline(recv) * rb_float_value_inline(
obj));
12354 if (FIXNUM_2_P(recv,
obj) &&
12358 else if (FLONUM_2_P(recv,
obj) &&
12378 if (FIXNUM_2_P(recv,
obj) &&
12382 else if (FLONUM_2_P(recv,
obj) &&
12384 return rb_float_new_inline(
ruby_float_mod(rb_float_value_inline(recv), rb_float_value_inline(
obj)));
12392 return rb_float_new_inline(
ruby_float_mod(rb_float_value_inline(recv), rb_float_value_inline(
obj)));
12403 VALUE val = opt_eq_func(recv,
obj, cd_eq);
12414 if (FIXNUM_2_P(recv,
obj) &&
12418 else if (FLONUM_2_P(recv,
obj) &&
12425 else if ((((
struct RBasic*)(recv))->klass) ==
rb_cFloat &&
12439 if (FIXNUM_2_P(recv,
obj) &&
12443 else if (FLONUM_2_P(recv,
obj) &&
12450 else if ((((
struct RBasic*)(recv))->klass) ==
rb_cFloat &&
12464 if (FIXNUM_2_P(recv,
obj) &&
12468 else if (FLONUM_2_P(recv,
obj) &&
12475 else if ((((
struct RBasic*)(recv))->klass) ==
rb_cFloat &&
12489 if (FIXNUM_2_P(recv,
obj) &&
12493 else if (FLONUM_2_P(recv,
obj) &&
12500 else if ((((
struct RBasic*)(recv))->klass) ==
rb_cFloat &&
12533 if (FIXNUM_2_P(recv,
obj) &&
12535 return (recv &
obj) | 1;
12545 if (FIXNUM_2_P(recv,
obj) &&
12558 if (FIXNUM_2_P(recv,
obj) &&
12567 return rb_ary_entry_internal(recv, ((
long)(((
long)(
obj))>>(
int)(1))));
12630vm_opt_length(
VALUE recv,
int bop)
12636 ((
__builtin_expect(!!((rb_current_vm()->redefined_flag[(bop)]&((1 << 2))) == 0), 1)))) {
12645 ((
__builtin_expect(!!((rb_current_vm()->redefined_flag[(bop)]&((1 << 3))) == 0), 1)))) {
12646 return rb_long2num_inline(rb_array_len(recv));
12649 ((
__builtin_expect(!!((rb_current_vm()->redefined_flag[(bop)]&((1 << 4))) == 0), 1)))) {
12657vm_opt_empty_p(
VALUE recv)
12673 else if (vm_method_cfunc_is(cd, recv,
rb_false)) {
12686 case ((~0UL)>>(
int)(1)):
12693vm_opt_succ(
VALUE recv)
12697 return fix_succ(recv);
12714 if (vm_method_cfunc_is(cd, recv, rb_obj_not)) {
12750 if (event & global_hooks->
events) {
12752 vm_dtrace(event, ec);
12753 rb_exec_event_hook_orig(ec, global_hooks, event,
self, 0, 0, 0 , val, 0);
12756 if (local_hooks != ((
void *)0)) {
12757 if (event & local_hooks->
events) {
12759 rb_exec_event_hook_orig(ec, local_hooks, event,
self, 0, 0, 0 , val, 0);
12777 enabled_flags |= local_hook_events;
12779 if ((pc_events & enabled_flags) == 0) {
12782 else if (ec->
trace_arg != ((
void *)0)) {
12798 do {
if ((pc_events & (0x0002 | 0x0008 | 0x0100)) & enabled_flags) { vm_trace_hook(ec,
reg_cfp,
pc, pc_events, (0x0002 | 0x0008 | 0x0100), global_hooks, local_hooks, (((
VALUE)
RUBY_Qundef))); } }
while (0);
12799 do {
if ((pc_events & (0x0001)) & enabled_flags) { vm_trace_hook(ec,
reg_cfp,
pc, pc_events, (0x0001), global_hooks, local_hooks, (((
VALUE)
RUBY_Qundef))); } }
while (0);
12800 do {
if ((pc_events & (0x010000)) & enabled_flags) { vm_trace_hook(ec,
reg_cfp,
pc, pc_events, (0x010000), global_hooks, local_hooks, (((
VALUE)
RUBY_Qundef))); } }
while (0);
12801 do {
if ((pc_events & (0x020000)) & enabled_flags) { vm_trace_hook(ec,
reg_cfp,
pc, pc_events, (0x020000), global_hooks, local_hooks, (((
VALUE)
RUBY_Qundef))); } }
while (0);
12802 do {
if ((pc_events & (0x0004 | 0x0010 | 0x0200)) & enabled_flags) { vm_trace_hook(ec,
reg_cfp,
pc, pc_events, (0x0004 | 0x0010 | 0x0200), global_hooks, local_hooks, ((*(((((
reg_cfp)->sp)))-(0)-1)))); } }
while (0);
12806void Init_vm_stack_canary(
void) { }
12811 return (*(rb_invoke_funcptr0_t)funcptr)(ec,
self);
12817 return (*(rb_invoke_funcptr1_t)funcptr)(ec,
self,
argv[0]);
12823 return (*(rb_invoke_funcptr2_t)funcptr)(ec,
self,
argv[0],
argv[1]);
12829 return (*(rb_invoke_funcptr3_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2]);
12835 return (*(rb_invoke_funcptr4_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3]);
12841 return (*(rb_invoke_funcptr5_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4]);
12864 typedef VALUE (*rb_invoke_funcptr9_t)(
rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9);
12865 return (*(rb_invoke_funcptr9_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8]);
12870 typedef VALUE (*rb_invoke_funcptr10_t)(
rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10);
12871 return (*(rb_invoke_funcptr10_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9]);
12876 typedef VALUE (*rb_invoke_funcptr11_t)(
rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11);
12877 return (*(rb_invoke_funcptr11_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10]);
12882 typedef VALUE (*rb_invoke_funcptr12_t)(
rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12);
12883 return (*(rb_invoke_funcptr12_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11]);
12888 typedef VALUE (*rb_invoke_funcptr13_t)(
rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12,
VALUE v13);
12889 return (*(rb_invoke_funcptr13_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11],
argv[12]);
12894 typedef VALUE (*rb_invoke_funcptr14_t)(
rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12,
VALUE v13,
VALUE v14);
12895 return (*(rb_invoke_funcptr14_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11],
argv[12],
argv[13]);
12900 typedef VALUE (*rb_invoke_funcptr15_t)(
rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12,
VALUE v13,
VALUE v14,
VALUE v15);
12901 return (*(rb_invoke_funcptr15_t)funcptr)(ec,
self,
argv[0],
argv[1],
argv[2],
argv[3],
argv[4],
argv[5],
argv[6],
argv[7],
argv[8],
argv[9],
argv[10],
argv[11],
argv[12],
argv[13],
argv[14]);
12905lookup_builtin_invoker(
int argc)
12925 return invokers[
argc];
12936 return invoke_bf(ec,
cfp, bf,
argv);
12943 for (
int i=0;
i<bf->
argc;
i++) {
12949 if (bf->
argc == 0) {
12950 return invoke_bf(ec,
cfp, bf, ((
void *)0));
12954 return invoke_bf(ec,
cfp, bf,
argv);
12974static VALUE rb_eUncaughtThrow;
12975static ID id_result, id_tag, id_value;
13006 rb_raise(e,
"method name must be a Symbol but %""l""i" "\v"" is given",
13011 format =
rb_fstring_new((
"private method `%s' called for %s%s%s"), (
sizeof(
"private method `%s' called for %s%s%s" "") - 1));
13014 format =
rb_fstring_new((
"protected method `%s' called for %s%s%s"), (
sizeof(
"protected method `%s' called for %s%s%s" "") - 1));
13017 format =
rb_fstring_new((
"undefined local variable or method `%s' for %s%s%s"), (
sizeof(
"undefined local variable or method `%s' for %s%s%s" "") - 1));
13021 format =
rb_fstring_new((
"super: no superclass method `%s' for %s%s%s"), (
sizeof(
"super: no superclass method `%s' for %s%s%s" "") - 1));
13027 rb_vm_pop_cfunc_frame();
13036 vm_passed_block_handler_set(ec, 0);
13051 nargv = ((
VALUE*)(((
size_t)(
argc + 1) < 1024 /
sizeof(
VALUE)) ? ((work) = 0, __builtin_alloca((
size_t)(
argc + 1) *
sizeof(
VALUE))) : rb_alloc_tmp_buffer2(&(work), (
long)(
argc + 1),
sizeof(
VALUE))));
13053 ((__builtin_object_size((nargv + 1), 0) != (
size_t)-1) ? __builtin___memcpy_chk((nargv + 1), (
argv),
sizeof(
VALUE)*(
size_t)(
argc), __builtin_object_size((nargv + 1), 0)) : __memcpy_ichk((nargv + 1), (
argv), sizeof(
VALUE)*(
size_t)(
argc)));
13057 if (!
klass)
goto missing;
13068 if (VM_FRAME_RUBYFRAME_P(
cfp)) {
13072 while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec,
cfp)) {
13073 if (VM_FRAME_RUBYFRAME_P(
cfp)) {
13084rb_vm_pop_cfunc_frame(
void)
13097 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 0, 0);
13103 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 0, 1);
13109 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 0, 2);
13115 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 0, 3);
13121 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 0, 4);
13127 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 0, 5);
13133 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 1, 0);
13139 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 1, 1);
13145 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 1, 2);
13151 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 1, 3);
13157 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 1, 4);
13163 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 1, 5);
13169 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 2, 0);
13175 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 2, 1);
13181 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 2, 2);
13187 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 2, 3);
13193 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 2, 4);
13199 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 2, 5);
13205 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 3, 0);
13211 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 3, 1);
13217 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 3, 2);
13223 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 3, 3);
13229 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 3, 4);
13235 return vm_call_iseq_setup_normal(ec,
cfp,
calling, cd->
cc.
me, 0, 3, 5);
13238{vm_call_iseq_setup_normal_0start_0params_0locals,
13239 vm_call_iseq_setup_normal_0start_0params_1locals,
13240 vm_call_iseq_setup_normal_0start_0params_2locals,
13241 vm_call_iseq_setup_normal_0start_0params_3locals,
13242 vm_call_iseq_setup_normal_0start_0params_4locals,
13243 vm_call_iseq_setup_normal_0start_0params_5locals},
13244{vm_call_iseq_setup_normal_0start_1params_0locals,
13245 vm_call_iseq_setup_normal_0start_1params_1locals,
13246 vm_call_iseq_setup_normal_0start_1params_2locals,
13247 vm_call_iseq_setup_normal_0start_1params_3locals,
13248 vm_call_iseq_setup_normal_0start_1params_4locals,
13249 vm_call_iseq_setup_normal_0start_1params_5locals},
13250{vm_call_iseq_setup_normal_0start_2params_0locals,
13251 vm_call_iseq_setup_normal_0start_2params_1locals,
13252 vm_call_iseq_setup_normal_0start_2params_2locals,
13253 vm_call_iseq_setup_normal_0start_2params_3locals,
13254 vm_call_iseq_setup_normal_0start_2params_4locals,
13255 vm_call_iseq_setup_normal_0start_2params_5locals},
13256{vm_call_iseq_setup_normal_0start_3params_0locals,
13257 vm_call_iseq_setup_normal_0start_3params_1locals,
13258 vm_call_iseq_setup_normal_0start_3params_2locals,
13259 vm_call_iseq_setup_normal_0start_3params_3locals,
13260 vm_call_iseq_setup_normal_0start_3params_4locals,
13261 vm_call_iseq_setup_normal_0start_3params_5locals}
13267 return &vm_call_iseq_setup_tailcall_0start;
13270 return &vm_call_iseq_setup_normal_0start;
13278 return &vm_call_iseq_setup_normal_0start;
13281#define MJIT_HEADER 1
13282#define _FORTIFY_SOURCE 2
13283#define RUBY_EXPORT 1
13284#define CANONICALIZATION_FOR_MATHN 1
13285#define _XOPEN_SOURCE 1
13286#define _GNU_SOURCE 1
13287#define RUBY_INTERNAL_H 1
13289#define HAVE_RUBY_DEFINES_H 1
13290#define HAVE_RUBY_ENCODING_H 1
13291#define HAVE_RUBY_INTERN_H 1
13292#define HAVE_RUBY_IO_H 1
13293#define HAVE_RUBY_MISSING_H 1
13294#define HAVE_RUBY_ONIGURUMA_H 1
13295#define HAVE_RUBY_RE_H 1
13296#define HAVE_RUBY_REGEX_H 1
13297#define HAVE_RUBY_RUBY_H 1
13298#define HAVE_RUBY_ST_H 1
13299#define HAVE_RUBY_THREAD_H 1
13300#define HAVE_RUBY_UTIL_H 1
13301#define HAVE_RUBY_VERSION_H 1
13302#define HAVE_RUBY_VM_H 1
13303#define RUBY_RUBY_H 1
13304#define INCLUDE_RUBY_CONFIG_H 1
13305#define HAVE_STDIO_H 1
13306#define HAVE_STDLIB_H 1
13307#define HAVE_STRING_H 1
13308#define HAVE_INTTYPES_H 1
13309#define HAVE_STDINT_H 1
13310#define HAVE_STRINGS_H 1
13311#define HAVE_SYS_STAT_H 1
13312#define HAVE_SYS_TYPES_H 1
13313#define HAVE_UNISTD_H 1
13314#define HAVE_WCHAR_H 1
13315#define STDC_HEADERS 1
13316#define _ALL_SOURCE 1
13317#define _DARWIN_C_SOURCE 1
13318#define _GNU_SOURCE 1
13319#define _HPUX_ALT_XOPEN_SOCKET_API 1
13320#define _NETBSD_SOURCE 1
13321#define _OPENBSD_SOURCE 1
13322#define _POSIX_PTHREAD_SEMANTICS 1
13323#define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1
13324#define __STDC_WANT_IEC_60559_BFP_EXT__ 1
13325#define __STDC_WANT_IEC_60559_DFP_EXT__ 1
13326#define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1
13327#define __STDC_WANT_IEC_60559_TYPES_EXT__ 1
13328#define __STDC_WANT_LIB_EXT2__ 1
13329#define __STDC_WANT_MATH_SPEC_FUNCS__ 1
13330#define _TANDEM_SOURCE 1
13331#define __EXTENSIONS__ 1
13332#define RUBY_SYMBOL_EXPORT_BEGIN _Pragma("GCC visibility push(default)")
13333#define RUBY_SYMBOL_EXPORT_END _Pragma("GCC visibility pop")
13334#define HAVE_STMT_AND_DECL_IN_EXPR 1
13335#define HAVE_CYGWIN_CONV_PATH 1
13336#define HAVE_LIBCRYPT 1
13337#define HAVE_LIBDL 1
13338#define HAVE_DIRENT_H 1
13339#define HAVE__BOOL 1
13340#define HAVE_STDBOOL_H 1
13341#define HAVE_SYS_WAIT_H 1
13342#define HAVE_A_OUT_H 1
13343#define HAVE_GRP_H 1
13344#define HAVE_FCNTL_H 1
13345#define HAVE_FLOAT_H 1
13346#define HAVE_IEEEFP_H 1
13347#define HAVE_LANGINFO_H 1
13348#define HAVE_LIMITS_H 1
13349#define HAVE_LOCALE_H 1
13350#define HAVE_MALLOC_H 1
13351#define HAVE_PROCESS_H 1
13352#define HAVE_PWD_H 1
13353#define HAVE_STDALIGN_H 1
13354#define HAVE_SYS_FCNTL_H 1
13355#define HAVE_SYS_FILE_H 1
13356#define HAVE_SYS_IOCTL_H 1
13357#define HAVE_SYS_PARAM_H 1
13358#define HAVE_SYS_RESOURCE_H 1
13359#define HAVE_SYS_SELECT_H 1
13360#define HAVE_SYS_SOCKET_H 1
13361#define HAVE_SYS_SYSMACROS_H 1
13362#define HAVE_SYS_TIME_H 1
13363#define HAVE_SYS_TIMES_H 1
13364#define HAVE_SYS_UIO_H 1
13365#define HAVE_SYS_UTIME_H 1
13366#define HAVE_TIME_H 1
13367#define HAVE_UCONTEXT_H 1
13368#define HAVE_UTIME_H 1
13369#define HAVE_GMP_H 1
13370#define HAVE_LIBGMP 1
13371#define HAVE_TYPEOF 1
13372#define restrict __restrict__
13373#define HAVE_LONG_LONG 1
13374#define HAVE_OFF_T 1
13375#define SIZEOF_INT 4
13376#define SIZEOF_SHORT 2
13377#define SIZEOF_LONG 8
13378#define SIZEOF_LONG_LONG 8
13379#define SIZEOF___INT64 0
13380#define SIZEOF___INT128 16
13381#define SIZEOF_OFF_T 8
13382#define SIZEOF_VOIDP 8
13383#define SIZEOF_FLOAT 4
13384#define SIZEOF_DOUBLE 8
13385#define SIZEOF_TIME_T 8
13386#define SIZEOF_CLOCK_T 8
13387#define PACKED_STRUCT(x) x __attribute__((packed))
13388#define USE_UNALIGNED_MEMBER_ACCESS 1
13389#define PRI_LL_PREFIX "ll"
13390#define HAVE_PID_T 1
13391#define rb_pid_t pid_t
13392#define SIGNEDNESS_OF_PID_T -1
13393#define PIDT2NUM(v) INT2NUM(v)
13394#define NUM2PIDT(v) NUM2INT(v)
13395#define PRI_PIDT_PREFIX PRI_INT_PREFIX
13396#define HAVE_UID_T 1
13397#define rb_uid_t uid_t
13398#define SIGNEDNESS_OF_UID_T +1
13399#define UIDT2NUM(v) UINT2NUM(v)
13400#define NUM2UIDT(v) NUM2UINT(v)
13401#define PRI_UIDT_PREFIX PRI_INT_PREFIX
13402#define HAVE_GID_T 1
13403#define rb_gid_t gid_t
13404#define SIGNEDNESS_OF_GID_T +1
13405#define GIDT2NUM(v) UINT2NUM(v)
13406#define NUM2GIDT(v) NUM2UINT(v)
13407#define PRI_GIDT_PREFIX PRI_INT_PREFIX
13408#define HAVE_TIME_T 1
13409#define rb_time_t time_t
13410#define SIGNEDNESS_OF_TIME_T -1
13411#define TIMET2NUM(v) LONG2NUM(v)
13412#define NUM2TIMET(v) NUM2LONG(v)
13413#define PRI_TIMET_PREFIX PRI_LONG_PREFIX
13414#define HAVE_DEV_T 1
13415#define rb_dev_t dev_t
13416#define SIGNEDNESS_OF_DEV_T +1
13417#define DEVT2NUM(v) UINT2NUM(v)
13418#define NUM2DEVT(v) NUM2UINT(v)
13419#define PRI_DEVT_PREFIX PRI_INT_PREFIX
13420#define HAVE_MODE_T 1
13421#define rb_mode_t mode_t
13422#define SIGNEDNESS_OF_MODE_T +1
13423#define MODET2NUM(v) UINT2NUM(v)
13424#define NUM2MODET(v) NUM2UINT(v)
13425#define PRI_MODET_PREFIX PRI_INT_PREFIX
13426#define HAVE_RLIM_T 1
13427#define rb_rlim_t rlim_t
13428#define SIGNEDNESS_OF_RLIM_T +1
13429#define RLIM2NUM(v) ULONG2NUM(v)
13430#define NUM2RLIM(v) NUM2ULONG(v)
13431#define PRI_RLIM_PREFIX PRI_LONG_PREFIX
13432#define HAVE_OFF_T 1
13433#define rb_off_t off_t
13434#define SIGNEDNESS_OF_OFF_T -1
13435#define OFFT2NUM(v) LONG2NUM(v)
13436#define NUM2OFFT(v) NUM2LONG(v)
13437#define PRI_OFFT_PREFIX PRI_LONG_PREFIX
13438#define HAVE_CLOCKID_T 1
13439#define rb_clockid_t clockid_t
13440#define SIGNEDNESS_OF_CLOCKID_T +1
13441#define CLOCKID2NUM(v) ULONG2NUM(v)
13442#define NUM2CLOCKID(v) NUM2ULONG(v)
13443#define PRI_CLOCKID_PREFIX PRI_LONG_PREFIX
13444#define HAVE_PROTOTYPES 1
13445#define TOKEN_PASTE(x,y) x ##y
13446#define STRINGIZE(expr) STRINGIZE0(expr)
13447#define HAVE_STDARG_PROTOTYPES 1
13448#define HAVE_VA_ARGS_MACRO 1
13449#define RUBY_ALIGNAS(x) __declspec(aligned(x))
13450#define RUBY_ALIGNOF alignof
13451#define CONSTFUNC(x) __attribute__ ((__const__)) x
13452#define PUREFUNC(x) __attribute__ ((__pure__)) x
13453#define NORETURN(x) __attribute__ ((__noreturn__)) x
13454#define DEPRECATED(x) __attribute__ ((__deprecated__)) x
13455#define DEPRECATED_BY(n,x) __attribute__ ((__deprecated__("by "#n))) x
13456#define DEPRECATED_TYPE(mesg,x) __attribute__ ((__deprecated__ mesg)) x
13457#define NOINLINE(x) __attribute__ ((__noinline__)) x
13458#define NO_SANITIZE(san,x) __attribute__ ((__no_sanitize__(san))) x
13459#define NO_SANITIZE_ADDRESS(x) __attribute__ ((__no_sanitize_address__)) x
13460#define NO_ADDRESS_SAFETY_ANALYSIS(x) __attribute__ ((__no_address_safety_analysis__)) x
13461#define WARN_UNUSED_RESULT(x) __attribute__ ((__warn_unused_result__)) x
13462#define MAYBE_UNUSED(x) __attribute__ ((__unused__)) x
13463#define ERRORFUNC(mesg,x) __attribute__ ((__error__ mesg)) x
13464#define WARNINGFUNC(mesg,x) __attribute__ ((__warning__ mesg)) x
13465#define WEAK(x) __attribute__ ((__weak__)) x
13466#define HAVE_FUNC_WEAK 1
13467#define RUBY_CXX_DEPRECATED(msg) __attribute__((__deprecated__(msg)))
13468#define FUNC_STDCALL(x) __attribute__ ((__stdcall__)) x
13469#define FUNC_CDECL(x) __attribute__ ((__cdecl__)) x
13470#define FUNC_FASTCALL(x) __attribute__ ((__fastcall__)) x
13471#define FUNC_UNOPTIMIZED(x) __attribute__ ((__optimize__("O0"))) x
13472#define FUNC_MINIMIZED(x) __attribute__ ((__optimize__("-Os","-fomit-frame-pointer"))) x
13473#define HAVE_ATTRIBUTE_FUNCTION_ALIAS 1
13474#define RUBY_ALIAS_FUNCTION_TYPE(type,prot,name,args) type prot __attribute__((alias(#name)));
13475#define RUBY_ALIAS_FUNCTION_VOID(prot,name,args) RUBY_ALIAS_FUNCTION_TYPE(void, prot, name, args)
13476#define HAVE_GCC_ATOMIC_BUILTINS 1
13477#define HAVE_GCC_SYNC_BUILTINS 1
13478#define UNREACHABLE __builtin_unreachable()
13479#define RUBY_FUNC_EXPORTED __attribute__ ((__visibility__("default"))) extern
13480#define RUBY_FUNC_NONNULL(n,x) __attribute__ ((__nonnull__(n))) x
13481#define RUBY_FUNCTION_NAME_STRING __func__
13482#define ENUM_OVER_INT 1
13483#define HAVE_DECL_SYS_NERR 1
13484#define HAVE_DECL_GETENV 1
13485#define SIZEOF_SIZE_T 8
13486#define SIZEOF_PTRDIFF_T 8
13487#define PRI_SIZE_PREFIX "z"
13488#define PRI_PTRDIFF_PREFIX "t"
13489#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
13490#define HAVE_STRUCT_STAT_ST_BLOCKS 1
13491#define HAVE_STRUCT_STAT_ST_RDEV 1
13492#define SIZEOF_STRUCT_STAT_ST_SIZE SIZEOF_OFF_T
13493#define SIZEOF_STRUCT_STAT_ST_BLOCKS SIZEOF_OFF_T
13494#define SIZEOF_STRUCT_STAT_ST_INO SIZEOF_LONG
13495#define HAVE_STRUCT_STAT_ST_ATIM 1
13496#define HAVE_STRUCT_STAT_ST_MTIM 1
13497#define HAVE_STRUCT_STAT_ST_CTIM 1
13498#define HAVE_STRUCT_TIMEVAL 1
13499#define SIZEOF_STRUCT_TIMEVAL_TV_SEC SIZEOF_TIME_T
13500#define HAVE_STRUCT_TIMESPEC 1
13501#define HAVE_STRUCT_TIMEZONE 1
13502#define HAVE_RB_FD_INIT 1
13503#define HAVE_INT8_T 1
13504#define SIZEOF_INT8_T 1
13505#define HAVE_UINT8_T 1
13506#define SIZEOF_UINT8_T 1
13507#define HAVE_INT16_T 1
13508#define SIZEOF_INT16_T 2
13509#define HAVE_UINT16_T 1
13510#define SIZEOF_UINT16_T 2
13511#define HAVE_INT32_T 1
13512#define SIZEOF_INT32_T 4
13513#define HAVE_UINT32_T 1
13514#define SIZEOF_UINT32_T 4
13515#define HAVE_INT64_T 1
13516#define SIZEOF_INT64_T 8
13517#define HAVE_UINT64_T 1
13518#define SIZEOF_UINT64_T 8
13519#define HAVE_INT128_T 1
13520#define int128_t __int128
13521#define SIZEOF_INT128_T SIZEOF___INT128
13522#define HAVE_UINT128_T 1
13523#define uint128_t unsigned __int128
13524#define SIZEOF_UINT128_T SIZEOF___INT128
13525#define HAVE_INTPTR_T 1
13526#define SIZEOF_INTPTR_T 8
13527#define HAVE_UINTPTR_T 1
13528#define SIZEOF_UINTPTR_T 8
13529#define PRI_PTR_PREFIX "l"
13530#define HAVE_SSIZE_T 1
13531#define SIZEOF_SSIZE_T 8
13532#define PRI_64_PREFIX "l"
13533#define GETGROUPS_T gid_t
13534#define RETSIGTYPE void
13535#define HAVE_ALLOCA_H 1
13536#define HAVE_ALLOCA 1
13537#define HAVE_ACOSH 1
13539#define HAVE_CRYPT 1
13542#define HAVE_EXPLICIT_BZERO 1
13544#define HAVE_FLOCK 1
13545#define HAVE_HYPOT 1
13546#define HAVE_LGAMMA_R 1
13547#define HAVE_MEMMOVE 1
13549#define HAVE_NEXTAFTER 1
13550#define HAVE_STRCHR 1
13551#define HAVE_STRERROR 1
13552#define HAVE_STRLCAT 1
13553#define HAVE_STRLCPY 1
13554#define HAVE_STRSTR 1
13555#define HAVE_TGAMMA 1
13556#define HAVE_FINITE 1
13557#define HAVE_ISINF 1
13558#define HAVE_ISNAN 1
13559#define HAVE_SIGNBIT 1
13561#define HAVE_VFORK 1
13562#define HAVE_WORKING_VFORK 1
13563#define HAVE_WORKING_FORK 1
13564#define HAVE__LONGJMP 1
13565#define HAVE_ARC4RANDOM_BUF 1
13566#define HAVE_ATAN2L 1
13567#define HAVE_ATAN2F 1
13568#define HAVE_CHROOT 1
13569#define HAVE_CLOCK_GETTIME 1
13571#define HAVE_CRYPT_R 1
13572#define HAVE_DIRFD 1
13573#define HAVE_DLOPEN 1
13574#define HAVE_DLADDR 1
13577#define HAVE_EACCESS 1
13578#define HAVE_ENDGRENT 1
13579#define HAVE_FCHMOD 1
13580#define HAVE_FCHOWN 1
13581#define HAVE_FCNTL 1
13582#define HAVE_FDATASYNC 1
13583#define HAVE_FDOPENDIR 1
13585#define HAVE_FSTATAT 1
13586#define HAVE_FSYNC 1
13587#define HAVE_FTRUNCATE 1
13588#define HAVE_GETCWD 1
13589#define HAVE_GETGRNAM 1
13590#define HAVE_GETGRNAM_R 1
13591#define HAVE_GETGROUPS 1
13592#define HAVE_GETLOGIN 1
13593#define HAVE_GETLOGIN_R 1
13594#define HAVE_GETPGID 1
13595#define HAVE_GETPGRP 1
13596#define HAVE_GETPRIORITY 1
13597#define HAVE_GETPWNAM 1
13598#define HAVE_GETPWNAM_R 1
13599#define HAVE_GETPWUID 1
13600#define HAVE_GETPWUID_R 1
13601#define HAVE_GETRANDOM 1
13602#define HAVE_GETRLIMIT 1
13603#define HAVE_GETSID 1
13604#define HAVE_GETTIMEOFDAY 1
13605#define HAVE_GMTIME_R 1
13606#define HAVE_GRANTPT 1
13607#define HAVE_INITGROUPS 1
13608#define HAVE_IOCTL 1
13609#define HAVE_ISSETUGID 1
13610#define HAVE_KILLPG 1
13611#define HAVE_LCHOWN 1
13613#define HAVE_LLABS 1
13614#define HAVE_LOCKF 1
13616#define HAVE_LSTAT 1
13617#define HAVE_LUTIMES 1
13618#define HAVE_MALLOC_USABLE_SIZE 1
13619#define HAVE_MBLEN 1
13620#define HAVE_MEMALIGN 1
13621#define HAVE_WRITEV 1
13622#define HAVE_MEMRCHR 1
13623#define HAVE_MEMMEM 1
13624#define HAVE_MKFIFO 1
13625#define HAVE_MKNOD 1
13626#define HAVE_MKTIME 1
13627#define HAVE_OPENAT 1
13628#define HAVE_PIPE2 1
13630#define HAVE_POSIX_FADVISE 1
13631#define HAVE_POSIX_MEMALIGN 1
13632#define HAVE_PPOLL 1
13633#define HAVE_PREAD 1
13634#define HAVE_PWRITE 1
13635#define HAVE_QSORT_R 1
13636#define HAVE_READLINK 1
13637#define HAVE_REALPATH 1
13638#define HAVE_ROUND 1
13639#define HAVE_SCHED_GETAFFINITY 1
13640#define HAVE_SEEKDIR 1
13641#define HAVE_SETEGID 1
13642#define HAVE_SETENV 1
13643#define HAVE_SETEUID 1
13644#define HAVE_SETGID 1
13645#define HAVE_SETGROUPS 1
13646#define HAVE_SETPGID 1
13647#define HAVE_SETPGRP 1
13648#define HAVE_SETREGID 1
13649#define HAVE_SETREUID 1
13650#define HAVE_SETRLIMIT 1
13651#define HAVE_SETSID 1
13652#define HAVE_SETUID 1
13653#define HAVE_SHUTDOWN 1
13654#define HAVE_SIGACTION 1
13655#define HAVE_SIGALTSTACK 1
13656#define HAVE_SIGPROCMASK 1
13658#define HAVE_SPAWNV 1
13659#define HAVE_SYMLINK 1
13660#define HAVE_SYSCONF 1
13662#define HAVE_TELLDIR 1
13663#define HAVE_TIMEGM 1
13664#define HAVE_TIMES 1
13665#define HAVE_TRUNCATE 1
13666#define HAVE_UNSETENV 1
13667#define HAVE_UTIMENSAT 1
13668#define HAVE_UTIMES 1
13669#define HAVE_WAIT4 1
13670#define HAVE_WAITPID 1
13671#define HAVE_CRYPT_H 1
13672#define HAVE_STRUCT_CRYPT_DATA_INITIALIZED 1
13673#define HAVE_BUILTIN___BUILTIN_ALLOCA_WITH_ALIGN 1
13674#define HAVE_BUILTIN___BUILTIN_ASSUME_ALIGNED 1
13675#define HAVE_BUILTIN___BUILTIN_BSWAP16 1
13676#define HAVE_BUILTIN___BUILTIN_BSWAP32 1
13677#define HAVE_BUILTIN___BUILTIN_BSWAP64 1
13678#define HAVE_BUILTIN___BUILTIN_POPCOUNT 1
13679#define HAVE_BUILTIN___BUILTIN_POPCOUNTLL 1
13680#define HAVE_BUILTIN___BUILTIN_CLZ 1
13681#define HAVE_BUILTIN___BUILTIN_CLZL 1
13682#define HAVE_BUILTIN___BUILTIN_CLZLL 1
13683#define HAVE_BUILTIN___BUILTIN_CTZ 1
13684#define HAVE_BUILTIN___BUILTIN_CTZLL 1
13685#define HAVE_BUILTIN___BUILTIN_ADD_OVERFLOW 1
13686#define HAVE_BUILTIN___BUILTIN_SUB_OVERFLOW 1
13687#define HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW 1
13688#define HAVE_BUILTIN___BUILTIN_MUL_OVERFLOW_P 1
13689#define HAVE_BUILTIN___BUILTIN_CONSTANT_P 1
13690#define HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR 1
13691#define HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P 1
13692#define HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P 1
13693#define HAVE_BUILTIN___BUILTIN_TRAP 1
13694#define HAVE_GNU_QSORT_R 1
13695#define ATAN2_INF_C99 1
13696#define HAVE_CLOCK_GETRES 1
13697#define HAVE_LIBRT 1
13698#define HAVE_LIBRT 1
13699#define HAVE_TIMER_CREATE 1
13700#define HAVE_TIMER_SETTIME 1
13701#define HAVE_STRUCT_TM_TM_ZONE 1
13702#define HAVE_TM_ZONE 1
13703#define HAVE_STRUCT_TM_TM_GMTOFF 1
13704#define HAVE_DAYLIGHT 1
13705#define NEGATIVE_TIME_T 1
13706#define POSIX_SIGNAL 1
13707#define HAVE_SIG_T 1
13708#define RSHIFT(x,y) ((x)>>(int)(y))
13709#define HAVE__SC_CLK_TCK 1
13710#define STACK_GROW_DIRECTION -1
13711#define COROUTINE_H "coroutine/ucontext/Context.h"
13712#define _REENTRANT 1
13713#define _THREAD_SAFE 1
13714#define HAVE_LIBPTHREAD 1
13715#define HAVE_SCHED_YIELD 1
13716#define HAVE_PTHREAD_ATTR_SETINHERITSCHED 1
13717#define HAVE_PTHREAD_ATTR_GETSTACK 1
13718#define HAVE_PTHREAD_ATTR_GETGUARDSIZE 1
13719#define HAVE_PTHREAD_CONDATTR_SETCLOCK 1
13720#define HAVE_PTHREAD_SIGMASK 1
13721#define HAVE_PTHREAD_SETNAME_NP 1
13722#define HAVE_PTHREAD_GETATTR_NP 1
13723#define SET_CURRENT_THREAD_NAME(name) pthread_setname_np(pthread_self(), name)
13724#define SET_ANOTHER_THREAD_NAME(thid,name) pthread_setname_np(thid, name)
13725#define DEFINE_MCONTEXT_PTR(mc,uc) mcontext_t *mc = &(uc)->uc_mcontext
13726#define HAVE_GETCONTEXT 1
13727#define HAVE_SETCONTEXT 1
13728#define DLEXT_MAXLEN 3
13730#define LIBDIR_BASENAME "lib"
13731#define EXECUTABLE_EXTS ".exe",".com",".cmd",".bat"
13732#define HAVE__SETJMP 1
13733#define RUBY_SETJMP(env) __builtin_setjmp((env))
13734#define RUBY_LONGJMP(env,val) __builtin_longjmp((env),val)
13736#define HAVE_PTHREAD_H 1
13737#define RUBY_PLATFORM "x86_64-cygwin"
13738#define RUBY_DEFINES_H 1
13739#define HAVE_ATTRIBUTE_ERRORFUNC 1
13740#define HAVE_ATTRIBUTE_WARNINGFUNC 1
13741#define GCC_VERSION_SINCE(major,minor,patchlevel) ((__GNUC__ > (major)) || ((__GNUC__ == (major) && ((__GNUC_MINOR__ > (minor)) || (__GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))))
13742#define GCC_VERSION_BEFORE(major,minor,patchlevel) ((__GNUC__ < (major)) || ((__GNUC__ == (major) && ((__GNUC_MINOR__ < (minor)) || (__GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ <= (patchlevel))))))
13743#define RB_LIKELY(x) (__builtin_expect(!!(x), 1))
13744#define RB_UNLIKELY(x) (__builtin_expect(!!(x), 0))
13745#define COLDFUNC __attribute__((cold))
13746#define PRINTF_ARGS(decl,string_index,first_to_check) decl __attribute__((format(printf, string_index, first_to_check)))
13747#define RB_GNUC_EXTENSION __extension__
13748#define RB_GNUC_EXTENSION_BLOCK(x) __extension__ ({ x; })
13750#define _ANSIDECL_H_
13751#define __NEWLIB_H__ 1
13752#define _NEWLIB_VERSION_H__ 1
13753#define _NEWLIB_VERSION "4.1.0"
13754#define __NEWLIB__ 4
13755#define __NEWLIB_MINOR__ 1
13756#define __NEWLIB_PATCHLEVEL__ 0
13757#define _WANT_IO_C99_FORMATS 1
13758#define _WANT_IO_LONG_LONG 1
13759#define _WANT_IO_LONG_DOUBLE 1
13760#define _WANT_IO_POS_ARGS 1
13761#define _REENT_CHECK_VERIFY 1
13762#define _MB_CAPABLE 1
13763#define _MB_LEN_MAX 8
13764#define _ATEXIT_DYNAMIC_ALLOC 1
13765#define _HAVE_LONG_DOUBLE 1
13766#define _HAVE_CC_INHIBIT_LOOP_TO_LIBCALL 1
13767#define _FVWRITE_IN_STREAMIO 1
13768#define _FSEEK_OPTIMIZATION 1
13769#define _WIDE_ORIENT 1
13770#define _UNBUF_STREAM_OPT 1
13771#define __SYS_CONFIG_H__
13772#define __IEEE_LITTLE_ENDIAN
13773#define _SUPPORTS_ERREXCEPT
13774#define __OBSOLETE_MATH_DEFAULT 0
13775#define __OBSOLETE_MATH __OBSOLETE_MATH_DEFAULT
13776#define _SYS_FEATURES_H
13777#define __GNUC_PREREQ(maj,min) ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
13778#define __GNUC_PREREQ__(ma,mi) __GNUC_PREREQ(ma, mi)
13779#undef _ATFILE_SOURCE
13780#define _ATFILE_SOURCE 1
13781#undef _DEFAULT_SOURCE
13782#define _DEFAULT_SOURCE 1
13783#undef _ISOC99_SOURCE
13784#define _ISOC99_SOURCE 1
13785#undef _ISOC11_SOURCE
13786#define _ISOC11_SOURCE 1
13787#undef _POSIX_SOURCE
13788#define _POSIX_SOURCE 1
13789#undef _POSIX_C_SOURCE
13790#define _POSIX_C_SOURCE 200809L
13791#undef _XOPEN_SOURCE
13792#define _XOPEN_SOURCE 700
13793#undef _XOPEN_SOURCE_EXTENDED
13794#define _XOPEN_SOURCE_EXTENDED 1
13795#undef _POSIX_SOURCE
13796#define _POSIX_SOURCE 1
13797#undef _POSIX_C_SOURCE
13798#define _POSIX_C_SOURCE 200809L
13799#undef _ATFILE_SOURCE
13800#define _ATFILE_SOURCE 1
13801#define __ATFILE_VISIBLE 1
13802#define __BSD_VISIBLE 1
13803#define __GNU_VISIBLE 1
13804#define __ISO_C_VISIBLE 2011
13805#define __LARGEFILE_VISIBLE 1
13806#define __MISC_VISIBLE 1
13807#define __POSIX_VISIBLE 200809
13808#define __SVID_VISIBLE 1
13809#define __XSI_VISIBLE 700
13810#define __SSP_FORTIFY_LEVEL 2
13811#define _POSIX_VERSION 200809L
13812#define _POSIX2_VERSION 200809L
13813#define _XOPEN_VERSION __XSI_VISIBLE
13814#define _POSIX_ADVISORY_INFO 200809L
13815#define _POSIX_ASYNCHRONOUS_IO 200809L
13816#define _POSIX_BARRIERS 200809L
13817#define _POSIX_CHOWN_RESTRICTED 1
13818#define _POSIX_CLOCK_SELECTION 200809L
13819#define _POSIX_CPUTIME 200809L
13820#define _POSIX_FSYNC 200809L
13821#define _POSIX_IPV6 200809L
13822#define _POSIX_JOB_CONTROL 1
13823#define _POSIX_MAPPED_FILES 200809L
13824#define _POSIX_MEMLOCK_RANGE 200809L
13825#define _POSIX_MEMORY_PROTECTION 200809L
13826#define _POSIX_MESSAGE_PASSING 200809L
13827#define _POSIX_MONOTONIC_CLOCK 200809L
13828#define _POSIX_NO_TRUNC 1
13829#define _POSIX_PRIORITY_SCHEDULING 200809L
13830#define _POSIX_RAW_SOCKETS 200809L
13831#define _POSIX_READER_WRITER_LOCKS 200809L
13832#define _POSIX_REALTIME_SIGNALS 200809L
13833#define _POSIX_REGEXP 1
13834#define _POSIX_SAVED_IDS 1
13835#define _POSIX_SEMAPHORES 200809L
13836#define _POSIX_SHARED_MEMORY_OBJECTS 200809L
13837#define _POSIX_SHELL 1
13838#define _POSIX_SPAWN 200809L
13839#define _POSIX_SPIN_LOCKS 200809L
13840#define _POSIX_SYNCHRONIZED_IO 200809L
13841#define _POSIX_THREAD_ATTR_STACKADDR 200809L
13842#define _POSIX_THREAD_ATTR_STACKSIZE 200809L
13843#define _POSIX_THREAD_CPUTIME 200809L
13844#define _POSIX_THREAD_PRIORITY_SCHEDULING 200809L
13845#define _POSIX_THREAD_PROCESS_SHARED 200809L
13846#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L
13847#define _POSIX_THREADS 200809L
13848#define _POSIX_TIMEOUTS 200809L
13849#define _POSIX_TIMERS 200809L
13850#define _POSIX_VDISABLE '\0'
13851#define _POSIX2_C_VERSION _POSIX2_VERSION
13852#define _POSIX2_C_BIND _POSIX2_VERSION
13853#define _POSIX2_C_DEV _POSIX2_VERSION
13854#define _POSIX2_CHAR_TERM _POSIX2_VERSION
13855#define _POSIX2_SW_DEV _POSIX2_VERSION
13856#define _POSIX2_UPE _POSIX2_VERSION
13857#define _POSIX_V6_ILP32_OFF32 -1
13858#define _POSIX_V6_ILP32_OFFBIG -1
13859#define _POSIX_V6_LP64_OFF64 1
13860#define _POSIX_V6_LPBIG_OFFBIG 1
13861#define _POSIX_V7_ILP32_OFF32 _POSIX_V6_ILP32_OFF32
13862#define _POSIX_V7_ILP32_OFFBIG _POSIX_V6_ILP32_OFFBIG
13863#define _POSIX_V7_LP64_OFF64 _POSIX_V6_LP64_OFF64
13864#define _POSIX_V7_LPBIG_OFFBIG _POSIX_V6_LPBIG_OFFBIG
13865#define _XBS5_ILP32_OFF32 _POSIX_V6_ILP32_OFF32
13866#define _XBS5_ILP32_OFFBIG _POSIX_V6_ILP32_OFFBIG
13867#define _XBS5_LP64_OFF64 _POSIX_V6_LP64_OFF64
13868#define _XBS5_LPBIG_OFFBIG _POSIX_V6_LPBIG_OFFBIG
13869#define _XOPEN_CRYPT 1
13870#define _XOPEN_ENH_I18N 1
13871#define _XOPEN_SHM 1
13872#define __STDC_ISO_10646__ 201806L
13873#define _POINTER_INT long
13875#define __RAND_MAX 0x7fffffff
13876#define _CYGWIN_CONFIG_H
13877#define __DYNAMIC_REENT__
13878#define __SYMBOL_PREFIX
13879#define _SYMSTR(x) __SYMBOL_PREFIX #x
13880#define __FILENAME_MAX__ 4096
13881#define _READ_WRITE_RETURN_TYPE _ssize_t
13882#define _READ_WRITE_BUFSIZE_TYPE size_t
13883#define __LARGE64_FILES 1
13884#define __USE_INTERNAL_STAT64 1
13885#define __LINUX_ERRNO_EXTENSIONS__ 1
13886#define _MB_EXTENDED_CHARSETS_ALL 1
13887#define __HAVE_LOCALE_INFO__ 1
13888#define __HAVE_LOCALE_INFO_EXTENDED__ 1
13889#define _WANT_C99_TIME_FORMATS 1
13890#define _GLIBC_EXTENSION 1
13891#define _STDIO_BSD_SEMANTICS 1
13892#define __TM_GMTOFF tm_gmtoff
13893#define __TM_ZONE tm_zone
13894#define _USE_LONG_TIME_T 1
13896#define __IMPORT __declspec(dllimport)
13897#define DEFAULT_LOCALE "C.UTF-8"
13898#define _MB_EXTENDED_CHARSETS_ISO 1
13899#define _MB_EXTENDED_CHARSETS_WINDOWS 1
13900#define _BEGIN_STD_C
13903#define _LONG_DOUBLE long double
13904#define _ATTRIBUTE(attrs) __attribute__ (attrs)
13905#define _ELIDABLE_INLINE static __inline__
13906#define _NOINLINE __attribute__ ((__noinline__))
13907#define _NOINLINE_STATIC _NOINLINE static
13909#define __need_size_t
13911#define _SYS_CDEFS_H_
13912#define _MACHINE__DEFAULT_TYPES_H
13913#define __EXP(x) __ ##x ##__
13914#define __have_longlong64 1
13915#define __have_long64 1
13916#define ___int8_t_defined 1
13917#define ___int16_t_defined 1
13918#define ___int32_t_defined 1
13919#define ___int64_t_defined 1
13920#define ___int_least8_t_defined 1
13921#define ___int_least16_t_defined 1
13922#define ___int_least32_t_defined 1
13923#define ___int_least64_t_defined 1
13928#define _SYS_SIZE_T_H
13933#define _BSD_SIZE_T_
13934#define _SIZE_T_DEFINED_
13935#define _SIZE_T_DEFINED
13936#define _BSD_SIZE_T_DEFINED_
13937#define _SIZE_T_DECLARED
13938#define ___int_size_t_h
13942#undef __need_size_t
13944#define NULL ((void *)0)
13946#define __PMT(args) args
13947#define __DOTS , ...
13949#define __ASMNAME(cname) __XSTRING (__USER_LABEL_PREFIX__) cname
13950#define __ptr_t void *
13951#define __long_double_t long double
13952#define __attribute_malloc__
13953#define __attribute_pure__
13954#define __attribute_format_strfmon__(a,b)
13955#define __flexarr [0]
13959#define __has_extension __has_feature
13960#define __has_feature(x) 0
13961#define __BEGIN_DECLS
13963#define __GNUCLIKE_ASM 3
13964#define __GNUCLIKE_MATH_BUILTIN_CONSTANTS
13965#define __GNUCLIKE___TYPEOF 1
13966#define __GNUCLIKE___OFFSETOF 1
13967#define __GNUCLIKE___SECTION 1
13968#define __GNUCLIKE_CTOR_SECTION_HANDLING 1
13969#define __GNUCLIKE_BUILTIN_CONSTANT_P 1
13970#define __GNUCLIKE_BUILTIN_VARARGS 1
13971#define __GNUCLIKE_BUILTIN_STDARG 1
13972#define __GNUCLIKE_BUILTIN_VAALIST 1
13973#define __GNUC_VA_LIST_COMPATIBILITY 1
13974#define __compiler_membar() __asm __volatile(" " : : : "memory")
13975#define __GNUCLIKE_BUILTIN_NEXT_ARG 1
13976#define __GNUCLIKE_MATH_BUILTIN_RELOPS
13977#define __GNUCLIKE_BUILTIN_MEMCPY 1
13978#define __CC_SUPPORTS_INLINE 1
13979#define __CC_SUPPORTS___INLINE 1
13980#define __CC_SUPPORTS___INLINE__ 1
13981#define __CC_SUPPORTS___FUNC__ 1
13982#define __CC_SUPPORTS_WARNING 1
13983#define __CC_SUPPORTS_VARADIC_XXX 1
13984#define __CC_SUPPORTS_DYNAMIC_ARRAY_INIT 1
13985#define __P(protos) protos
13986#define __CONCAT1(x,y) x ## y
13987#define __CONCAT(x,y) __CONCAT1(x,y)
13988#define __STRING(x) #x
13989#define __XSTRING(x) __STRING(x)
13990#define __const const
13991#define __signed signed
13992#define __volatile volatile
13993#define __weak_symbol __attribute__((__weak__))
13994#define __dead2 __attribute__((__noreturn__))
13995#define __pure2 __attribute__((__const__))
13996#define __unused __attribute__((__unused__))
13997#define __used __attribute__((__used__))
13998#define __packed __attribute__((__packed__))
13999#define __aligned(x) __attribute__((__aligned__(x)))
14000#define __section(x) __attribute__((__section__(x)))
14001#define __alloc_size(x) __attribute__((__alloc_size__(x)))
14002#define __alloc_size2(n,x) __attribute__((__alloc_size__(n, x)))
14003#define __alloc_align(x) __attribute__((__alloc_align__(x)))
14004#define __generic(expr,t,yes,no) _Generic(expr, t: yes, default: no)
14005#define __min_size(x) static (x)
14006#define __malloc_like __attribute__((__malloc__))
14007#define __pure __attribute__((__pure__))
14008#define __always_inline __inline__ __attribute__((__always_inline__))
14009#define __noinline __attribute__ ((__noinline__))
14010#define __nonnull(x) __attribute__((__nonnull__ x))
14011#define __nonnull_all __attribute__((__nonnull__))
14012#define __fastcall __attribute__((__fastcall__))
14013#define __result_use_check __attribute__((__warn_unused_result__))
14014#define __returns_twice __attribute__((__returns_twice__))
14015#define __unreachable() __builtin_unreachable()
14016#define __restrict restrict
14017#define __predict_true(exp) __builtin_expect((exp), 1)
14018#define __predict_false(exp) __builtin_expect((exp), 0)
14019#define __null_sentinel __attribute__((__sentinel__))
14020#define __exported __attribute__((__visibility__("default")))
14022#define __offsetof(type,field) offsetof(type, field)
14023#define __rangeof(type,start,end) (__offsetof(type, end) - __offsetof(type, start))
14024#define __containerof(x,s,m) ({ const volatile __typeof(((s *)0)->m) *__x = (x); __DEQUALIFY(s *, (const volatile char *)__x - __offsetof(s, m));})
14025#define __printflike(fmtarg,firstvararg) __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
14026#define __scanflike(fmtarg,firstvararg) __attribute__((__format__ (__scanf__, fmtarg, firstvararg)))
14027#define __format_arg(fmtarg) __attribute__((__format_arg__ (fmtarg)))
14028#define __strfmonlike(fmtarg,firstvararg) __attribute__((__format__ (__strfmon__, fmtarg, firstvararg)))
14029#define __strftimelike(fmtarg,firstvararg) __attribute__((__format__ (__strftime__, fmtarg, firstvararg)))
14030#define __printf0like(fmtarg,firstvararg)
14031#define __strong_reference(sym,aliassym) extern __typeof (sym) aliassym __attribute__ ((__alias__ (#sym)))
14032#define __weak_reference(sym,alias) __asm__(".stabs \"_" #alias "\",11,0,0,0"); __asm__(".stabs \"_" #sym "\",1,0,0,0")
14033#define __warn_references(sym,msg) __asm__(".stabs \"" msg "\",30,0,0,0"); __asm__(".stabs \"_" #sym "\",1,0,0,0")
14034#define __FBSDID(s) struct __hack
14035#define __RCSID(s) struct __hack
14036#define __RCSID_SOURCE(s) struct __hack
14037#define __SCCSID(s) struct __hack
14038#define __COPYRIGHT(s) struct __hack
14039#define __DECONST(type,var) ((type)(__uintptr_t)(const void *)(var))
14040#define __DEVOLATILE(type,var) ((type)(__uintptr_t)(volatile void *)(var))
14041#define __DEQUALIFY(type,var) ((type)(__uintptr_t)(const volatile void *)(var))
14044#define _Null_unspecified
14045#define __NULLABILITY_PRAGMA_PUSH
14046#define __NULLABILITY_PRAGMA_POP
14047#define __arg_type_tag(arg_kind,arg_idx,type_tag_idx)
14048#define __datatype_type_tag(kind,type)
14049#define __lock_annotate(x)
14050#define __lockable __lock_annotate(lockable)
14051#define __locks_exclusive(...) __lock_annotate(exclusive_lock_function(__VA_ARGS__))
14052#define __locks_shared(...) __lock_annotate(shared_lock_function(__VA_ARGS__))
14053#define __trylocks_exclusive(...) __lock_annotate(exclusive_trylock_function(__VA_ARGS__))
14054#define __trylocks_shared(...) __lock_annotate(shared_trylock_function(__VA_ARGS__))
14055#define __unlocks(...) __lock_annotate(unlock_function(__VA_ARGS__))
14056#define __asserts_exclusive(...) __lock_annotate(assert_exclusive_lock(__VA_ARGS__))
14057#define __asserts_shared(...) __lock_annotate(assert_shared_lock(__VA_ARGS__))
14058#define __requires_exclusive(...) __lock_annotate(exclusive_locks_required(__VA_ARGS__))
14059#define __requires_shared(...) __lock_annotate(shared_locks_required(__VA_ARGS__))
14060#define __requires_unlocked(...) __lock_annotate(locks_excluded(__VA_ARGS__))
14061#define __no_lock_analysis __lock_annotate(no_thread_safety_analysis)
14062#define __nosanitizeaddress
14063#define __nosanitizethread
14064#define __guarded_by(x) __lock_annotate(guarded_by(x))
14065#define __pt_guarded_by(x) __lock_annotate(pt_guarded_by(x))
14068#define _ANSI_STDDEF_H
14074#define _BSD_PTRDIFF_T_
14075#define ___int_ptrdiff_t_h
14076#define _GCC_PTRDIFF_T
14077#define _PTRDIFF_T_DECLARED
14078#undef __need_ptrdiff_t
14079#undef __need_size_t
14087#define _BSD_WCHAR_T_
14088#define _WCHAR_T_DEFINED_
14089#define _WCHAR_T_DEFINED
14091#define ___int_wchar_t_h
14092#define __INT_WCHAR_T_H
14093#define _GCC_WCHAR_T
14094#define _WCHAR_T_DECLARED
14095#undef _BSD_WCHAR_T_
14096#undef __need_wchar_t
14098#define NULL ((void *)0)
14100#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
14101#define _GCC_MAX_ALIGN_T
14102#define __need___va_list
14103#undef __need___va_list
14104#define __GNUC_VA_LIST
14105#define _VA_LIST_DEFINED
14106#define _SYS_REENT_H_
14107#define _SYS__TYPES_H
14108#define __need_size_t
14109#define __need_wint_t
14110#undef __need_ptrdiff_t
14111#undef __need_size_t
14112#undef __need_wchar_t
14114#undef __need_wint_t
14116#define NULL ((void *)0)
14118#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
14119#define _MACHINE__TYPES_H
14120#define __machine_blkcnt_t_defined
14121#define __machine_blksize_t_defined
14122#define __machine_dev_t_defined
14123#define __machine_fsblkcnt_t_defined
14124#define __machine_fsfilcnt_t_defined
14125#define __machine_uid_t_defined
14126#define __machine_gid_t_defined
14127#define __machine_ino_t_defined
14128#define __machine_key_t_defined
14129#define __machine_sa_family_t_defined
14130#define __machine_socklen_t_defined
14132#define unsigned signed
14134#define _CLOCK_T_ unsigned long
14135#define _TIME_T_ long
14136#define _CLOCKID_T_ unsigned long
14137#define _TIMER_T_ unsigned long
14140#define _SYS_LOCK_H_
14141#define _LOCK_RECURSIVE_T _LOCK_T
14142#define _LOCK_T_RECURSIVE_INITIALIZER ((_LOCK_T)18)
14143#define _LOCK_T_INITIALIZER ((_LOCK_T)19)
14144#define __LOCK_INIT(CLASS,NAME) CLASS _LOCK_T NAME = _LOCK_T_INITIALIZER;
14145#define __LOCK_INIT_RECURSIVE(CLASS,NAME) CLASS _LOCK_T NAME = _LOCK_T_RECURSIVE_INITIALIZER;
14146#define __lock_init(__lock) __cygwin_lock_init(&__lock)
14147#define __lock_init_recursive(__lock) __cygwin_lock_init_recursive(&__lock)
14148#define __lock_close(__lock) __cygwin_lock_fini(&__lock)
14149#define __lock_close_recursive(__lock) __cygwin_lock_fini(&__lock)
14150#define __lock_acquire(__lock) __cygwin_lock_lock(&__lock)
14151#define __lock_acquire_recursive(__lock) __cygwin_lock_lock(&__lock)
14152#define __lock_try_acquire(lock) __cygwin_lock_trylock(&__lock)
14153#define __lock_try_acquire_recursive(lock) __cygwin_lock_trylock(&__lock)
14154#define __lock_release(__lock) __cygwin_lock_unlock(&__lock)
14155#define __lock_release_recursive(__lock) __cygwin_lock_unlock(&__lock)
14156#define _ATEXIT_SIZE 32
14157#define _ATEXIT_INIT {_NULL, 0, {_NULL}, {{_NULL}, {_NULL}, 0, 0}}
14158#define _REENT_INIT_ATEXIT _NULL, _ATEXIT_INIT,
14159#define _REENT_SMALL_CHECK_INIT(ptr)
14160#define _RAND48_SEED_0 (0x330e)
14161#define _RAND48_SEED_1 (0xabcd)
14162#define _RAND48_SEED_2 (0x1234)
14163#define _RAND48_MULT_0 (0xe66d)
14164#define _RAND48_MULT_1 (0xdeec)
14165#define _RAND48_MULT_2 (0x0005)
14166#define _RAND48_ADD (0x000b)
14167#define _REENT_EMERGENCY_SIZE 25
14168#define _REENT_ASCTIME_SIZE 26
14169#define _REENT_SIGNAL_SIZE 24
14171#define _REENT_STDIO_STREAM(var,index) &(var)->__sf[index]
14172#define _REENT_INIT(var) { 0, _REENT_STDIO_STREAM(&(var), 0), _REENT_STDIO_STREAM(&(var), 1), _REENT_STDIO_STREAM(&(var), 2), 0, "", 0, _NULL, 0, _NULL, _NULL, 0, _NULL, _NULL, 0, _NULL, { { 0, _NULL, "", {0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 1, { {_RAND48_SEED_0, _RAND48_SEED_1, _RAND48_SEED_2}, {_RAND48_MULT_0, _RAND48_MULT_1, _RAND48_MULT_2}, _RAND48_ADD }, {0, {0}}, {0, {0}}, {0, {0}}, "", "", 0, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}}, {0, {0}} } }, _REENT_INIT_ATEXIT _NULL, {_NULL, 0, _NULL} }
14173#define _REENT_INIT_PTR_ZEROED(var) { (var)->_stdin = _REENT_STDIO_STREAM(var, 0); (var)->_stdout = _REENT_STDIO_STREAM(var, 1); (var)->_stderr = _REENT_STDIO_STREAM(var, 2); (var)->_new._reent._rand_next = 1; (var)->_new._reent._r48._seed[0] = _RAND48_SEED_0; (var)->_new._reent._r48._seed[1] = _RAND48_SEED_1; (var)->_new._reent._r48._seed[2] = _RAND48_SEED_2; (var)->_new._reent._r48._mult[0] = _RAND48_MULT_0; (var)->_new._reent._r48._mult[1] = _RAND48_MULT_1; (var)->_new._reent._r48._mult[2] = _RAND48_MULT_2; (var)->_new._reent._r48._add = _RAND48_ADD; }
14174#define _REENT_CHECK_RAND48(ptr)
14175#define _REENT_CHECK_MP(ptr)
14176#define _REENT_CHECK_TM(ptr)
14177#define _REENT_CHECK_ASCTIME_BUF(ptr)
14178#define _REENT_CHECK_EMERGENCY(ptr)
14179#define _REENT_CHECK_MISC(ptr)
14180#define _REENT_CHECK_SIGNAL_BUF(ptr)
14181#define _REENT_SIGNGAM(ptr) ((ptr)->_new._reent._gamma_signgam)
14182#define _REENT_RAND_NEXT(ptr) ((ptr)->_new._reent._rand_next)
14183#define _REENT_RAND48_SEED(ptr) ((ptr)->_new._reent._r48._seed)
14184#define _REENT_RAND48_MULT(ptr) ((ptr)->_new._reent._r48._mult)
14185#define _REENT_RAND48_ADD(ptr) ((ptr)->_new._reent._r48._add)
14186#define _REENT_MP_RESULT(ptr) ((ptr)->_result)
14187#define _REENT_MP_RESULT_K(ptr) ((ptr)->_result_k)
14188#define _REENT_MP_P5S(ptr) ((ptr)->_p5s)
14189#define _REENT_MP_FREELIST(ptr) ((ptr)->_freelist)
14190#define _REENT_ASCTIME_BUF(ptr) ((ptr)->_new._reent._asctime_buf)
14191#define _REENT_TM(ptr) (&(ptr)->_new._reent._localtime_buf)
14192#define _REENT_EMERGENCY(ptr) ((ptr)->_emergency)
14193#define _REENT_STRTOK_LAST(ptr) ((ptr)->_new._reent._strtok_last)
14194#define _REENT_MBLEN_STATE(ptr) ((ptr)->_new._reent._mblen_state)
14195#define _REENT_MBTOWC_STATE(ptr) ((ptr)->_new._reent._mbtowc_state)
14196#define _REENT_WCTOMB_STATE(ptr) ((ptr)->_new._reent._wctomb_state)
14197#define _REENT_MBRLEN_STATE(ptr) ((ptr)->_new._reent._mbrlen_state)
14198#define _REENT_MBRTOWC_STATE(ptr) ((ptr)->_new._reent._mbrtowc_state)
14199#define _REENT_MBSRTOWCS_STATE(ptr) ((ptr)->_new._reent._mbsrtowcs_state)
14200#define _REENT_WCRTOMB_STATE(ptr) ((ptr)->_new._reent._wcrtomb_state)
14201#define _REENT_WCSRTOMBS_STATE(ptr) ((ptr)->_new._reent._wcsrtombs_state)
14202#define _REENT_L64A_BUF(ptr) ((ptr)->_new._reent._l64a_buf)
14203#define _REENT_SIGNAL_BUF(ptr) ((ptr)->_new._reent._signal_buf)
14204#define _REENT_GETDATE_ERR_P(ptr) (&((ptr)->_new._reent._getdate_err))
14205#define _REENT_INIT_PTR(var) { memset((var), 0, sizeof(*(var))); _REENT_INIT_PTR_ZEROED(var); }
14206#define _Kmax (sizeof (size_t) << 3)
14207#define __ATTRIBUTE_IMPURE_PTR__
14208#define _REENT (__getreent())
14209#define _GLOBAL_REENT _global_impure_ptr
14210#define _GLOBAL_ATEXIT (_GLOBAL_REENT->_atexit)
14211#define __BIT_TYPES_DEFINED__ 1
14212#define _SYS_TYPES_H
14213#define _SYS__STDINT_H
14214#define _INT8_T_DECLARED
14215#define _UINT8_T_DECLARED
14216#define __int8_t_defined 1
14217#define _INT16_T_DECLARED
14218#define _UINT16_T_DECLARED
14219#define __int16_t_defined 1
14220#define _INT32_T_DECLARED
14221#define _UINT32_T_DECLARED
14222#define __int32_t_defined 1
14223#define _INT64_T_DECLARED
14224#define _UINT64_T_DECLARED
14225#define __int64_t_defined 1
14226#define _INTMAX_T_DECLARED
14227#define _UINTMAX_T_DECLARED
14228#define _INTPTR_T_DECLARED
14229#define _UINTPTR_T_DECLARED
14230#define __MACHINE_ENDIAN_H__
14231#define _BITS_ENDIAN_H_
14232#define __BIG_ENDIAN 4321
14233#define __LITTLE_ENDIAN 1234
14234#define __BYTE_ORDER __LITTLE_ENDIAN
14235#define _LITTLE_ENDIAN __LITTLE_ENDIAN
14236#define _BIG_ENDIAN __BIG_ENDIAN
14237#define _PDP_ENDIAN __PDP_ENDIAN
14238#define _BYTE_ORDER __BYTE_ORDER
14239#define __machine_host_to_from_network_defined
14240#define __htonl(_x) __ntohl(_x)
14241#define __htons(_x) __ntohs(_x)
14242#define _QUAD_HIGHWORD 1
14243#define _QUAD_LOWWORD 0
14244#define LITTLE_ENDIAN _LITTLE_ENDIAN
14245#define BIG_ENDIAN _BIG_ENDIAN
14246#define PDP_ENDIAN _PDP_ENDIAN
14247#define BYTE_ORDER _BYTE_ORDER
14248#define __bswap16(_x) __builtin_bswap16(_x)
14249#define __bswap32(_x) __builtin_bswap32(_x)
14250#define __bswap64(_x) __builtin_bswap64(_x)
14251#define _SYS_SELECT_H
14252#define _SYS__SIGSET_H_
14253#define _SYS__TIMEVAL_H_
14254#define _SUSECONDS_T_DECLARED
14255#define __time_t_defined
14256#define _TIME_T_DECLARED
14257#define _TIMEVAL_DEFINED
14258#define _SYS_TIMESPEC_H_
14259#define _SYS__TIMESPEC_H_
14260#define TIMEVAL_TO_TIMESPEC(tv,ts) do { (ts)->tv_sec = (tv)->tv_sec; (ts)->tv_nsec = (tv)->tv_usec * 1000; } while (0)
14261#define TIMESPEC_TO_TIMEVAL(tv,ts) do { (tv)->tv_sec = (ts)->tv_sec; (tv)->tv_usec = (ts)->tv_nsec / 1000; } while (0)
14262#define _SIGSET_T_DECLARED
14263#define _SYS_TYPES_FD_SET
14264#define FD_SETSIZE 64
14265#define _NFDBITS ((int)sizeof(__fd_mask) * 8)
14266#define NFDBITS _NFDBITS
14267#define _howmany(x,y) (((x) + ((y) - 1)) / (y))
14268#define fds_bits __fds_bits
14269#define __fdset_mask(n) ((__fd_mask)1 << ((n) % _NFDBITS))
14270#define FD_CLR(n,p) ((p)->__fds_bits[(n)/_NFDBITS] &= ~__fdset_mask(n))
14271#define FD_COPY(f,t) (void)(*(t) = *(f))
14272#define FD_ISSET(n,p) (((p)->__fds_bits[(n)/_NFDBITS] & __fdset_mask(n)) != 0)
14273#define FD_SET(n,p) ((p)->__fds_bits[(n)/_NFDBITS] |= __fdset_mask(n))
14274#define FD_ZERO(p) do { fd_set *_p; __size_t _n; _p = (p); _n = _howmany(FD_SETSIZE, _NFDBITS); while (_n > 0) _p->__fds_bits[--_n] = 0; } while (0)
14275#define physadr physadr_t
14277#define _IN_ADDR_T_DECLARED
14278#define _IN_PORT_T_DECLARED
14279#define __u_char_defined
14280#define __u_short_defined
14281#define __u_int_defined
14282#define __u_long_defined
14283#define _BSDTYPES_DEFINED
14284#define _BLKCNT_T_DECLARED
14285#define _BLKSIZE_T_DECLARED
14286#define __clock_t_defined
14287#define _CLOCK_T_DECLARED
14288#define __daddr_t_defined
14289#define __caddr_t_defined
14290#define _FSBLKCNT_T_DECLARED
14291#define _ID_T_DECLARED
14292#define _INO_T_DECLARED
14293#define _OFF_T_DECLARED
14294#define _DEV_T_DECLARED
14295#define _UID_T_DECLARED
14296#define _GID_T_DECLARED
14297#define _PID_T_DECLARED
14298#define _KEY_T_DECLARED
14299#define _SSIZE_T_DECLARED
14300#define _MODE_T_DECLARED
14301#define _NLINK_T_DECLARED
14302#define __clockid_t_defined
14303#define _CLOCKID_T_DECLARED
14304#define __timer_t_defined
14305#define _TIMER_T_DECLARED
14306#define _USECONDS_T_DECLARED
14307#define _SYS__PTHREADTYPES_H_
14308#define _SYS_CPUSET_H_
14309#define __CPU_SETSIZE 1024
14310#define __NCPUBITS (8 * sizeof (__cpu_mask))
14311#define __CPU_GROUPMAX (__CPU_SETSIZE / __NCPUBITS)
14312#define __CPUELT(cpu) ((cpu) / __NCPUBITS)
14313#define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
14314#define CPU_ALLOC_SIZE(num) ((num+__NCPUBITS-1) / __NCPUBITS) * sizeof (__cpu_mask)
14315#define CPU_ALLOC(num) __builtin_malloc (CPU_ALLOC_SIZE(num))
14316#define CPU_FREE(set) __builtin_free (set)
14317#define CPU_ZERO_S(siz,set) __builtin_memset (set, 0, siz)
14318#define CPU_SET_S(cpu,siz,set) if (cpu < 8 * siz) (set)->__bits[__CPUELT(cpu)] |= __CPUMASK(cpu);
14319#define CPU_CLR_S(cpu,siz,set) if (cpu < 8 * siz) (set)->__bits[__CPUELT(cpu)] &= ~(__CPUMASK(cpu));
14320#define CPU_ISSET_S(cpu,siz,set) ({int res = 0; if (cpu < 8 * siz) res = !!((set)->__bits[__CPUELT(cpu)] & __CPUMASK(cpu)); res;})
14321#define CPU_COUNT_S(siz,set) ({int tot = 0; for (int i = 0; i < siz / sizeof (__cpu_mask); i++) tot += __builtin_popcountl ((set)->__bits[i]); tot;})
14322#define CPU_AND_S(siz,dst,src1,src2) for (int i = 0; i < siz / sizeof (__cpu_mask); i++) (dst)->__bits[i] = (src1)->__bits[i] & (src2)->__bits[i];
14323#define CPU_OR_S(siz,dst,src1,src2) for (int i = 0; i < siz / sizeof (__cpu_mask); i++) (dst)->__bits[i] = (src1)->__bits[i] | (src2)->__bits[i];
14324#define CPU_XOR_S(siz,dst,src1,src2) for (int i = 0; i < siz / sizeof (__cpu_mask); i++) (dst)->__bits[i] = (src1)->__bits[i] ^ (src2)->__bits[i];
14325#define CPU_EQUAL_S(siz,src1,src2) ({int res = 1; for (int i = 0; res && i < siz / sizeof (__cpu_mask); i++) res &= (src1)->__bits[i] == (src2)->__bits[i]; res;})
14326#define CPU_ZERO(set) CPU_ZERO_S(sizeof (cpu_set_t), set)
14327#define CPU_SET(cpu,set) CPU_SET_S(cpu, sizeof (cpu_set_t), set)
14328#define CPU_CLR(cpu,set) CPU_CLR_S(cpu, sizeof (cpu_set_t), set)
14329#define CPU_ISSET(cpu,set) CPU_ISSET_S(cpu, sizeof (cpu_set_t), set)
14330#define CPU_COUNT(set) CPU_COUNT_S(sizeof (cpu_set_t), set)
14331#define CPU_AND(dst,src1,src2) CPU_AND_S(sizeof (cpu_set_t), dst, src1, src2)
14332#define CPU_OR(dst,src1,src2) CPU_OR_S(sizeof (cpu_set_t), dst, src1, src2)
14333#define CPU_XOR(dst,src1,src2) CPU_XOR_S(sizeof (cpu_set_t), dst, src1, src2)
14334#define CPU_EQUAL(src1,src2) CPU_EQUAL_S(sizeof (cpu_set_t), src1, src2)
14335#define CPU_SETSIZE __CPU_SETSIZE
14337#define __LONG_LONG_PAIR(HI,LO) LO, HI
14338#define _BITS_BYTESWAP_H
14339#define htobe16(x) __bswap_16(x)
14340#define htobe32(x) __bswap_32(x)
14341#define htobe64(x) __bswap_64(x)
14342#define be16toh(x) __bswap_16(x)
14343#define be32toh(x) __bswap_32(x)
14344#define be64toh(x) __bswap_64(x)
14345#define htole16(x) (x)
14346#define htole32(x) (x)
14347#define htole64(x) (x)
14348#define le16toh(x) (x)
14349#define le32toh(x) (x)
14350#define le64toh(x) (x)
14351#define _WORDSIZE_H 1
14352#define __WORDSIZE 64
14353#define __WORDSIZE_COMPAT32 1
14354#define __timespec_t_defined
14355#define __timestruc_t_defined
14356#define __BIT_TYPES_DEFINED__ 1
14357#define __vm_offset_t_defined
14358#define __vm_size_t_defined
14359#define __vm_object_t_defined
14360#define __addr_t_defined
14361#define _SYS_SYSMACROS_H
14362#define major(dev) gnu_dev_major(dev)
14363#define minor(dev) gnu_dev_minor(dev)
14364#define makedev(maj,min) gnu_dev_makedev(maj, min)
14365#undef __need_inttypes
14366#define __FILE_defined
14367#define _SYS_STDIO_H_
14368#define _flockfile(fp) ({ if (!((fp)->_flags & __SSTR)) __cygwin_lock_lock ((_LOCK_T *)&(fp)->_lock); })
14369#define _ftrylockfile(fp) (((fp)->_flags & __SSTR) ? 0 : __cygwin_lock_trylock ((_LOCK_T *)&(fp)->_lock))
14370#define _funlockfile(fp) ({ if (!((fp)->_flags & __SSTR)) __cygwin_lock_unlock ((_LOCK_T *)&(fp)->_lock); })
14371#define __SLBF 0x0001
14372#define __SNBF 0x0002
14373#define __SRD 0x0004
14374#define __SWR 0x0008
14375#define __SRW 0x0010
14376#define __SEOF 0x0020
14377#define __SERR 0x0040
14378#define __SMBF 0x0080
14379#define __SAPP 0x0100
14380#define __SSTR 0x0200
14381#define __SOPT 0x0400
14382#define __SNPT 0x0800
14383#define __SOFF 0x1000
14384#define __SORD 0x2000
14385#define __SCLE 0x4000
14386#define __SL64 0x8000
14387#define __SNLK 0x0001
14388#define __SWID 0x2000
14394#define FOPEN_MAX 20
14395#define FILENAME_MAX __FILENAME_MAX__
14396#define L_tmpnam FILENAME_MAX
14397#define P_tmpdir "/tmp"
14402#define stdin (_REENT->_stdin)
14403#define stdout (_REENT->_stdout)
14404#define stderr (_REENT->_stderr)
14405#define _stdin_r(x) ((x)->_stdin)
14406#define _stdout_r(x) ((x)->_stdout)
14407#define _stderr_r(x) ((x)->_stderr)
14408#define __VALIST __gnuc_va_list
14409#define fropen(__cookie,__fn) funopen(__cookie, __fn, (int (*)())0, (fpos_t (*)())0, (int (*)())0)
14410#define fwopen(__cookie,__fn) funopen(__cookie, (int (*)())0, __fn, (fpos_t (*)())0, (int (*)())0)
14411#define __sgetc_raw_r(__ptr,__f) (--(__f)->_r < 0 ? __srget_r(__ptr, __f) : (int)(*(__f)->_p++))
14412#define __sfeof(p) ((int)(((p)->_flags & __SEOF) != 0))
14413#define __sferror(p) ((int)(((p)->_flags & __SERR) != 0))
14414#define __sclearerr(p) ((void)((p)->_flags &= ~(__SERR|__SEOF)))
14415#define __sfileno(p) ((p)->_file)
14416#define feof(p) __sfeof(p)
14417#define ferror(p) __sferror(p)
14418#define clearerr(p) __sclearerr(p)
14419#define feof_unlocked(p) __sfeof(p)
14420#define ferror_unlocked(p) __sferror(p)
14421#define clearerr_unlocked(p) __sclearerr(p)
14422#define getchar_unlocked() _getchar_unlocked()
14423#define putchar_unlocked(_c) _putchar_unlocked(_c)
14424#define fast_putc(x,p) (--(p)->_w < 0 ? __swbuf_r(_REENT, (int)(x), p) == EOF : (*(p)->_p = (x), (p)->_p++, 0))
14426#define L_ctermid 16
14427#define _SSP_STDIO_H_
14429#define __ssp_real_(fun) __ssp_real_ ## fun
14430#define __ssp_real(fun) __ssp_real_(fun)
14431#define __ssp_inline extern __inline__ __attribute__((__always_inline__, __gnu_inline__))
14432#define __ssp_bos(ptr) __builtin_object_size(ptr, __SSP_FORTIFY_LEVEL > 1)
14433#define __ssp_bos0(ptr) __builtin_object_size(ptr, 0)
14434#define __ssp_check(buf,len,bos) if (bos(buf) != (size_t)-1 && len > bos(buf)) __chk_fail()
14435#define __ssp_decl(rtype,fun,args) rtype __ssp_real_(fun) args __asm__(__ASMNAME(#fun)); __ssp_inline rtype fun args
14436#define __ssp_redirect_raw(rtype,fun,args,call,cond,bos) __ssp_decl(rtype, fun, args) { if (cond) __ssp_check(__buf, __len, bos); return __ssp_real_(fun) call; }
14437#define __ssp_redirect(rtype,fun,args,call) __ssp_redirect_raw(rtype, fun, args, call, 1, __ssp_bos)
14438#define __ssp_redirect0(rtype,fun,args,call) __ssp_redirect_raw(rtype, fun, args, call, 1, __ssp_bos0)
14439#define __ssp_overlap(a,b,l) (((a) <= (b) && (b) < (a) + (l)) || ((b) <= (a) && (a) < (b) + (l)))
14440#define sprintf(str,...) __builtin___sprintf_chk(str, 0, __ssp_bos(str), __VA_ARGS__)
14441#define vsprintf(str,fmt,ap) __builtin___vsprintf_chk(str, 0, __ssp_bos(str), fmt, ap)
14442#define snprintf(str,len,...) __builtin___snprintf_chk(str, len, 0, __ssp_bos(str), __VA_ARGS__)
14443#define vsnprintf(str,len,fmt,ap) __builtin___vsnprintf_chk(str, len, 0, __ssp_bos(str), fmt, ap)
14444#define gets(str) __gets_chk(str, __ssp_bos(str))
14447#define __need_size_t
14449#undef __need_ptrdiff_t
14450#undef __need_size_t
14451#undef __need_wchar_t
14453#define NULL ((void *)0)
14455#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
14456#define _MACHTIME_H_
14457#define _CLOCKS_PER_SEC_ 1000
14458#define CLOCKS_PER_SEC _CLOCKS_PER_SEC_
14459#define CLK_TCK CLOCKS_PER_SEC
14460#define _SYS__LOCALE_H
14461#define tzname _tzname
14462#define _CYGWIN_TIME_H
14463#define TIMER_RELTIME 0
14465#define _SYS_SIGNAL_H
14467#define _SYS__INTSUP_H
14468#define __STDINT_EXP(x) __ ##x ##__
14482#define __int20__ +2
14485#define _INTPTR_EQ_LONG
14490#define __FAST8 "hh"
14491#define __FAST16 "l"
14492#define __FAST32 "l"
14493#define __FAST64 "l"
14494#define __LEAST8 "hh"
14495#define __LEAST16 "h"
14497#define __LEAST64 "l"
14506#define __int_least8_t_defined 1
14507#define __int_least16_t_defined 1
14508#define __int_least32_t_defined 1
14509#define __int_least64_t_defined 1
14510#define __int_fast8_t_defined 1
14511#define __int_fast16_t_defined 1
14512#define __int_fast32_t_defined 1
14513#define __int_fast64_t_defined 1
14514#define INTPTR_MIN (-__INTPTR_MAX__ - 1)
14515#define INTPTR_MAX (__INTPTR_MAX__)
14516#define UINTPTR_MAX (__UINTPTR_MAX__)
14517#define INT8_MIN (-__INT8_MAX__ - 1)
14518#define INT8_MAX (__INT8_MAX__)
14519#define UINT8_MAX (__UINT8_MAX__)
14520#define INT_LEAST8_MIN (-__INT_LEAST8_MAX__ - 1)
14521#define INT_LEAST8_MAX (__INT_LEAST8_MAX__)
14522#define UINT_LEAST8_MAX (__UINT_LEAST8_MAX__)
14523#define INT16_MIN (-__INT16_MAX__ - 1)
14524#define INT16_MAX (__INT16_MAX__)
14525#define UINT16_MAX (__UINT16_MAX__)
14526#define INT_LEAST16_MIN (-__INT_LEAST16_MAX__ - 1)
14527#define INT_LEAST16_MAX (__INT_LEAST16_MAX__)
14528#define UINT_LEAST16_MAX (__UINT_LEAST16_MAX__)
14529#define INT32_MIN (-__INT32_MAX__ - 1)
14530#define INT32_MAX (__INT32_MAX__)
14531#define UINT32_MAX (__UINT32_MAX__)
14532#define INT_LEAST32_MIN (-__INT_LEAST32_MAX__ - 1)
14533#define INT_LEAST32_MAX (__INT_LEAST32_MAX__)
14534#define UINT_LEAST32_MAX (__UINT_LEAST32_MAX__)
14535#define INT64_MIN (-__INT64_MAX__ - 1)
14536#define INT64_MAX (__INT64_MAX__)
14537#define UINT64_MAX (__UINT64_MAX__)
14538#define INT_LEAST64_MIN (-__INT_LEAST64_MAX__ - 1)
14539#define INT_LEAST64_MAX (__INT_LEAST64_MAX__)
14540#define UINT_LEAST64_MAX (__UINT_LEAST64_MAX__)
14541#define INT_FAST8_MIN (-__INT_FAST8_MAX__ - 1)
14542#define INT_FAST8_MAX (__INT_FAST8_MAX__)
14543#define UINT_FAST8_MAX (__UINT_FAST8_MAX__)
14544#define INT_FAST16_MIN (-__INT_FAST16_MAX__ - 1)
14545#define INT_FAST16_MAX (__INT_FAST16_MAX__)
14546#define UINT_FAST16_MAX (__UINT_FAST16_MAX__)
14547#define INT_FAST32_MIN (-__INT_FAST32_MAX__ - 1)
14548#define INT_FAST32_MAX (__INT_FAST32_MAX__)
14549#define UINT_FAST32_MAX (__UINT_FAST32_MAX__)
14550#define INT_FAST64_MIN (-__INT_FAST64_MAX__ - 1)
14551#define INT_FAST64_MAX (__INT_FAST64_MAX__)
14552#define UINT_FAST64_MAX (__UINT_FAST64_MAX__)
14553#define INTMAX_MAX (__INTMAX_MAX__)
14554#define INTMAX_MIN (-INTMAX_MAX - 1)
14555#define UINTMAX_MAX (__UINTMAX_MAX__)
14556#define SIZE_MAX (__SIZE_MAX__)
14557#define SIG_ATOMIC_MIN (-__STDINT_EXP(INT_MAX) - 1)
14558#define SIG_ATOMIC_MAX (__STDINT_EXP(INT_MAX))
14559#define PTRDIFF_MAX (__PTRDIFF_MAX__)
14560#define PTRDIFF_MIN (-PTRDIFF_MAX - 1)
14561#define WCHAR_MIN (__WCHAR_MIN__)
14562#define WCHAR_MAX (__WCHAR_MAX__)
14563#define WINT_MAX (__WINT_MAX__)
14564#define WINT_MIN (__WINT_MIN__)
14565#define INT8_C(x) __INT8_C(x)
14566#define UINT8_C(x) __UINT8_C(x)
14567#define INT16_C(x) __INT16_C(x)
14568#define UINT16_C(x) __UINT16_C(x)
14569#define INT32_C(x) __INT32_C(x)
14570#define UINT32_C(x) __UINT32_C(x)
14571#define INT64_C(x) __INT64_C(x)
14572#define UINT64_C(x) __UINT64_C(x)
14573#define INTMAX_C(x) __INTMAX_C(x)
14574#define UINTMAX_C(x) __UINTMAX_C(x)
14575#define _GCC_WRAP_STDINT_H
14576#define _CYGWIN_SIGNAL_H
14577#define __COPY_CONTEXT_SIZE 816
14578#pragma pack(push,4)
14579#define __SI_PAD_SIZE 32
14581#define SI_USER SI_USER
14582#define SI_ASYNCIO SI_ASYNCIO
14583#define SI_MESGQ SI_MESGQ
14584#define SI_TIMER SI_TIMER
14585#define SI_QUEUE SI_QUEUE
14586#define SI_KERNEL SI_KERNEL
14587#define ILL_ILLOPC ILL_ILLOPC
14588#define ILL_ILLOPN ILL_ILLOPN
14589#define ILL_ILLADR ILL_ILLADR
14590#define ILL_ILLTRP ILL_ILLTRP
14591#define ILL_PRVOPC ILL_PRVOPC
14592#define ILL_PRVREG ILL_PRVREG
14593#define ILL_COPROC ILL_COPROC
14594#define ILL_BADSTK ILL_BADSTK
14595#define FPE_INTDIV FPE_INTDIV
14596#define FPE_INTOVF FPE_INTOVF
14597#define FPE_FLTDIV FPE_FLTDIV
14598#define FPE_FLTOVF FPE_FLTOVF
14599#define FPE_FLTUND FPE_FLTUND
14600#define FPE_FLTRES FPE_FLTRES
14601#define FPE_FLTINV FPE_FLTINV
14602#define FPE_FLTSUB FPE_FLTSUB
14603#define SEGV_MAPERR SEGV_MAPERR
14604#define SEGV_ACCERR SEGV_ACCERR
14605#define BUS_ADRALN BUS_ADRALN
14606#define BUS_ADRERR BUS_ADRERR
14607#define BUS_OBJERR BUS_OBJERR
14608#define CLD_EXITED CLD_EXITED
14609#define CLD_KILLED CLD_KILLED
14610#define CLD_DUMPED CLD_DUMPED
14611#define CLD_TRAPPED CLD_TRAPPED
14612#define CLD_STOPPED CLD_STOPPED
14613#define CLD_CONTINUED CLD_CONTINUED
14614#define SIGEV_SIGNAL SIGEV_SIGNAL
14615#define SIGEV_NONE SIGEV_NONE
14616#define SIGEV_THREAD SIGEV_THREAD
14617#define SA_NOCLDSTOP 1
14618#define SA_SIGINFO 2
14619#define SA_RESTART 0x10000000
14620#define SA_ONSTACK 0x20000000
14621#define SA_NODEFER 0x40000000
14622#define SA_RESETHAND 0x80000000
14623#define SA_ONESHOT SA_RESETHAND
14624#define SA_NOMASK SA_NODEFER
14625#define _SA_INTERNAL_MASK 0xf000
14627#define MINSIGSTKSZ 8192
14629#define SIGSTKSZ 32768
14636#define SIGIOT SIGABRT
14655#define SIGPOLL SIGIO
14658#define SIGVTALRM 26
14662#define SIGPWR SIGLOST
14668#define SIGRTMAX (_NSIG - 1)
14669#define SIG_HOLD ((_sig_func_ptr)2)
14670#define SS_ONSTACK 0x1
14671#define SS_DISABLE 0x2
14672#define SIG_SETMASK 0
14674#define SIG_UNBLOCK 2
14675#define SIG2STR_MAX (sizeof("RTMAX+") + sizeof("4294967295") - 1)
14676#define _SYS_UCONTEXT_H_
14677#define SIG_DFL ((_sig_func_ptr)0)
14678#define SIG_IGN ((_sig_func_ptr)1)
14679#define SIG_ERR ((_sig_func_ptr)-1)
14680#define CLOCK_ENABLED 1
14681#define CLOCK_DISABLED 0
14682#define CLOCK_ALLOWED 1
14683#define CLOCK_DISALLOWED 0
14684#define TIMER_ABSTIME 4
14685#define CLOCK_REALTIME_COARSE ((clockid_t) 0)
14686#define CLOCK_REALTIME ((clockid_t) 1)
14687#define CLOCK_PROCESS_CPUTIME_ID ((clockid_t) 2)
14688#define CLOCK_THREAD_CPUTIME_ID ((clockid_t) 3)
14689#define CLOCK_MONOTONIC ((clockid_t) 4)
14690#define CLOCK_MONOTONIC_RAW ((clockid_t) 5)
14691#define CLOCK_MONOTONIC_COARSE ((clockid_t) 6)
14692#define CLOCK_BOOTTIME ((clockid_t) 7)
14693#define CLOCK_REALTIME_ALARM ((clockid_t) 8)
14694#define CLOCK_BOOTTIME_ALARM ((clockid_t) 9)
14695#define _CYGWIN_STAT_H
14696#define st_atime st_atim.tv_sec
14697#define st_mtime st_mtim.tv_sec
14698#define st_ctime st_ctim.tv_sec
14699#define st_birthtime st_birthtim.tv_sec
14700#define S_TYPEISMQ(buf) ((void)(buf)->st_mode,0)
14701#define S_TYPEISSEM(buf) ((void)(buf)->st_mode,0)
14702#define S_TYPEISSHM(buf) ((void)(buf)->st_mode,0)
14703#define _IFMT 0170000
14704#define _IFDIR 0040000
14705#define _IFCHR 0020000
14706#define _IFBLK 0060000
14707#define _IFREG 0100000
14708#define _IFLNK 0120000
14709#define _IFSOCK 0140000
14710#define _IFIFO 0010000
14711#define S_BLKSIZE 1024
14712#define S_ISUID 0004000
14713#define S_ISGID 0002000
14714#define S_ISVTX 0001000
14715#define S_IREAD 0000400
14716#define S_IWRITE 0000200
14717#define S_IEXEC 0000100
14718#define S_ENFMT 0002000
14719#define S_IFMT _IFMT
14720#define S_IFDIR _IFDIR
14721#define S_IFCHR _IFCHR
14722#define S_IFBLK _IFBLK
14723#define S_IFREG _IFREG
14724#define S_IFLNK _IFLNK
14725#define S_IFSOCK _IFSOCK
14726#define S_IFIFO _IFIFO
14727#define S_IRWXU (S_IRUSR | S_IWUSR | S_IXUSR)
14728#define S_IRUSR 0000400
14729#define S_IWUSR 0000200
14730#define S_IXUSR 0000100
14731#define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
14732#define S_IRGRP 0000040
14733#define S_IWGRP 0000020
14734#define S_IXGRP 0000010
14735#define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH)
14736#define S_IROTH 0000004
14737#define S_IWOTH 0000002
14738#define S_IXOTH 0000001
14739#define ACCESSPERMS (S_IRWXU | S_IRWXG | S_IRWXO)
14740#define ALLPERMS (S_ISUID | S_ISGID | S_ISVTX | S_IRWXU | S_IRWXG | S_IRWXO)
14741#define DEFFILEMODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
14742#define S_ISBLK(m) (((m)&_IFMT) == _IFBLK)
14743#define S_ISCHR(m) (((m)&_IFMT) == _IFCHR)
14744#define S_ISDIR(m) (((m)&_IFMT) == _IFDIR)
14745#define S_ISFIFO(m) (((m)&_IFMT) == _IFIFO)
14746#define S_ISREG(m) (((m)&_IFMT) == _IFREG)
14747#define S_ISLNK(m) (((m)&_IFMT) == _IFLNK)
14748#define S_ISSOCK(m) (((m)&_IFMT) == _IFSOCK)
14749#define UTIME_NOW -2L
14750#define UTIME_OMIT -1L
14752#define __need_size_t
14753#define __need_wchar_t
14755#undef __need_ptrdiff_t
14756#undef __need_size_t
14757#undef __need_wchar_t
14759#define NULL ((void *)0)
14761#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
14762#define _MACHSTDLIB_H_
14763#define _NEWLIB_ALLOCA_H
14765#define alloca(size) __builtin_alloca(size)
14766#define _CYGWIN_STDLIB_H
14767#define _CYGWIN_WAIT_H
14768#define WAIT_ANY (pid_t)-1
14769#define WAIT_MYPGRP (pid_t)0
14772#define WCONTINUED 8
14773#define __W_CONTINUED 0xffff
14774#define WIFEXITED(_w) (((_w) & 0xff) == 0)
14775#define WIFSIGNALED(_w) (((_w) & 0x7f) > 0 && (((_w) & 0x7f) < 0x7f))
14776#define WIFSTOPPED(_w) (((_w) & 0xff) == 0x7f)
14777#define WIFCONTINUED(_w) (((_w) & 0xffff) == __W_CONTINUED)
14778#define WEXITSTATUS(_w) (((_w) >> 8) & 0xff)
14779#define WTERMSIG(_w) ((_w) & 0x7f)
14780#define WSTOPSIG WEXITSTATUS
14781#define WCOREDUMP(_w) (WIFSIGNALED(_w) && ((_w) & 0x80))
14783#define _malloc_r(r,s) malloc (s)
14785#define _free_r(r,p) free (p)
14787#define _realloc_r(r,p,s) realloc (p, s)
14789#define _calloc_r(r,s1,s2) calloc (s1, s2);
14791#define _memalign_r(r,s1,s2) memalign (s1, s2);
14793#define _mallinfo_r(r) mallinfo ()
14794#undef _malloc_stats_r
14795#define _malloc_stats_r(r) malloc_stats ()
14797#define _mallopt_r(i1,i2) mallopt (i1, i2)
14798#undef _malloc_usable_size_r
14799#define _malloc_usable_size_r(r,p) malloc_usable_size (p)
14801#define _valloc_r(r,s) valloc (s)
14803#define _pvalloc_r(r,s) pvalloc (s)
14804#undef _malloc_trim_r
14805#define _malloc_trim_r(r,s) malloc_trim (s)
14807#define _mstats_r(r,p) mstats (p)
14808#define __compar_fn_t_defined
14809#define EXIT_FAILURE 1
14810#define EXIT_SUCCESS 0
14811#define RAND_MAX __RAND_MAX
14812#define MB_CUR_MAX __locale_mb_cur_max()
14813#define strtodf strtof
14814#define _SSP_STDLIB_H_
14816#define __need_size_t
14818#undef __need_ptrdiff_t
14819#undef __need_size_t
14820#undef __need_wchar_t
14822#define NULL ((void *)0)
14824#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
14826#define _SSP_STRINGS_H_
14827#define bcopy(src,dst,len) ((__ssp_bos0(dst) != (size_t)-1) ? __builtin___memmove_chk(dst, src, len, __ssp_bos0(dst)) : __memmove_ichk(dst, src, len))
14828#define bzero(dst,len) ((__ssp_bos0(dst) != (size_t)-1) ? __builtin___memset_chk(dst, 0, len, __ssp_bos0(dst)) : __memset_ichk(dst, 0, len))
14829#define strdupa(__s) (__extension__ ({const char *__sin = (__s); size_t __len = strlen (__sin) + 1; char * __sout = (char *) __builtin_alloca (__len); (char *) memcpy (__sout, __sin, __len);}))
14830#define strndupa(__s,__n) (__extension__ ({const char *__sin = (__s); size_t __len = strnlen (__sin, (__n)) + 1; char *__sout = (char *) __builtin_alloca (__len); __sout[__len-1] = '\0'; (char *) memcpy (__sout, __sin, __len-1);}))
14831#define basename basename
14832#define _SSP_STRING_H_
14833#define __ssp_bos_check3(fun,dst,src,len) ((__ssp_bos0(dst) != (size_t)-1) ? __builtin___ ## fun ## _chk(dst, src, len, __ssp_bos0(dst)) : __ ## fun ## _ichk(dst, src, len))
14834#define __ssp_bos_check2(fun,dst,src) ((__ssp_bos0(dst) != (size_t)-1) ? __builtin___ ## fun ## _chk(dst, src, __ssp_bos0(dst)) : __ ## fun ## _ichk(dst, src))
14835#define __ssp_bos_icheck3_restrict(fun,type1,type2) __ssp_inline type1 __ ## fun ## _ichk(type1 __restrict, type2 __restrict, size_t); __ssp_inline type1 __ ## fun ## _ichk(type1 __restrict dst, type2 __restrict src, size_t len) { return __builtin___ ## fun ## _chk(dst, src, len, __ssp_bos0(dst)); }
14836#define __ssp_bos_icheck3(fun,type1,type2) __ssp_inline type1 __ ## fun ## _ichk(type1, type2, size_t); __ssp_inline type1 __ ## fun ## _ichk(type1 dst, type2 src, size_t len) { return __builtin___ ## fun ## _chk(dst, src, len, __ssp_bos0(dst)); }
14837#define __ssp_bos_icheck2_restrict(fun,type1,type2) __ssp_inline type1 __ ## fun ## _ichk(type1, type2); __ssp_inline type1 __ ## fun ## _ichk(type1 __restrict dst, type2 __restrict src) { return __builtin___ ## fun ## _chk(dst, src, __ssp_bos0(dst)); }
14838#define memcpy(dst,src,len) __ssp_bos_check3(memcpy, dst, src, len)
14839#define memmove(dst,src,len) __ssp_bos_check3(memmove, dst, src, len)
14840#define mempcpy(dst,src,len) __ssp_bos_check3(mempcpy, dst, src, len)
14841#define memset(dst,val,len) __ssp_bos_check3(memset, dst, val, len)
14842#define stpcpy(dst,src) __ssp_bos_check2(stpcpy, dst, src)
14843#define stpncpy(dst,src,len) __ssp_bos_check3(stpncpy, dst, src, len)
14844#define strcpy(dst,src) __ssp_bos_check2(strcpy, dst, src)
14845#define strcat(dst,src) __ssp_bos_check2(strcat, dst, src)
14846#define strncpy(dst,src,len) __ssp_bos_check3(strncpy, dst, src, len)
14847#define strncat(dst,src,len) __ssp_bos_check3(strncat, dst, src, len)
14849#define __need_wchar_t
14850#undef __need_ptrdiff_t
14851#undef __need_size_t
14852#undef __need_wchar_t
14854#define NULL ((void *)0)
14856#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
14857#define __STRINGIFY(a) #a
14858#define __PRI8(x) __INT8 __STRINGIFY(x)
14859#define __PRI8LEAST(x) __LEAST8 __STRINGIFY(x)
14860#define __PRI8FAST(x) __FAST8 __STRINGIFY(x)
14861#define __SCN8(x) __INT8 __STRINGIFY(x)
14862#define __SCN8LEAST(x) __LEAST8 __STRINGIFY(x)
14863#define __SCN8FAST(x) __FAST8 __STRINGIFY(x)
14864#define PRId8 __PRI8(d)
14865#define PRIi8 __PRI8(i)
14866#define PRIo8 __PRI8(o)
14867#define PRIu8 __PRI8(u)
14868#define PRIx8 __PRI8(x)
14869#define PRIX8 __PRI8(X)
14870#define SCNd8 __SCN8(d)
14871#define SCNi8 __SCN8(i)
14872#define SCNo8 __SCN8(o)
14873#define SCNu8 __SCN8(u)
14874#define SCNx8 __SCN8(x)
14875#define PRIdLEAST8 __PRI8LEAST(d)
14876#define PRIiLEAST8 __PRI8LEAST(i)
14877#define PRIoLEAST8 __PRI8LEAST(o)
14878#define PRIuLEAST8 __PRI8LEAST(u)
14879#define PRIxLEAST8 __PRI8LEAST(x)
14880#define PRIXLEAST8 __PRI8LEAST(X)
14881#define SCNdLEAST8 __SCN8LEAST(d)
14882#define SCNiLEAST8 __SCN8LEAST(i)
14883#define SCNoLEAST8 __SCN8LEAST(o)
14884#define SCNuLEAST8 __SCN8LEAST(u)
14885#define SCNxLEAST8 __SCN8LEAST(x)
14886#define PRIdFAST8 __PRI8FAST(d)
14887#define PRIiFAST8 __PRI8FAST(i)
14888#define PRIoFAST8 __PRI8FAST(o)
14889#define PRIuFAST8 __PRI8FAST(u)
14890#define PRIxFAST8 __PRI8FAST(x)
14891#define PRIXFAST8 __PRI8FAST(X)
14892#define SCNdFAST8 __SCN8FAST(d)
14893#define SCNiFAST8 __SCN8FAST(i)
14894#define SCNoFAST8 __SCN8FAST(o)
14895#define SCNuFAST8 __SCN8FAST(u)
14896#define SCNxFAST8 __SCN8FAST(x)
14897#define __PRI16(x) __INT16 __STRINGIFY(x)
14898#define __PRI16LEAST(x) __LEAST16 __STRINGIFY(x)
14899#define __PRI16FAST(x) __FAST16 __STRINGIFY(x)
14900#define __SCN16(x) __INT16 __STRINGIFY(x)
14901#define __SCN16LEAST(x) __LEAST16 __STRINGIFY(x)
14902#define __SCN16FAST(x) __FAST16 __STRINGIFY(x)
14903#define PRId16 __PRI16(d)
14904#define PRIi16 __PRI16(i)
14905#define PRIo16 __PRI16(o)
14906#define PRIu16 __PRI16(u)
14907#define PRIx16 __PRI16(x)
14908#define PRIX16 __PRI16(X)
14909#define SCNd16 __SCN16(d)
14910#define SCNi16 __SCN16(i)
14911#define SCNo16 __SCN16(o)
14912#define SCNu16 __SCN16(u)
14913#define SCNx16 __SCN16(x)
14914#define PRIdLEAST16 __PRI16LEAST(d)
14915#define PRIiLEAST16 __PRI16LEAST(i)
14916#define PRIoLEAST16 __PRI16LEAST(o)
14917#define PRIuLEAST16 __PRI16LEAST(u)
14918#define PRIxLEAST16 __PRI16LEAST(x)
14919#define PRIXLEAST16 __PRI16LEAST(X)
14920#define SCNdLEAST16 __SCN16LEAST(d)
14921#define SCNiLEAST16 __SCN16LEAST(i)
14922#define SCNoLEAST16 __SCN16LEAST(o)
14923#define SCNuLEAST16 __SCN16LEAST(u)
14924#define SCNxLEAST16 __SCN16LEAST(x)
14925#define PRIdFAST16 __PRI16FAST(d)
14926#define PRIiFAST16 __PRI16FAST(i)
14927#define PRIoFAST16 __PRI16FAST(o)
14928#define PRIuFAST16 __PRI16FAST(u)
14929#define PRIxFAST16 __PRI16FAST(x)
14930#define PRIXFAST16 __PRI16FAST(X)
14931#define SCNdFAST16 __SCN16FAST(d)
14932#define SCNiFAST16 __SCN16FAST(i)
14933#define SCNoFAST16 __SCN16FAST(o)
14934#define SCNuFAST16 __SCN16FAST(u)
14935#define SCNxFAST16 __SCN16FAST(x)
14936#define __PRI32(x) __INT32 __STRINGIFY(x)
14937#define __SCN32(x) __INT32 __STRINGIFY(x)
14938#define __PRI32LEAST(x) __LEAST32 __STRINGIFY(x)
14939#define __SCN32LEAST(x) __LEAST32 __STRINGIFY(x)
14940#define __PRI32FAST(x) __FAST32 __STRINGIFY(x)
14941#define __SCN32FAST(x) __FAST32 __STRINGIFY(x)
14942#define PRId32 __PRI32(d)
14943#define PRIi32 __PRI32(i)
14944#define PRIo32 __PRI32(o)
14945#define PRIu32 __PRI32(u)
14946#define PRIx32 __PRI32(x)
14947#define PRIX32 __PRI32(X)
14948#define SCNd32 __SCN32(d)
14949#define SCNi32 __SCN32(i)
14950#define SCNo32 __SCN32(o)
14951#define SCNu32 __SCN32(u)
14952#define SCNx32 __SCN32(x)
14953#define PRIdLEAST32 __PRI32LEAST(d)
14954#define PRIiLEAST32 __PRI32LEAST(i)
14955#define PRIoLEAST32 __PRI32LEAST(o)
14956#define PRIuLEAST32 __PRI32LEAST(u)
14957#define PRIxLEAST32 __PRI32LEAST(x)
14958#define PRIXLEAST32 __PRI32LEAST(X)
14959#define SCNdLEAST32 __SCN32LEAST(d)
14960#define SCNiLEAST32 __SCN32LEAST(i)
14961#define SCNoLEAST32 __SCN32LEAST(o)
14962#define SCNuLEAST32 __SCN32LEAST(u)
14963#define SCNxLEAST32 __SCN32LEAST(x)
14964#define PRIdFAST32 __PRI32FAST(d)
14965#define PRIiFAST32 __PRI32FAST(i)
14966#define PRIoFAST32 __PRI32FAST(o)
14967#define PRIuFAST32 __PRI32FAST(u)
14968#define PRIxFAST32 __PRI32FAST(x)
14969#define PRIXFAST32 __PRI32FAST(X)
14970#define SCNdFAST32 __SCN32FAST(d)
14971#define SCNiFAST32 __SCN32FAST(i)
14972#define SCNoFAST32 __SCN32FAST(o)
14973#define SCNuFAST32 __SCN32FAST(u)
14974#define SCNxFAST32 __SCN32FAST(x)
14975#define __PRI64(x) __INT64 __STRINGIFY(x)
14976#define __SCN64(x) __INT64 __STRINGIFY(x)
14977#define __PRI64LEAST(x) __LEAST64 __STRINGIFY(x)
14978#define __SCN64LEAST(x) __LEAST64 __STRINGIFY(x)
14979#define __PRI64FAST(x) __FAST64 __STRINGIFY(x)
14980#define __SCN64FAST(x) __FAST64 __STRINGIFY(x)
14981#define PRId64 __PRI64(d)
14982#define PRIi64 __PRI64(i)
14983#define PRIo64 __PRI64(o)
14984#define PRIu64 __PRI64(u)
14985#define PRIx64 __PRI64(x)
14986#define PRIX64 __PRI64(X)
14987#define SCNd64 __SCN64(d)
14988#define SCNi64 __SCN64(i)
14989#define SCNo64 __SCN64(o)
14990#define SCNu64 __SCN64(u)
14991#define SCNx64 __SCN64(x)
14992#define PRIdLEAST64 __PRI64LEAST(d)
14993#define PRIiLEAST64 __PRI64LEAST(i)
14994#define PRIoLEAST64 __PRI64LEAST(o)
14995#define PRIuLEAST64 __PRI64LEAST(u)
14996#define PRIxLEAST64 __PRI64LEAST(x)
14997#define PRIXLEAST64 __PRI64LEAST(X)
14998#define SCNdLEAST64 __SCN64LEAST(d)
14999#define SCNiLEAST64 __SCN64LEAST(i)
15000#define SCNoLEAST64 __SCN64LEAST(o)
15001#define SCNuLEAST64 __SCN64LEAST(u)
15002#define SCNxLEAST64 __SCN64LEAST(x)
15003#define PRIdFAST64 __PRI64FAST(d)
15004#define PRIiFAST64 __PRI64FAST(i)
15005#define PRIoFAST64 __PRI64FAST(o)
15006#define PRIuFAST64 __PRI64FAST(u)
15007#define PRIxFAST64 __PRI64FAST(x)
15008#define PRIXFAST64 __PRI64FAST(X)
15009#define SCNdFAST64 __SCN64FAST(d)
15010#define SCNiFAST64 __SCN64FAST(i)
15011#define SCNoFAST64 __SCN64FAST(o)
15012#define SCNuFAST64 __SCN64FAST(u)
15013#define SCNxFAST64 __SCN64FAST(x)
15014#define __PRIMAX(x) __STRINGIFY(l ##x)
15015#define __SCNMAX(x) __STRINGIFY(l ##x)
15016#define PRIdMAX __PRIMAX(d)
15017#define PRIiMAX __PRIMAX(i)
15018#define PRIoMAX __PRIMAX(o)
15019#define PRIuMAX __PRIMAX(u)
15020#define PRIxMAX __PRIMAX(x)
15021#define PRIXMAX __PRIMAX(X)
15022#define SCNdMAX __SCNMAX(d)
15023#define SCNiMAX __SCNMAX(i)
15024#define SCNoMAX __SCNMAX(o)
15025#define SCNuMAX __SCNMAX(u)
15026#define SCNxMAX __SCNMAX(x)
15027#define __PRIPTR(x) __STRINGIFY(l ##x)
15028#define __SCNPTR(x) __STRINGIFY(l ##x)
15029#define PRIdPTR __PRIPTR(d)
15030#define PRIiPTR __PRIPTR(i)
15031#define PRIoPTR __PRIPTR(o)
15032#define PRIuPTR __PRIPTR(u)
15033#define PRIxPTR __PRIPTR(x)
15034#define PRIXPTR __PRIPTR(X)
15035#define SCNdPTR __SCNPTR(d)
15036#define SCNiPTR __SCNPTR(i)
15037#define SCNoPTR __SCNPTR(o)
15038#define SCNuPTR __SCNPTR(u)
15039#define SCNxPTR __SCNPTR(x)
15041#define alignas _Alignas
15042#define alignof _Alignof
15043#define __alignas_is_defined 1
15044#define __alignof_is_defined 1
15046#define _SYS_UNISTD_H
15047#define __need_size_t
15048#define __need_ptrdiff_t
15049#undef __need_ptrdiff_t
15050#undef __need_size_t
15051#undef __need_wchar_t
15053#define NULL ((void *)0)
15055#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
15060#define __UNISTD_GETOPT__
15061#define __GETOPT_H__
15062#undef __UNISTD_GETOPT__
15070#define STDIN_FILENO 0
15071#define STDOUT_FILENO 1
15072#define STDERR_FILENO 2
15073#define _SC_ARG_MAX 0
15074#define _SC_CHILD_MAX 1
15075#define _SC_CLK_TCK 2
15076#define _SC_NGROUPS_MAX 3
15077#define _SC_OPEN_MAX 4
15078#define _SC_JOB_CONTROL 5
15079#define _SC_SAVED_IDS 6
15080#define _SC_VERSION 7
15081#define _SC_PAGESIZE 8
15082#define _SC_PAGE_SIZE _SC_PAGESIZE
15083#define _SC_NPROCESSORS_CONF 9
15084#define _SC_NPROCESSORS_ONLN 10
15085#define _SC_PHYS_PAGES 11
15086#define _SC_AVPHYS_PAGES 12
15087#define _SC_MQ_OPEN_MAX 13
15088#define _SC_MQ_PRIO_MAX 14
15089#define _SC_RTSIG_MAX 15
15090#define _SC_SEM_NSEMS_MAX 16
15091#define _SC_SEM_VALUE_MAX 17
15092#define _SC_SIGQUEUE_MAX 18
15093#define _SC_TIMER_MAX 19
15094#define _SC_TZNAME_MAX 20
15095#define _SC_ASYNCHRONOUS_IO 21
15096#define _SC_FSYNC 22
15097#define _SC_MAPPED_FILES 23
15098#define _SC_MEMLOCK 24
15099#define _SC_MEMLOCK_RANGE 25
15100#define _SC_MEMORY_PROTECTION 26
15101#define _SC_MESSAGE_PASSING 27
15102#define _SC_PRIORITIZED_IO 28
15103#define _SC_REALTIME_SIGNALS 29
15104#define _SC_SEMAPHORES 30
15105#define _SC_SHARED_MEMORY_OBJECTS 31
15106#define _SC_SYNCHRONIZED_IO 32
15107#define _SC_TIMERS 33
15108#define _SC_AIO_LISTIO_MAX 34
15109#define _SC_AIO_MAX 35
15110#define _SC_AIO_PRIO_DELTA_MAX 36
15111#define _SC_DELAYTIMER_MAX 37
15112#define _SC_THREAD_KEYS_MAX 38
15113#define _SC_THREAD_STACK_MIN 39
15114#define _SC_THREAD_THREADS_MAX 40
15115#define _SC_TTY_NAME_MAX 41
15116#define _SC_THREADS 42
15117#define _SC_THREAD_ATTR_STACKADDR 43
15118#define _SC_THREAD_ATTR_STACKSIZE 44
15119#define _SC_THREAD_PRIORITY_SCHEDULING 45
15120#define _SC_THREAD_PRIO_INHERIT 46
15121#define _SC_THREAD_PRIO_PROTECT 47
15122#define _SC_THREAD_PRIO_CEILING _SC_THREAD_PRIO_PROTECT
15123#define _SC_THREAD_PROCESS_SHARED 48
15124#define _SC_THREAD_SAFE_FUNCTIONS 49
15125#define _SC_GETGR_R_SIZE_MAX 50
15126#define _SC_GETPW_R_SIZE_MAX 51
15127#define _SC_LOGIN_NAME_MAX 52
15128#define _SC_THREAD_DESTRUCTOR_ITERATIONS 53
15129#define _SC_ADVISORY_INFO 54
15130#define _SC_ATEXIT_MAX 55
15131#define _SC_BARRIERS 56
15132#define _SC_BC_BASE_MAX 57
15133#define _SC_BC_DIM_MAX 58
15134#define _SC_BC_SCALE_MAX 59
15135#define _SC_BC_STRING_MAX 60
15136#define _SC_CLOCK_SELECTION 61
15137#define _SC_COLL_WEIGHTS_MAX 62
15138#define _SC_CPUTIME 63
15139#define _SC_EXPR_NEST_MAX 64
15140#define _SC_HOST_NAME_MAX 65
15141#define _SC_IOV_MAX 66
15143#define _SC_LINE_MAX 68
15144#define _SC_MONOTONIC_CLOCK 69
15145#define _SC_RAW_SOCKETS 70
15146#define _SC_READER_WRITER_LOCKS 71
15147#define _SC_REGEXP 72
15148#define _SC_RE_DUP_MAX 73
15149#define _SC_SHELL 74
15150#define _SC_SPAWN 75
15151#define _SC_SPIN_LOCKS 76
15152#define _SC_SPORADIC_SERVER 77
15153#define _SC_SS_REPL_MAX 78
15154#define _SC_SYMLOOP_MAX 79
15155#define _SC_THREAD_CPUTIME 80
15156#define _SC_THREAD_SPORADIC_SERVER 81
15157#define _SC_TIMEOUTS 82
15158#define _SC_TRACE 83
15159#define _SC_TRACE_EVENT_FILTER 84
15160#define _SC_TRACE_EVENT_NAME_MAX 85
15161#define _SC_TRACE_INHERIT 86
15162#define _SC_TRACE_LOG 87
15163#define _SC_TRACE_NAME_MAX 88
15164#define _SC_TRACE_SYS_MAX 89
15165#define _SC_TRACE_USER_EVENT_MAX 90
15166#define _SC_TYPED_MEMORY_OBJECTS 91
15167#define _SC_V7_ILP32_OFF32 92
15168#define _SC_V6_ILP32_OFF32 _SC_V7_ILP32_OFF32
15169#define _SC_XBS5_ILP32_OFF32 _SC_V7_ILP32_OFF32
15170#define _SC_V7_ILP32_OFFBIG 93
15171#define _SC_V6_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG
15172#define _SC_XBS5_ILP32_OFFBIG _SC_V7_ILP32_OFFBIG
15173#define _SC_V7_LP64_OFF64 94
15174#define _SC_V6_LP64_OFF64 _SC_V7_LP64_OFF64
15175#define _SC_XBS5_LP64_OFF64 _SC_V7_LP64_OFF64
15176#define _SC_V7_LPBIG_OFFBIG 95
15177#define _SC_V6_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG
15178#define _SC_XBS5_LPBIG_OFFBIG _SC_V7_LPBIG_OFFBIG
15179#define _SC_XOPEN_CRYPT 96
15180#define _SC_XOPEN_ENH_I18N 97
15181#define _SC_XOPEN_LEGACY 98
15182#define _SC_XOPEN_REALTIME 99
15183#define _SC_STREAM_MAX 100
15184#define _SC_PRIORITY_SCHEDULING 101
15185#define _SC_XOPEN_REALTIME_THREADS 102
15186#define _SC_XOPEN_SHM 103
15187#define _SC_XOPEN_STREAMS 104
15188#define _SC_XOPEN_UNIX 105
15189#define _SC_XOPEN_VERSION 106
15190#define _SC_2_CHAR_TERM 107
15191#define _SC_2_C_BIND 108
15192#define _SC_2_C_DEV 109
15193#define _SC_2_FORT_DEV 110
15194#define _SC_2_FORT_RUN 111
15195#define _SC_2_LOCALEDEF 112
15196#define _SC_2_PBS 113
15197#define _SC_2_PBS_ACCOUNTING 114
15198#define _SC_2_PBS_CHECKPOINT 115
15199#define _SC_2_PBS_LOCATE 116
15200#define _SC_2_PBS_MESSAGE 117
15201#define _SC_2_PBS_TRACK 118
15202#define _SC_2_SW_DEV 119
15203#define _SC_2_UPE 120
15204#define _SC_2_VERSION 121
15205#define _SC_THREAD_ROBUST_PRIO_INHERIT 122
15206#define _SC_THREAD_ROBUST_PRIO_PROTECT 123
15207#define _SC_XOPEN_UUCP 124
15208#define _SC_LEVEL1_ICACHE_SIZE 125
15209#define _SC_LEVEL1_ICACHE_ASSOC 126
15210#define _SC_LEVEL1_ICACHE_LINESIZE 127
15211#define _SC_LEVEL1_DCACHE_SIZE 128
15212#define _SC_LEVEL1_DCACHE_ASSOC 129
15213#define _SC_LEVEL1_DCACHE_LINESIZE 130
15214#define _SC_LEVEL2_CACHE_SIZE 131
15215#define _SC_LEVEL2_CACHE_ASSOC 132
15216#define _SC_LEVEL2_CACHE_LINESIZE 133
15217#define _SC_LEVEL3_CACHE_SIZE 134
15218#define _SC_LEVEL3_CACHE_ASSOC 135
15219#define _SC_LEVEL3_CACHE_LINESIZE 136
15220#define _SC_LEVEL4_CACHE_SIZE 137
15221#define _SC_LEVEL4_CACHE_ASSOC 138
15222#define _SC_LEVEL4_CACHE_LINESIZE 139
15223#define _SC_POSIX_26_VERSION 140
15224#define _PC_LINK_MAX 0
15225#define _PC_MAX_CANON 1
15226#define _PC_MAX_INPUT 2
15227#define _PC_NAME_MAX 3
15228#define _PC_PATH_MAX 4
15229#define _PC_PIPE_BUF 5
15230#define _PC_CHOWN_RESTRICTED 6
15231#define _PC_NO_TRUNC 7
15232#define _PC_VDISABLE 8
15233#define _PC_ASYNC_IO 9
15234#define _PC_PRIO_IO 10
15235#define _PC_SYNC_IO 11
15236#define _PC_FILESIZEBITS 12
15237#define _PC_2_SYMLINKS 13
15238#define _PC_SYMLINK_MAX 14
15239#define _PC_ALLOC_SIZE_MIN 15
15240#define _PC_REC_INCR_XFER_SIZE 16
15241#define _PC_REC_MAX_XFER_SIZE 17
15242#define _PC_REC_MIN_XFER_SIZE 18
15243#define _PC_REC_XFER_ALIGN 19
15244#define _PC_TIMESTAMP_RESOLUTION 20
15245#define _PC_POSIX_PERMISSIONS 90
15246#define _PC_POSIX_SECURITY 91
15247#define _PC_CASE_INSENSITIVE 92
15249#define _CS_POSIX_V7_ILP32_OFF32_CFLAGS 1
15250#define _CS_POSIX_V6_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS
15251#define _CS_XBS5_ILP32_OFF32_CFLAGS _CS_POSIX_V7_ILP32_OFF32_CFLAGS
15252#define _CS_POSIX_V7_ILP32_OFF32_LDFLAGS 2
15253#define _CS_POSIX_V6_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
15254#define _CS_XBS5_ILP32_OFF32_LDFLAGS _CS_POSIX_V7_ILP32_OFF32_LDFLAGS
15255#define _CS_POSIX_V7_ILP32_OFF32_LIBS 3
15256#define _CS_POSIX_V6_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS
15257#define _CS_XBS5_ILP32_OFF32_LIBS _CS_POSIX_V7_ILP32_OFF32_LIBS
15258#define _CS_XBS5_ILP32_OFF32_LINTFLAGS 4
15259#define _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS 5
15260#define _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
15261#define _CS_XBS5_ILP32_OFFBIG_CFLAGS _CS_POSIX_V7_ILP32_OFFBIG_CFLAGS
15262#define _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS 6
15263#define _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
15264#define _CS_XBS5_ILP32_OFFBIG_LDFLAGS _CS_POSIX_V7_ILP32_OFFBIG_LDFLAGS
15265#define _CS_POSIX_V7_ILP32_OFFBIG_LIBS 7
15266#define _CS_POSIX_V6_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS
15267#define _CS_XBS5_ILP32_OFFBIG_LIBS _CS_POSIX_V7_ILP32_OFFBIG_LIBS
15268#define _CS_XBS5_ILP32_OFFBIG_LINTFLAGS 8
15269#define _CS_POSIX_V7_LP64_OFF64_CFLAGS 9
15270#define _CS_POSIX_V6_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS
15271#define _CS_XBS5_LP64_OFF64_CFLAGS _CS_POSIX_V7_LP64_OFF64_CFLAGS
15272#define _CS_POSIX_V7_LP64_OFF64_LDFLAGS 10
15273#define _CS_POSIX_V6_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS
15274#define _CS_XBS5_LP64_OFF64_LDFLAGS _CS_POSIX_V7_LP64_OFF64_LDFLAGS
15275#define _CS_POSIX_V7_LP64_OFF64_LIBS 11
15276#define _CS_POSIX_V6_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS
15277#define _CS_XBS5_LP64_OFF64_LIBS _CS_POSIX_V7_LP64_OFF64_LIBS
15278#define _CS_XBS5_LP64_OFF64_LINTFLAGS 12
15279#define _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS 13
15280#define _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
15281#define _CS_XBS5_LPBIG_OFFBIG_CFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_CFLAGS
15282#define _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS 14
15283#define _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
15284#define _CS_XBS5_LPBIG_OFFBIG_LDFLAGS _CS_POSIX_V7_LPBIG_OFFBIG_LDFLAGS
15285#define _CS_POSIX_V7_LPBIG_OFFBIG_LIBS 15
15286#define _CS_POSIX_V6_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
15287#define _CS_XBS5_LPBIG_OFFBIG_LIBS _CS_POSIX_V7_LPBIG_OFFBIG_LIBS
15288#define _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS 16
15289#define _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS 17
15290#define _CS_POSIX_V6_WIDTH_RESTRICTED_ENVS _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS
15291#define _CS_XBS5_WIDTH_RESTRICTED_ENVS _CS_POSIX_V7_WIDTH_RESTRICTED_ENVS
15292#define _CS_POSIX_V7_THREADS_CFLAGS 18
15293#define _CS_POSIX_V7_THREADS_LDFLAGS 19
15294#define _CS_V7_ENV 20
15295#define _CS_V6_ENV _CS_V7_ENV
15296#define _CS_LFS_CFLAGS 21
15297#define _CS_LFS_LDFLAGS 22
15298#define _CS_LFS_LIBS 23
15299#define _CS_LFS_LINTFLAGS 24
15300#define _SSP_UNISTD_H_
15301#define RUBY_MISSING_H 1
15303#define _M_LN2 0.693147180559945309417
15304#define HUGE_VAL (__builtin_huge_val())
15305#define HUGE_VALF (__builtin_huge_valf())
15306#define HUGE_VALL (__builtin_huge_vall())
15307#define INFINITY (__builtin_inff())
15308#define NAN (__builtin_nanf(""))
15309#define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
15310#define __TMP_FLT_EVAL_METHOD
15311#undef FLT_EVAL_METHOD
15313#define FP_INFINITE 1
15315#define FP_SUBNORMAL 3
15317#define FP_ILOGB0 (-__INT_MAX__)
15318#define FP_ILOGBNAN __INT_MAX__
15319#define MATH_ERRNO 1
15320#define MATH_ERREXCEPT 2
15321#define _MATH_ERRHANDLING_ERRNO MATH_ERRNO
15322#define _MATH_ERRHANDLING_ERREXCEPT MATH_ERREXCEPT
15323#define math_errhandling (_MATH_ERRHANDLING_ERRNO | _MATH_ERRHANDLING_ERREXCEPT)
15324#define fpclassify(__x) (__builtin_fpclassify (FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, FP_ZERO, __x))
15325#define isfinite(__x) (__builtin_isfinite (__x))
15326#define isinf(__x) (__builtin_isinf_sign (__x))
15327#define isnan(__x) (__builtin_isnan (__x))
15328#define isnormal(__x) (__builtin_isnormal (__x))
15329#define signbit(__x) ((sizeof(__x) == sizeof(float)) ? __builtin_signbitf(__x) : (sizeof(__x) == sizeof(double)) ? __builtin_signbit (__x) : __builtin_signbitl(__x))
15330#define isgreater(__x,__y) (__builtin_isgreater (__x, __y))
15331#define isgreaterequal(__x,__y) (__builtin_isgreaterequal (__x, __y))
15332#define isless(__x,__y) (__builtin_isless (__x, __y))
15333#define islessequal(__x,__y) (__builtin_islessequal (__x, __y))
15334#define islessgreater(__x,__y) (__builtin_islessgreater (__x, __y))
15335#define isunordered(__x,__y) (__builtin_isunordered (__x, __y))
15336#define log2(x) (log (x) / _M_LN2)
15337#define signgam (*__signgam())
15338#define __signgam_r(ptr) _REENT_SIGNGAM(ptr)
15339#define MAXFLOAT 3.40282347e+38F
15340#define M_E 2.7182818284590452354
15341#define M_LOG2E 1.4426950408889634074
15342#define M_LOG10E 0.43429448190325182765
15343#define M_LN2 _M_LN2
15344#define M_LN10 2.30258509299404568402
15345#define M_PI 3.14159265358979323846
15346#define M_PI_2 1.57079632679489661923
15347#define M_PI_4 0.78539816339744830962
15348#define M_1_PI 0.31830988618379067154
15349#define M_2_PI 0.63661977236758134308
15350#define M_2_SQRTPI 1.12837916709551257390
15351#define M_SQRT2 1.41421356237309504880
15352#define M_SQRT1_2 0.70710678118654752440
15353#define M_TWOPI (M_PI * 2.0)
15354#define M_3PI_4 2.3561944901923448370E0
15355#define M_SQRTPI 1.77245385090551602792981
15356#define M_LN2LO 1.9082149292705877000E-10
15357#define M_LN2HI 6.9314718036912381649E-1
15358#define M_SQRT3 1.73205080756887719000
15359#define M_IVLN10 0.43429448190325182765
15360#define M_LOG2_E _M_LN2
15361#define M_INVLN2 1.4426950408889633870E0
15363#define RUBY_EXTERN extern
15364#pragma GCC visibility push(default)
15365#pragma GCC visibility pop
15368#define _(args) args
15370#define __(args) args
15372#pragma GCC visibility push(default)
15373#define xmalloc ruby_xmalloc
15374#define xmalloc2 ruby_xmalloc2
15375#define xcalloc ruby_xcalloc
15376#define xrealloc ruby_xrealloc
15377#define xrealloc2 ruby_xrealloc2
15378#define xfree ruby_xfree
15379#define RUBY_ATTR_ALLOC_SIZE(params) __attribute__ ((alloc_size params))
15380#define RUBY_ATTR_MALLOC __attribute__((__malloc__))
15381#define RUBY_ATTR_RETURNS_NONNULL __attribute__((__returns_nonnull__))
15382#define USE_GC_MALLOC_OBJ_INFO_DETAILS 0
15383#define STRINGIZE(expr) STRINGIZE0(expr)
15384#define STRINGIZE0(expr) #expr
15385#define HAVE_TRUE_LONG_LONG 1
15386#define LONG_LONG long long
15391#define MJIT_FUNC_EXPORTED RUBY_FUNC_EXPORTED
15392#define MJIT_SYMBOL_EXPORT_BEGIN RUBY_SYMBOL_EXPORT_BEGIN
15393#define MJIT_SYMBOL_EXPORT_END RUBY_SYMBOL_EXPORT_END
15394#define RUBY_EXTERN extern
15395#define EXTERN _Pragma("message \"EXTERN is deprecated, use RUBY_EXTERN instead\""); RUBY_EXTERN
15396#define RUBY_MBCHAR_MAXSIZE INT_MAX
15397#define FLUSH_REGISTER_WINDOWS ((void)0)
15398#define PATH_SEP ":"
15399#define PATH_SEP_CHAR PATH_SEP[0]
15400#define PATH_ENV "PATH"
15401#define CASEFOLD_FILESYSTEM 0
15402#define RUBY_ALIAS_FUNCTION(prot,name,args) RUBY_ALIAS_FUNCTION_TYPE(VALUE, prot, name, args)
15403#define UNALIGNED_WORD_ACCESS 1
15404#define PACKED_STRUCT_UNALIGNED(x) PACKED_STRUCT(x)
15405#define NORETURN_STYLE_NEW 1
15406#pragma GCC visibility pop
15407#define RUBY_ASSERT_H
15408#define RUBY_ASSERT_FAIL(expr) rb_assert_failure(__FILE__, __LINE__, RUBY_FUNCTION_NAME_STRING, expr)
15409#define RUBY_ASSERT_MESG(expr,mesg) ((expr) ? (void)0 : RUBY_ASSERT_FAIL(mesg))
15410#define RUBY_ASSERT_MESG_WHEN(cond,expr,mesg) ((RUBY_DEBUG+0) ? RUBY_ASSERT_MESG((expr), mesg) : __builtin_choose_expr( __builtin_constant_p(cond), __builtin_choose_expr(cond, RUBY_ASSERT_MESG(expr, mesg), (void)0), RUBY_ASSERT_MESG(!(cond) || (expr), mesg)))
15411#define RUBY_ASSERT(expr) RUBY_ASSERT_MESG_WHEN((!RUBY_NDEBUG+0), expr, #expr)
15412#define RUBY_ASSERT_WHEN(cond,expr) RUBY_ASSERT_MESG_WHEN(cond, expr, #expr)
15413#define RUBY_ASSERT_ALWAYS(expr) RUBY_ASSERT_MESG_WHEN(TRUE, expr, #expr)
15414#define RUBY_DEBUG 0
15415#define RUBY_NDEBUG 0
15416#define ASSUME(x) (RB_LIKELY(!!(x)) ? (void)0 : UNREACHABLE)
15417#define UNREACHABLE_RETURN(val) UNREACHABLE
15418#define RUBY_MACRO_SELECT(base,n) TOKEN_PASTE(base, n)
15420#define _ANSI_STDARG_H_
15421#undef __need___va_list
15422#define va_start(v,l) __builtin_va_start(v,l)
15423#define va_end(v) __builtin_va_end(v)
15424#define va_arg(v,l) __builtin_va_arg(v,l)
15425#define va_copy(d,s) __builtin_va_copy(d,s)
15426#define __va_copy(d,s) __builtin_va_copy(d,s)
15429#define _VA_LIST_T_H
15431#pragma GCC visibility push(default)
15432#define SIGNED_VALUE long
15433#define SIZEOF_VALUE SIZEOF_LONG
15434#define PRI_VALUE_PREFIX "l"
15435#define PRI_INT_PREFIX ""
15436#define PRI_LONG_PREFIX "l"
15437#define PRI_SHORT_PREFIX "h"
15438#define RUBY_PRI_VALUE_MARK "\v"
15439#define PRIdVALUE PRI_VALUE_PREFIX"d"
15440#define PRIoVALUE PRI_VALUE_PREFIX"o"
15441#define PRIuVALUE PRI_VALUE_PREFIX"u"
15442#define PRIxVALUE PRI_VALUE_PREFIX"x"
15443#define PRIXVALUE PRI_VALUE_PREFIX"X"
15444#define PRIsVALUE PRI_VALUE_PREFIX"i" RUBY_PRI_VALUE_MARK
15445#define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d"
15446#define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i"
15447#define PRIoPTRDIFF PRI_PTRDIFF_PREFIX"o"
15448#define PRIuPTRDIFF PRI_PTRDIFF_PREFIX"u"
15449#define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x"
15450#define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X"
15451#define PRIdSIZE PRI_SIZE_PREFIX"d"
15452#define PRIiSIZE PRI_SIZE_PREFIX"i"
15453#define PRIoSIZE PRI_SIZE_PREFIX"o"
15454#define PRIuSIZE PRI_SIZE_PREFIX"u"
15455#define PRIxSIZE PRI_SIZE_PREFIX"x"
15456#define PRIXSIZE PRI_SIZE_PREFIX"X"
15457#define _GCC_LIMITS_H_
15458#define _GCC_NEXT_LIMITS_H
15460#define _CYGWIN_LIMITS_H__
15461#define __AIO_LISTIO_MAX 32
15463#define __AIO_PRIO_DELTA_MAX 0
15464#define __ARG_MAX 32000
15465#define __ATEXIT_MAX 32
15466#define __CHILD_MAX 256
15467#define __DELAYTIMER_MAX __INT_MAX__
15468#define __HOST_NAME_MAX 255
15469#define __IOV_MAX 1024
15470#define __LOGIN_NAME_MAX 256
15471#define __MQ_OPEN_MAX 256
15472#define __MQ_PRIO_MAX INT_MAX
15473#define __OPEN_MAX 3200
15474#define __PAGESIZE 65536
15475#define __PTHREAD_DESTRUCTOR_ITERATIONS 4
15476#define __PTHREAD_KEYS_MAX 1024
15477#define __PTHREAD_STACK_MIN 65536
15478#define __RTSIG_MAX 33
15479#define __SEM_VALUE_MAX 1147483648
15480#define __SIGQUEUE_MAX 32
15481#define __STREAM_MAX 20
15482#define __SYMLOOP_MAX 10
15483#define __TIMER_MAX 32
15484#define __TTY_NAME_MAX 32
15485#define __FILESIZEBITS 64
15486#define __LINK_MAX 1024
15487#define __MAX_CANON 255
15488#define __MAX_INPUT 255
15489#define __NAME_MAX 255
15490#define __PATH_MAX 4096
15491#define __PIPE_BUF 4096
15492#define _LIMITS_H___
15493#define _MACH_MACHLIMITS_H_
15495#define CHAR_BIT __CHAR_BIT__
15497#define LONG_BIT (__SIZEOF_LONG__ * __CHAR_BIT__)
15499#define WORD_BIT (__SIZEOF_INT__ * __CHAR_BIT__)
15500#define MB_LEN_MAX 8
15502#define SCHAR_MIN (-128)
15504#define SCHAR_MAX 127
15506#define UCHAR_MAX 255
15508#define CHAR_MIN (-128)
15510#define CHAR_MAX 127
15512#define SHRT_MIN (-32768)
15514#define SHRT_MAX 32767
15516#define USHRT_MAX 65535
15518#define INT_MIN (-INT_MAX-1)
15520#define INT_MAX __INT_MAX__
15522#define UINT_MAX (INT_MAX * 2U + 1)
15524#define LONG_MIN (-LONG_MAX-1L)
15526#define LONG_MAX __LONG_MAX__
15528#define ULONG_MAX (LONG_MAX * 2UL + 1)
15529#undef LONG_LONG_MIN
15530#define LONG_LONG_MIN (-LONG_LONG_MAX-1)
15531#undef LONG_LONG_MAX
15532#define LONG_LONG_MAX __LONG_LONG_MAX__
15533#undef ULONG_LONG_MAX
15534#define ULONG_LONG_MAX (LONG_LONG_MAX * 2ULL + 1)
15536#define LLONG_MIN (-LLONG_MAX-1)
15538#define LLONG_MAX __LONG_LONG_MAX__
15540#define ULLONG_MAX (LLONG_MAX * 2ULL + 1)
15542#define SSIZE_MAX (__LONG_MAX__)
15543#define AIO_LISTIO_MAX __AIO_LISTIO_MAX
15544#define AIO_MAX __AIO_MAX
15545#define AIO_PRIO_DELTA_MAX __AIO_PRIO_DELTA_MAX
15547#define ARG_MAX __ARG_MAX
15549#define ATEXIT_MAX __ATEXIT_MAX
15551#define CHILD_MAX __CHILD_MAX
15552#undef DELAYTIMER_MAX
15553#define DELAYTIMER_MAX __DELAYTIMER_MAX
15554#undef HOST_NAME_MAX
15555#define HOST_NAME_MAX __HOST_NAME_MAX
15557#define IOV_MAX __IOV_MAX
15558#undef LOGIN_NAME_MAX
15559#define LOGIN_NAME_MAX __LOGIN_NAME_MAX
15561#define MQ_OPEN_MAX __MQ_OPEN_MAX
15563#define MQ_PRIO_MAX __MQ_PRIO_MAX
15565#define OPEN_MAX __OPEN_MAX
15567#define PAGESIZE __PAGESIZE
15569#define PAGE_SIZE PAGESIZE
15570#undef PTHREAD_DESTRUCTOR_ITERATIONS
15571#define PTHREAD_DESTRUCTOR_ITERATIONS __PTHREAD_DESTRUCTOR_ITERATIONS
15572#undef PTHREAD_KEYS_MAX
15573#define PTHREAD_KEYS_MAX __PTHREAD_KEYS_MAX
15574#undef PTHREAD_STACK_MIN
15575#define PTHREAD_STACK_MIN __PTHREAD_STACK_MIN
15576#undef PTHREAD_THREADS_MAX
15578#define RTSIG_MAX __RTSIG_MAX
15579#undef SEM_NSEMS_MAX
15580#undef SEM_VALUE_MAX
15581#define SEM_VALUE_MAX __SEM_VALUE_MAX
15583#define SIGQUEUE_MAX __SIGQUEUE_MAX
15586#define STREAM_MAX __STREAM_MAX
15588#define SYMLOOP_MAX __SYMLOOP_MAX
15590#define TIMER_MAX __TIMER_MAX
15591#undef TRACE_EVENT_NAME_MAX
15592#undef TRACE_NAME_MAX
15593#undef TRACE_SYS_MAX
15594#undef TRACE_USER_EVENT_MAX
15596#define TTY_NAME_MAX __TTY_NAME_MAX
15599#define FILESIZEBITS __FILESIZEBITS
15601#define LINK_MAX __LINK_MAX
15603#define MAX_CANON __MAX_CANON
15605#define MAX_INPUT __MAX_INPUT
15607#define NAME_MAX __NAME_MAX
15609#define PATH_MAX __PATH_MAX
15611#define PIPE_BUF __PIPE_BUF
15612#undef POSIX_ALLOC_SIZE_MIN
15613#undef POSIX_REC_INCR_XFER_SIZE
15614#undef POSIX_REC_MAX_XFER_SIZE
15615#undef POSIX_REC_MIN_XFER_SIZE
15616#undef POSIX_REC_XFER_ALIGN
15618#define SYMLINK_MAX (PATH_MAX - 1)
15620#define BC_BASE_MAX 99
15622#define BC_DIM_MAX 2048
15624#define BC_SCALE_MAX 99
15625#undef BC_STRING_MAX
15626#define BC_STRING_MAX 1000
15627#undef CHARCLASS_NAME_MAX
15628#undef COLL_WEIGHTS_MAX
15629#undef EXPR_NEST_MAX
15630#define EXPR_NEST_MAX 32
15632#define LINE_MAX 2048
15634#define NGROUPS_MAX 1024
15636#define RE_DUP_MAX 255
15637#define _POSIX_CLOCKRES_MIN 20000000
15638#define _POSIX_AIO_LISTIO_MAX 2
15639#define _POSIX_AIO_MAX 1
15640#define _POSIX_ARG_MAX 4096
15641#define _POSIX_CHILD_MAX 25
15642#define _POSIX_DELAYTIMER_MAX 32
15643#define _POSIX_HOST_NAME_MAX 255
15644#define _POSIX_LINK_MAX 8
15645#define _POSIX_LOGIN_NAME_MAX 9
15646#define _POSIX_MAX_CANON 255
15647#define _POSIX_MAX_INPUT 255
15648#define _POSIX_MQ_OPEN_MAX 8
15649#define _POSIX_MQ_PRIO_MAX 32
15650#define _POSIX_NAME_MAX 14
15651#define _POSIX_NGROUPS_MAX 8
15652#define _POSIX_OPEN_MAX 20
15653#define _POSIX_PATH_MAX 256
15654#define _POSIX_PIPE_BUF 512
15655#define _POSIX_RE_DUP_MAX 255
15656#define _POSIX_RTSIG_MAX 8
15657#define _POSIX_SEM_NSEMS_MAX 256
15658#define _POSIX_SEM_VALUE_MAX 32767
15659#define _POSIX_SIGQUEUE_MAX 32
15660#define _POSIX_SSIZE_MAX 32767
15661#define _POSIX_STREAM_MAX 8
15662#define _POSIX_SS_REPL_MAX 4
15663#define _POSIX_SYMLINK_MAX 255
15664#define _POSIX_SYMLOOP_MAX 8
15665#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
15666#define _POSIX_THREAD_KEYS_MAX 128
15667#define _POSIX_THREAD_THREADS_MAX 64
15668#define _POSIX_TIMER_MAX 32
15669#define _POSIX_TRACE_EVENT_NAME_MAX 30
15670#define _POSIX_TRACE_NAME_MAX 8
15671#define _POSIX_TRACE_SYS_MAX 8
15672#define _POSIX_TRACE_USER_EVENT_MAX 32
15673#define _POSIX_TTY_NAME_MAX 9
15674#define _POSIX_TZNAME_MAX 6
15675#define _POSIX2_BC_BASE_MAX 99
15676#define _POSIX2_BC_DIM_MAX 2048
15677#define _POSIX2_BC_SCALE_MAX 99
15678#define _POSIX2_BC_STRING_MAX 1000
15679#define _POSIX2_COLL_WEIGHTS_MAX 2
15680#define _POSIX2_EXPR_NEST_MAX 32
15681#define _POSIX2_LINE_MAX 2048
15682#define _POSIX2_RE_DUP_MAX 255
15683#define _XOPEN_IOV_MAX 16
15684#define _XOPEN_NAME_MAX 255
15685#define _XOPEN_PATH_MAX 1024
15687#define NL_LANGMAX 14
15688#define NL_MSGMAX 32767
15689#define NL_SETMAX 255
15690#define NL_TEXTMAX _POSIX2_LINE_MAX
15693#undef _GCC_NEXT_LIMITS_H
15694#define RUBY_FIXNUM_MAX (LONG_MAX>>1)
15695#define RUBY_FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
15696#define FIXNUM_MAX RUBY_FIXNUM_MAX
15697#define FIXNUM_MIN RUBY_FIXNUM_MIN
15698#define RB_INT2FIX(i) (((VALUE)(i))<<1 | RUBY_FIXNUM_FLAG)
15699#define INT2FIX(i) RB_INT2FIX(i)
15700#define RB_LONG2FIX(i) RB_INT2FIX(i)
15701#define LONG2FIX(i) RB_INT2FIX(i)
15702#define rb_fix_new(v) RB_INT2FIX(v)
15703#define rb_int_new(v) rb_int2inum(v)
15704#define rb_uint_new(v) rb_uint2inum(v)
15705#define LL2NUM(v) rb_ll2inum(v)
15706#define ULL2NUM(v) rb_ull2inum(v)
15707#define SIZET2NUM(v) ULONG2NUM(v)
15708#define SSIZET2NUM(v) LONG2NUM(v)
15709#define rb_long2int(n) rb_long2int_inline(n)
15710#define RB_FIX2LONG(x) ((long)RSHIFT((SIGNED_VALUE)(x),1))
15711#define RB_FIX2ULONG(x) ((unsigned long)RB_FIX2LONG(x))
15712#define RB_FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&RUBY_FIXNUM_FLAG)
15713#define RB_POSFIXABLE(f) ((f) < RUBY_FIXNUM_MAX+1)
15714#define RB_NEGFIXABLE(f) ((f) >= RUBY_FIXNUM_MIN)
15715#define RB_FIXABLE(f) (RB_POSFIXABLE(f) && RB_NEGFIXABLE(f))
15716#define FIX2LONG(x) RB_FIX2LONG(x)
15717#define FIX2ULONG(x) RB_FIX2ULONG(x)
15718#define FIXNUM_P(f) RB_FIXNUM_P(f)
15719#define POSFIXABLE(f) RB_POSFIXABLE(f)
15720#define NEGFIXABLE(f) RB_NEGFIXABLE(f)
15721#define FIXABLE(f) RB_FIXABLE(f)
15722#define RB_IMMEDIATE_P(x) ((VALUE)(x) & RUBY_IMMEDIATE_MASK)
15723#define IMMEDIATE_P(x) RB_IMMEDIATE_P(x)
15724#define RB_STATIC_SYM_P(x) (((VALUE)(x)&~((~(VALUE)0)<<RUBY_SPECIAL_SHIFT)) == RUBY_SYMBOL_FLAG)
15725#define RB_DYNAMIC_SYM_P(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) == (RUBY_T_SYMBOL))
15726#define RB_SYMBOL_P(x) (RB_STATIC_SYM_P(x)||RB_DYNAMIC_SYM_P(x))
15727#define RB_ID2SYM(x) (rb_id2sym(x))
15728#define RB_SYM2ID(x) (rb_sym2id(x))
15729#define STATIC_SYM_P(x) RB_STATIC_SYM_P(x)
15730#define DYNAMIC_SYM_P(x) RB_DYNAMIC_SYM_P(x)
15731#define SYMBOL_P(x) RB_SYMBOL_P(x)
15732#define ID2SYM(x) RB_ID2SYM(x)
15733#define SYM2ID(x) RB_SYM2ID(x)
15734#define USE_FLONUM 1
15735#define RB_FLONUM_P(x) ((((int)(SIGNED_VALUE)(x))&RUBY_FLONUM_MASK) == RUBY_FLONUM_FLAG)
15736#define FLONUM_P(x) RB_FLONUM_P(x)
15737#define USE_SYMBOL_AS_METHOD_NAME 1
15738#define RUBY_Qfalse ((VALUE)RUBY_Qfalse)
15739#define RUBY_Qtrue ((VALUE)RUBY_Qtrue)
15740#define RUBY_Qnil ((VALUE)RUBY_Qnil)
15741#define RUBY_Qundef ((VALUE)RUBY_Qundef)
15742#define Qfalse RUBY_Qfalse
15743#define Qtrue RUBY_Qtrue
15744#define Qnil RUBY_Qnil
15745#define Qundef RUBY_Qundef
15746#define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK
15747#define FIXNUM_FLAG RUBY_FIXNUM_FLAG
15748#define FLONUM_MASK RUBY_FLONUM_MASK
15749#define FLONUM_FLAG RUBY_FLONUM_FLAG
15750#define SYMBOL_FLAG RUBY_SYMBOL_FLAG
15751#define RB_TEST(v) !(((VALUE)(v) & (VALUE)~RUBY_Qnil) == 0)
15752#define RB_NIL_P(v) !((VALUE)(v) != RUBY_Qnil)
15753#define RTEST(v) RB_TEST(v)
15754#define NIL_P(v) RB_NIL_P(v)
15755#define CLASS_OF(v) rb_class_of((VALUE)(v))
15756#define T_NONE RUBY_T_NONE
15757#define T_NIL RUBY_T_NIL
15758#define T_OBJECT RUBY_T_OBJECT
15759#define T_CLASS RUBY_T_CLASS
15760#define T_ICLASS RUBY_T_ICLASS
15761#define T_MODULE RUBY_T_MODULE
15762#define T_FLOAT RUBY_T_FLOAT
15763#define T_STRING RUBY_T_STRING
15764#define T_REGEXP RUBY_T_REGEXP
15765#define T_ARRAY RUBY_T_ARRAY
15766#define T_HASH RUBY_T_HASH
15767#define T_STRUCT RUBY_T_STRUCT
15768#define T_BIGNUM RUBY_T_BIGNUM
15769#define T_FILE RUBY_T_FILE
15770#define T_FIXNUM RUBY_T_FIXNUM
15771#define T_TRUE RUBY_T_TRUE
15772#define T_FALSE RUBY_T_FALSE
15773#define T_DATA RUBY_T_DATA
15774#define T_MATCH RUBY_T_MATCH
15775#define T_SYMBOL RUBY_T_SYMBOL
15776#define T_RATIONAL RUBY_T_RATIONAL
15777#define T_COMPLEX RUBY_T_COMPLEX
15778#define T_IMEMO RUBY_T_IMEMO
15779#define T_UNDEF RUBY_T_UNDEF
15780#define T_NODE RUBY_T_NODE
15781#define T_ZOMBIE RUBY_T_ZOMBIE
15782#define T_MOVED RUBY_T_MOVED
15783#define T_MASK RUBY_T_MASK
15784#define RB_BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & RUBY_T_MASK)
15785#define BUILTIN_TYPE(x) RB_BUILTIN_TYPE(x)
15786#define TYPE(x) rb_type((VALUE)(x))
15787#define RB_FLOAT_TYPE_P(obj) ( RB_FLONUM_P(obj) || (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == RUBY_T_FLOAT))
15788#define RB_TYPE_P(obj,type) ( ((type) == RUBY_T_FIXNUM) ? RB_FIXNUM_P(obj) : ((type) == RUBY_T_TRUE) ? ((obj) == RUBY_Qtrue) : ((type) == RUBY_T_FALSE) ? ((obj) == RUBY_Qfalse) : ((type) == RUBY_T_NIL) ? ((obj) == RUBY_Qnil) : ((type) == RUBY_T_UNDEF) ? ((obj) == RUBY_Qundef) : ((type) == RUBY_T_SYMBOL) ? RB_SYMBOL_P(obj) : ((type) == RUBY_T_FLOAT) ? RB_FLOAT_TYPE_P(obj) : (!RB_SPECIAL_CONST_P(obj) && RB_BUILTIN_TYPE(obj) == (type)))
15789#define RB_GC_GUARD(v) (*__extension__ ({ volatile VALUE *rb_gc_guarded_ptr = &(v); __asm__("" : : "m"(rb_gc_guarded_ptr)); rb_gc_guarded_ptr; }))
15790#define RB_UNUSED_VAR(x) x __attribute__ ((unused))
15791#define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
15792#define StringValue(v) rb_string_value(&(v))
15793#define StringValuePtr(v) rb_string_value_ptr(&(v))
15794#define StringValueCStr(v) rb_string_value_cstr(&(v))
15795#define SafeStringValue(v) StringValue(v)
15796#define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
15797#define ExportStringValue(v) do { StringValue(v); (v) = rb_str_export(v);} while (0)
15798#define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v))
15799#define FilePathStringValue(v) ((v) = rb_get_path(v))
15800#define RUBY_SAFE_LEVEL_MAX 1
15801#define ruby_safe_level_2_warning() ruby_safe_level_2_error()
15802#define RUBY_SAFE_LEVEL_INVALID_P(level) __extension__( __builtin_choose_expr( __builtin_constant_p(level), ((level) < 0 || RUBY_SAFE_LEVEL_MAX < (level)), 0))
15803#define RUBY_SAFE_LEVEL_CHECK(level,type) __extension__(__builtin_choose_expr(RUBY_SAFE_LEVEL_INVALID_P(level), ruby_safe_level_2_ ##type(), (level)))
15804#define rb_secure(level) rb_secure(RUBY_SAFE_LEVEL_CHECK(level, warning))
15805#define rb_set_safe_level(level) rb_set_safe_level(RUBY_SAFE_LEVEL_CHECK(level, error))
15806#define RB_NUM2LONG(x) rb_num2long_inline(x)
15807#define NUM2LONG(x) RB_NUM2LONG(x)
15808#define RB_NUM2ULONG(x) rb_num2ulong_inline(x)
15809#define NUM2ULONG(x) RB_NUM2ULONG(x)
15810#define RB_FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))
15811#define RB_NUM2INT(x) rb_num2int_inline(x)
15812#define RB_NUM2UINT(x) ((unsigned int)rb_num2uint(x))
15813#define RB_FIX2UINT(x) ((unsigned int)rb_fix2uint(x))
15814#define NUM2INT(x) RB_NUM2INT(x)
15815#define NUM2UINT(x) RB_NUM2UINT(x)
15816#define FIX2INT(x) RB_FIX2INT(x)
15817#define FIX2UINT(x) RB_FIX2UINT(x)
15818#define RB_FIX2SHORT(x) (rb_fix2short((VALUE)(x)))
15819#define FIX2SHORT(x) RB_FIX2SHORT(x)
15820#define RB_NUM2SHORT(x) rb_num2short_inline(x)
15821#define RB_NUM2USHORT(x) rb_num2ushort(x)
15822#define NUM2SHORT(x) RB_NUM2SHORT(x)
15823#define NUM2USHORT(x) RB_NUM2USHORT(x)
15824#define RB_NUM2LL(x) rb_num2ll_inline(x)
15825#define RB_NUM2ULL(x) rb_num2ull(x)
15826#define NUM2LL(x) RB_NUM2LL(x)
15827#define NUM2ULL(x) RB_NUM2ULL(x)
15828#define NUM2SIZET(x) NUM2ULONG(x)
15829#define NUM2SSIZET(x) NUM2LONG(x)
15830#define NUM2DBL(x) rb_num2dbl((VALUE)(x))
15831#define RB_NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()
15832#define RB_NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)rb_newobj_of(klass, flags)
15833#define NEWOBJ(obj,type) RB_NEWOBJ(obj,type)
15834#define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags)
15835#define OBJSETUP(obj,c,t) rb_obj_setup(obj, c, t)
15836#define CLONESETUP(clone,obj) rb_clone_setup(clone,obj)
15837#define DUPSETUP(dup,obj) rb_dup_setup(dup,obj)
15838#define USE_RGENGC 1
15839#define USE_RINCGC 1
15840#define RGENGC_WB_PROTECTED_ARRAY 1
15841#define RGENGC_WB_PROTECTED_HASH 1
15842#define RGENGC_WB_PROTECTED_STRUCT 1
15843#define RGENGC_WB_PROTECTED_STRING 1
15844#define RGENGC_WB_PROTECTED_OBJECT 1
15845#define RGENGC_WB_PROTECTED_REGEXP 1
15846#define RGENGC_WB_PROTECTED_CLASS 1
15847#define RGENGC_WB_PROTECTED_FLOAT 1
15848#define RGENGC_WB_PROTECTED_COMPLEX 1
15849#define RGENGC_WB_PROTECTED_RATIONAL 1
15850#define RGENGC_WB_PROTECTED_BIGNUM 1
15851#define RGENGC_WB_PROTECTED_NODE_CREF 1
15852#define RUBY_FL_USER_N(n) RUBY_FL_USER ##n = (1<<(RUBY_FL_USHIFT+n))
15853#define RB_OBJ_WB_UNPROTECT_FOR(type,obj) __extension__( __builtin_choose_expr( RGENGC_WB_PROTECTED_ ##type, OBJ_WB_UNPROTECT((VALUE)(obj)), ((VALUE)(obj))))
15854#define RBASIC_CLASS(obj) (RBASIC(obj)->klass)
15855#define RVALUE_EMBED_LEN_MAX RVALUE_EMBED_LEN_MAX
15856#define ROBJECT_EMBED_LEN_MAX ROBJECT_EMBED_LEN_MAX
15857#define ROBJECT_EMBED ROBJECT_EMBED
15858#define ROBJECT_NUMIV(o) ((RBASIC(o)->flags & ROBJECT_EMBED) ? ROBJECT_EMBED_LEN_MAX : ROBJECT(o)->as.heap.numiv)
15859#define ROBJECT_IVPTR(o) ((RBASIC(o)->flags & ROBJECT_EMBED) ? ROBJECT(o)->as.ary : ROBJECT(o)->as.heap.ivptr)
15860#define ROBJECT_IV_INDEX_TBL(o) ((RBASIC(o)->flags & ROBJECT_EMBED) ? RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : ROBJECT(o)->as.heap.iv_index_tbl)
15861#define RCLASS_SUPER(c) rb_class_get_superclass(c)
15862#define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
15863#define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
15864#define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
15865#define RMODULE_SUPER(m) RCLASS_SUPER(m)
15866#define RMODULE_IS_OVERLAID RMODULE_IS_OVERLAID
15867#define RMODULE_IS_REFINEMENT RMODULE_IS_REFINEMENT
15868#define RMODULE_INCLUDED_INTO_REFINEMENT RMODULE_INCLUDED_INTO_REFINEMENT
15869#define RFLOAT_VALUE(v) rb_float_value(v)
15870#define DBL2NUM(dbl) rb_float_new(dbl)
15871#define RUBY_ELTS_SHARED RUBY_ELTS_SHARED
15872#define ELTS_SHARED RUBY_ELTS_SHARED
15873#define RSTRING_NOEMBED RSTRING_NOEMBED
15874#define RSTRING_EMBED_LEN_MASK RSTRING_EMBED_LEN_MASK
15875#define RSTRING_EMBED_LEN_SHIFT RSTRING_EMBED_LEN_SHIFT
15876#define RSTRING_EMBED_LEN_MAX RSTRING_EMBED_LEN_MAX
15877#define RSTRING_FSTR RSTRING_FSTR
15878#define RSTRING_EMBED_LEN(str) (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))
15879#define RSTRING_LEN(str) (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? RSTRING_EMBED_LEN(str) : RSTRING(str)->as.heap.len)
15880#define RSTRING_PTR(str) (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? RSTRING(str)->as.ary : RSTRING(str)->as.heap.ptr)
15881#define RSTRING_END(str) (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len))
15882#define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
15883#define RSTRING_GETMEM(str,ptrvar,lenvar) (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))
15884#define USE_TRANSIENT_HEAP 1
15885#define RARRAY_TRANSIENT_FLAG RARRAY_TRANSIENT_FLAG
15886#define RARRAY_EMBED_FLAG (VALUE)RARRAY_EMBED_FLAG
15887#define RARRAY_EMBED_LEN_MASK (VALUE)RARRAY_EMBED_LEN_MASK
15888#define RARRAY_EMBED_LEN_MAX RARRAY_EMBED_LEN_MAX
15889#define RARRAY_EMBED_LEN_SHIFT RARRAY_EMBED_LEN_SHIFT
15890#define RARRAY_EMBED_LEN(a) (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT))
15891#define RARRAY_LEN(a) rb_array_len(a)
15892#define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary))
15893#define RARRAY_CONST_PTR(a) rb_array_const_ptr(a)
15894#define RARRAY_CONST_PTR_TRANSIENT(a) rb_array_const_ptr_transient(a)
15895#define RARRAY_TRANSIENT_P(ary) FL_TEST_RAW((ary), RARRAY_TRANSIENT_FLAG)
15896#define RARRAY_PTR_USE_START_TRANSIENT(a) rb_array_ptr_use_start(a, 1)
15897#define RARRAY_PTR_USE_END_TRANSIENT(a) rb_array_ptr_use_end(a, 1)
15898#define RARRAY_PTR_USE_TRANSIENT(ary,ptr_name,expr) do { const VALUE _ary = (ary); VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START_TRANSIENT(_ary); expr; RARRAY_PTR_USE_END_TRANSIENT(_ary); } while (0)
15899#define RARRAY_PTR_USE_START(a) rb_array_ptr_use_start(a, 0)
15900#define RARRAY_PTR_USE_END(a) rb_array_ptr_use_end(a, 0)
15901#define RARRAY_PTR_USE(ary,ptr_name,expr) do { const VALUE _ary = (ary); VALUE *ptr_name = (VALUE *)RARRAY_PTR_USE_START(_ary); expr; RARRAY_PTR_USE_END(_ary); } while (0)
15902#define RARRAY_AREF(a,i) (RARRAY_CONST_PTR_TRANSIENT(a)[i])
15903#define RARRAY_ASET(a,i,v) do { const VALUE _ary = (a); const VALUE _v = (v); VALUE *ptr = (VALUE *)RARRAY_PTR_USE_START_TRANSIENT(_ary); RB_OBJ_WRITE(_ary, &ptr[i], _v); RARRAY_PTR_USE_END_TRANSIENT(_ary); } while (0)
15904#define RARRAY_PTR(a) ((VALUE *)RARRAY_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(ARRAY, a)))
15905#define RREGEXP_PTR(r) (RREGEXP(r)->ptr)
15906#define RREGEXP_SRC(r) (RREGEXP(r)->src)
15907#define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src)
15908#define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src)
15909#define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src)
15910#define RHASH_TBL(h) rb_hash_tbl(h, __FILE__, __LINE__)
15911#define RHASH_ITER_LEV(h) rb_hash_iter_lev(h)
15912#define RHASH_IFNONE(h) rb_hash_ifnone(h)
15913#define RHASH_SIZE(h) rb_hash_size_num(h)
15914#define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
15915#define RHASH_SET_IFNONE(h,ifnone) rb_hash_set_ifnone((VALUE)h, ifnone)
15916#define HAVE_TYPE_RB_DATA_TYPE_T 1
15917#define HAVE_RB_DATA_TYPE_T_FUNCTION 1
15918#define HAVE_RB_DATA_TYPE_T_PARENT 1
15919#define DATA_PTR(dta) (RDATA(dta)->data)
15920#define RTYPEDDATA_P(v) (RTYPEDDATA(v)->typed_flag == 1)
15921#define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type)
15922#define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data)
15923#define RUBY_UNTYPED_DATA_WARNING 1
15924#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))
15925#define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1)
15926#define RUBY_NEVER_FREE ((RUBY_DATA_FUNC)0)
15927#define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE
15928#define RUBY_TYPED_NEVER_FREE RUBY_NEVER_FREE
15929#define RUBY_TYPED_FREE_IMMEDIATELY 1
15930#define RUBY_TYPED_WB_PROTECTED RUBY_FL_WB_PROTECTED
15931#define RUBY_TYPED_PROMOTED1 RUBY_FL_PROMOTED1
15932#define Data_Wrap_Struct(klass,mark,free,sval) rb_data_object_wrap((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))
15933#define Data_Make_Struct0(result,klass,type,size,mark,free,sval) VALUE result = rb_data_object_zalloc((klass), (size), (RUBY_DATA_FUNC)(mark), (RUBY_DATA_FUNC)(free)); (void)((sval) = (type *)DATA_PTR(result));
15934#define Data_Make_Struct(klass,type,mark,free,sval) ({ Data_Make_Struct0(data_struct_obj, klass, type, sizeof(type), mark, free, sval); data_struct_obj; })
15935#define TypedData_Wrap_Struct(klass,data_type,sval) rb_data_typed_object_wrap((klass),(sval),(data_type))
15936#define TypedData_Make_Struct0(result,klass,type,size,data_type,sval) VALUE result = rb_data_typed_object_zalloc(klass, size, data_type); (void)((sval) = (type *)DATA_PTR(result));
15937#define TypedData_Make_Struct(klass,type,data_type,sval) ({ TypedData_Make_Struct0(data_struct_obj, klass, type, sizeof(type), data_type, sval); data_struct_obj; })
15938#define Data_Get_Struct(obj,type,sval) ((sval) = (type*)rb_data_object_get(obj))
15939#define TypedData_Get_Struct(obj,type,data_type,sval) ((sval) = (type*)rb_check_typeddata((obj), (data_type)))
15940#define RSTRUCT_LEN(st) NUM2LONG(rb_struct_size(st))
15941#define RSTRUCT_PTR(st) rb_struct_ptr(st)
15942#define RSTRUCT_SET(st,idx,v) rb_struct_aset(st, INT2NUM(idx), (v))
15943#define RSTRUCT_GET(st,idx) rb_struct_aref(st, INT2NUM(idx))
15944#define RBIGNUM_SIGN(b) (rb_big_sign(b))
15945#define RBIGNUM_POSITIVE_P(b) (RBIGNUM_SIGN(b)!=0)
15946#define RBIGNUM_NEGATIVE_P(b) (RBIGNUM_SIGN(b)==0)
15947#define R_CAST(st) (struct st*)
15948#define RMOVED(obj) (R_CAST(RMoved)(obj))
15949#define RBASIC(obj) (R_CAST(RBasic)(obj))
15950#define ROBJECT(obj) (R_CAST(RObject)(obj))
15951#define RCLASS(obj) (R_CAST(RClass)(obj))
15952#define RMODULE(obj) RCLASS(obj)
15953#define RSTRING(obj) (R_CAST(RString)(obj))
15954#define RREGEXP(obj) (R_CAST(RRegexp)(obj))
15955#define RARRAY(obj) (R_CAST(RArray)(obj))
15956#define RDATA(obj) (R_CAST(RData)(obj))
15957#define RTYPEDDATA(obj) (R_CAST(RTypedData)(obj))
15958#define RFILE(obj) (R_CAST(RFile)(obj))
15959#define FL_SINGLETON ((VALUE)RUBY_FL_SINGLETON)
15960#define FL_WB_PROTECTED ((VALUE)RUBY_FL_WB_PROTECTED)
15961#define FL_PROMOTED0 ((VALUE)RUBY_FL_PROMOTED0)
15962#define FL_PROMOTED1 ((VALUE)RUBY_FL_PROMOTED1)
15963#define FL_FINALIZE ((VALUE)RUBY_FL_FINALIZE)
15964#define FL_TAINT ((VALUE)RUBY_FL_TAINT)
15965#define FL_UNTRUSTED ((VALUE)RUBY_FL_UNTRUSTED)
15966#define FL_SEEN_OBJ_ID ((VALUE)RUBY_FL_SEEN_OBJ_ID)
15967#define FL_EXIVAR ((VALUE)RUBY_FL_EXIVAR)
15968#define FL_FREEZE ((VALUE)RUBY_FL_FREEZE)
15969#define FL_USHIFT ((VALUE)RUBY_FL_USHIFT)
15970#define FL_USER0 ((VALUE)RUBY_FL_USER0)
15971#define FL_USER1 ((VALUE)RUBY_FL_USER1)
15972#define FL_USER2 ((VALUE)RUBY_FL_USER2)
15973#define FL_USER3 ((VALUE)RUBY_FL_USER3)
15974#define FL_USER4 ((VALUE)RUBY_FL_USER4)
15975#define FL_USER5 ((VALUE)RUBY_FL_USER5)
15976#define FL_USER6 ((VALUE)RUBY_FL_USER6)
15977#define FL_USER7 ((VALUE)RUBY_FL_USER7)
15978#define FL_USER8 ((VALUE)RUBY_FL_USER8)
15979#define FL_USER9 ((VALUE)RUBY_FL_USER9)
15980#define FL_USER10 ((VALUE)RUBY_FL_USER10)
15981#define FL_USER11 ((VALUE)RUBY_FL_USER11)
15982#define FL_USER12 ((VALUE)RUBY_FL_USER12)
15983#define FL_USER13 ((VALUE)RUBY_FL_USER13)
15984#define FL_USER14 ((VALUE)RUBY_FL_USER14)
15985#define FL_USER15 ((VALUE)RUBY_FL_USER15)
15986#define FL_USER16 ((VALUE)RUBY_FL_USER16)
15987#define FL_USER17 ((VALUE)RUBY_FL_USER17)
15988#define FL_USER18 ((VALUE)RUBY_FL_USER18)
15989#define FL_USER19 ((VALUE)(unsigned int)RUBY_FL_USER19)
15990#define RB_SPECIAL_CONST_P(x) (RB_IMMEDIATE_P(x) || !RB_TEST(x))
15991#define SPECIAL_CONST_P(x) RB_SPECIAL_CONST_P(x)
15992#define RB_FL_ABLE(x) (!RB_SPECIAL_CONST_P(x) && RB_BUILTIN_TYPE(x) != RUBY_T_NODE)
15993#define RB_FL_TEST_RAW(x,f) (RBASIC(x)->flags&(f))
15994#define RB_FL_TEST(x,f) (RB_FL_ABLE(x)?RB_FL_TEST_RAW((x),(f)):0)
15995#define RB_FL_ANY_RAW(x,f) RB_FL_TEST_RAW((x),(f))
15996#define RB_FL_ANY(x,f) RB_FL_TEST((x),(f))
15997#define RB_FL_ALL_RAW(x,f) (RB_FL_TEST_RAW((x),(f)) == (f))
15998#define RB_FL_ALL(x,f) (RB_FL_TEST((x),(f)) == (f))
15999#define RB_FL_SET_RAW(x,f) (void)(RBASIC(x)->flags |= (f))
16000#define RB_FL_SET(x,f) (RB_FL_ABLE(x) ? RB_FL_SET_RAW(x, f) : (void)0)
16001#define RB_FL_UNSET_RAW(x,f) (void)(RBASIC(x)->flags &= ~(VALUE)(f))
16002#define RB_FL_UNSET(x,f) (RB_FL_ABLE(x) ? RB_FL_UNSET_RAW(x, f) : (void)0)
16003#define RB_FL_REVERSE_RAW(x,f) (void)(RBASIC(x)->flags ^= (f))
16004#define RB_FL_REVERSE(x,f) (RB_FL_ABLE(x) ? RB_FL_REVERSE_RAW(x, f) : (void)0)
16005#define RB_OBJ_TAINTABLE(x) (RB_FL_ABLE(x) && RB_BUILTIN_TYPE(x) != RUBY_T_BIGNUM && RB_BUILTIN_TYPE(x) != RUBY_T_FLOAT)
16006#define RB_OBJ_TAINTED_RAW(x) RB_FL_TEST_RAW(x, RUBY_FL_TAINT)
16007#define RB_OBJ_TAINTED(x) (!!RB_FL_TEST((x), RUBY_FL_TAINT))
16008#define RB_OBJ_TAINT_RAW(x) RB_FL_SET_RAW(x, RUBY_FL_TAINT)
16009#define RB_OBJ_TAINT(x) (RB_OBJ_TAINTABLE(x) ? RB_OBJ_TAINT_RAW(x) : (void)0)
16010#define RB_OBJ_UNTRUSTED(x) RB_OBJ_TAINTED(x)
16011#define RB_OBJ_UNTRUST(x) RB_OBJ_TAINT(x)
16012#define RB_OBJ_INFECT_RAW(x,s) RB_FL_SET_RAW(x, RB_OBJ_TAINTED_RAW(s))
16013#define RB_OBJ_INFECT(x,s) ( (RB_OBJ_TAINTABLE(x) && RB_FL_ABLE(s)) ? RB_OBJ_INFECT_RAW(x, s) : (void)0)
16014#define RB_OBJ_FROZEN_RAW(x) (RBASIC(x)->flags&RUBY_FL_FREEZE)
16015#define RB_OBJ_FROZEN(x) (!RB_FL_ABLE(x) || RB_OBJ_FROZEN_RAW(x))
16016#define RB_OBJ_FREEZE_RAW(x) (void)(RBASIC(x)->flags |= RUBY_FL_FREEZE)
16017#define RB_OBJ_FREEZE(x) rb_obj_freeze_inline((VALUE)x)
16018#define FL_ABLE(x) RB_FL_ABLE(x)
16019#define FL_TEST_RAW(x,f) RB_FL_TEST_RAW(x,f)
16020#define FL_TEST(x,f) RB_FL_TEST(x,f)
16021#define FL_ANY_RAW(x,f) RB_FL_ANY_RAW(x,f)
16022#define FL_ANY(x,f) RB_FL_ANY(x,f)
16023#define FL_ALL_RAW(x,f) RB_FL_ALL_RAW(x,f)
16024#define FL_ALL(x,f) RB_FL_ALL(x,f)
16025#define FL_SET_RAW(x,f) RB_FL_SET_RAW(x,f)
16026#define FL_SET(x,f) RB_FL_SET(x,f)
16027#define FL_UNSET_RAW(x,f) RB_FL_UNSET_RAW(x,f)
16028#define FL_UNSET(x,f) RB_FL_UNSET(x,f)
16029#define FL_REVERSE_RAW(x,f) RB_FL_REVERSE_RAW(x,f)
16030#define FL_REVERSE(x,f) RB_FL_REVERSE(x,f)
16031#define OBJ_TAINTABLE(x) RB_OBJ_TAINTABLE(x)
16032#define OBJ_TAINTED_RAW(x) RB_OBJ_TAINTED_RAW(x)
16033#define OBJ_TAINTED(x) RB_OBJ_TAINTED(x)
16034#define OBJ_TAINT_RAW(x) RB_OBJ_TAINT_RAW(x)
16035#define OBJ_TAINT(x) RB_OBJ_TAINT(x)
16036#define OBJ_UNTRUSTED(x) RB_OBJ_UNTRUSTED(x)
16037#define OBJ_UNTRUST(x) RB_OBJ_UNTRUST(x)
16038#define OBJ_INFECT_RAW(x,s) RB_OBJ_INFECT_RAW(x,s)
16039#define OBJ_INFECT(x,s) RB_OBJ_INFECT(x,s)
16040#define OBJ_FROZEN_RAW(x) RB_OBJ_FROZEN_RAW(x)
16041#define OBJ_FROZEN(x) RB_OBJ_FROZEN(x)
16042#define OBJ_FREEZE_RAW(x) RB_OBJ_FREEZE_RAW(x)
16043#define OBJ_FREEZE(x) RB_OBJ_FREEZE(x)
16044#define RUBY_UNTYPED_DATA_FUNC(func) func __attribute__((warning("untyped Data is unsafe; use TypedData instead")))
16045#define rb_data_object_wrap_warning(klass,ptr,mark,free) __extension__( __builtin_choose_expr( __builtin_constant_p(klass) && !(klass), rb_data_object_wrap(klass, ptr, mark, free), rb_data_object_wrap_warning(klass, ptr, mark, free)))
16046#define rb_data_object_wrap_0 rb_data_object_wrap
16047#define rb_data_object_wrap_1 rb_data_object_wrap_warning
16048#define rb_data_object_wrap RUBY_MACRO_SELECT(rb_data_object_wrap_, RUBY_UNTYPED_DATA_WARNING)
16049#define rb_data_object_get_0 rb_data_object_get
16050#define rb_data_object_get_1 rb_data_object_get_warning
16051#define rb_data_object_get RUBY_MACRO_SELECT(rb_data_object_get_, RUBY_UNTYPED_DATA_WARNING)
16052#define rb_data_object_make_0 rb_data_object_make
16053#define rb_data_object_make_1 rb_data_object_make_warning
16054#define rb_data_object_make RUBY_MACRO_SELECT(rb_data_object_make_, RUBY_UNTYPED_DATA_WARNING)
16055#define RB_OBJ_PROMOTED_RAW(x) RB_FL_ALL_RAW(x, RUBY_FL_PROMOTED)
16056#define RB_OBJ_PROMOTED(x) (RB_SPECIAL_CONST_P(x) ? 0 : RB_OBJ_PROMOTED_RAW(x))
16057#define RB_OBJ_WB_UNPROTECT(x) rb_obj_wb_unprotect(x, __FILE__, __LINE__)
16058#define OBJ_PROMOTED_RAW(x) RB_OBJ_PROMOTED_RAW(x)
16059#define OBJ_PROMOTED(x) RB_OBJ_PROMOTED(x)
16060#define OBJ_WB_UNPROTECT(x) RB_OBJ_WB_UNPROTECT(x)
16061#define RB_OBJ_WRITE(a,slot,b) rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__)
16062#define RB_OBJ_WRITTEN(a,oldv,b) rb_obj_written((VALUE)(a), (VALUE)(oldv), (VALUE)(b), __FILE__, __LINE__)
16063#define USE_RGENGC_LOGGING_WB_UNPROTECT 0
16064#define RUBY_INTEGER_UNIFICATION 1
16065#define RB_INTEGER_TYPE_P(obj) rb_integer_type_p(obj)
16066#define RB_INT2NUM(v) RB_INT2FIX((int)(v))
16067#define RB_UINT2NUM(v) RB_LONG2FIX((unsigned int)(v))
16068#define INT2NUM(x) RB_INT2NUM(x)
16069#define UINT2NUM(x) RB_UINT2NUM(x)
16070#define RB_LONG2NUM(x) rb_long2num_inline(x)
16071#define RB_ULONG2NUM(x) rb_ulong2num_inline(x)
16072#define RB_NUM2CHR(x) rb_num2char_inline(x)
16073#define RB_CHR2FIX(x) RB_INT2FIX((long)((x)&0xff))
16074#define LONG2NUM(x) RB_LONG2NUM(x)
16075#define ULONG2NUM(x) RB_ULONG2NUM(x)
16076#define USHORT2NUM(x) RB_INT2FIX(x)
16077#define NUM2CHR(x) RB_NUM2CHR(x)
16078#define CHR2FIX(x) RB_CHR2FIX(x)
16079#define RB_ST2FIX(h) RB_LONG2FIX((long)(h))
16080#define ST2FIX(h) RB_ST2FIX(h)
16081#define RB_ALLOC_N(type,n) ((type*)ruby_xmalloc2((size_t)(n),sizeof(type)))
16082#define RB_ALLOC(type) ((type*)ruby_xmalloc(sizeof(type)))
16083#define RB_ZALLOC_N(type,n) ((type*)ruby_xcalloc((size_t)(n),sizeof(type)))
16084#define RB_ZALLOC(type) (RB_ZALLOC_N(type,1))
16085#define RB_REALLOC_N(var,type,n) ((var)=(type*)ruby_xrealloc2((char*)(var),(size_t)(n),sizeof(type)))
16086#define ALLOC_N(type,n) RB_ALLOC_N(type,n)
16087#define ALLOC(type) RB_ALLOC(type)
16088#define ZALLOC_N(type,n) RB_ZALLOC_N(type,n)
16089#define ZALLOC(type) RB_ZALLOC(type)
16090#define REALLOC_N(var,type,n) RB_REALLOC_N(var,type,n)
16091#define ALLOCA_N(type,n) (type*)__builtin_alloca_with_align((sizeof(type)*(n)), RUBY_ALIGNOF(type) * CHAR_BIT)
16092#define DSIZE_T uint128_t
16093#define RUBY_ALLOCV_LIMIT 1024
16094#define RB_ALLOCV(v,n) ((n) < RUBY_ALLOCV_LIMIT ? ((v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n)))
16095#define RB_ALLOCV_N(type,v,n) ((type*)(((size_t)(n) < RUBY_ALLOCV_LIMIT / sizeof(type)) ? ((v) = 0, alloca((size_t)(n) * sizeof(type))) : rb_alloc_tmp_buffer2(&(v), (long)(n), sizeof(type))))
16096#define RB_ALLOCV_END(v) rb_free_tmp_buffer(&(v))
16097#define ALLOCV(v,n) RB_ALLOCV(v, n)
16098#define ALLOCV_N(type,v,n) RB_ALLOCV_N(type, v, n)
16099#define ALLOCV_END(v) RB_ALLOCV_END(v)
16100#define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(size_t)(n))
16101#define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(size_t)(n))
16102#define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(size_t)(n))
16103#define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(size_t)(n))
16104#define RUBY_CONST_ID_CACHE_NB(result,str) static ID rb_intern_id_cache; if (!rb_intern_id_cache) rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); result rb_intern_id_cache;
16105#define RUBY_CONST_ID_CACHE(result,str) { RUBY_CONST_ID_CACHE_NB(result, str) }
16106#define RUBY_CONST_ID(var,str) do RUBY_CONST_ID_CACHE((var) =, (str)) while (0)
16107#define CONST_ID_CACHE(result,str) RUBY_CONST_ID_CACHE(result, str)
16108#define CONST_ID(var,str) RUBY_CONST_ID(var, str)
16109#define rb_intern(str) (__builtin_constant_p(str) ? __extension__ ({RUBY_CONST_ID_CACHE_NB((ID), (str))}) : rb_intern(str))
16110#define rb_intern_const(str) (__builtin_constant_p(str) ? __extension__ (rb_intern2((str), (long)strlen(str))) : (rb_intern)(str))
16111#define rb_varargs_argc_check_runtime(argc,vargc) (((argc) <= (vargc)) ? (argc) : (rb_fatal("argc(%d) exceeds actual arguments(%d)", argc, vargc), 0))
16112#define rb_varargs_argc_valid_p(argc,vargc) ((argc) == 0 ? (vargc) <= 1 : (argc) == (vargc))
16113#define rb_varargs_argc_check(argc,vargc) __builtin_choose_expr(__builtin_constant_p(argc), (rb_varargs_argc_valid_p(argc, vargc) ? (argc) : rb_varargs_bad_length(argc, vargc)), rb_varargs_argc_check_runtime(argc, vargc))
16114#define rb_funcall2 rb_funcallv
16115#define rb_funcall3 rb_funcallv_public
16116#define RB_SCAN_ARGS_PASS_CALLED_KEYWORDS 0
16117#define RB_SCAN_ARGS_KEYWORDS 1
16118#define RB_SCAN_ARGS_EMPTY_KEYWORDS 2
16119#define RB_SCAN_ARGS_LAST_HASH_KEYWORDS 3
16120#define HAVE_RB_SCAN_ARGS_OPTIONAL_HASH 1
16121#define ruby_verbose (*rb_ruby_verbose_ptr())
16122#define ruby_debug (*rb_ruby_debug_ptr())
16123#define RB_IO_WAIT_READABLE RB_IO_WAIT_READABLE
16124#define RB_IO_WAIT_WRITABLE RB_IO_WAIT_WRITABLE
16125#define RB_BLOCK_CALL_FUNC_STRICT 1
16126#define RUBY_BLOCK_CALL_FUNC_TAKES_BLOCKARG 1
16127#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg,callback_arg) VALUE yielded_arg, VALUE callback_arg, int argc, const VALUE *argv, VALUE blockarg
16128#define RB_NO_KEYWORDS 0
16129#define RB_PASS_KEYWORDS 1
16130#define RB_PASS_EMPTY_KEYWORDS 2
16131#define RB_PASS_CALLED_KEYWORDS 3
16132#define rb_type_p(obj,type) __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : rb_type(obj) == (type))
16133#define rb_special_const_p(obj) __extension__ ({ VALUE special_const_obj = (obj); (int)(RB_SPECIAL_CONST_P(special_const_obj) ? RUBY_Qtrue : RUBY_Qfalse); })
16134#define RUBY_INTERN_H 1
16136#pragma GCC visibility push(default)
16137#define ST_DATA_T_DEFINED
16138#define MAX_ST_INDEX_VAL (~(st_index_t) 0)
16139#define SIZEOF_ST_INDEX_T SIZEOF_VOIDP
16140#define ST_INDEX_BITS (SIZEOF_ST_INDEX_T * CHAR_BIT)
16141#define ST_DATA_COMPATIBLE_P(type) __builtin_choose_expr(__builtin_types_compatible_p(type, st_data_t), 1, 0)
16142#define st_is_member(table,key) st_lookup((table),(key),(st_data_t *)0)
16143#define st_init_table rb_st_init_table
16144#define st_init_table_with_size rb_st_init_table_with_size
16145#define st_init_numtable rb_st_init_numtable
16146#define st_init_numtable_with_size rb_st_init_numtable_with_size
16147#define st_init_strtable rb_st_init_strtable
16148#define st_init_strtable_with_size rb_st_init_strtable_with_size
16149#define st_init_strcasetable rb_st_init_strcasetable
16150#define st_init_strcasetable_with_size rb_st_init_strcasetable_with_size
16151#define st_delete rb_st_delete
16152#define st_delete_safe rb_st_delete_safe
16153#define st_shift rb_st_shift
16154#define st_insert rb_st_insert
16155#define st_insert2 rb_st_insert2
16156#define st_lookup rb_st_lookup
16157#define st_get_key rb_st_get_key
16158#define st_update rb_st_update
16159#define st_foreach_with_replace rb_st_foreach_with_replace
16160#define st_foreach rb_st_foreach
16161#define st_foreach_check rb_st_foreach_check
16162#define st_keys rb_st_keys
16163#define st_keys_check rb_st_keys_check
16164#define st_values rb_st_values
16165#define st_values_check rb_st_values_check
16166#define st_add_direct rb_st_add_direct
16167#define st_free_table rb_st_free_table
16168#define st_cleanup_safe rb_st_cleanup_safe
16169#define st_clear rb_st_clear
16170#define st_copy rb_st_copy
16171#define st_numcmp rb_st_numcmp
16172#define st_numhash rb_st_numhash
16173#define st_locale_insensitive_strcasecmp rb_st_locale_insensitive_strcasecmp
16174#define st_locale_insensitive_strncasecmp rb_st_locale_insensitive_strncasecmp
16175#define st_strcasecmp rb_st_locale_insensitive_strcasecmp
16176#define st_strncasecmp rb_st_locale_insensitive_strncasecmp
16177#define st_memsize rb_st_memsize
16178#define st_hash rb_st_hash
16179#define st_hash_uint32 rb_st_hash_uint32
16180#define st_hash_uint rb_st_hash_uint
16181#define st_hash_end rb_st_hash_end
16182#define st_hash_start(h) ((st_index_t)(h))
16183#pragma GCC visibility pop
16184#define MJIT_STATIC static
16185#pragma GCC visibility push(default)
16186#define UNLIMITED_ARGUMENTS (-1)
16187#define rb_ary_new2 rb_ary_new_capa
16188#define rb_ary_new3 rb_ary_new_from_args
16189#define rb_ary_new4 rb_ary_new_from_values
16190#define rb_big2int(x) rb_big2long(x)
16191#define rb_big2uint(x) rb_big2ulong(x)
16192#define INTEGER_PACK_MSWORD_FIRST 0x01
16193#define INTEGER_PACK_LSWORD_FIRST 0x02
16194#define INTEGER_PACK_MSBYTE_FIRST 0x10
16195#define INTEGER_PACK_LSBYTE_FIRST 0x20
16196#define INTEGER_PACK_NATIVE_BYTE_ORDER 0x40
16197#define INTEGER_PACK_2COMP 0x80
16198#define INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION 0x400
16199#define INTEGER_PACK_FORCE_BIGNUM 0x100
16200#define INTEGER_PACK_NEGATIVE 0x200
16201#define INTEGER_PACK_LITTLE_ENDIAN (INTEGER_PACK_LSWORD_FIRST | INTEGER_PACK_LSBYTE_FIRST)
16202#define INTEGER_PACK_BIG_ENDIAN (INTEGER_PACK_MSWORD_FIRST | INTEGER_PACK_MSBYTE_FIRST)
16203#define rb_rational_raw1(x) rb_rational_raw((x), INT2FIX(1))
16204#define rb_rational_raw2(x,y) rb_rational_raw((x), (y))
16205#define rb_rational_new1(x) rb_rational_new((x), INT2FIX(1))
16206#define rb_rational_new2(x,y) rb_rational_new((x), (y))
16207#define rb_Rational1(x) rb_Rational((x), INT2FIX(1))
16208#define rb_Rational2(x,y) rb_Rational((x), (y))
16209#define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0))
16210#define rb_complex_raw2(x,y) rb_complex_raw((x), (y))
16211#define rb_complex_new1(x) rb_complex_new((x), INT2FIX(0))
16212#define rb_complex_new2(x,y) rb_complex_new((x), (y))
16213#define rb_complex_add rb_complex_plus
16214#define rb_complex_sub rb_complex_minus
16215#define rb_complex_nagate rb_complex_uminus
16216#define rb_Complex1(x) rb_Complex((x), INT2FIX(0))
16217#define rb_Complex2(x,y) rb_Complex((x), (y))
16218#define SIZED_ENUMERATOR(obj,argc,argv,size_fn) rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), (argc), (argv), (size_fn))
16219#define SIZED_ENUMERATOR_KW(obj,argc,argv,size_fn,kw_splat) rb_enumeratorize_with_size_kw((obj), ID2SYM(rb_frame_this_func()), (argc), (argv), (size_fn), (kw_splat))
16220#define RETURN_SIZED_ENUMERATOR(obj,argc,argv,size_fn) do { if (!rb_block_given_p()) return SIZED_ENUMERATOR(obj, argc, argv, size_fn); } while (0)
16221#define RETURN_SIZED_ENUMERATOR_KW(obj,argc,argv,size_fn,kw_splat) do { if (!rb_block_given_p()) return SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat); } while (0)
16222#define RETURN_ENUMERATOR(obj,argc,argv) RETURN_SIZED_ENUMERATOR(obj, argc, argv, 0)
16223#define RETURN_ENUMERATOR_KW(obj,argc,argv,kw_splat) RETURN_SIZED_ENUMERATOR_KW(obj, argc, argv, 0, kw_splat)
16224#define rb_exc_new2 rb_exc_new_cstr
16225#define rb_exc_new3 rb_exc_new_str
16226#define rb_check_frozen_internal(obj) do { VALUE frozen_obj = (obj); if (RB_UNLIKELY(RB_OBJ_FROZEN(frozen_obj))) { rb_error_frozen_object(frozen_obj); } } while (0)
16227#define rb_check_frozen(obj) __extension__({rb_check_frozen_internal(obj);})
16228#define RB_OBJ_INIT_COPY(obj,orig) ((obj) != (orig) && (rb_obj_init_copy((obj), (orig)), 1))
16229#define OBJ_INIT_COPY(obj,orig) RB_OBJ_INIT_COPY(obj, orig)
16230#define rb_check_arity rb_check_arity
16231#define rb_fd_ptr(f) ((f)->fdset)
16232#define rb_fd_max(f) ((f)->maxfd)
16233#define HAVE_RB_DEFINE_ALLOC_FUNC 1
16234#define st_foreach_safe rb_st_foreach_safe
16235#define rb_defout rb_stdout
16236#define RB_RESERVED_FD_P(fd) rb_reserved_fd_p(fd)
16237#define RB_NUM_COERCE_FUNCS_NEED_OPID 1
16238#define rb_memcmp memcmp
16239#define HAVE_RB_REG_NEW_STR 1
16240#define rb_argv rb_get_argv()
16241#define posix_signal ruby_posix_signal
16242#define rb_str_dup_frozen rb_str_new_frozen
16243#define rb_hash_uint32(h,i) st_hash_uint32((h), (i))
16244#define rb_hash_uint(h,i) st_hash_uint((h), (i))
16245#define rb_hash_end(h) st_hash_end(h)
16246#define rb_str_new(str,len) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str) && __builtin_constant_p(len)) ? rb_str_new_static((str), (len)) : rb_str_new((str), (len)) )
16247#define rb_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_str_new_static((str), (long)strlen(str)) : rb_str_new_cstr(str) )
16248#define rb_usascii_str_new(str,len) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str) && __builtin_constant_p(len)) ? rb_usascii_str_new_static((str), (len)) : rb_usascii_str_new((str), (len)) )
16249#define rb_utf8_str_new(str,len) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str) && __builtin_constant_p(len)) ? rb_utf8_str_new_static((str), (len)) : rb_utf8_str_new((str), (len)) )
16250#define rb_tainted_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_tainted_str_new((str), (long)strlen(str)) : rb_tainted_str_new_cstr(str) )
16251#define rb_usascii_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_usascii_str_new_static((str), (long)strlen(str)) : rb_usascii_str_new_cstr(str) )
16252#define rb_utf8_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_utf8_str_new_static((str), (long)strlen(str)) : rb_utf8_str_new_cstr(str) )
16253#define rb_external_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_external_str_new((str), (long)strlen(str)) : rb_external_str_new_cstr(str) )
16254#define rb_locale_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_locale_str_new((str), (long)strlen(str)) : rb_locale_str_new_cstr(str) )
16255#define rb_str_buf_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_str_buf_cat(rb_str_buf_new((long)strlen(str)), (str), (long)strlen(str)) : rb_str_buf_new_cstr(str) )
16256#define rb_str_cat_cstr(str,ptr) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(ptr)) ? rb_str_cat((str), (ptr), (long)strlen(ptr)) : rb_str_cat_cstr((str), (ptr)) )
16257#define rb_exc_new_cstr(klass,ptr) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(ptr)) ? rb_exc_new((klass), (ptr), (long)strlen(ptr)) : rb_exc_new_cstr((klass), (ptr)) )
16258#define rb_str_new2 rb_str_new_cstr
16259#define rb_str_new3 rb_str_new_shared
16260#define rb_str_new4 rb_str_new_frozen
16261#define rb_str_new5 rb_str_new_with_class
16262#define rb_tainted_str_new2 rb_tainted_str_new_cstr
16263#define rb_str_buf_new2 rb_str_buf_new_cstr
16264#define rb_usascii_str_new2 rb_usascii_str_new_cstr
16265#define rb_str_buf_cat rb_str_cat
16266#define rb_str_buf_cat2 rb_str_cat_cstr
16267#define rb_str_cat2 rb_str_cat_cstr
16268#define rb_strlen_lit(str) (sizeof(str "") - 1)
16269#define rb_str_new_lit(str) rb_str_new_static((str), rb_strlen_lit(str))
16270#define rb_usascii_str_new_lit(str) rb_usascii_str_new_static((str), rb_strlen_lit(str))
16271#define rb_utf8_str_new_lit(str) rb_utf8_str_new_static((str), rb_strlen_lit(str))
16272#define rb_enc_str_new_lit(str,enc) rb_enc_str_new_static((str), rb_strlen_lit(str), (enc))
16273#define rb_str_new_literal(str) rb_str_new_lit(str)
16274#define rb_usascii_str_new_literal(str) rb_usascii_str_new_lit(str)
16275#define rb_utf8_str_new_literal(str) rb_utf8_str_new_lit(str)
16276#define rb_enc_str_new_literal(str,enc) rb_enc_str_new_lit(str, enc)
16277#define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
16278#define RUBY_UBF_PROCESS ((rb_unblock_function_t *)-1)
16279#pragma GCC visibility pop
16280#define rb_f_notimplement_p(f) __builtin_types_compatible_p(__typeof__(f),__typeof__(rb_f_notimplement))
16281#define FIX_CONST_VALUE_PTR(x) (x)
16283#define HAVE_NATIVETHREAD
16284#define RUBY_EVENT_NONE 0x0000
16285#define RUBY_EVENT_LINE 0x0001
16286#define RUBY_EVENT_CLASS 0x0002
16287#define RUBY_EVENT_END 0x0004
16288#define RUBY_EVENT_CALL 0x0008
16289#define RUBY_EVENT_RETURN 0x0010
16290#define RUBY_EVENT_C_CALL 0x0020
16291#define RUBY_EVENT_C_RETURN 0x0040
16292#define RUBY_EVENT_RAISE 0x0080
16293#define RUBY_EVENT_ALL 0x00ff
16294#define RUBY_EVENT_B_CALL 0x0100
16295#define RUBY_EVENT_B_RETURN 0x0200
16296#define RUBY_EVENT_THREAD_BEGIN 0x0400
16297#define RUBY_EVENT_THREAD_END 0x0800
16298#define RUBY_EVENT_FIBER_SWITCH 0x1000
16299#define RUBY_EVENT_SCRIPT_COMPILED 0x2000
16300#define RUBY_EVENT_TRACEPOINT_ALL 0xffff
16301#define RUBY_EVENT_RESERVED_FOR_INTERNAL_USE 0x030000
16302#define RUBY_INTERNAL_EVENT_SWITCH 0x040000
16303#define RUBY_EVENT_SWITCH 0x040000
16304#define RUBY_INTERNAL_EVENT_NEWOBJ 0x100000
16305#define RUBY_INTERNAL_EVENT_FREEOBJ 0x200000
16306#define RUBY_INTERNAL_EVENT_GC_START 0x400000
16307#define RUBY_INTERNAL_EVENT_GC_END_MARK 0x800000
16308#define RUBY_INTERNAL_EVENT_GC_END_SWEEP 0x1000000
16309#define RUBY_INTERNAL_EVENT_GC_ENTER 0x2000000
16310#define RUBY_INTERNAL_EVENT_GC_EXIT 0x4000000
16311#define RUBY_INTERNAL_EVENT_OBJSPACE_MASK 0x7f00000
16312#define RUBY_INTERNAL_EVENT_MASK 0xffff0000
16313#define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1
16314#define ISASCII(c) rb_isascii(c)
16315#define ISPRINT(c) rb_isprint(c)
16316#define ISGRAPH(c) rb_isgraph(c)
16317#define ISSPACE(c) rb_isspace(c)
16318#define ISUPPER(c) rb_isupper(c)
16319#define ISLOWER(c) rb_islower(c)
16320#define ISALNUM(c) rb_isalnum(c)
16321#define ISALPHA(c) rb_isalpha(c)
16322#define ISDIGIT(c) rb_isdigit(c)
16323#define ISXDIGIT(c) rb_isxdigit(c)
16324#define ISBLANK(c) rb_isblank(c)
16325#define ISCNTRL(c) rb_iscntrl(c)
16326#define ISPUNCT(c) rb_ispunct(c)
16327#define TOUPPER(c) rb_toupper(c)
16328#define TOLOWER(c) rb_tolower(c)
16329#define STRCASECMP(s1,s2) (st_locale_insensitive_strcasecmp((s1), (s2)))
16330#define STRNCASECMP(s1,s2,n) (st_locale_insensitive_strncasecmp((s1), (s2), (n)))
16331#define STRTOUL(str,endptr,base) (ruby_strtoul((str), (endptr), (base)))
16332#define InitVM(ext) {void InitVM_ ##ext(void);InitVM_ ##ext();}
16333#define rb_scan_args(argc,argvp,fmt,...) __builtin_choose_expr(__builtin_constant_p(fmt), rb_scan_args0(argc,argvp,fmt, (sizeof((VALUE*[]){__VA_ARGS__})/sizeof(VALUE*)), ((VALUE*[]){__VA_ARGS__})), rb_scan_args(argc,argvp,fmt, ##__VA_ARGS__))
16334#define rb_scan_args_isdigit(c) ((unsigned char)((c)-'0')<10)
16335#define rb_scan_args_count_end(fmt,ofs,vari) (fmt[ofs] ? -1 : (vari))
16336#define rb_scan_args_count_block(fmt,ofs,vari) (fmt[ofs]!='&' ? rb_scan_args_count_end(fmt, ofs, vari) : rb_scan_args_count_end(fmt, ofs+1, vari+1))
16337#define rb_scan_args_count_hash(fmt,ofs,vari) (fmt[ofs]!=':' ? rb_scan_args_count_block(fmt, ofs, vari) : rb_scan_args_count_block(fmt, ofs+1, vari+1))
16338#define rb_scan_args_count_trail(fmt,ofs,vari) (!rb_scan_args_isdigit(fmt[ofs]) ? rb_scan_args_count_hash(fmt, ofs, vari) : rb_scan_args_count_hash(fmt, ofs+1, vari+(fmt[ofs]-'0')))
16339#define rb_scan_args_count_var(fmt,ofs,vari) (fmt[ofs]!='*' ? rb_scan_args_count_trail(fmt, ofs, vari) : rb_scan_args_count_trail(fmt, ofs+1, vari+1))
16340#define rb_scan_args_count_opt(fmt,ofs,vari) (!rb_scan_args_isdigit(fmt[ofs]) ? rb_scan_args_count_var(fmt, ofs, vari) : rb_scan_args_count_var(fmt, ofs+1, vari+fmt[ofs]-'0'))
16341#define rb_scan_args_count_lead(fmt,ofs,vari) (!rb_scan_args_isdigit(fmt[ofs]) ? rb_scan_args_count_var(fmt, ofs, vari) : rb_scan_args_count_opt(fmt, ofs+1, vari+fmt[ofs]-'0'))
16342#define rb_scan_args_count(fmt) rb_scan_args_count_lead(fmt, 0, 0)
16343#define rb_scan_args_verify(fmt,varc) (sizeof(char[1-2*(rb_scan_args_count(fmt)<0)])!=1 ? rb_scan_args_bad_format(fmt) : sizeof(char[1-2*(rb_scan_args_count(fmt)!=(varc))])!=1 ? rb_scan_args_length_mismatch(fmt, varc) : (void)0)
16344#define rb_scan_args0(argc,argv,fmt,varc,vars) rb_scan_args_set(argc, argv, rb_scan_args_n_lead(fmt), rb_scan_args_n_opt(fmt), rb_scan_args_n_trail(fmt), rb_scan_args_f_var(fmt), rb_scan_args_f_hash(fmt), rb_scan_args_f_block(fmt), (rb_scan_args_verify(fmt, varc), vars), (char *)fmt, varc)
16345#define rb_yield_values(argc,...) __extension__({ const int rb_yield_values_argc = (argc); const VALUE rb_yield_values_args[] = {__VA_ARGS__}; const int rb_yield_values_nargs = (int)(sizeof(rb_yield_values_args) / sizeof(VALUE)); rb_yield_values2( rb_varargs_argc_check(rb_yield_values_argc, rb_yield_values_nargs), rb_yield_values_nargs ? rb_yield_values_args : NULL); })
16346#define rb_funcall(recv,mid,argc,...) __extension__({ const int rb_funcall_argc = (argc); const VALUE rb_funcall_args[] = {__VA_ARGS__}; const int rb_funcall_nargs = (int)(sizeof(rb_funcall_args) / sizeof(VALUE)); rb_funcallv(recv, mid, rb_varargs_argc_check(rb_funcall_argc, rb_funcall_nargs), rb_funcall_nargs ? rb_funcall_args : NULL); })
16347#define RUBY_SUBST_H 1
16350#define snprintf ruby_snprintf
16351#define vsnprintf ruby_vsnprintf
16352#define RUBY_INIT_STACK VALUE variable_in_this_stack_frame; ruby_init_stack(&variable_in_this_stack_frame);
16353#pragma GCC visibility pop
16354#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
16359#define __bool_true_false_are_defined 1
16360#define HALF_LONG_MSB ((SIGNED_VALUE)1<<((SIZEOF_LONG*CHAR_BIT-1)/2))
16361#define LIKELY(x) RB_LIKELY(x)
16362#define UNLIKELY(x) RB_UNLIKELY(x)
16363#define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) NO_SANITIZE("address", NOINLINE(x))
16365#define NO_SANITIZE(x,y) COMPILER_WARNING_PUSH; COMPILER_WARNING_IGNORED(-Wattributes); __attribute__((__no_sanitize__(x))) y; COMPILER_WARNING_POP
16366#define VALGRIND_MAKE_MEM_DEFINED(p,n) 0
16367#define VALGRIND_MAKE_MEM_UNDEFINED(p,n) 0
16368#define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
16369#define ACCESS_ONCE(type,x) (*((volatile type *)&(x)))
16370#define STATIC_ASSERT(name,expr) _Static_assert(expr, #name ": " #expr)
16371#define SIGNED_INTEGER_TYPE_P(int_type) (0 > ((int_type)0)-1)
16372#define SIGNED_INTEGER_MAX(sint_type) (sint_type) ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) | ((((sint_type)1) << (sizeof(sint_type) * CHAR_BIT - 2)) - 1))
16373#define SIGNED_INTEGER_MIN(sint_type) (-SIGNED_INTEGER_MAX(sint_type)-1)
16374#define UNSIGNED_INTEGER_MAX(uint_type) (~(uint_type)0)
16375#define TIMET_MAX SIGNED_INTEGER_MAX(time_t)
16376#define TIMET_MIN SIGNED_INTEGER_MIN(time_t)
16377#define TIMET_MAX_PLUS_ONE (2*(double)(TIMET_MAX/2+1))
16378#define MUL_OVERFLOW_P(a,b) __builtin_mul_overflow_p((a), (b), (__typeof__(a * b))0)
16379#define MUL_OVERFLOW_SIGNED_INTEGER_P(a,b,min,max) ( (a) == 0 ? 0 : (a) == -1 ? (b) < -(max) : (a) > 0 ? ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
16380#define MUL_OVERFLOW_FIXNUM_P(a,b) ({ struct { long fixnum : SIZEOF_LONG * CHAR_BIT - 1; } c; __builtin_mul_overflow_p((a), (b), c.fixnum); })
16381#define MUL_OVERFLOW_LONG_LONG_P(a,b) MUL_OVERFLOW_P(a, b)
16382#define MUL_OVERFLOW_LONG_P(a,b) MUL_OVERFLOW_P(a, b)
16383#define MUL_OVERFLOW_INT_P(a,b) MUL_OVERFLOW_P(a, b)
16384#define swap16(x) __builtin_bswap16(x)
16385#define swap32(x) __builtin_bswap32(x)
16386#define swap64(x) __builtin_bswap64(x)
16387#define DLONG int128_t
16388#define DL2NUM(x) (RB_FIXABLE(x) ? LONG2FIX(x) : rb_int128t2big(x))
16389#define bit_length(x) (unsigned int) (sizeof(x) <= SIZEOF_INT ? SIZEOF_INT * CHAR_BIT - nlz_int((unsigned int)(x)) : sizeof(x) <= SIZEOF_LONG ? SIZEOF_LONG * CHAR_BIT - nlz_long((unsigned long)(x)) : sizeof(x) <= SIZEOF_LONG_LONG ? SIZEOF_LONG_LONG * CHAR_BIT - nlz_long_long((unsigned LONG_LONG)(x)) : SIZEOF_INT128_T * CHAR_BIT - nlz_int128((uint128_t)(x)))
16390#define BDIGIT unsigned int
16391#define SIZEOF_BDIGIT SIZEOF_INT
16392#define BDIGIT_DBL unsigned LONG_LONG
16393#define BDIGIT_DBL_SIGNED LONG_LONG
16394#define PRI_BDIGIT_PREFIX ""
16395#define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX
16396#define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGIT
16397#define PRIdBDIGIT PRI_BDIGIT_PREFIX"d"
16398#define PRIiBDIGIT PRI_BDIGIT_PREFIX"i"
16399#define PRIoBDIGIT PRI_BDIGIT_PREFIX"o"
16400#define PRIuBDIGIT PRI_BDIGIT_PREFIX"u"
16401#define PRIxBDIGIT PRI_BDIGIT_PREFIX"x"
16402#define PRIXBDIGIT PRI_BDIGIT_PREFIX"X"
16403#define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d"
16404#define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i"
16405#define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o"
16406#define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u"
16407#define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x"
16408#define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X"
16409#define BIGNUM_EMBED_LEN_NUMBITS 3
16410#define BIGNUM_EMBED_LEN_MAX (SIZEOF_VALUE*RVALUE_EMBED_LEN_MAX/SIZEOF_ACTUAL_BDIGIT)
16411#define BIGNUM_SIGN_BIT ((VALUE)FL_USER1)
16412#define BIGNUM_SIGN(b) ((RBASIC(b)->flags & BIGNUM_SIGN_BIT) != 0)
16413#define BIGNUM_SET_SIGN(b,sign) ((sign) ? (RBASIC(b)->flags |= BIGNUM_SIGN_BIT) : (RBASIC(b)->flags &= ~BIGNUM_SIGN_BIT))
16414#define BIGNUM_POSITIVE_P(b) BIGNUM_SIGN(b)
16415#define BIGNUM_NEGATIVE_P(b) (!BIGNUM_SIGN(b))
16416#define BIGNUM_NEGATE(b) (RBASIC(b)->flags ^= BIGNUM_SIGN_BIT)
16417#define BIGNUM_EMBED_FLAG ((VALUE)FL_USER2)
16418#define BIGNUM_EMBED_LEN_MASK (~(~(VALUE)0U << BIGNUM_EMBED_LEN_NUMBITS) << BIGNUM_EMBED_LEN_SHIFT)
16419#define BIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3)
16420#define BIGNUM_LEN(b) ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? (size_t)((RBASIC(b)->flags >> BIGNUM_EMBED_LEN_SHIFT) & (BIGNUM_EMBED_LEN_MASK >> BIGNUM_EMBED_LEN_SHIFT)) : RBIGNUM(b)->as.heap.len)
16421#define BIGNUM_DIGITS(b) ((RBASIC(b)->flags & BIGNUM_EMBED_FLAG) ? RBIGNUM(b)->as.ary : RBIGNUM(b)->as.heap.digits)
16422#define BIGNUM_LENINT(b) rb_long2int(BIGNUM_LEN(b))
16423#define RBIGNUM(obj) (R_CAST(RBignum)(obj))
16424#define RRATIONAL(obj) (R_CAST(RRational)(obj))
16425#define RRATIONAL_SET_NUM(rat,n) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->num,(n))
16426#define RRATIONAL_SET_DEN(rat,d) RB_OBJ_WRITE((rat), &((struct RRational *)(rat))->den,(d))
16427#define RFLOAT(obj) (R_CAST(RFloat)(obj))
16428#define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
16429#define RCOMPLEX_SET_REAL(cmp,r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r))
16430#define RCOMPLEX_SET_IMAG(cmp,i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i))
16431#define RHASH_AR_TABLE_MAX_SIZE SIZEOF_VALUE
16432#define RHASH_LEV_MASK (FL_USER13 | FL_USER14 | FL_USER15 | FL_USER16 | FL_USER17 | FL_USER18 | FL_USER19)
16433#define RHASH_AR_TABLE_SIZE_RAW(h) ((unsigned int)((RBASIC(h)->flags & RHASH_AR_TABLE_SIZE_MASK) >> RHASH_AR_TABLE_SIZE_SHIFT))
16434#define RHASH_AR_TABLE_P(hash) (!FL_TEST_RAW((hash), RHASH_ST_TABLE_FLAG))
16435#define RHASH_AR_TABLE(hash) (RHASH(hash)->as.ar)
16436#define RHASH_ST_TABLE(hash) (RHASH(hash)->as.st)
16437#define RHASH(obj) (R_CAST(RHash)(obj))
16438#define RHASH_ST_SIZE(h) (RHASH_ST_TABLE(h)->num_entries)
16439#define RHASH_ST_TABLE_P(h) (!RHASH_AR_TABLE_P(h))
16440#define RHASH_ST_CLEAR(h) (FL_UNSET_RAW(h, RHASH_ST_TABLE_FLAG), RHASH(h)->as.ar = NULL)
16441#define RHASH_AR_TABLE_SIZE_MASK (VALUE)RHASH_AR_TABLE_SIZE_MASK
16442#define RHASH_AR_TABLE_SIZE_SHIFT RHASH_AR_TABLE_SIZE_SHIFT
16443#define RHASH_AR_TABLE_BOUND_MASK (VALUE)RHASH_AR_TABLE_BOUND_MASK
16444#define RHASH_AR_TABLE_BOUND_SHIFT RHASH_AR_TABLE_BOUND_SHIFT
16445#define RHASH_TRANSIENT_P(hash) FL_TEST_RAW((hash), RHASH_TRANSIENT_FLAG)
16446#define RHASH_SET_TRANSIENT_FLAG(h) FL_SET_RAW(h, RHASH_TRANSIENT_FLAG)
16447#define RHASH_UNSET_TRANSIENT_FLAG(h) FL_UNSET_RAW(h, RHASH_TRANSIENT_FLAG)
16450#define RHASH_IFNONE(h) (RHASH(h)->ifnone)
16451#define RHASH_SIZE(h) (RHASH_AR_TABLE_P(h) ? RHASH_AR_TABLE_SIZE_RAW(h) : RHASH_ST_SIZE(h))
16452#define RSTRUCT_EMBED_LEN_MAX RSTRUCT_EMBED_LEN_MAX
16453#define RSTRUCT_EMBED_LEN_MASK RSTRUCT_EMBED_LEN_MASK
16454#define RSTRUCT_EMBED_LEN_SHIFT RSTRUCT_EMBED_LEN_SHIFT
16455#define RSTRUCT_TRANSIENT_P(st) FL_TEST_RAW((obj), RSTRUCT_TRANSIENT_FLAG)
16456#define RSTRUCT_TRANSIENT_SET(st) FL_SET_RAW((st), RSTRUCT_TRANSIENT_FLAG)
16457#define RSTRUCT_TRANSIENT_UNSET(st) FL_UNSET_RAW((st), RSTRUCT_TRANSIENT_FLAG)
16462#define RSTRUCT_EMBED_LEN(st) (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT))
16463#define RSTRUCT_LEN(st) rb_struct_len(st)
16464#define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
16465#define RSTRUCT_CONST_PTR(st) rb_struct_const_ptr(st)
16466#define RSTRUCT_PTR(st) ((VALUE *)RSTRUCT_CONST_PTR(RB_OBJ_WB_UNPROTECT_FOR(STRUCT, st)))
16467#define RSTRUCT_SET(st,idx,v) RB_OBJ_WRITE(st, &RSTRUCT_CONST_PTR(st)[idx], (v))
16468#define RSTRUCT_GET(st,idx) (RSTRUCT_CONST_PTR(st)[idx])
16469#define RSTRUCT(obj) (R_CAST(RStruct)(obj))
16470#define SERIALT2NUM ULL2NUM
16471#define PRI_SERIALT_PREFIX PRI_LL_PREFIX
16472#define SIZEOF_SERIAL_T SIZEOF_LONG_LONG
16474#define RCLASS_EXT(c) (RCLASS(c)->ptr)
16475#define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
16476#define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
16477#define RCLASS_M_TBL(c) (RCLASS_EXT(c)->m_tbl)
16478#define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)
16479#define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)
16480#define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)
16481#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
16482#define RCLASS_SERIAL(c) (RCLASS(c)->class_serial)
16483#define RCLASS_INCLUDER(c) (RCLASS_EXT(c)->includer)
16484#define RCLASS_CLONED FL_USER6
16485#define RICLASS_IS_ORIGIN FL_USER5
16486#define RCLASS_REFINED_BY_ANY FL_USER7
16488#define IMEMO_DEBUG 0
16489#define IMEMO_MASK 0x0f
16490#define IMEMO_FL_USHIFT (FL_USHIFT + 4)
16491#define IMEMO_FL_USER0 FL_USER4
16492#define IMEMO_FL_USER1 FL_USER5
16493#define IMEMO_FL_USER2 FL_USER6
16494#define IMEMO_FL_USER3 FL_USER7
16495#define IMEMO_FL_USER4 FL_USER8
16496#define THROW_DATA_CONSUMED IMEMO_FL_USER0
16497#define THROW_DATA_P(err) RB_TYPE_P((VALUE)(err), T_IMEMO)
16498#define IFUNC_NEW(a,b,c) ((struct vm_ifunc *)rb_imemo_new(imemo_ifunc, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
16499#define rb_imemo_tmpbuf_auto_free_pointer() rb_imemo_new(imemo_tmpbuf, 0, 0, 0, 0)
16500#define RB_IMEMO_TMPBUF_PTR(v) ((void *)(((const struct rb_imemo_tmpbuf_struct *)(v))->ptr))
16501#define MEMO_V1_SET(m,v) RB_OBJ_WRITE((m), &(m)->v1, (v))
16502#define MEMO_V2_SET(m,v) RB_OBJ_WRITE((m), &(m)->v2, (v))
16503#define MEMO_CAST(m) ((struct MEMO *)m)
16504#define MEMO_NEW(a,b,c) ((struct MEMO *)rb_imemo_new(imemo_memo, (VALUE)(a), (VALUE)(b), (VALUE)(c), 0))
16505#define roomof(x,y) (((x) + (y) - 1) / (y))
16506#define type_roomof(x,y) roomof(sizeof(x), sizeof(y))
16507#define MEMO_FOR(type,value) ((type *)RARRAY_PTR(value))
16508#define NEW_MEMO_FOR(type,value) ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
16509#define NEW_PARTIAL_MEMO_FOR(type,value,member) ((value) = rb_ary_tmp_new_fill(type_roomof(type, VALUE)), rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), MEMO_FOR(type, value))
16510#define STRING_P(s) (RB_TYPE_P((s), T_STRING) && CLASS_OF(s) == rb_cString)
16511#define rb_cFixnum rb_cInteger
16512#define rb_cBignum rb_cInteger
16513#define NEW_CMP_OPT_MEMO(type,value) NEW_PARTIAL_MEMO_FOR(type, value, cmp_opt)
16514#define CMP_OPTIMIZABLE_BIT(type) (1U << TOKEN_PASTE(cmp_opt_,type))
16515#define CMP_OPTIMIZABLE(data,type) (((data).opt_inited & CMP_OPTIMIZABLE_BIT(type)) ? ((data).opt_methods & CMP_OPTIMIZABLE_BIT(type)) : (((data).opt_inited |= CMP_OPTIMIZABLE_BIT(type)), rb_method_basic_definition_p(TOKEN_PASTE(rb_c,type), id_cmp) && ((data).opt_methods |= CMP_OPTIMIZABLE_BIT(type))))
16516#define OPTIMIZED_CMP(a,b,data) ((FIXNUM_P(a) && FIXNUM_P(b) && CMP_OPTIMIZABLE(data, Fixnum)) ? (((long)a > (long)b) ? 1 : ((long)a < (long)b) ? -1 : 0) : (STRING_P(a) && STRING_P(b) && CMP_OPTIMIZABLE(data, String)) ? rb_str_cmp(a, b) : (RB_FLOAT_TYPE_P(a) && RB_FLOAT_TYPE_P(b) && CMP_OPTIMIZABLE(data, Float)) ? rb_float_cmp(a, b) : rb_cmpint(rb_funcallv(a, id_cmp, 1, &b), a, b))
16517#define ARRAY_DEBUG (0+RUBY_DEBUG)
16518#define RARRAY_PTR_IN_USE_FLAG FL_USER14
16519#define ARY_PTR_USING_P(ary) FL_TEST_RAW((ary), RARRAY_PTR_IN_USE_FLAG)
16520#define RARY_TRANSIENT_SET(ary) FL_SET_RAW((ary), RARRAY_TRANSIENT_FLAG);
16521#define RARY_TRANSIENT_UNSET(ary) FL_UNSET_RAW((ary), RARRAY_TRANSIENT_FLAG);
16522#define rb_ary_new_from_args(n,...) __extension__ ({ const VALUE args_to_new_ary[] = {__VA_ARGS__}; if (__builtin_constant_p(n)) { STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); } rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); })
16523#define rp(obj) rb_obj_info_dump_loc((VALUE)(obj), __FILE__, __LINE__, __func__)
16524#define rp_m(msg,obj) do { fprintf(stderr, "%s", (msg)); rb_obj_info_dump((VALUE)obj); } while (0)
16525#define bp() ruby_debug_breakpoint()
16526#define rb_raise_cstr(etype,mesg) rb_exc_raise(rb_exc_new_str(etype, rb_str_new_cstr(mesg)))
16527#define rb_raise_static(etype,mesg) rb_exc_raise(rb_exc_new_str(etype, rb_str_new_static(mesg, rb_strlen_lit(mesg))))
16528#define rb_name_err_raise_str(mesg,recv,name) rb_exc_raise(rb_name_err_new(mesg, recv, name))
16529#define rb_name_err_raise(mesg,recv,name) rb_name_err_raise_str(rb_fstring_cstr(mesg), (recv), (name))
16530#define rb_key_err_raise(mesg,recv,name) rb_exc_raise(rb_key_err_new(mesg, recv, name))
16531#define id_signo ruby_static_id_signo
16532#define id_status ruby_static_id_status
16533#pragma GCC visibility push(default)
16534#pragma GCC visibility pop
16535#define rb_sys_fail_path(path) rb_sys_fail_path_in(RUBY_FUNCTION_NAME_STRING, path)
16536#define rb_syserr_fail_path(err,path) rb_syserr_fail_path_in(RUBY_FUNCTION_NAME_STRING, (err), (path))
16537#define ruby_sized_xrealloc(ptr,new_size,old_size) ruby_xrealloc(ptr, new_size)
16538#define ruby_sized_xrealloc2(ptr,new_count,element_size,old_count) ruby_xrealloc2(ptr, new_count, element_size)
16539#define ruby_sized_xfree(ptr,size) ruby_xfree(ptr)
16540#define SIZED_REALLOC_N(var,type,n,old_n) REALLOC_N(var, type, n)
16543#define RB_NEWOBJ_OF(obj,type,klass,flags) type *(obj) = (type*)(((flags) & FL_WB_PROTECTED) ? rb_wb_protected_newobj_of(klass, (flags) & ~FL_WB_PROTECTED) : rb_wb_unprotected_newobj_of(klass, flags))
16544#define NEWOBJ_OF(obj,type,klass,flags) RB_NEWOBJ_OF(obj,type,klass,flags)
16545#define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h)
16546#pragma GCC visibility push(default)
16547#pragma GCC visibility pop
16548#define rb_io_fptr_finalize rb_io_fptr_finalize_internal
16549#define FIXNUM_POSITIVE_P(num) ((SIGNED_VALUE)(num) > (SIGNED_VALUE)INT2FIX(0))
16550#define FIXNUM_NEGATIVE_P(num) ((SIGNED_VALUE)(num) < 0)
16551#define FIXNUM_ZERO_P(num) ((num) == INT2FIX(0))
16552#define INT_NEGATIVE_P(x) (FIXNUM_P(x) ? FIXNUM_NEGATIVE_P(x) : BIGNUM_NEGATIVE_P(x))
16553#define FLOAT_ZERO_P(x) (RFLOAT_VALUE(x) == 0.0)
16554#define ROUND_DEFAULT RUBY_NUM_ROUND_HALF_UP
16555#define ROUND_TO(mode,even,up,down) ((mode) == RUBY_NUM_ROUND_HALF_EVEN ? even : (mode) == RUBY_NUM_ROUND_HALF_UP ? up : down)
16556#define ROUND_FUNC(mode,name) ROUND_TO(mode, name ##_half_even, name ##_half_up, name ##_half_down)
16557#define ROUND_CALL(mode,name,args) ROUND_TO(mode, name ##_half_even args, name ##_half_up args, name ##_half_down args)
16558#define RUBY_BIT_ROTL(v,n) (((v) << (n)) | ((v) >> ((sizeof(v) * 8) - n)))
16559#define RUBY_BIT_ROTR(v,n) (((v) >> (n)) | ((v) << ((sizeof(v) * 8) - n)))
16560#define rb_float_value(v) rb_float_value_inline(v)
16561#define rb_float_new(d) rb_float_new_inline(d)
16562#define RBASIC_CLEAR_CLASS(obj) memset(&(((struct RBasicRaw *)((VALUE)(obj)))->klass), 0, sizeof(VALUE))
16563#define RBASIC_SET_CLASS_RAW(obj,cls) memcpy(&((struct RBasicRaw *)((VALUE)(obj)))->klass, &(cls), sizeof(VALUE))
16564#define RBASIC_SET_CLASS(obj,cls) do { VALUE _obj_ = (obj); RB_OBJ_WRITE(_obj_, &((struct RBasicRaw *)(_obj_))->klass, cls); } while (0)
16565#define USE_SYMBOL_GC 1
16566#pragma GCC visibility push(default)
16567#pragma GCC visibility pop
16568#define RB_MAX_GROUPS (65536)
16569#define ARGVSTR2ARGV(argv_str) ((char **)RB_IMEMO_TMPBUF_PTR(argv_str) + 1)
16570#define RANGE_BEG(r) (RSTRUCT(r)->as.ary[0])
16571#define RANGE_END(r) (RSTRUCT(r)->as.ary[1])
16572#define RANGE_EXCL(r) (RSTRUCT(r)->as.ary[2])
16573#define rb_fstring_lit(str) rb_fstring_new((str), rb_strlen_lit(str))
16574#define rb_fstring_literal(str) rb_fstring_lit(str)
16575#define rb_fstring_cstr(str) RB_GNUC_EXTENSION_BLOCK( (__builtin_constant_p(str)) ? rb_fstring_new((str), (long)strlen(str)) : rb_fstring_cstr(str) )
16576#define QUOTE(str) rb_str_quote_unprintable(str)
16577#define QUOTE_ID(id) rb_id_quote_unprintable(id)
16578#define STR_NOEMBED FL_USER1
16579#define STR_SHARED FL_USER2
16580#define STR_EMBED_P(str) (!FL_TEST_RAW((str), STR_NOEMBED))
16581#define STR_SHARED_P(s) FL_ALL_RAW((s), STR_NOEMBED|ELTS_SHARED)
16582#define is_ascii_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT)
16583#define is_broken_string(str) (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN)
16584#define rb_sym_intern_ascii_cstr(ptr) __extension__ ( { (__builtin_constant_p(ptr)) ? rb_sym_intern_ascii((ptr), (long)strlen(ptr)) : rb_sym_intern_ascii_cstr(ptr); })
16585#define COVERAGE_INDEX_LINES 0
16586#define COVERAGE_INDEX_BRANCHES 1
16587#define COVERAGE_TARGET_LINES 1
16588#define COVERAGE_TARGET_BRANCHES 2
16589#define COVERAGE_TARGET_METHODS 4
16590#define COVERAGE_TARGET_ONESHOT_LINES 8
16591#define ROBJECT_TRANSIENT_FLAG FL_USER13
16592#define ROBJ_TRANSIENT_P(obj) FL_TEST_RAW((obj), ROBJECT_TRANSIENT_FLAG)
16593#define ROBJ_TRANSIENT_SET(obj) FL_SET_RAW((obj), ROBJECT_TRANSIENT_FLAG)
16594#define ROBJ_TRANSIENT_UNSET(obj) FL_UNSET_RAW((obj), ROBJECT_TRANSIENT_FLAG)
16595#define CACHELINE 64
16596#define rb_funcallv(recv,mid,argc,argv) __extension__({ static struct rb_call_data rb_funcallv_data; rb_funcallv_with_cc(&rb_funcallv_data, recv, mid, argc, argv); })
16597#define rb_method_basic_definition_p(klass,mid) __extension__({ static struct rb_call_data rb_mbdp; (klass == Qfalse) ? true : rb_method_basic_definition_p_with_cc(&rb_mbdp, klass, mid); })
16598#pragma GCC visibility push(default)
16600#define Check_Type(v,t) (!RB_TYPE_P((VALUE)(v), (t)) || ((t) == RUBY_T_DATA && RTYPEDDATA_P(v)) ? rb_unexpected_type((VALUE)(v), (t)) : (void)0)
16601#define rb_typeddata_is_instance_of rb_typeddata_is_instance_of_inline
16602#define RB_OBJ_GC_FLAGS_MAX 6
16603#pragma GCC visibility pop
16604#define RUBY_DTRACE_CREATE_HOOK(name,arg) RUBY_DTRACE_HOOK(name ##_CREATE, arg)
16605#define RUBY_DTRACE_HOOK(name,arg) do { if (UNLIKELY(RUBY_DTRACE_ ##name ##_ENABLED())) { int dtrace_line; const char *dtrace_file = rb_source_location_cstr(&dtrace_line); if (!dtrace_file) dtrace_file = ""; RUBY_DTRACE_ ##name(arg, dtrace_file, dtrace_line); } } while (0)
16606#define RB_OBJ_BUILTIN_TYPE(obj) rb_obj_builtin_type(obj)
16607#define OBJ_BUILTIN_TYPE(obj) RB_OBJ_BUILTIN_TYPE(obj)
16608#define rb_obj_builtin_type(obj) __extension__({ VALUE arg_obj = (obj); RB_SPECIAL_CONST_P(arg_obj) ? -1 : RB_BUILTIN_TYPE(arg_obj); })
16609#define FLEX_ARY_LEN
16610#define BITFIELD(type,name,size) type name : size
16611#define COMPILER_WARNING_PUSH _Pragma("GCC diagnostic push")
16612#define COMPILER_WARNING_POP _Pragma("GCC diagnostic pop")
16613#define COMPILER_WARNING_SPECIFIER(kind,msg) GCC diagnostic kind #msg
16614#define COMPILER_WARNING_ERROR(flag) COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(error, flag))
16615#define COMPILER_WARNING_IGNORED(flag) COMPILER_WARNING_PRAGMA(COMPILER_WARNING_SPECIFIER(ignored, flag))
16616#define COMPILER_WARNING_PRAGMA(str) COMPILER_WARNING_PRAGMA_(str)
16617#define COMPILER_WARNING_PRAGMA_(str) _Pragma(#str)
16618#define UNALIGNED_MEMBER_ACCESS(expr) __extension__({ COMPILER_WARNING_PUSH; COMPILER_WARNING_IGNORED(-Waddress-of-packed-member); typeof(expr) unaligned_member_access_result = (expr); COMPILER_WARNING_POP; unaligned_member_access_result; })
16619#define UNALIGNED_MEMBER_PTR(ptr,mem) UNALIGNED_MEMBER_ACCESS(&(ptr)->mem)
16621#define RB_OBJ_WRITE(a,slot,b) UNALIGNED_MEMBER_ACCESS(rb_obj_write((VALUE)(a), (VALUE *)(slot), (VALUE)(b), __FILE__, __LINE__))
16623#pragma GCC visibility push(default)
16624#pragma GCC visibility pop
16625#define vm_exec rb_vm_exec
16627#define SET_MACHINE_STACK_END(p) __asm__ __volatile__ ("movq\t%%rsp, %0" : "=r" (*(p)))
16628#define RUBY_MARK_FREE_DEBUG 0
16629#define RUBY_MARK_ENTER(msg)
16630#define RUBY_MARK_LEAVE(msg)
16631#define RUBY_FREE_ENTER(msg)
16632#define RUBY_FREE_LEAVE(msg)
16633#define RUBY_GC_INFO if(0)printf
16634#define RUBY_MARK_NO_PIN_UNLESS_NULL(ptr) do { VALUE markobj = (ptr); if (RTEST(markobj)) {rb_gc_mark_movable(markobj);} } while (0)
16635#define RUBY_MARK_UNLESS_NULL(ptr) do { VALUE markobj = (ptr); if (RTEST(markobj)) {rb_gc_mark(markobj);} } while (0)
16636#define RUBY_FREE_UNLESS_NULL(ptr) if(ptr){ruby_xfree(ptr);(ptr)=NULL;}
16637#define STACK_UPPER(x,a,b) (b)
16638#define STACK_GROW_DIR_DETECTION
16639#define STACK_DIR_UPPER(a,b) STACK_UPPER(0, (a), (b))
16640#define IS_STACK_DIR_UPPER() STACK_DIR_UPPER(1,0)
16641#pragma GCC visibility push(default)
16642#pragma GCC visibility pop
16643#define RUBY_VM_CORE_H
16644#define N_OR_RUBY_DEBUG(n) (((n) > 0) ? (n) : RUBY_DEBUG)
16645#define VM_CHECK_MODE N_OR_RUBY_DEBUG(0)
16648#define assert RUBY_ASSERT
16649#define VM_ASSERT(expr) ((void)0)
16650#define VM_UNREACHABLE(func) UNREACHABLE
16651#define RUBY_VM_THREAD_MODEL 2
16652#define VM_INSN_INFO_TABLE_IMPL 2
16653#define RUBY_NODE_H 1
16654#define RNODE(obj) (R_CAST(RNode)(obj))
16655#define NODE_FL_NEWLINE (((VALUE)1)<<7)
16656#define NODE_TYPESHIFT 8
16657#define NODE_TYPEMASK (((VALUE)0x7f)<<NODE_TYPESHIFT)
16658#define nd_type(n) ((int) (((n)->flags & NODE_TYPEMASK)>>NODE_TYPESHIFT))
16659#define nd_set_type(n,t) (n)->flags=(((n)->flags&~NODE_TYPEMASK)|((((unsigned long)(t))<<NODE_TYPESHIFT)&NODE_TYPEMASK))
16660#define NODE_LSHIFT (NODE_TYPESHIFT+7)
16661#define NODE_LMASK (((SIGNED_VALUE)1<<(sizeof(VALUE)*CHAR_BIT-NODE_LSHIFT))-1)
16662#define nd_line(n) (int)(((SIGNED_VALUE)(n)->flags)>>NODE_LSHIFT)
16663#define nd_set_line(n,l) (n)->flags=(((n)->flags&~((VALUE)(-1)<<NODE_LSHIFT))|((VALUE)((l)&NODE_LMASK)<<NODE_LSHIFT))
16664#define nd_first_column(n) ((int)((n)->nd_loc.beg_pos.column))
16665#define nd_set_first_column(n,v) ((n)->nd_loc.beg_pos.column = (v))
16666#define nd_first_lineno(n) ((int)((n)->nd_loc.beg_pos.lineno))
16667#define nd_set_first_lineno(n,v) ((n)->nd_loc.beg_pos.lineno = (v))
16668#define nd_first_loc(n) ((n)->nd_loc.beg_pos)
16669#define nd_set_first_loc(n,v) (nd_first_loc(n) = (v))
16670#define nd_last_column(n) ((int)((n)->nd_loc.end_pos.column))
16671#define nd_set_last_column(n,v) ((n)->nd_loc.end_pos.column = (v))
16672#define nd_last_lineno(n) ((int)((n)->nd_loc.end_pos.lineno))
16673#define nd_set_last_lineno(n,v) ((n)->nd_loc.end_pos.lineno = (v))
16674#define nd_last_loc(n) ((n)->nd_loc.end_pos)
16675#define nd_set_last_loc(n,v) (nd_last_loc(n) = (v))
16676#define nd_node_id(n) ((n)->node_id)
16677#define nd_set_node_id(n,id) ((n)->node_id = (id))
16678#define nd_head u1.node
16679#define nd_alen u2.argc
16680#define nd_next u3.node
16681#define nd_cond u1.node
16682#define nd_body u2.node
16683#define nd_else u3.node
16684#define nd_resq u2.node
16685#define nd_ensr u3.node
16686#define nd_1st u1.node
16687#define nd_2nd u2.node
16688#define nd_stts u1.node
16689#define nd_entry u3.entry
16690#define nd_vid u1.id
16691#define nd_cflag u2.id
16692#define nd_cval u3.value
16693#define nd_oid u1.id
16694#define nd_tbl u1.tbl
16695#define nd_var u1.node
16696#define nd_iter u3.node
16697#define nd_value u2.node
16698#define nd_aid u3.id
16699#define nd_lit u1.value
16700#define nd_rest u1.id
16701#define nd_opt u1.node
16702#define nd_pid u1.id
16703#define nd_plen u2.argc
16704#define nd_recv u1.node
16705#define nd_mid u2.id
16706#define nd_args u3.node
16707#define nd_ainfo u3.args
16708#define nd_defn u3.node
16709#define nd_cpath u1.node
16710#define nd_super u3.node
16711#define nd_beg u1.node
16712#define nd_end u2.node
16713#define nd_state u3.state
16714#define nd_rval u2.value
16715#define nd_nth u2.argc
16716#define nd_tag u1.id
16717#define nd_alias u1.id
16718#define nd_orig u2.id
16719#define nd_undef u2.node
16720#define nd_brace u2.argc
16721#define nd_pconst u1.node
16722#define nd_pkwargs u2.node
16723#define nd_pkwrestarg u3.node
16724#define nd_apinfo u3.apinfo
16725#define NEW_NODE(t,a0,a1,a2,loc) rb_node_newnode((t),(VALUE)(a0),(VALUE)(a1),(VALUE)(a2),loc)
16726#define NEW_NODE_WITH_LOCALS(t,a1,a2,loc) node_newnode_with_locals(p, (t),(VALUE)(a1),(VALUE)(a2),loc)
16727#define NEW_DEFN(i,a,d,loc) NEW_NODE(NODE_DEFN,0,i,NEW_SCOPE(a,d,loc),loc)
16728#define NEW_DEFS(r,i,a,d,loc) NEW_NODE(NODE_DEFS,r,i,NEW_SCOPE(a,d,loc),loc)
16729#define NEW_SCOPE(a,b,loc) NEW_NODE_WITH_LOCALS(NODE_SCOPE,b,a,loc)
16730#define NEW_BLOCK(a,loc) NEW_NODE(NODE_BLOCK,a,0,0,loc)
16731#define NEW_IF(c,t,e,loc) NEW_NODE(NODE_IF,c,t,e,loc)
16732#define NEW_UNLESS(c,t,e,loc) NEW_NODE(NODE_UNLESS,c,t,e,loc)
16733#define NEW_CASE(h,b,loc) NEW_NODE(NODE_CASE,h,b,0,loc)
16734#define NEW_CASE2(b,loc) NEW_NODE(NODE_CASE2,0,b,0,loc)
16735#define NEW_CASE3(h,b,loc) NEW_NODE(NODE_CASE3,h,b,0,loc)
16736#define NEW_WHEN(c,t,e,loc) NEW_NODE(NODE_WHEN,c,t,e,loc)
16737#define NEW_IN(c,t,e,loc) NEW_NODE(NODE_IN,c,t,e,loc)
16738#define NEW_WHILE(c,b,n,loc) NEW_NODE(NODE_WHILE,c,b,n,loc)
16739#define NEW_UNTIL(c,b,n,loc) NEW_NODE(NODE_UNTIL,c,b,n,loc)
16740#define NEW_FOR(i,b,loc) NEW_NODE(NODE_FOR,0,b,i,loc)
16741#define NEW_FOR_MASGN(v,loc) NEW_NODE(NODE_FOR_MASGN,v,0,0,loc)
16742#define NEW_ITER(a,b,loc) NEW_NODE(NODE_ITER,0,NEW_SCOPE(a,b,loc),0,loc)
16743#define NEW_LAMBDA(a,b,loc) NEW_NODE(NODE_LAMBDA,0,NEW_SCOPE(a,b,loc),0,loc)
16744#define NEW_BREAK(s,loc) NEW_NODE(NODE_BREAK,s,0,0,loc)
16745#define NEW_NEXT(s,loc) NEW_NODE(NODE_NEXT,s,0,0,loc)
16746#define NEW_REDO(loc) NEW_NODE(NODE_REDO,0,0,0,loc)
16747#define NEW_RETRY(loc) NEW_NODE(NODE_RETRY,0,0,0,loc)
16748#define NEW_BEGIN(b,loc) NEW_NODE(NODE_BEGIN,0,b,0,loc)
16749#define NEW_RESCUE(b,res,e,loc) NEW_NODE(NODE_RESCUE,b,res,e,loc)
16750#define NEW_RESBODY(a,ex,n,loc) NEW_NODE(NODE_RESBODY,n,ex,a,loc)
16751#define NEW_ENSURE(b,en,loc) NEW_NODE(NODE_ENSURE,b,0,en,loc)
16752#define NEW_RETURN(s,loc) NEW_NODE(NODE_RETURN,s,0,0,loc)
16753#define NEW_YIELD(a,loc) NEW_NODE(NODE_YIELD,a,0,0,loc)
16754#define NEW_LIST(a,loc) NEW_NODE(NODE_LIST,a,1,0,loc)
16755#define NEW_ZLIST(loc) NEW_NODE(NODE_ZLIST,0,0,0,loc)
16756#define NEW_HASH(a,loc) NEW_NODE(NODE_HASH,a,0,0,loc)
16757#define NEW_MASGN(l,r,loc) NEW_NODE(NODE_MASGN,l,0,r,loc)
16758#define NEW_GASGN(v,val,loc) NEW_NODE(NODE_GASGN,v,val,rb_global_entry(v),loc)
16759#define NEW_LASGN(v,val,loc) NEW_NODE(NODE_LASGN,v,val,0,loc)
16760#define NEW_DASGN(v,val,loc) NEW_NODE(NODE_DASGN,v,val,0,loc)
16761#define NEW_DASGN_CURR(v,val,loc) NEW_NODE(NODE_DASGN_CURR,v,val,0,loc)
16762#define NEW_IASGN(v,val,loc) NEW_NODE(NODE_IASGN,v,val,0,loc)
16763#define NEW_CDECL(v,val,path,loc) NEW_NODE(NODE_CDECL,v,val,path,loc)
16764#define NEW_CVASGN(v,val,loc) NEW_NODE(NODE_CVASGN,v,val,0,loc)
16765#define NEW_OP_ASGN1(p,id,a,loc) NEW_NODE(NODE_OP_ASGN1,p,id,a,loc)
16766#define NEW_OP_ASGN2(r,t,i,o,val,loc) NEW_NODE(NODE_OP_ASGN2,r,val,NEW_OP_ASGN22(i,o,t,loc),loc)
16767#define NEW_OP_ASGN22(i,o,t,loc) NEW_NODE(NODE_OP_ASGN2,i,o,t,loc)
16768#define NEW_OP_ASGN_OR(i,val,loc) NEW_NODE(NODE_OP_ASGN_OR,i,val,0,loc)
16769#define NEW_OP_ASGN_AND(i,val,loc) NEW_NODE(NODE_OP_ASGN_AND,i,val,0,loc)
16770#define NEW_OP_CDECL(v,op,val,loc) NEW_NODE(NODE_OP_CDECL,v,val,op,loc)
16771#define NEW_GVAR(v,loc) NEW_NODE(NODE_GVAR,v,0,rb_global_entry(v),loc)
16772#define NEW_LVAR(v,loc) NEW_NODE(NODE_LVAR,v,0,0,loc)
16773#define NEW_DVAR(v,loc) NEW_NODE(NODE_DVAR,v,0,0,loc)
16774#define NEW_IVAR(v,loc) NEW_NODE(NODE_IVAR,v,0,0,loc)
16775#define NEW_CONST(v,loc) NEW_NODE(NODE_CONST,v,0,0,loc)
16776#define NEW_CVAR(v,loc) NEW_NODE(NODE_CVAR,v,0,0,loc)
16777#define NEW_NTH_REF(n,loc) NEW_NODE(NODE_NTH_REF,0,n,0,loc)
16778#define NEW_BACK_REF(n,loc) NEW_NODE(NODE_BACK_REF,0,n,0,loc)
16779#define NEW_MATCH(c,loc) NEW_NODE(NODE_MATCH,c,0,0,loc)
16780#define NEW_MATCH2(n1,n2,loc) NEW_NODE(NODE_MATCH2,n1,n2,0,loc)
16781#define NEW_MATCH3(r,n2,loc) NEW_NODE(NODE_MATCH3,r,n2,0,loc)
16782#define NEW_LIT(l,loc) NEW_NODE(NODE_LIT,l,0,0,loc)
16783#define NEW_STR(s,loc) NEW_NODE(NODE_STR,s,0,0,loc)
16784#define NEW_DSTR(s,loc) NEW_NODE(NODE_DSTR,s,1,0,loc)
16785#define NEW_XSTR(s,loc) NEW_NODE(NODE_XSTR,s,0,0,loc)
16786#define NEW_DXSTR(s,loc) NEW_NODE(NODE_DXSTR,s,0,0,loc)
16787#define NEW_DSYM(s,loc) NEW_NODE(NODE_DSYM,s,0,0,loc)
16788#define NEW_EVSTR(n,loc) NEW_NODE(NODE_EVSTR,0,(n),0,loc)
16789#define NEW_CALL(r,m,a,loc) NEW_NODE(NODE_CALL,r,m,a,loc)
16790#define NEW_OPCALL(r,m,a,loc) NEW_NODE(NODE_OPCALL,r,m,a,loc)
16791#define NEW_FCALL(m,a,loc) NEW_NODE(NODE_FCALL,0,m,a,loc)
16792#define NEW_VCALL(m,loc) NEW_NODE(NODE_VCALL,0,m,0,loc)
16793#define NEW_SUPER(a,loc) NEW_NODE(NODE_SUPER,0,0,a,loc)
16794#define NEW_ZSUPER(loc) NEW_NODE(NODE_ZSUPER,0,0,0,loc)
16795#define NEW_ARGS_AUX(r,b,loc) NEW_NODE(NODE_ARGS_AUX,r,b,0,loc)
16796#define NEW_OPT_ARG(i,v,loc) NEW_NODE(NODE_OPT_ARG,i,v,0,loc)
16797#define NEW_KW_ARG(i,v,loc) NEW_NODE(NODE_KW_ARG,i,v,0,loc)
16798#define NEW_POSTARG(i,v,loc) NEW_NODE(NODE_POSTARG,i,v,0,loc)
16799#define NEW_ARGSCAT(a,b,loc) NEW_NODE(NODE_ARGSCAT,a,b,0,loc)
16800#define NEW_ARGSPUSH(a,b,loc) NEW_NODE(NODE_ARGSPUSH,a,b,0,loc)
16801#define NEW_SPLAT(a,loc) NEW_NODE(NODE_SPLAT,a,0,0,loc)
16802#define NEW_BLOCK_PASS(b,loc) NEW_NODE(NODE_BLOCK_PASS,0,b,0,loc)
16803#define NEW_ALIAS(n,o,loc) NEW_NODE(NODE_ALIAS,n,o,0,loc)
16804#define NEW_VALIAS(n,o,loc) NEW_NODE(NODE_VALIAS,n,o,0,loc)
16805#define NEW_UNDEF(i,loc) NEW_NODE(NODE_UNDEF,0,i,0,loc)
16806#define NEW_CLASS(n,b,s,loc) NEW_NODE(NODE_CLASS,n,NEW_SCOPE(0,b,loc),(s),loc)
16807#define NEW_SCLASS(r,b,loc) NEW_NODE(NODE_SCLASS,r,NEW_SCOPE(0,b,loc),0,loc)
16808#define NEW_MODULE(n,b,loc) NEW_NODE(NODE_MODULE,n,NEW_SCOPE(0,b,loc),0,loc)
16809#define NEW_COLON2(c,i,loc) NEW_NODE(NODE_COLON2,c,i,0,loc)
16810#define NEW_COLON3(i,loc) NEW_NODE(NODE_COLON3,0,i,0,loc)
16811#define NEW_DOT2(b,e,loc) NEW_NODE(NODE_DOT2,b,e,0,loc)
16812#define NEW_DOT3(b,e,loc) NEW_NODE(NODE_DOT3,b,e,0,loc)
16813#define NEW_SELF(loc) NEW_NODE(NODE_SELF,0,0,1,loc)
16814#define NEW_NIL(loc) NEW_NODE(NODE_NIL,0,0,0,loc)
16815#define NEW_TRUE(loc) NEW_NODE(NODE_TRUE,0,0,0,loc)
16816#define NEW_FALSE(loc) NEW_NODE(NODE_FALSE,0,0,0,loc)
16817#define NEW_ERRINFO(loc) NEW_NODE(NODE_ERRINFO,0,0,0,loc)
16818#define NEW_DEFINED(e,loc) NEW_NODE(NODE_DEFINED,e,0,0,loc)
16819#define NEW_PREEXE(b,loc) NEW_SCOPE(b,loc)
16820#define NEW_POSTEXE(b,loc) NEW_NODE(NODE_POSTEXE,0,b,0,loc)
16821#define NEW_ATTRASGN(r,m,a,loc) NEW_NODE(NODE_ATTRASGN,r,m,a,loc)
16822#define NODE_SPECIAL_REQUIRED_KEYWORD ((NODE *)-1)
16823#define NODE_REQUIRED_KEYWORD_P(node) ((node)->nd_value == NODE_SPECIAL_REQUIRED_KEYWORD)
16824#define NODE_SPECIAL_NO_NAME_REST ((NODE *)-1)
16825#define NODE_NAMED_REST_P(node) ((node) != NODE_SPECIAL_NO_NAME_REST)
16826#define NODE_SPECIAL_EXCESSIVE_COMMA ((ID)1)
16827#define NODE_SPECIAL_NO_REST_KEYWORD ((NODE *)-1)
16828#pragma GCC visibility push(default)
16829#pragma GCC visibility pop
16830#define RUBY_VM_OPTS_H
16831#define OPT_TAILCALL_OPTIMIZATION 0
16832#define OPT_PEEPHOLE_OPTIMIZATION 1
16833#define OPT_SPECIALISED_INSTRUCTION 1
16834#define OPT_INLINE_CONST_CACHE 1
16835#define OPT_FROZEN_STRING_LITERAL 0
16836#define OPT_DEBUG_FROZEN_STRING_LITERAL 0
16837#define OPT_THREADED_CODE 0
16838#define OPT_DIRECT_THREADED_CODE (OPT_THREADED_CODE == 0)
16839#define OPT_TOKEN_THREADED_CODE (OPT_THREADED_CODE == 1)
16840#define OPT_CALL_THREADED_CODE (OPT_THREADED_CODE == 2)
16841#define OPT_CHECKED_RUN 1
16842#define OPT_INLINE_METHOD_CACHE 1
16843#define OPT_GLOBAL_METHOD_CACHE 1
16844#define OPT_BLOCKINLINING 0
16845#define OPT_IC_FOR_IVAR 1
16846#define OPT_OPERANDS_UNIFICATION 1
16847#define OPT_INSTRUCTIONS_UNIFICATION 0
16848#define OPT_UNIFY_ALL_COMBINATION 0
16849#define OPT_STACK_CACHING 0
16850#define OPT_SUPPORT_JOKE 0
16851#define VM_COLLECT_USAGE_DETAILS 0
16853#define ID_STATIC_SYM RUBY_ID_STATIC_SYM
16854#define ID_SCOPE_SHIFT RUBY_ID_SCOPE_SHIFT
16855#define ID_SCOPE_MASK RUBY_ID_SCOPE_MASK
16856#define ID_LOCAL RUBY_ID_LOCAL
16857#define ID_INSTANCE RUBY_ID_INSTANCE
16858#define ID_GLOBAL RUBY_ID_GLOBAL
16859#define ID_ATTRSET RUBY_ID_ATTRSET
16860#define ID_CONST RUBY_ID_CONST
16861#define ID_CLASS RUBY_ID_CLASS
16862#define ID_JUNK RUBY_ID_JUNK
16863#define ID_INTERNAL RUBY_ID_INTERNAL
16864#define symIFUNC ID2SYM(idIFUNC)
16865#define symCFUNC ID2SYM(idCFUNC)
16866#define RUBY_TOKEN_DOT2 128
16867#define RUBY_TOKEN_DOT3 129
16868#define RUBY_TOKEN_BDOT2 130
16869#define RUBY_TOKEN_BDOT3 131
16870#define RUBY_TOKEN_UPLUS 132
16871#define RUBY_TOKEN_UMINUS 133
16872#define RUBY_TOKEN_POW 134
16873#define RUBY_TOKEN_CMP 135
16874#define RUBY_TOKEN_LSHFT 136
16875#define RUBY_TOKEN_RSHFT 137
16876#define RUBY_TOKEN_LEQ 138
16877#define RUBY_TOKEN_GEQ 139
16878#define RUBY_TOKEN_EQ 140
16879#define RUBY_TOKEN_EQQ 141
16880#define RUBY_TOKEN_NEQ 142
16881#define RUBY_TOKEN_MATCH 143
16882#define RUBY_TOKEN_NMATCH 144
16883#define RUBY_TOKEN_AREF 145
16884#define RUBY_TOKEN_ASET 146
16885#define RUBY_TOKEN_COLON2 147
16886#define RUBY_TOKEN_ANDOP 148
16887#define RUBY_TOKEN_OROP 149
16888#define RUBY_TOKEN_ANDDOT 150
16889#define RUBY_TOKEN(t) RUBY_TOKEN_ ##t
16890#define RUBY_TOKEN2ID_TYPE(tok,type) ((tok<<RUBY_ID_SCOPE_SHIFT)|type|RUBY_ID_STATIC_SYM)
16891#define TOKEN2LOCALID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_LOCAL)
16892#define TOKEN2INSTANCEID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_INSTANCE)
16893#define TOKEN2GLOBALID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_GLOBAL)
16894#define TOKEN2CONSTID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_CONST)
16895#define TOKEN2CLASSID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_CLASS)
16896#define TOKEN2ATTRSETID(tok) RUBY_TOKEN2ID_TYPE(tok, RUBY_ID_ATTRSET)
16897#define DEFINE_LOCALID_FROM_TOKEN(n) id ##n = TOKEN2LOCALID(t ##n)
16898#define DEFINE_INSTANCEID_FROM_TOKEN(n) id ##n = TOKEN2INSTANCEID(t ##n)
16899#define DEFINE_GLOBALID_FROM_TOKEN(n) id ##n = TOKEN2GLOBALID(t ##n)
16900#define DEFINE_CONSTID_FROM_TOKEN(n) id ##n = TOKEN2CONSTID(t ##n)
16901#define DEFINE_CLASSID_FROM_TOKEN(n) id ##n = TOKEN2CLASSID(t ##n)
16902#define DEFINE_ATTRSETID_FROM_TOKEN(n) id ##n = TOKEN2ATTRSETID(t ##n)
16903#define RUBY_METHOD_H 1
16904#define END_OF_ENUMERATION(key)
16905#define METHOD_ENTRY_VISI(me) (rb_method_visibility_t)(((me)->flags & (IMEMO_FL_USER0 | IMEMO_FL_USER1)) >> (IMEMO_FL_USHIFT+0))
16906#define METHOD_ENTRY_BASIC(me) (int) (((me)->flags & (IMEMO_FL_USER2 )) >> (IMEMO_FL_USHIFT+2))
16907#define METHOD_ENTRY_COMPLEMENTED(me) ((me)->flags & IMEMO_FL_USER3)
16908#define METHOD_ENTRY_COMPLEMENTED_SET(me) ((me)->flags = (me)->flags | IMEMO_FL_USER3)
16909#define VM_METHOD_TYPE_MINIMUM_BITS 4
16910#define rb_iseq_t rb_iseq_t
16911#define UNDEFINED_METHOD_ENTRY_P(me) (!(me) || !(me)->def || (me)->def->type == VM_METHOD_TYPE_UNDEF)
16912#define UNDEFINED_REFINED_METHOD_P(def) ((def)->type == VM_METHOD_TYPE_REFINED && UNDEFINED_METHOD_ENTRY_P((def)->body.refined.orig_me))
16913#pragma GCC visibility push(default)
16914#pragma GCC visibility pop
16915#define RUBY_ATOMIC_H
16916#define ATOMIC_SET(var,val) (void)__atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
16917#define ATOMIC_INC(var) __atomic_fetch_add(&(var), 1, __ATOMIC_SEQ_CST)
16918#define ATOMIC_DEC(var) __atomic_fetch_sub(&(var), 1, __ATOMIC_SEQ_CST)
16919#define ATOMIC_OR(var,val) __atomic_fetch_or(&(var), (val), __ATOMIC_SEQ_CST)
16920#define ATOMIC_EXCHANGE(var,val) __atomic_exchange_n(&(var), (val), __ATOMIC_SEQ_CST)
16921#define ATOMIC_CAS(var,oldval,newval) ({ __typeof__(var) oldvaldup = (oldval); __atomic_compare_exchange_n(&(var), &oldvaldup, (newval), 0, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); oldvaldup; })
16922#define ATOMIC_SIZE_ADD(var,val) __atomic_fetch_add(&(var), (val), __ATOMIC_SEQ_CST)
16923#define ATOMIC_SIZE_SUB(var,val) __atomic_fetch_sub(&(var), (val), __ATOMIC_SEQ_CST)
16924#define RUBY_ATOMIC_GENERIC_MACRO 1
16925#define ATOMIC_SIZE_INC(var) ATOMIC_INC(var)
16926#define ATOMIC_SIZE_DEC(var) ATOMIC_DEC(var)
16927#define ATOMIC_SIZE_EXCHANGE(var,val) ATOMIC_EXCHANGE(var, val)
16928#define ATOMIC_SIZE_CAS(var,oldval,val) ATOMIC_CAS(var, oldval, val)
16929#define ATOMIC_PTR_EXCHANGE(var,val) ATOMIC_EXCHANGE(var, val)
16930#define ATOMIC_PTR_CAS(var,oldval,newval) ATOMIC_CAS(var, oldval, newval)
16931#define ATOMIC_VALUE_EXCHANGE(var,val) ATOMIC_EXCHANGE(var, val)
16932#define ATOMIC_VALUE_CAS(var,oldval,val) ATOMIC_CAS(var, oldval, val)
16935#define assert(__e) ((__e) ? (void)0 : __assert_func (__FILE__, __LINE__, __ASSERT_FUNC, #__e))
16936#define __ASSERT_FUNC __func__
16937#define static_assert _Static_assert
16939#define stringify(expr) stringify_1(expr)
16940#define stringify_1(expr) #expr
16941#define CCAN_CONTAINER_OF_H
16942#define CCAN_CHECK_TYPE_H
16943#define check_type(expr,type) ((typeof(expr) *)0 != (type *)0)
16944#define check_types_match(expr1,expr2) ((typeof(expr1) *)0 != (typeof(expr2) *)0)
16945#define container_of(member_ptr,containing_type,member) ((containing_type *) ((char *)(member_ptr) - container_off(containing_type, member)) + check_types_match(*(member_ptr), ((containing_type *)0)->member))
16946#define container_of_or_null(member_ptr,containing_type,member) ((containing_type *) container_of_or_null_(member_ptr, container_off(containing_type, member)) + check_types_match(*(member_ptr), ((containing_type *)0)->member))
16947#define container_off(containing_type,member) offsetof(containing_type, member)
16948#define container_of_var(member_ptr,container_var,member) container_of(member_ptr, typeof(*container_var), member)
16949#define container_off_var(var,member) container_off(typeof(*var), member)
16950#define LIST_LOC __FILE__ ":" stringify(__LINE__)
16951#define list_debug(h,loc) ((void)loc, h)
16952#define list_debug_node(n,loc) ((void)loc, n)
16953#define LIST_HEAD_INIT(name) { { &(name).n, &(name).n } }
16954#define LIST_HEAD(name) struct list_head name = LIST_HEAD_INIT(name)
16955#define list_add_after(h,p,n) list_add_after_(h, p, n, LIST_LOC)
16956#define list_add(h,n) list_add_(h, n, LIST_LOC)
16957#define list_add_before(h,p,n) list_add_before_(h, p, n, LIST_LOC)
16958#define list_add_tail(h,n) list_add_tail_(h, n, LIST_LOC)
16959#define list_empty(h) list_empty_(h, LIST_LOC)
16960#define list_empty_nodebug(h) list_empty(h)
16961#define list_del(n) list_del_(n, LIST_LOC)
16962#define list_del_init(n) list_del_init_(n, LIST_LOC)
16963#define list_swap(o,n) list_swap_(o, n, LIST_LOC)
16964#define list_entry(n,type,member) container_of(n, type, member)
16965#define list_top(h,type,member) ((type *)list_top_((h), list_off_(type, member)))
16966#define list_pop(h,type,member) ((type *)list_pop_((h), list_off_(type, member)))
16967#define list_tail(h,type,member) ((type *)list_tail_((h), list_off_(type, member)))
16968#define list_for_each(h,i,member) list_for_each_off(h, i, list_off_var_(i, member))
16969#define list_for_each_rev(h,i,member) list_for_each_rev_off(h, i, list_off_var_(i, member))
16970#define list_for_each_rev_safe(h,i,nxt,member) list_for_each_rev_safe_off(h, i, nxt, list_off_var_(i, member))
16971#define list_for_each_safe(h,i,nxt,member) list_for_each_safe_off(h, i, nxt, list_off_var_(i, member))
16972#define list_next(h,i,member) ((list_typeof(i))list_entry_or_null(list_debug(h, __FILE__ ":" stringify(__LINE__)), (i)->member.next, list_off_var_((i), member)))
16973#define list_prev(h,i,member) ((list_typeof(i))list_entry_or_null(list_debug(h, __FILE__ ":" stringify(__LINE__)), (i)->member.prev, list_off_var_((i), member)))
16974#define list_append_list(t,f) list_append_list_(t, f, __FILE__ ":" stringify(__LINE__))
16975#define list_prepend_list(t,f) list_prepend_list_(t, f, LIST_LOC)
16976#define list_for_each_off_dir_(h,i,off,dir) for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, (off)); list_node_from_off_((void *)i, (off)) != &(h)->n; i = list_node_to_off_(list_node_from_off_((void *)i, (off))->dir, (off)))
16977#define list_for_each_safe_off_dir_(h,i,nxt,off,dir) for (i = list_node_to_off_(list_debug(h, LIST_LOC)->n.dir, (off)), nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, (off)); list_node_from_off_(i, (off)) != &(h)->n; i = nxt, nxt = list_node_to_off_(list_node_from_off_(i, (off))->dir, (off)))
16978#define list_for_each_off(h,i,off) list_for_each_off_dir_((h),(i),(off),next)
16979#define list_for_each_rev_off(h,i,off) list_for_each_off_dir_((h),(i),(off),prev)
16980#define list_for_each_safe_off(h,i,nxt,off) list_for_each_safe_off_dir_((h),(i),(nxt),(off),next)
16981#define list_for_each_rev_safe_off(h,i,nxt,off) list_for_each_safe_off_dir_((h),(i),(nxt),(off),prev)
16982#define list_entry_off(n,type,off) ((type *)list_node_from_off_((n), (off)))
16983#define list_head_off(h,type,off) ((type *)list_head_off((h), (off)))
16984#define list_tail_off(h,type,off) ((type *)list_tail_((h), (off)))
16985#define list_add_off(h,n,off) list_add((h), list_node_from_off_((n), (off)))
16986#define list_del_off(n,off) list_del(list_node_from_off_((n), (off)))
16987#define list_del_from_off(h,n,off) list_del_from(h, list_node_from_off_((n), (off)))
16988#define list_off_(type,member) (container_off(type, member) + check_type(((type *)0)->member, struct list_node))
16989#define list_off_var_(var,member) (container_off_var(var, member) + check_type(var->member, struct list_node))
16990#define list_typeof(var) typeof(var)
16991#define RUBY_THREAD_NATIVE_H 1
16993#define _SYS_SCHED_H_
16994#define SCHED_OTHER 3
16995#define SCHED_FIFO 1
16998#define PTHREAD_CANCEL_ASYNCHRONOUS 1
16999#define PTHREAD_CANCEL_ENABLE 0
17000#define PTHREAD_CANCEL_DEFERRED 0
17001#define PTHREAD_CANCEL_DISABLE 1
17002#define PTHREAD_CANCELED ((void *)-1)
17003#define PTHREAD_COND_INITIALIZER (pthread_cond_t)21
17004#define PTHREAD_CREATE_DETACHED 1
17005#define PTHREAD_CREATE_JOINABLE 0
17006#define PTHREAD_EXPLICIT_SCHED 1
17007#define PTHREAD_INHERIT_SCHED 0
17008#define PTHREAD_MUTEX_RECURSIVE 0
17009#define PTHREAD_MUTEX_ERRORCHECK 1
17010#define PTHREAD_MUTEX_NORMAL 2
17011#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
17012#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP (pthread_mutex_t)18
17013#define PTHREAD_NORMAL_MUTEX_INITIALIZER_NP (pthread_mutex_t)19
17014#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP (pthread_mutex_t)20
17015#define PTHREAD_MUTEX_INITIALIZER PTHREAD_NORMAL_MUTEX_INITIALIZER_NP
17016#define PTHREAD_ONCE_INIT { PTHREAD_MUTEX_INITIALIZER, 0 }
17017#define PTHREAD_PROCESS_SHARED 1
17018#define PTHREAD_PROCESS_PRIVATE 0
17019#define PTHREAD_RWLOCK_INITIALIZER (pthread_rwlock_t)22
17020#define PTHREAD_SCOPE_PROCESS 0
17021#define PTHREAD_SCOPE_SYSTEM 1
17022#define PTHREAD_BARRIER_SERIAL_THREAD (-1)
17023#define pthread_cleanup_push(_fn,_arg) { __pthread_cleanup_handler __cleanup_handler = { _fn, _arg, NULL }; _pthread_cleanup_push( &__cleanup_handler );
17024#define pthread_cleanup_pop(_execute) _pthread_cleanup_pop( _execute ); }
17025#pragma GCC visibility push(default)
17026#pragma GCC visibility pop
17027#define RUBY_THREAD_PTHREAD_H
17028#define RB_NATIVETHREAD_LOCK_INIT PTHREAD_MUTEX_INITIALIZER
17029#define RB_NATIVETHREAD_COND_INIT PTHREAD_COND_INITIALIZER
17035#define _JBTYPE long
17037#define _SAVEMASK _JBLEN
17038#define _SIGMASK (_JBLEN+1)
17039#define _CYGWIN_WORKING_SIGSETJMP
17040#define __SIGMASK_FUNC pthread_sigmask
17041#define sigsetjmp(env,savemask) __extension__ ({ sigjmp_buf *_sjbuf = &(env); ((*_sjbuf)[_SAVEMASK] = savemask, __SIGMASK_FUNC (SIG_SETMASK, 0, (sigset_t *)((*_sjbuf) + _SIGMASK)), setjmp (*_sjbuf)); })
17042#define siglongjmp(env,val) __extension__ ({ sigjmp_buf *_sjbuf = &(env); ((((*_sjbuf)[_SAVEMASK]) ? __SIGMASK_FUNC (SIG_SETMASK, (sigset_t *)((*_sjbuf) + _SIGMASK), 0) : 0), longjmp (*_sjbuf, val)); })
17043#define RUBY_NSIG NSIG
17044#define RUBY_SIGCHLD (SIGCLD)
17045#define SIGCHLD_LOSSY (0)
17046#define WAITPID_USE_SIGCHLD (RUBY_SIGCHLD || SIGCHLD_LOSSY)
17047#define va_init_list(a,b) va_start((a),(b))
17048#define USE_SIGALTSTACK
17049#define RB_ALTSTACK_INIT(var) var = rb_register_sigaltstack()
17050#define RB_ALTSTACK_FREE(var) xfree(var)
17051#define RB_ALTSTACK(var) var
17052#define TAG_NONE RUBY_TAG_NONE
17053#define TAG_RETURN RUBY_TAG_RETURN
17054#define TAG_BREAK RUBY_TAG_BREAK
17055#define TAG_NEXT RUBY_TAG_NEXT
17056#define TAG_RETRY RUBY_TAG_RETRY
17057#define TAG_REDO RUBY_TAG_REDO
17058#define TAG_RAISE RUBY_TAG_RAISE
17059#define TAG_THROW RUBY_TAG_THROW
17060#define TAG_FATAL RUBY_TAG_FATAL
17061#define TAG_MASK RUBY_TAG_MASK
17062#define CoreDataFromValue(obj,type) (type*)DATA_PTR(obj)
17063#define GetCoreDataFromValue(obj,type,ptr) ((ptr) = CoreDataFromValue((obj), type))
17064#define PATHOBJ_PATH 0
17065#define PATHOBJ_REALPATH 1
17066#define USE_LAZY_LOAD 0
17067#define GetVMPtr(obj,ptr) GetCoreDataFromValue((obj), rb_vm_t, (ptr))
17068#define RUBY_VM_SIZE_ALIGN 4096
17069#define RUBY_VM_THREAD_VM_STACK_SIZE ( 128 * 1024 * sizeof(VALUE))
17070#define RUBY_VM_THREAD_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE))
17071#define RUBY_VM_THREAD_MACHINE_STACK_SIZE ( 128 * 1024 * sizeof(VALUE))
17072#define RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE))
17073#define RUBY_VM_FIBER_VM_STACK_SIZE ( 16 * 1024 * sizeof(VALUE))
17074#define RUBY_VM_FIBER_VM_STACK_SIZE_MIN ( 2 * 1024 * sizeof(VALUE))
17075#define RUBY_VM_FIBER_MACHINE_STACK_SIZE ( 64 * 1024 * sizeof(VALUE))
17076#define RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN ( 16 * 1024 * sizeof(VALUE))
17077#define INTEGER_REDEFINED_OP_FLAG (1 << 0)
17078#define FLOAT_REDEFINED_OP_FLAG (1 << 1)
17079#define STRING_REDEFINED_OP_FLAG (1 << 2)
17080#define ARRAY_REDEFINED_OP_FLAG (1 << 3)
17081#define HASH_REDEFINED_OP_FLAG (1 << 4)
17082#define SYMBOL_REDEFINED_OP_FLAG (1 << 6)
17083#define TIME_REDEFINED_OP_FLAG (1 << 7)
17084#define REGEXP_REDEFINED_OP_FLAG (1 << 8)
17085#define NIL_REDEFINED_OP_FLAG (1 << 9)
17086#define TRUE_REDEFINED_OP_FLAG (1 << 10)
17087#define FALSE_REDEFINED_OP_FLAG (1 << 11)
17088#define PROC_REDEFINED_OP_FLAG (1 << 12)
17089#define BASIC_OP_UNREDEFINED_P(op,klass) (LIKELY((GET_VM()->redefined_flag[(op)]&(klass)) == 0))
17090#define VM_DEBUG_BP_CHECK 0
17091#define VM_DEBUG_VERIFY_METHOD_CACHE (VMDEBUG != 0)
17092#define VM_CORE_H_EC_DEFINED 1
17093#define VM_DEFINECLASS_TYPE(x) ((rb_vm_defineclass_type_t)(x) & VM_DEFINECLASS_TYPE_MASK)
17094#define VM_DEFINECLASS_FLAG_SCOPED 0x08
17095#define VM_DEFINECLASS_FLAG_HAS_SUPERCLASS 0x10
17096#define VM_DEFINECLASS_SCOPED_P(x) ((x) & VM_DEFINECLASS_FLAG_SCOPED)
17097#define VM_DEFINECLASS_HAS_SUPERCLASS_P(x) ((x) & VM_DEFINECLASS_FLAG_HAS_SUPERCLASS)
17098#pragma GCC visibility push(default)
17099#pragma GCC visibility pop
17100#define GetProcPtr(obj,ptr) GetCoreDataFromValue((obj), rb_proc_t, (ptr))
17101#define GetBindingPtr(obj,ptr) GetCoreDataFromValue((obj), rb_binding_t, (ptr))
17102#define VM_CHECKMATCH_TYPE_MASK 0x03
17103#define VM_CHECKMATCH_ARRAY 0x04
17104#define VM_CALL_ARGS_SPLAT (0x01 << VM_CALL_ARGS_SPLAT_bit)
17105#define VM_CALL_ARGS_BLOCKARG (0x01 << VM_CALL_ARGS_BLOCKARG_bit)
17106#define VM_CALL_FCALL (0x01 << VM_CALL_FCALL_bit)
17107#define VM_CALL_VCALL (0x01 << VM_CALL_VCALL_bit)
17108#define VM_CALL_ARGS_SIMPLE (0x01 << VM_CALL_ARGS_SIMPLE_bit)
17109#define VM_CALL_BLOCKISEQ (0x01 << VM_CALL_BLOCKISEQ_bit)
17110#define VM_CALL_KWARG (0x01 << VM_CALL_KWARG_bit)
17111#define VM_CALL_KW_SPLAT (0x01 << VM_CALL_KW_SPLAT_bit)
17112#define VM_CALL_TAILCALL (0x01 << VM_CALL_TAILCALL_bit)
17113#define VM_CALL_SUPER (0x01 << VM_CALL_SUPER_bit)
17114#define VM_CALL_ZSUPER (0x01 << VM_CALL_ZSUPER_bit)
17115#define VM_CALL_OPT_SEND (0x01 << VM_CALL_OPT_SEND_bit)
17116#define VM_TAGGED_PTR_SET(p,tag) ((VALUE)(p) | (tag))
17117#define VM_TAGGED_PTR_REF(v,mask) ((void *)((v) & ~mask))
17118#define GC_GUARDED_PTR(p) VM_TAGGED_PTR_SET((p), 0x01)
17119#define GC_GUARDED_PTR_REF(p) VM_TAGGED_PTR_REF((p), 0x03)
17120#define GC_GUARDED_PTR_P(p) (((VALUE)(p)) & 0x01)
17121#define VM_ENV_DATA_SIZE ( 3)
17122#define VM_ENV_DATA_INDEX_ME_CREF (-2)
17123#define VM_ENV_DATA_INDEX_SPECVAL (-1)
17124#define VM_ENV_DATA_INDEX_FLAGS ( 0)
17125#define VM_ENV_DATA_INDEX_ENV ( 1)
17126#define VM_ENV_INDEX_LAST_LVAR (-VM_ENV_DATA_SIZE)
17127#define RUBYVM_CFUNC_FRAME_P(cfp) (VM_FRAME_TYPE(cfp) == VM_FRAME_MAGIC_CFUNC)
17128#define VM_GUARDED_PREV_EP(ep) GC_GUARDED_PTR(ep)
17129#define VM_BLOCK_HANDLER_NONE 0
17130#define RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp) ((cfp)+1)
17131#define RUBY_VM_NEXT_CONTROL_FRAME(cfp) ((cfp)-1)
17132#define RUBY_VM_VALID_CONTROL_FRAME_P(cfp,ecfp) ((void *)(ecfp) > (void *)(cfp))
17133#define SDR() rb_vmdebug_stack_dump_raw(GET_EC(), GET_EC()->cfp)
17134#define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_EC(), (cfp))
17135#pragma GCC visibility push(default)
17136#pragma GCC visibility pop
17137#define rb_vm_register_special_exception(sp,e,m) rb_vm_register_special_exception_str(sp, e, rb_usascii_str_new_static((m), (long)rb_strlen_lit(m)))
17138#define sysstack_error GET_VM()->special_exceptions[ruby_error_sysstack]
17139#define RUBY_CONST_ASSERT(expr) (1/!!(expr))
17140#define VM_STACK_OVERFLOWED_P(cfp,sp,margin) (!RUBY_CONST_ASSERT(sizeof(*(sp)) == sizeof(VALUE)) || !RUBY_CONST_ASSERT(sizeof(*(cfp)) == sizeof(rb_control_frame_t)) || ((rb_control_frame_t *)((sp) + (margin)) + 1) >= (cfp))
17141#define WHEN_VM_STACK_OVERFLOWED(cfp,sp,margin) if (LIKELY(!VM_STACK_OVERFLOWED_P(cfp, sp, margin))) {(void)0;} else
17142#define CHECK_VM_STACK_OVERFLOW0(cfp,sp,margin) WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) vm_stackoverflow()
17143#define CHECK_VM_STACK_OVERFLOW(cfp,margin) WHEN_VM_STACK_OVERFLOWED(cfp, (cfp)->sp, margin) vm_stackoverflow()
17144#pragma GCC visibility push(default)
17145#pragma GCC visibility pop
17146#define GET_VM() rb_current_vm()
17147#define GET_THREAD() rb_current_thread()
17148#define GET_EC() rb_current_execution_context()
17149#define RUBY_VM_SET_TIMER_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, TIMER_INTERRUPT_MASK)
17150#define RUBY_VM_SET_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, PENDING_INTERRUPT_MASK)
17151#define RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, POSTPONED_JOB_INTERRUPT_MASK)
17152#define RUBY_VM_SET_TRAP_INTERRUPT(ec) ATOMIC_OR((ec)->interrupt_flag, TRAP_INTERRUPT_MASK)
17153#define RUBY_VM_INTERRUPTED(ec) ((ec)->interrupt_flag & ~(ec)->interrupt_mask & (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK))
17154#define RUBY_VM_INTERRUPTED_ANY(ec) ((ec)->interrupt_flag & ~(ec)->interrupt_mask)
17155#define RUBY_VM_CHECK_INTS(ec) rb_vm_check_ints(ec)
17156#define EXEC_EVENT_HOOK_ORIG(ec_,hooks_,flag_,self_,id_,called_id_,klass_,data_,pop_p_) do { const rb_event_flag_t flag_arg_ = (flag_); rb_hook_list_t *hooks_arg_ = (hooks_); if (UNLIKELY((hooks_arg_)->events & (flag_arg_))) { rb_exec_event_hook_orig(ec_, hooks_arg_, flag_arg_, self_, id_, called_id_, klass_, data_, pop_p_); } } while (0)
17157#define EXEC_EVENT_HOOK(ec_,flag_,self_,id_,called_id_,klass_,data_) EXEC_EVENT_HOOK_ORIG(ec_, rb_vm_global_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 0)
17158#define EXEC_EVENT_HOOK_AND_POP_FRAME(ec_,flag_,self_,id_,called_id_,klass_,data_) EXEC_EVENT_HOOK_ORIG(ec_, rb_vm_global_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 1)
17159#pragma GCC visibility push(default)
17160#define RUBY_EVENT_COVERAGE_LINE 0x010000
17161#define RUBY_EVENT_COVERAGE_BRANCH 0x020000
17162#pragma GCC visibility pop
17163#define RUBY_DEBUG_H
17164#pragma GCC visibility push(default)
17165#define dpv(h,v) ruby_debug_print_value(-1, 0, (h), (v))
17166#define dp(v) ruby_debug_print_value(-1, 0, "", (v))
17167#define dpi(i) ruby_debug_print_id(-1, 0, "", (i))
17168#define dpn(n) ruby_debug_print_node(-1, 0, "", (n))
17169#pragma GCC visibility pop
17170#define RUBY_ISEQ_H 1
17171#define ISEQ_MAJOR_VERSION ((unsigned int)ruby_api_version[0])
17172#define ISEQ_MINOR_VERSION ((unsigned int)ruby_api_version[1])
17173#define ISEQ_COVERAGE(iseq) iseq->body->variable.coverage
17174#define ISEQ_COVERAGE_SET(iseq,cov) RB_OBJ_WRITE(iseq, &iseq->body->variable.coverage, cov)
17175#define ISEQ_LINE_COVERAGE(iseq) RARRAY_AREF(ISEQ_COVERAGE(iseq), COVERAGE_INDEX_LINES)
17176#define ISEQ_BRANCH_COVERAGE(iseq) RARRAY_AREF(ISEQ_COVERAGE(iseq), COVERAGE_INDEX_BRANCHES)
17177#define ISEQ_PC2BRANCHINDEX(iseq) iseq->body->variable.pc2branchindex
17178#define ISEQ_PC2BRANCHINDEX_SET(iseq,h) RB_OBJ_WRITE(iseq, &iseq->body->variable.pc2branchindex, h)
17179#define ISEQ_FLIP_CNT(iseq) (iseq)->body->variable.flip_count
17180#define ISEQ_TRACE_EVENTS (RUBY_EVENT_LINE | RUBY_EVENT_CLASS | RUBY_EVENT_END | RUBY_EVENT_CALL | RUBY_EVENT_RETURN| RUBY_EVENT_B_CALL| RUBY_EVENT_B_RETURN| RUBY_EVENT_COVERAGE_LINE| RUBY_EVENT_COVERAGE_BRANCH)
17181#define ISEQ_NOT_LOADED_YET IMEMO_FL_USER1
17182#define ISEQ_USE_COMPILE_DATA IMEMO_FL_USER2
17183#define ISEQ_TRANSLATED IMEMO_FL_USER3
17184#define ISEQ_MARKABLE_ISEQ IMEMO_FL_USER4
17185#define ISEQ_EXECUTABLE_P(iseq) (FL_TEST_RAW((iseq), ISEQ_NOT_LOADED_YET | ISEQ_USE_COMPILE_DATA) == 0)
17186#pragma GCC visibility push(default)
17187#define INITIAL_ISEQ_COMPILE_DATA_STORAGE_BUFF_SIZE (512)
17188#pragma GCC visibility pop
17189#define RUBY_EVAL_INTERN_H
17190#define PASS_PASSED_BLOCK_HANDLER_EC(ec) pass_passed_block_handler(ec)
17191#define PASS_PASSED_BLOCK_HANDLER() pass_passed_block_handler(GET_EC())
17192#define ruby_setjmp(env) RUBY_SETJMP(env)
17193#define ruby_longjmp(env,val) RUBY_LONGJMP((env),(val))
17195#define __error_t_defined 1
17196#define _SYS_ERRNO_H_
17197#define errno (*__errno())
17198#define __errno_r(ptr) ((ptr)->_errno)
17251#define EDEADLOCK 56
17265#define EMULTIHOP 74
17280#define ENOTEMPTY 90
17281#define ENAMETOOLONG 91
17283#define EOPNOTSUPP 95
17284#define EPFNOSUPPORT 96
17285#define ECONNRESET 104
17287#define EAFNOSUPPORT 106
17288#define EPROTOTYPE 107
17289#define ENOTSOCK 108
17290#define ENOPROTOOPT 109
17291#define ESHUTDOWN 110
17292#define ECONNREFUSED 111
17293#define EADDRINUSE 112
17294#define ECONNABORTED 113
17295#define ENETUNREACH 114
17296#define ENETDOWN 115
17297#define ETIMEDOUT 116
17298#define EHOSTDOWN 117
17299#define EHOSTUNREACH 118
17300#define EINPROGRESS 119
17301#define EALREADY 120
17302#define EDESTADDRREQ 121
17303#define EMSGSIZE 122
17304#define EPROTONOSUPPORT 123
17305#define ESOCKTNOSUPPORT 124
17306#define EADDRNOTAVAIL 125
17307#define ENETRESET 126
17309#define ENOTCONN 128
17310#define ETOOMANYREFS 129
17311#define EPROCLIM 130
17316#define ENOMEDIUM 135
17317#define ENOSHARE 136
17318#define ECASECLASH 137
17320#define EOVERFLOW 139
17321#define ECANCELED 140
17322#define ENOTRECOVERABLE 141
17323#define EOWNERDEAD 142
17324#define ESTRPIPE 143
17325#define EWOULDBLOCK EAGAIN
17326#define __ELASTERROR 2000
17327#define _SYS_PARAM_H
17329#undef __need_ptrdiff_t
17330#undef __need_size_t
17331#undef __need_wchar_t
17333#define NULL ((void *)0)
17335#define offsetof(TYPE,MEMBER) __builtin_offsetof (TYPE, MEMBER)
17337#define NGROUPS NGROUPS_MAX
17339#define MAXHOSTNAMELEN 128
17340#define MAXPATHLEN PATH_MAX
17341#define MAXSYMLINKS SYMLOOP_MAX
17342#define DEV_BSIZE 1024
17344#define setbit(a,i) ((a)[(i)/NBBY] |= 1<<((i)%NBBY))
17345#define clrbit(a,i) ((a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
17346#define isset(a,i) ((a)[(i)/NBBY] & (1<<((i)%NBBY)))
17347#define isclr(a,i) (((a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
17348#define howmany(x,y) (((x)+((y)-1))/(y))
17349#define rounddown(x,y) (((x)/(y))*(y))
17350#define roundup(x,y) ((((x)+((y)-1))/(y))*(y))
17351#define roundup2(x,y) (((x)+((y)-1))&(~((y)-1)))
17352#define powerof2(x) ((((x)-1)&(x))==0)
17353#define MIN(a,b) (((a)<(b))?(a):(b))
17354#define MAX(a,b) (((a)>(b))?(a):(b))
17355#define SAVE_ROOT_JMPBUF_BEFORE_STMT
17356#define SAVE_ROOT_JMPBUF_AFTER_STMT
17357#define SAVE_ROOT_JMPBUF(th,stmt) do if (ruby_setjmp((th)->root_jmpbuf) == 0) { SAVE_ROOT_JMPBUF_BEFORE_STMT stmt; SAVE_ROOT_JMPBUF_AFTER_STMT } else { rb_fiber_start(); } while (0)
17358#define EC_PUSH_TAG(ec) do { rb_execution_context_t * const _ec = (ec); struct rb_vm_tag _tag; _tag.state = TAG_NONE; _tag.tag = Qundef; _tag.prev = _ec->tag;
17359#define EC_POP_TAG() _ec->tag = _tag.prev; } while (0)
17360#define EC_TMPPOP_TAG() _ec->tag = _tag.prev
17361#define EC_REPUSH_TAG() (void)(_ec->tag = &_tag)
17362#define VAR_FROM_MEMORY(var) (var)
17363#define VAR_INITIALIZED(var) ((void)&(var))
17364#define VAR_NOCLOBBERED(var) var
17365#define EC_EXEC_TAG() (ruby_setjmp(_tag.buf) ? rb_ec_tag_state(VAR_FROM_MEMORY(_ec)) : (EC_REPUSH_TAG(), 0))
17366#define EC_JUMP_TAG(ec,st) rb_ec_tag_jump(ec, st)
17367#define INTERNAL_EXCEPTION_P(exc) FIXNUM_P(exc)
17368#define CREF_FL_PUSHED_BY_EVAL IMEMO_FL_USER1
17369#define CREF_FL_OMOD_SHARED IMEMO_FL_USER2
17370#pragma GCC diagnostic push
17371#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17372#pragma GCC diagnostic pop
17373#define rb_ec_raised_set(ec,f) ((ec)->raised_flag |= (f))
17374#define rb_ec_raised_reset(ec,f) ((ec)->raised_flag &= ~(f))
17375#define rb_ec_raised_p(ec,f) (((ec)->raised_flag & (f)) != 0)
17376#define rb_ec_raised_clear(ec) ((ec)->raised_flag = 0)
17377#define CharNext(p) rb_char_next(p)
17378#define BUILTIN_H_INCLUDED
17379#define RB_BUILTIN_FUNCTION(_i,_name,_fname,_arity) { .name = #_name, .func_ptr = (void *)_fname, .argc = _arity, .index = _i }
17381#define DTRACE_PROBES_DISABLED 1
17382#define RUBY_DTRACE_METHOD_ENTRY_ENABLED() 0
17383#define RUBY_DTRACE_METHOD_ENTRY(classname,methodname,filename,lineno) do {} while (0)
17384#define RUBY_DTRACE_METHOD_RETURN_ENABLED() 0
17385#define RUBY_DTRACE_METHOD_RETURN(classname,methodname,filename,lineno) do {} while (0)
17386#define RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() 0
17387#define RUBY_DTRACE_CMETHOD_ENTRY(classname,methodname,filename,lineno) do {} while (0)
17388#define RUBY_DTRACE_CMETHOD_RETURN_ENABLED() 0
17389#define RUBY_DTRACE_CMETHOD_RETURN(classname,methodname,filename,lineno) do {} while (0)
17390#define RUBY_DTRACE_REQUIRE_ENTRY_ENABLED() 0
17391#define RUBY_DTRACE_REQUIRE_ENTRY(rquiredfile,filename,lineno) do {} while (0)
17392#define RUBY_DTRACE_REQUIRE_RETURN_ENABLED() 0
17393#define RUBY_DTRACE_REQUIRE_RETURN(requiredfile,filename,lineno) do {} while (0)
17394#define RUBY_DTRACE_FIND_REQUIRE_ENTRY_ENABLED() 0
17395#define RUBY_DTRACE_FIND_REQUIRE_ENTRY(requiredfile,filename,lineno) do {} while (0)
17396#define RUBY_DTRACE_FIND_REQUIRE_RETURN_ENABLED() 0
17397#define RUBY_DTRACE_FIND_REQUIRE_RETURN(requiredfile,filename,lineno) do {} while (0)
17398#define RUBY_DTRACE_LOAD_ENTRY_ENABLED() 0
17399#define RUBY_DTRACE_LOAD_ENTRY(loadedfile,filename,lineno) do {} while (0)
17400#define RUBY_DTRACE_LOAD_RETURN_ENABLED() 0
17401#define RUBY_DTRACE_LOAD_RETURN(loadedfile,filename,lineno) do {} while (0)
17402#define RUBY_DTRACE_RAISE_ENABLED() 0
17403#define RUBY_DTRACE_RAISE(classname,filename,lineno) do {} while (0)
17404#define RUBY_DTRACE_OBJECT_CREATE_ENABLED() 0
17405#define RUBY_DTRACE_OBJECT_CREATE(classname,filename,lineno) do {} while (0)
17406#define RUBY_DTRACE_ARRAY_CREATE_ENABLED() 0
17407#define RUBY_DTRACE_ARRAY_CREATE(length,filename,lineno) do {} while (0)
17408#define RUBY_DTRACE_HASH_CREATE_ENABLED() 0
17409#define RUBY_DTRACE_HASH_CREATE(length,filename,lineno) do {} while (0)
17410#define RUBY_DTRACE_STRING_CREATE_ENABLED() 0
17411#define RUBY_DTRACE_STRING_CREATE(length,filename,lineno) do {} while (0)
17412#define RUBY_DTRACE_SYMBOL_CREATE_ENABLED() 0
17413#define RUBY_DTRACE_SYMBOL_CREATE(str,filename,lineno) do {} while (0)
17414#define RUBY_DTRACE_PARSE_BEGIN_ENABLED() 0
17415#define RUBY_DTRACE_PARSE_BEGIN(sourcefile,lineno) do {} while (0)
17416#define RUBY_DTRACE_PARSE_END_ENABLED() 0
17417#define RUBY_DTRACE_PARSE_END(sourcefile,lineno) do {} while (0)
17418#define RUBY_DTRACE_INSN_ENABLED() 0
17419#define RUBY_DTRACE_INSN(insns_name) do {} while (0)
17420#define RUBY_DTRACE_INSN_OPERAND_ENABLED() 0
17421#define RUBY_DTRACE_INSN_OPERAND(val,insns_name) do {} while (0)
17422#define RUBY_DTRACE_GC_MARK_BEGIN_ENABLED() 0
17423#define RUBY_DTRACE_GC_MARK_BEGIN() do {} while (0)
17424#define RUBY_DTRACE_GC_MARK_END_ENABLED() 0
17425#define RUBY_DTRACE_GC_MARK_END() do {} while (0)
17426#define RUBY_DTRACE_GC_SWEEP_BEGIN_ENABLED() 0
17427#define RUBY_DTRACE_GC_SWEEP_BEGIN() do {} while (0)
17428#define RUBY_DTRACE_GC_SWEEP_END_ENABLED() 0
17429#define RUBY_DTRACE_GC_SWEEP_END() do {} while (0)
17430#define RUBY_DTRACE_METHOD_CACHE_CLEAR_ENABLED() 0
17431#define RUBY_DTRACE_METHOD_CACHE_CLEAR(class,filename,lineno) do {} while (0)
17432#define RUBY_PROBES_HELPER_H
17433#define RUBY_DTRACE_METHOD_HOOK(name,ec,klazz,id) do { if (UNLIKELY(RUBY_DTRACE_ ##name ##_ENABLED())) { struct ruby_dtrace_method_hook_args args; if (rb_dtrace_setup(ec, klazz, id, &args)) { RUBY_DTRACE_ ##name(args.classname, args.methodname, args.filename, args.line_no); } } } while (0)
17434#define RUBY_DTRACE_METHOD_ENTRY_HOOK(ec,klass,id) RUBY_DTRACE_METHOD_HOOK(METHOD_ENTRY, ec, klass, id)
17435#define RUBY_DTRACE_METHOD_RETURN_HOOK(ec,klass,id) RUBY_DTRACE_METHOD_HOOK(METHOD_RETURN, ec, klass, id)
17436#define RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec,klass,id) RUBY_DTRACE_METHOD_HOOK(CMETHOD_ENTRY, ec, klass, id)
17437#define RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec,klass,id) RUBY_DTRACE_METHOD_HOOK(CMETHOD_RETURN, ec, klass, id)
17438#pragma GCC diagnostic push
17439#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17440#pragma GCC diagnostic pop
17441#define RUBY_MJIT_H 1
17442#define USE_DEBUG_COUNTER 0
17443#define RUBY_DEBUG_COUNTER_H 1
17444#define RB_DEBUG_COUNTER(name) RB_DEBUG_COUNTER_ ##name,
17445#undef RB_DEBUG_COUNTER
17446#define RB_DEBUG_COUNTER_INC(type) ((void)0)
17447#define RB_DEBUG_COUNTER_INC_UNLESS(type,cond) (cond)
17448#define RB_DEBUG_COUNTER_INC_IF(type,cond) (cond)
17449#pragma GCC visibility push(default)
17450#pragma GCC visibility pop
17451#pragma GCC visibility push(default)
17452#pragma GCC visibility pop
17453#define JIT_ISEQ_SIZE_THRESHOLD 1000
17454#define RUBY_INSNHELPER_H
17455#pragma GCC visibility push(default)
17456#pragma GCC visibility pop
17457#define COLLECT_USAGE_INSN(insn)
17458#define COLLECT_USAGE_OPERAND(insn,n,op)
17459#define COLLECT_USAGE_REGISTER(reg,s)
17460#define PUSH(x) (SET_SV(x), INC_SP(1))
17461#define TOPN(n) (*(GET_SP()-(n)-1))
17462#define POPN(n) (DEC_SP(n))
17463#define POP() (DEC_SP(1))
17464#define STACK_ADDR_FROM_TOP(n) (GET_SP()-(n))
17465#define VM_REG_CFP (reg_cfp)
17466#define VM_REG_PC (VM_REG_CFP->pc)
17467#define VM_REG_SP (VM_REG_CFP->sp)
17468#define VM_REG_EP (VM_REG_CFP->ep)
17469#define RESTORE_REGS() do { VM_REG_CFP = ec->cfp; } while (0)
17470#define COLLECT_USAGE_REGISTER_HELPER(a,b,v) (v)
17471#define GET_PC() (COLLECT_USAGE_REGISTER_HELPER(PC, GET, VM_REG_PC))
17472#define SET_PC(x) (VM_REG_PC = (COLLECT_USAGE_REGISTER_HELPER(PC, SET, (x))))
17473#define GET_CURRENT_INSN() (*GET_PC())
17474#define GET_OPERAND(n) (GET_PC()[(n)])
17475#define ADD_PC(n) (SET_PC(VM_REG_PC + (n)))
17476#define JUMP(dst) (SET_PC(VM_REG_PC + (dst)))
17477#define GET_CFP() (COLLECT_USAGE_REGISTER_HELPER(CFP, GET, VM_REG_CFP))
17478#define GET_EP() (COLLECT_USAGE_REGISTER_HELPER(EP, GET, VM_REG_EP))
17479#define SET_EP(x) (VM_REG_EP = (COLLECT_USAGE_REGISTER_HELPER(EP, SET, (x))))
17480#define GET_LEP() (VM_EP_LEP(GET_EP()))
17481#define GET_SP() (COLLECT_USAGE_REGISTER_HELPER(SP, GET, VM_REG_SP))
17482#define SET_SP(x) (VM_REG_SP = (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
17483#define INC_SP(x) (VM_REG_SP += (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
17484#define DEC_SP(x) (VM_REG_SP -= (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
17485#define SET_SV(x) (*GET_SP() = (x))
17486#define GET_ISEQ() (GET_CFP()->iseq)
17487#define GET_PREV_EP(ep) ((VALUE *)((ep)[VM_ENV_DATA_INDEX_SPECVAL] & ~0x03))
17488#define GET_SELF() (COLLECT_USAGE_REGISTER_HELPER(SELF, GET, GET_CFP()->self))
17489#define GET_BLOCK_HANDLER() (GET_LEP()[VM_ENV_DATA_INDEX_SPECVAL])
17490#define SETUP_CANARY()
17491#define CHECK_CANARY()
17492#define PREV_CLASS_SERIAL() (ruby_vm_class_serial)
17493#define NEXT_CLASS_SERIAL() (++ruby_vm_class_serial)
17494#define GET_GLOBAL_METHOD_STATE() (ruby_vm_global_method_state)
17495#define INC_GLOBAL_METHOD_STATE() (++ruby_vm_global_method_state)
17496#define GET_GLOBAL_CONSTANT_STATE() (ruby_vm_global_constant_state)
17497#define INC_GLOBAL_CONSTANT_STATE() (++ruby_vm_global_constant_state)
17498#define IS_ARGS_SPLAT(ci) ((ci)->flag & VM_CALL_ARGS_SPLAT)
17499#define IS_ARGS_KEYWORD(ci) ((ci)->flag & VM_CALL_KWARG)
17500#define IS_ARGS_KW_SPLAT(ci) ((ci)->flag & VM_CALL_KW_SPLAT)
17501#define IS_ARGS_KW_OR_KW_SPLAT(ci) ((ci)->flag & (VM_CALL_KWARG | VM_CALL_KW_SPLAT))
17502#define RUBY_VM_EXEC_H
17504#define DEBUG_ENTER_INSN(insn)
17505#define DEBUG_END_INSN()
17506#define throwdebug if(0)printf
17507#define LABEL(x) INSN_LABEL_ ##x
17508#define ELABEL(x) INSN_ELABEL_ ##x
17509#define LABEL_PTR(x) RB_GNUC_EXTENSION(&&LABEL(x))
17510#define INSN_ENTRY_SIG(insn) if (0) fprintf(stderr, "exec: %s@(%"PRIdPTRDIFF", %"PRIdPTRDIFF")@%s:%u\n", #insn, (reg_pc - reg_cfp->iseq->body->iseq_encoded), (reg_cfp->pc - reg_cfp->iseq->body->iseq_encoded), RSTRING_PTR(rb_iseq_path(reg_cfp->iseq)), rb_iseq_line_no(reg_cfp->iseq, reg_pc - reg_cfp->iseq->body->iseq_encoded));
17511#define INSN_DISPATCH_SIG(insn)
17512#define INSN_ENTRY(insn) LABEL(insn): INSN_ENTRY_SIG(insn);
17513#define TC_DISPATCH(insn) INSN_DISPATCH_SIG(insn); RB_GNUC_EXTENSION_BLOCK(goto *(void const *)GET_CURRENT_INSN()); ;
17514#define END_INSN(insn) DEBUG_END_INSN(); TC_DISPATCH(insn);
17515#define INSN_DISPATCH() TC_DISPATCH(__START__) {
17516#define END_INSNS_DISPATCH() rb_bug("unknown insn: %"PRIdVALUE, GET_CURRENT_INSN()); }
17517#define NEXT_INSN() TC_DISPATCH(__NEXT_INSN__)
17518#define START_OF_ORIGINAL_INSN(x) start_of_ ##x:
17519#define DISPATCH_ORIGINAL_INSN(x) goto start_of_ ##x;
17520#define VM_SP_CNT(ec,sp) ((sp) - (ec)->vm_stack)
17521#define THROW_EXCEPTION(exc) do { ec->errinfo = (VALUE)(exc); EC_JUMP_TAG(ec, ec->tag->state); } while (0)
17522#define SCREG(r) (reg_ ##r)
17523#define VM_DEBUG_STACKOVERFLOW 0
17524#define CHECK_VM_STACK_OVERFLOW_FOR_INSN(cfp,margin)
17525#define INSN_LABEL2(insn,name) INSN_LABEL_ ## insn ## _ ## name
17526#define INSN_LABEL(x) INSN_LABEL2(NAME_OF_CURRENT_INSN, x)
17527#define BIN(n) YARVINSN_ ##n
17528#define ASSERT_VM_INSTRUCTION_SIZE(array) STATIC_ASSERT(numberof_ ##array, numberof(array) == VM_INSTRUCTION_SIZE)
17530#define RB_CONST_PRIVATE_P(ce) (((ce)->flag & CONST_VISIBILITY_MASK) == CONST_PRIVATE)
17531#define RB_CONST_PUBLIC_P(ce) (((ce)->flag & CONST_VISIBILITY_MASK) == CONST_PUBLIC)
17532#define RB_CONST_DEPRECATED_P(ce) ((ce)->flag & CONST_DEPRECATED)
17533#define vm_check_canary(ec,sp)
17534#define vm_check_frame(a,b,c,d)
17535#pragma GCC diagnostic push
17536#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17537#pragma GCC diagnostic pop
17538#pragma GCC diagnostic push
17539#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17540#pragma GCC diagnostic pop
17541#pragma GCC diagnostic push
17542#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17543#pragma GCC diagnostic pop
17544#pragma GCC diagnostic push
17545#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17546#pragma GCC diagnostic pop
17547#pragma GCC diagnostic push
17548#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17549#pragma GCC diagnostic pop
17550#pragma GCC diagnostic push
17551#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17552#pragma GCC diagnostic pop
17553#pragma GCC diagnostic push
17554#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17555#pragma GCC diagnostic pop
17556#define BUILTIN_CLASS_P(x,k) (!SPECIAL_CONST_P(x) && RBASIC_CLASS(x) == k)
17557#define EQ_UNREDEFINED_P(t) BASIC_OP_UNREDEFINED_P(BOP_EQ, t ##_REDEFINED_OP_FLAG)
17558#undef BUILTIN_CLASS_P
17559#undef EQ_UNREDEFINED_P
17560#define CHECK_CMP_NAN(a,b)
17561#pragma GCC diagnostic push
17562#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17563#pragma GCC diagnostic pop
17564#define KW_HASH_HAS_NO_KEYS 0
17565#define KW_HASH_HAS_SYMBOL_KEY 1
17566#define KW_HASH_HAS_OTHER_KEY 2
17567#define KW_HASH_HAS_BOTH_KEYS 3
17568#pragma GCC diagnostic push
17569#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17570#pragma GCC diagnostic pop
17571#define KW_SPECIFIED_BITS_MAX (32-1)
17572#pragma GCC diagnostic push
17573#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17574#pragma GCC diagnostic pop
17575#define USE_OPT_HIST 0
17576#define CHECK_CFP_CONSISTENCY(func) (LIKELY(vm_cfp_consistent_p(ec, reg_cfp)) ? (void)0 : rb_bug(func ": cfp consistency error (%p, %p)", (void *)reg_cfp, (void *)(ec->cfp+1)))
17577#pragma GCC diagnostic push
17578#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17579#pragma GCC diagnostic pop
17580#pragma GCC diagnostic push
17581#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17582#pragma GCC diagnostic pop
17583#define id_cmp idCmp
17585#pragma GCC diagnostic push
17586#pragma GCC diagnostic ignored "-Waddress-of-packed-member"
17587#pragma GCC diagnostic pop
17588#define VM_TRACE_HOOK(target_event,val) do { if ((pc_events & (target_event)) & enabled_flags) { vm_trace_hook(ec, reg_cfp, pc, pc_events, (target_event), global_hooks, local_hooks, (val)); } } while (0)
17589#define id_mesg idMesg
VALUE rb_int2big(intptr_t n)
VALUE rb_uint2big(uintptr_t n)
void rb_cmperr(VALUE x, VALUE y)
VALUE rb_complex_polar(VALUE x, VALUE y)
void rb_fiber_start(void)
#define range(low, item, hi)
struct rb_encoding_entry * list
int rb_data_is_encoding(VALUE obj)
char str[HTML_ESCAPE_MAX_LEN+1]
void ruby_stop(int ex)
Calls ruby_cleanup() and exits the process.
VALUE rb_f_raise(int argc, VALUE *argv)
void rb_print_undef(VALUE klass, ID id, rb_method_visibility_t visi)
void rb_print_inaccessible(VALUE klass, ID id, rb_method_visibility_t visi)
void rb_print_undef_str(VALUE klass, VALUE name)
#define __builtin_expect(x, expected_value)
#define rb_data_object_alloc
void * rb_aligned_malloc(size_t alignment, size_t size)
VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *type)
void ruby_malloc_size_overflow(size_t count, size_t elsize)
VALUE rb_newobj_of(VALUE klass, VALUE flags)
#define rb_data_typed_object_alloc
VALUE rb_class_protected_instance_methods(int, const VALUE *, VALUE)
void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE, VALUE), VALUE)
void rb_include_module(VALUE, VALUE)
void rb_extend_object(VALUE, VALUE)
Extend the object with the module.
VALUE rb_define_class(const char *, VALUE)
Defines a top-level class.
VALUE rb_class_new(VALUE)
Creates a new class.
VALUE rb_singleton_class_clone(VALUE)
VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj)
void rb_class_subclass_add(VALUE super, VALUE klass)
VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj)
void rb_prepend_module(VALUE, VALUE)
VALUE rb_singleton_class(VALUE)
Returns the singleton class of obj.
void rb_class_detach_subclasses(VALUE)
void Init_class_hierarchy(void)
VALUE rb_define_class_under(VALUE, const char *, VALUE)
Defines a class under the namespace of outer.
VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach)
VALUE rb_include_class_new(VALUE, VALUE)
VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj)
VALUE rb_obj_singleton_methods(int, const VALUE *, VALUE)
VALUE rb_module_new(void)
int rb_singleton_class_internal_p(VALUE sklass)
VALUE rb_class_instance_methods(int, const VALUE *, VALUE)
VALUE rb_class_inherited(VALUE, VALUE)
Calls Class::inherited.
void rb_check_inheritable(VALUE)
Ensures a class can be derived from super.
VALUE rb_class_public_instance_methods(int, const VALUE *, VALUE)
VALUE rb_class_boot(VALUE)
A utility function that wraps class_alloc.
VALUE rb_define_module(const char *)
void rb_class_modify_check(VALUE)
Asserts that klass is not a frozen class.
void rb_class_detach_module_subclasses(VALUE)
VALUE rb_special_singleton_class(VALUE)
VALUE rb_define_module_id_under(VALUE, ID)
void rb_singleton_class_attached(VALUE, VALUE)
Attach a object to a singleton class.
void rb_freeze_singleton_class(VALUE x)
VALUE rb_mod_included_modules(VALUE)
VALUE rb_define_class_id_under(VALUE, ID, VALUE)
Defines a class under the namespace of outer.
VALUE rb_mod_ancestors(VALUE)
VALUE rb_mod_include_p(VALUE, VALUE)
VALUE rb_class_private_instance_methods(int, const VALUE *, VALUE)
void rb_class_remove_from_module_subclasses(VALUE)
VALUE rb_mod_init_copy(VALUE, VALUE)
VALUE rb_define_module_under(VALUE, const char *)
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
VALUE rb_make_metaclass(VALUE, VALUE)
VALUE rb_define_module_id(ID)
VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj)
VALUE rb_define_class_id(ID, VALUE)
Defines a new class.
void rb_class_remove_from_super_subclasses(VALUE)
ID rb_frame_callee(void)
The name of the current method.
ID rb_frame_this_func(void)
The original name of the current method.
VALUE rb_extract_keywords(VALUE *orighash)
int rb_class_has_methods(VALUE c)
void rb_need_block(void)
Declares that the current method needs a block.
VALUE rb_keyword_error_new(const char *error, VALUE keys)
void rb_define_attr(VALUE, const char *, int, int)
Defines (a) public accessor method(s) for an attribute.
void rb_undef_method(VALUE, const char *)
int rb_scan_args_kw(int, int, const VALUE *, const char *,...)
void rb_define_alias(VALUE, const char *, const char *)
Defines an alias of a method.
void rb_undef_methods_from(VALUE klass, VALUE super)
int rb_block_given_p(void)
Determines if the current method is given a block.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *)
VALUE rb_cTrueClass
TrueClass class.
VALUE rb_cNilClass
NilClass class.
size_t(* dsize)(const void *)
VALUE rb_mKernel
Kernel module.
VALUE rb_cClass
Class class.
VALUE rb_cData
Data class.
const rb_data_type_t * parent
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_cObject
Object class.
const VALUE ary[RARRAY_EMBED_LEN_MAX]
VALUE rb_cFalseClass
FalseClass class.
union RString::@157::@158::@159 aux
char ary[RSTRING_EMBED_LEN_MAX+1]
const rb_data_type_t * type
VALUE rb_eFloatDomainError
const char * wrap_struct_name
struct RObject::@155::@156 heap
struct RArray::@160::@161 heap
VALUE rb_cModule
Module class.
union RArray::@160::@161::@162 aux
struct RString::@157::@158 heap
VALUE ary[ROBJECT_EMBED_LEN_MAX]
struct re_pattern_buffer * ptr
VALUE rb_eMathDomainError
void rb_notimplement(void)
int rb_bug_reporter_add(void(*func)(FILE *, void *), void *data)
void rb_syserr_fail(int e, const char *mesg)
VALUE rb_get_backtrace(VALUE info)
void rb_raise(VALUE exc, const char *fmt,...)
_Bool rb_warning_category_enabled_p(rb_warning_category_t category)
int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent)
void rb_mod_sys_fail_str(VALUE mod, VALUE mesg)
VALUE rb_rescue2(VALUE(*)(VALUE), VALUE, VALUE(*)(VALUE, VALUE), VALUE,...)
An equivalent of rescue clause.
void rb_mod_sys_fail(VALUE mod, const char *mesg)
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
void rb_bug(const char *fmt,...)
void rb_name_error(ID id, const char *fmt,...)
VALUE rb_nomethod_err_new(VALUE mesg, VALUE recv, VALUE method, VALUE args, int priv)
VALUE rb_syserr_new(int, const char *)
void rb_check_copyable(VALUE obj, VALUE orig)
VALUE rb_syserr_new_str(int n, VALUE arg)
void rb_error_frozen(const char *what)
void rb_set_errinfo(VALUE err)
Sets the current exception ($!) to the given value.
void rb_syserr_fail_str(int e, VALUE mesg)
const char * rb_builtin_type_name(int t)
void rb_interrupt(void)
Raises an Interrupt exception.
void rb_sys_fail_str(VALUE mesg)
void rb_error_untrusted(VALUE)
VALUE rb_eNoMatchingPatternError
void rb_name_error_str(VALUE str, const char *fmt,...)
void rb_fatal(const char *fmt,...)
void rb_frozen_error_raise(VALUE frozen_obj, const char *fmt,...)
void rb_vraise(VALUE exc, const char *fmt, va_list ap)
VALUE rb_protect(VALUE(*)(VALUE), VALUE, int *)
Protects a function call from potential global escapes from the function.
void rb_load_fail(VALUE path, const char *err)
void rb_unexpected_type(VALUE x, int t)
void rb_invalid_str(const char *str, const char *type)
const char * rb_builtin_class_name(VALUE x)
VALUE rb_make_exception(int, const VALUE *)
Make an Exception object from the list of arguments in a manner similar to Kernel#raise.
MJIT_FUNC_EXPORTED void rb_assert_failure(const char *file, int line, const char *name, const char *expr)
void rb_exc_fatal(VALUE mesg)
Raises a fatal error in the current thread.
void rb_bug_errno(const char *mesg, int errno_arg)
VALUE rb_name_err_new(VALUE mesg, VALUE recv, VALUE method)
void * rb_check_typeddata(VALUE obj, const rb_data_type_t *data_type)
void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *ctx, const char *fmt,...)
void rb_warn(const char *fmt,...)
rb_warning_category_t rb_warning_category_from_name(VALUE category)
VALUE rb_exc_new(VALUE, const char *, long)
void rb_error_frozen_object(VALUE frozen_obj)
VALUE rb_exc_new_str(VALUE, VALUE)
void rb_mod_syserr_fail(VALUE mod, int e, const char *mesg)
void rb_loaderror(const char *fmt,...)
VALUE rb_rescue(VALUE(*)(VALUE), VALUE, VALUE(*)(VALUE, VALUE), VALUE)
An equivalent of rescue clause.
VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt)
void rb_loaderror_with_path(VALUE path, const char *fmt,...)
VALUE rb_ensure(VALUE(*)(VALUE), VALUE, VALUE(*)(VALUE), VALUE)
An equivalent to ensure clause.
void rb_report_bug_valist(VALUE file, int line, const char *fmt, va_list args)
VALUE rb_errinfo(void)
The current exception in the current thread.
void rb_async_bug_errno(const char *mesg, int errno_arg)
void rb_check_trusted(VALUE)
void rb_jump_tag(int tag)
Continues the exception caught by rb_protect() and rb_eval_string_protect().
void rb_sys_fail(const char *mesg)
void rb_mod_syserr_fail_str(VALUE mod, int e, VALUE mesg)
void rb_check_type(VALUE, int)
VALUE rb_eSystemCallError
VALUE rb_key_err_new(VALUE mesg, VALUE recv, VALUE name)
VALUE rb_class_superclass(VALUE)
Returns the superclass of klass.
VALUE rb_obj_taint(VALUE)
call-seq: obj.taint -> obj
VALUE rb_false(VALUE obj)
VALUE rb_obj_trust(VALUE)
call-seq: obj.trust -> obj
VALUE rb_class_get_superclass(VALUE)
Returns the superclass of klass The return value might be an iclass of a module, unlike rb_class_supe...
VALUE rb_convert_type(VALUE, int, const char *, const char *)
Converts an object into another type.
VALUE rb_Float(VALUE)
Equivalent to Kernel#Float in Ruby.
VALUE rb_check_to_int(VALUE)
Tries to convert val into Integer.
VALUE rb_obj_reveal(VALUE obj, VALUE klass)
Make a hidden object visible again.
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
Tries to convert an object into another type.
VALUE rb_obj_dig(int argc, VALUE *argv, VALUE self, VALUE notfound)
void rb_obj_call_init(VALUE, int, const VALUE *)
Calls #initialize method of obj with the given arguments.
VALUE rb_any_to_s(VALUE)
Default implementation of #to_s.
VALUE rb_obj_alloc(VALUE)
Allocates an instance of klass.
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
Allocates and initializes an instance of klass.
VALUE rb_class_new_instance_kw(int, const VALUE *, VALUE, int)
void rb_obj_copy_ivar(VALUE dest, VALUE obj)
int rb_opts_exception_p(VALUE opts, int default_value)
VALUE rb_obj_hide(VALUE obj)
Make the object invisible from Ruby code.
double rb_num_to_dbl(VALUE val)
int rb_bool_expected(VALUE, const char *)
VALUE rb_check_to_float(VALUE)
Tries to convert an object into Float.
VALUE rb_Hash(VALUE)
Equivalent to Kernel#Hash in Ruby.
void rb_obj_infect(VALUE victim, VALUE carrier)
Does nothing.
VALUE rb_obj_frozen_p(VALUE obj)
Determines if the object is frozen.
VALUE rb_obj_init_copy(VALUE, VALUE)
Default implementation of #initialize_copy.
int rb_eql(VALUE, VALUE)
Determines if obj1 and obj2 are equal in terms of Object::eql?.
double rb_str_to_dbl(VALUE, int)
Parses a string representation of a floating point number.
VALUE rb_Integer(VALUE)
Equivalent to Kernel#Integer in Ruby.
VALUE rb_Array(VALUE)
Equivalent to Kernel#Array in Ruby.
VALUE rb_obj_class(VALUE)
Equivalent to Object#class in Ruby.
VALUE rb_obj_dup(VALUE)
Equivalent to Object#dup in Ruby.
VALUE rb_inspect(VALUE)
Convenient wrapper of Object::inspect.
VALUE rb_obj_untrust(VALUE)
call-seq: obj.untrust -> obj
VALUE rb_class_inherited_p(VALUE mod, VALUE arg)
Determines if mod inherits arg.
VALUE rb_obj_is_instance_of(VALUE, VALUE)
Determines if obj is an instance of c.
VALUE rb_convert_type_with_id(VALUE, int, const char *, ID)
VALUE rb_class_real(VALUE cl)
Looks up the nearest ancestor of cl, skipping singleton classes or module inclusions.
VALUE rb_to_float(VALUE)
Converts a Numeric object into Float.
double rb_num2dbl(VALUE)
Converts a Numeric object to double.
VALUE rb_equal(VALUE, VALUE)
Same as Object#===, case equality.
VALUE rb_obj_clone(VALUE)
Almost same as Object::clone.
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Determines if obj is a kind of c.
double rb_cstr_to_dbl(const char *, int)
Parses a string representation of a floating point number.
VALUE rb_obj_freeze(VALUE)
Make the object unmodifiable.
VALUE rb_check_to_integer(VALUE, const char *)
Tries to convert val into Integer.
VALUE rb_immutable_obj_clone(int, VALUE *, VALUE)
VALUE rb_class_search_ancestor(VALUE klass, VALUE super)
VALUE rb_obj_untrusted(VALUE obj)
call-seq: obj.untrusted? -> false
VALUE rb_String(VALUE)
Equivalent to Kernel#String in Ruby.
VALUE rb_obj_untaint(VALUE)
call-seq: obj.untaint -> obj
VALUE rb_obj_tainted(VALUE obj)
call-seq: obj.tainted? -> false
VALUE rb_check_convert_type_with_id(VALUE, int, const char *, ID)
VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2)
VALUE rb_to_int(VALUE)
Converts val into Integer.
VALUE rb_obj_setup(VALUE obj, VALUE klass, VALUE type)
Fills common (RBasic) fields in obj.
size_t rb_hash_size_num(VALUE hash)
void rb_readwrite_syserr_fail(enum rb_io_wait_readwrite writable, int n, const char *mesg)
void rb_readwrite_sys_fail(enum rb_io_wait_readwrite writable, const char *mesg)
VALUE type(ANYARGS)
ANYARGS-ed function type.
unsigned char buf[MIME_BUF_SIZE]
void rb_num_zerodiv(void)
long rb_num2int(VALUE val)
VALUE rb_dbl_cmp(double a, double b)
long rb_fix2int(VALUE val)
my_ffi_struct callee(struct my_ffi_struct a1, struct my_ffi_struct a2)
VALUE rb_find_defined_class_by_owner(VALUE current_class, VALUE target_owner)
void rb_method_name_error(VALUE klass, VALUE str)
VALUE rb_f_abort(int argc, const VALUE *argv)
VALUE rb_f_exit(int argc, const VALUE *argv)
VALUE rb_f_exec(int argc, const VALUE *argv)
VALUE rb_data_object_zalloc(VALUE, size_t, RUBY_DATA_FUNC, RUBY_DATA_FUNC)
void rb_set_safe_level_force(int)
void rb_secure_update(VALUE)
VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type)
VALUE rb_float_new_in_heap(double)
unsigned short rb_fix2ushort(VALUE)
unsigned long rb_num2ulong(VALUE)
short rb_fix2short(VALUE)
short rb_num2short(VALUE)
unsigned short rb_num2ushort(VALUE)
void rb_insecure_operation(void)
rb_atomic_t cnt[RUBY_NSIG]
st_index_t rb_st_hash_start(st_index_t h)
size_t rb_str_capacity(VALUE str)
_ssize_t(* _read)(struct _reent *, void *, char *, size_t)
_ssize_t(* _write)(struct _reent *, void *, const char *, size_t)
_fpos64_t(* _seek64)(struct _reent *, void *, _fpos64_t, int)
int(* _close)(struct _reent *, void *)
_fpos_t(* _seek)(struct _reent *, void *, _fpos_t, int)
_ssize_t(* _read)(struct _reent *, void *, char *, size_t)
_fpos_t(* _seek)(struct _reent *, void *, _fpos_t, int)
_ssize_t(* _write)(struct _reent *, void *, const char *, size_t)
int(* _close)(struct _reent *, void *)
struct _uc_xmmreg xmm[16]
struct _pthread_cleanup_handler * next
struct _reent::@8::@9 _reent
_mbstate_t _wcrtomb_state
struct __tm _localtime_buf
unsigned int _unused_rand
unsigned int _nmalloc[30]
_mbstate_t _wcsrtombs_state
__extension__ unsigned long long _rand_next
_mbstate_t _mbrtowc_state
int _unspecified_locale_info
void(* __cleanup)(struct _reent *)
struct __locale_t * _locale
_mbstate_t _mbsrtowcs_state
struct _Bigint ** _freelist
struct _reent::@8::@10 _unused
unsigned char * _nextf[30]
void * _si_process_handle
int64_t _si_pipe_unique_id
__uint16_t significand[4]
struct RBignum::@27::@28 heap
unsigned int ary[(8 *RVALUE_EMBED_LEN_MAX/4)]
struct ar_table_struct * ar
rb_code_location_t nd_loc
struct rb_args_info * args
struct rb_ary_pattern_info * apinfo
struct rb_global_entry * entry
struct RStruct::@31::@32 heap
const VALUE ary[RSTRUCT_EMBED_LEN_MAX]
const struct rb_call_info_kw_arg * kw_arg
const unsigned char * bin
cookie_read_function_t * read
cookie_seek_function_t * seek
cookie_write_function_t * write
cookie_close_function_t * close
__fd_mask __fds_bits[(((64)+((((int) sizeof(__fd_mask) *8)) - 1))/(((int) sizeof(__fd_mask) *8)))]
enum iseq_catch_table_entry::catch_type type
struct iseq_compile_data_storage * next
struct iseq_compile_data_ensure_node_stack * ensure_node_stack
const struct rb_builtin_function * builtin_function_table
const rb_compile_option_t * option
struct iseq_compile_data_storage * storage_current
const rb_iseq_t * current_block
struct iseq_compile_data::@60 node
struct iseq_compile_data_storage * storage_head
struct rb_id_table * ivar_cache_table
struct iseq_label_data * start_label
struct iseq_label_data * end_label
struct iseq_label_data * redo_label
const VALUE catch_table_ary
const rb_cref_t * ic_cref
struct timespec it_interval
long double __max_align_ld __attribute__((__aligned__(__alignof__(long double))))
long long __max_align_ll __attribute__((__aligned__(__alignof__(long long))))
struct native_thread_data_struct::@43 cond
rb_nativethread_cond_t intr
rb_nativethread_cond_t gvlq
union native_thread_data_struct::@42 node
unsigned int ruby2_keywords
node_buffer_t * node_buffer
struct rb_at_exit_list * next
rb_vm_at_exit_func * func
unsigned short first_lineno
const struct rb_block block
struct rb_captured_block captured
const void *const func_ptr
enum method_missing_reason method_missing_reason
const struct rb_callable_method_entry_struct * me
rb_serial_t class_serial[(64 - 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)]
union rb_call_cache::@37 aux
VALUE(* call)(struct rb_execution_context_struct *ec, struct rb_control_frame_struct *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)
struct rb_call_info_kw_arg * kw_arg
struct rb_method_definition_struct *const def
const VALUE defined_class
const struct vm_ifunc * ifunc
union rb_captured_block::@53 code
rb_subclass_entry_t ** parent_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...
struct st_table * iv_index_tbl
struct rb_id_table * m_tbl
struct rb_id_table * const_tbl
rb_subclass_entry_t * subclasses
rb_alloc_func_t allocator
struct rb_id_table * callable_m_tbl
const VALUE refined_class
rb_code_position_t beg_pos
rb_code_position_t end_pos
unsigned int debug_frozen_string_literal
unsigned int operands_unification
unsigned int tailcall_optimization
unsigned int coverage_enabled
unsigned int peephole_optimization
unsigned int specialized_instruction
unsigned int stack_caching
unsigned int frozen_string_literal
unsigned int instructions_unification
unsigned int inline_const_cache
const rb_scope_visibility_t scope_visi
struct rb_cref_struct * next
char conflict[sizeof(VALUE) *3]
struct rb_ensure_entry entry
struct rb_ensure_list * next
struct rb_execarg::@34::@36 cmd
unsigned unsetenv_others_given
unsigned new_pgroup_given
union rb_execarg::@34 invoke
struct waitpid_state * waitpid_state
unsigned unsetenv_others_do
unsigned close_others_given
struct rb_execarg::@34::@35 sh
VALUE local_storage_recursive_hash_for_trace
enum method_missing_reason method_missing_reason
struct rb_thread_struct * thread_ptr
struct rb_execution_context_struct::@55 machine
VALUE private_const_reference
VALUE passed_block_handler
rb_ensure_list_t * ensure_list
rb_atomic_t interrupt_flag
rb_atomic_t interrupt_mask
struct rb_vm_protect_tag * protect_tag
struct rb_trace_arg_struct * trace_arg
VALUE local_storage_recursive_hash
struct rb_global_variable * var
rb_nativethread_cond_t switch_wait_cond
const struct rb_thread_struct * owner
rb_nativethread_cond_t switch_cond
rb_nativethread_lock_t lock
const struct rb_thread_struct * timer
struct rb_event_hook_struct * hooks
struct rb_imemo_tmpbuf_struct * next
struct succ_index_table * succ_index_table
const struct iseq_insn_info_entry * body
unsigned int ruby2_keywords
unsigned int ambiguous_param0
struct rb_iseq_constant_body::iseq_insn_info insns_info
enum rb_iseq_constant_body::iseq_type type
struct rb_iseq_constant_body::@45 param
union iseq_inline_storage_entry * is_entries
unsigned int local_table_size
const struct rb_iseq_constant_body::@45::rb_iseq_param_keyword * keyword
VALUE(* jit_func)(struct rb_execution_context_struct *, struct rb_control_frame_struct *)
rb_iseq_location_t location
struct rb_iseq_constant_body::@45::@47 flags
struct rb_call_data * call_data
unsigned int accepts_no_kwarg
struct iseq_catch_table * catch_table
const struct rb_iseq_struct * parent_iseq
long unsigned total_calls
struct rb_iseq_constant_body::@46 variable
struct rb_iseq_struct * local_iseq
struct rb_mjit_unit * jit_unit
rb_code_location_t code_location
void(* func)(rb_iseq_t *, struct iseq_link_anchor *, const void *)
struct rb_hook_list_struct * local_hooks
struct rb_iseq_constant_body * body
struct iseq_compile_data * compile_data
union rb_iseq_struct::@48 aux
struct rb_iseq_struct::@48::@49 loader
rb_event_flag_t global_trace_events
struct rb_iseq_struct::@48::@50 exec
struct rb_call_info_with_kwarg ci_kw
struct rb_method_entry_struct * original_me
struct rb_hook_list_struct * hooks
VALUE(* invoker)(VALUE recv, int argc, const VALUE *argv, VALUE(*func)())
unsigned int no_redef_warning
rb_method_bmethod_t bmethod
enum method_optimized_type optimize_type
union rb_method_definition_struct::@41 body
rb_method_refined_t refined
struct rb_method_definition_struct *const def
rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
rb_cref_t * cref
class reference, should be marked
struct rb_method_entry_struct * orig_me
unsigned int is_from_method
rb_method_visibility_t method_visi
rb_subclass_entry_t * next
struct rb_thread_list_struct * next
struct rb_thread_struct * th
rb_execution_context_t * ec
native_thread_data_t native_thread_data
struct rb_calling_info * calling
unsigned int pending_interrupt_queue_checked
struct list_node vmlt_node
enum rb_thread_status status
unsigned int abort_on_exception
rb_nativethread_id_t thread_id
VALUE pending_interrupt_mask_stack
rb_nativethread_lock_t interrupt_lock
@ thread_invoke_type_proc
unsigned int report_on_exception
struct rb_mutex_struct * keeping_mutexes
VALUE pending_interrupt_queue
void * blocking_region_buffer
rb_thread_list_t * join_list
const rb_control_frame_t * cfp
rb_execution_context_t * ec
rb_unblock_function_t * func
struct rb_vm_protect_tag * prev
VALUE load_path_check_cache
struct st_table * loaded_features_index
struct rb_objspace * objspace
rb_at_exit_list * at_exit
const struct rb_thread_struct * running_thread
struct st_table * ensure_rollback_table
struct st_table * loading_table
short redefined_flag[BOP_LAST_]
rb_nativethread_lock_t waitpid_lock
struct rb_thread_struct * main_thread
struct list_head waiting_fds
st_table * frozen_strings
st_table * defined_module_hash
const struct rb_builtin_function * builtin_function_table
rb_hook_list_t global_hooks
struct list_head waiting_pids
struct list_head workqueue
size_t fiber_vm_stack_size
volatile int ubf_async_safe
struct rb_postponed_job_struct * postponed_job_buffer
size_t fiber_machine_stack_size
size_t thread_vm_stack_size
const VALUE special_exceptions[ruby_special_error_count]
struct rb_vm_struct::@51 trap_list
VALUE loaded_features_snapshot
struct rb_vm_struct::@52 default_params
struct list_head waiting_grps
unsigned int thread_report_on_exception
rb_nativethread_lock_t workqueue_lock
unsigned int thread_abort_on_exception
size_t thread_machine_stack_size
struct list_head living_threads
void(* sa_sigaction)(int, siginfo_t *, void *)
void(* sigev_notify_function)(sigval_t)
pthread_attr_t * sigev_notify_attributes
st_index_t(* hash)(st_data_t)
int(* compare)(st_data_t, st_data_t)
unsigned int rebuilds_num
unsigned char entry_power
const struct st_hash_type * type
IFUNC (Internal FUNCtion)
struct vm_ifunc_argc argc
rb_block_call_func_t func
const VALUE cref_or_me
class reference or rb_method_entry_t
const struct rb_control_frame_struct * catch_frame
int rb_is_global_id(ID id)
int rb_is_instance_id(ID id)
int rb_is_const_id(ID id)
int rb_is_attrset_sym(VALUE sym)
int rb_is_class_id(ID id)
int rb_is_attrset_id(ID id)
int rb_is_local_id(ID id)
int rb_is_const_sym(VALUE sym)
struct iseq_inline_storage_entry::@44 once
struct iseq_inline_iv_cache_entry iv_cache
struct rb_thread_struct * running_thread
struct iseq_inline_cache_entry cache
MJIT_FUNC_EXPORTED void rb_const_warn_if_deprecated(const rb_const_entry_t *ce, VALUE klass, ID id)
VALUE rb_mod_const_missing(VALUE klass, VALUE name)
void rb_vm_jump_tag_but_local_jump(int state)
VALUE rb_vm_top_self(void)
MJIT_FUNC_EXPORTED void rb_vm_localjump_error(const char *mesg, VALUE value, int reason)
st_table * rb_vm_fstring_table(void)
void rb_iter_break_value(VALUE val)
MJIT_FUNC_EXPORTED int rb_dtrace_setup(rb_execution_context_t *ec, VALUE klass, ID id, struct ruby_dtrace_method_hook_args *args)
MJIT_FUNC_EXPORTED const rb_callable_method_entry_t * rb_resolve_refined_method_callable(VALUE refinements, const rb_callable_method_entry_t *me)
rb_control_frame_t *FUNC_FASTCALL rb_insn_func_t(rb_execution_context_t *, rb_control_frame_t *)
void rb_throw(const char *tag, VALUE val)
void rb_throw_obj(VALUE tag, VALUE value)
rb_control_frame_t *FUNC_FASTCALL() rb_vm_opt_struct_aset(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
MJIT_STATIC void rb_ec_stack_overflow(rb_execution_context_t *ec, int crit)
MJIT_STATIC void rb_error_arity(int argc, int min, int max)
rb_control_frame_t *FUNC_FASTCALL() rb_vm_opt_struct_aref(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
MJIT_STATIC bool rb_simple_iseq_p(const rb_iseq_t *iseq)
MJIT_FUNC_EXPORTED void rb_vm_search_method_slowpath(struct rb_call_data *cd, VALUE klass)
bool rb_method_basic_definition_p_with_cc(struct rb_call_data *cd, VALUE klass, ID mid)
VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)