/**********************************************************************

[0] Fix | Delete

[1] Fix | Delete

intern.h -

[2] Fix | Delete

[3] Fix | Delete

$Author$

[4] Fix | Delete

created at: Thu Jun 10 14:22:17 JST 1993

[5] Fix | Delete

[6] Fix | Delete

Copyright (C) 1993-2007 Yukihiro Matsumoto

[7] Fix | Delete

Copyright (C) 2000 Network Applied Communication Laboratory, Inc.

[8] Fix | Delete

Copyright (C) 2000 Information-technology Promotion Agency, Japan

[9] Fix | Delete

[10] Fix | Delete

**********************************************************************/

[11] Fix | Delete

[12] Fix | Delete

#ifndef RUBY_INTERN_H

[13] Fix | Delete

#define RUBY_INTERN_H 1

[14] Fix | Delete

[15] Fix | Delete

#if defined(__cplusplus)

[16] Fix | Delete

extern "C" {

[17] Fix | Delete

#if 0

[18] Fix | Delete

} /* satisfy cc-mode */

[19] Fix | Delete

#endif

[20] Fix | Delete

#endif

[21] Fix | Delete

[22] Fix | Delete

#if !defined(__has_attribute)

[23] Fix | Delete

#define __has_attribute(x) 0

[24] Fix | Delete

#endif

[25] Fix | Delete

[26] Fix | Delete

#include "ruby/defines.h"

[27] Fix | Delete

#ifdef RUBY_EXTCONF_H

[28] Fix | Delete

#include RUBY_EXTCONF_H

[29] Fix | Delete

#endif

[30] Fix | Delete

[31] Fix | Delete

#ifdef HAVE_STDARG_PROTOTYPES

[32] Fix | Delete

# include <stdarg.h>

[33] Fix | Delete

#else

[34] Fix | Delete

# include <varargs.h>

[35] Fix | Delete

#endif

[36] Fix | Delete

[37] Fix | Delete

#include "ruby/st.h"

[38] Fix | Delete

[39] Fix | Delete

/* On mswin, MJIT header transformation can't be used since cl.exe can't output

[40] Fix | Delete

preprocessed output preserving macros. So this `MJIT_STATIC` is needed

[41] Fix | Delete

to force non-static function to static on MJIT header to avoid symbol conflict. */

[42] Fix | Delete

#ifdef MJIT_HEADER

[43] Fix | Delete

# define MJIT_STATIC static

[44] Fix | Delete

#else

[45] Fix | Delete

# define MJIT_STATIC

[46] Fix | Delete

#endif

[47] Fix | Delete

[48] Fix | Delete

RUBY_SYMBOL_EXPORT_BEGIN

[49] Fix | Delete

[50] Fix | Delete

/*

[51] Fix | Delete

* Functions and variables that are used by more than one source file of

[52] Fix | Delete

* the kernel.

[53] Fix | Delete

*/

[54] Fix | Delete

[55] Fix | Delete

#define UNLIMITED_ARGUMENTS (-1)

[56] Fix | Delete

[57] Fix | Delete

/* array.c */

[58] Fix | Delete

void rb_mem_clear(VALUE*, long);

[59] Fix | Delete

VALUE rb_assoc_new(VALUE, VALUE);

[60] Fix | Delete

VALUE rb_check_array_type(VALUE);

[61] Fix | Delete

VALUE rb_ary_new(void);

[62] Fix | Delete

VALUE rb_ary_new_capa(long capa);

[63] Fix | Delete

VALUE rb_ary_new_from_args(long n, ...);

[64] Fix | Delete

VALUE rb_ary_new_from_values(long n, const VALUE *elts);

[65] Fix | Delete

VALUE rb_ary_tmp_new(long);

[66] Fix | Delete

void rb_ary_free(VALUE);

[67] Fix | Delete

void rb_ary_modify(VALUE);

[68] Fix | Delete

VALUE rb_ary_freeze(VALUE);

[69] Fix | Delete

VALUE rb_ary_shared_with_p(VALUE, VALUE);

[70] Fix | Delete

VALUE rb_ary_aref(int, const VALUE*, VALUE);

[71] Fix | Delete

VALUE rb_ary_subseq(VALUE, long, long);

[72] Fix | Delete

void rb_ary_store(VALUE, long, VALUE);

[73] Fix | Delete

VALUE rb_ary_dup(VALUE);

[74] Fix | Delete

VALUE rb_ary_resurrect(VALUE ary);

[75] Fix | Delete

VALUE rb_ary_to_ary(VALUE);

[76] Fix | Delete

VALUE rb_ary_to_s(VALUE);

[77] Fix | Delete

VALUE rb_ary_cat(VALUE, const VALUE *, long);

[78] Fix | Delete

VALUE rb_ary_push(VALUE, VALUE);

[79] Fix | Delete

VALUE rb_ary_pop(VALUE);

[80] Fix | Delete

VALUE rb_ary_shift(VALUE);

[81] Fix | Delete

VALUE rb_ary_unshift(VALUE, VALUE);

[82] Fix | Delete

VALUE rb_ary_entry(VALUE, long);

[83] Fix | Delete

VALUE rb_ary_each(VALUE);

[84] Fix | Delete

VALUE rb_ary_join(VALUE, VALUE);

[85] Fix | Delete

VALUE rb_ary_reverse(VALUE);

[86] Fix | Delete

VALUE rb_ary_rotate(VALUE, long);

[87] Fix | Delete

VALUE rb_ary_sort(VALUE);

[88] Fix | Delete

VALUE rb_ary_sort_bang(VALUE);

[89] Fix | Delete

VALUE rb_ary_delete(VALUE, VALUE);

[90] Fix | Delete

VALUE rb_ary_delete_at(VALUE, long);

[91] Fix | Delete

VALUE rb_ary_clear(VALUE);

[92] Fix | Delete

VALUE rb_ary_plus(VALUE, VALUE);

[93] Fix | Delete

VALUE rb_ary_concat(VALUE, VALUE);

[94] Fix | Delete

VALUE rb_ary_assoc(VALUE, VALUE);

[95] Fix | Delete

VALUE rb_ary_rassoc(VALUE, VALUE);

[96] Fix | Delete

VALUE rb_ary_includes(VALUE, VALUE);

[97] Fix | Delete

VALUE rb_ary_cmp(VALUE, VALUE);

[98] Fix | Delete

VALUE rb_ary_replace(VALUE copy, VALUE orig);

[99] Fix | Delete

VALUE rb_get_values_at(VALUE, long, int, const VALUE*, VALUE(*)(VALUE,long));

[100] Fix | Delete

VALUE rb_ary_resize(VALUE ary, long len);

[101] Fix | Delete

#define rb_ary_new2 rb_ary_new_capa

[102] Fix | Delete

#define rb_ary_new3 rb_ary_new_from_args

[103] Fix | Delete

#define rb_ary_new4 rb_ary_new_from_values

[104] Fix | Delete

/* bignum.c */

[105] Fix | Delete

VALUE rb_big_new(size_t, int);

[106] Fix | Delete

int rb_bigzero_p(VALUE x);

[107] Fix | Delete

VALUE rb_big_clone(VALUE);

[108] Fix | Delete

void rb_big_2comp(VALUE);

[109] Fix | Delete

VALUE rb_big_norm(VALUE);

[110] Fix | Delete

void rb_big_resize(VALUE big, size_t len);

[111] Fix | Delete

VALUE rb_cstr_to_inum(const char*, int, int);

[112] Fix | Delete

VALUE rb_str_to_inum(VALUE, int, int);

[113] Fix | Delete

VALUE rb_cstr2inum(const char*, int);

[114] Fix | Delete

VALUE rb_str2inum(VALUE, int);

[115] Fix | Delete

VALUE rb_big2str(VALUE, int);

[116] Fix | Delete

long rb_big2long(VALUE);

[117] Fix | Delete

#define rb_big2int(x) rb_big2long(x)

[118] Fix | Delete

unsigned long rb_big2ulong(VALUE);

[119] Fix | Delete

#define rb_big2uint(x) rb_big2ulong(x)

[120] Fix | Delete

#if HAVE_LONG_LONG

[121] Fix | Delete

LONG_LONG rb_big2ll(VALUE);

[122] Fix | Delete

unsigned LONG_LONG rb_big2ull(VALUE);

[123] Fix | Delete

#endif /* HAVE_LONG_LONG */

[124] Fix | Delete

void rb_big_pack(VALUE val, unsigned long *buf, long num_longs);

[125] Fix | Delete

VALUE rb_big_unpack(unsigned long *buf, long num_longs);

[126] Fix | Delete

int rb_uv_to_utf8(char[6],unsigned long);

[127] Fix | Delete

VALUE rb_dbl2big(double);

[128] Fix | Delete

double rb_big2dbl(VALUE);

[129] Fix | Delete

VALUE rb_big_cmp(VALUE, VALUE);

[130] Fix | Delete

VALUE rb_big_eq(VALUE, VALUE);

[131] Fix | Delete

VALUE rb_big_eql(VALUE, VALUE);

[132] Fix | Delete

VALUE rb_big_plus(VALUE, VALUE);

[133] Fix | Delete

VALUE rb_big_minus(VALUE, VALUE);

[134] Fix | Delete

VALUE rb_big_mul(VALUE, VALUE);

[135] Fix | Delete

VALUE rb_big_div(VALUE, VALUE);

[136] Fix | Delete

VALUE rb_big_idiv(VALUE, VALUE);

[137] Fix | Delete

VALUE rb_big_modulo(VALUE, VALUE);

[138] Fix | Delete

VALUE rb_big_divmod(VALUE, VALUE);

[139] Fix | Delete

VALUE rb_big_pow(VALUE, VALUE);

[140] Fix | Delete

VALUE rb_big_and(VALUE, VALUE);

[141] Fix | Delete

VALUE rb_big_or(VALUE, VALUE);

[142] Fix | Delete

VALUE rb_big_xor(VALUE, VALUE);

[143] Fix | Delete

VALUE rb_big_lshift(VALUE, VALUE);

[144] Fix | Delete

VALUE rb_big_rshift(VALUE, VALUE);

[145] Fix | Delete

[146] Fix | Delete

/* For rb_integer_pack and rb_integer_unpack: */

[147] Fix | Delete

/* "MS" in MSWORD and MSBYTE means "most significant" */

[148] Fix | Delete

/* "LS" in LSWORD and LSBYTE means "least significant" */

[149] Fix | Delete

#define INTEGER_PACK_MSWORD_FIRST 0x01

[150] Fix | Delete

#define INTEGER_PACK_LSWORD_FIRST 0x02

[151] Fix | Delete

#define INTEGER_PACK_MSBYTE_FIRST 0x10

[152] Fix | Delete

#define INTEGER_PACK_LSBYTE_FIRST 0x20

[153] Fix | Delete

#define INTEGER_PACK_NATIVE_BYTE_ORDER 0x40

[154] Fix | Delete

#define INTEGER_PACK_2COMP 0x80

[155] Fix | Delete

#define INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION 0x400

[156] Fix | Delete

/* For rb_integer_unpack: */

[157] Fix | Delete

#define INTEGER_PACK_FORCE_BIGNUM 0x100

[158] Fix | Delete

#define INTEGER_PACK_NEGATIVE 0x200

[159] Fix | Delete

/* Combinations: */

[160] Fix | Delete

#define INTEGER_PACK_LITTLE_ENDIAN \

[161] Fix | Delete

(INTEGER_PACK_LSWORD_FIRST | \

[162] Fix | Delete

INTEGER_PACK_LSBYTE_FIRST)

[163] Fix | Delete

#define INTEGER_PACK_BIG_ENDIAN \

[164] Fix | Delete

(INTEGER_PACK_MSWORD_FIRST | \

[165] Fix | Delete

INTEGER_PACK_MSBYTE_FIRST)

[166] Fix | Delete

int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags);

[167] Fix | Delete

VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags);

[168] Fix | Delete

size_t rb_absint_size(VALUE val, int *nlz_bits_ret);

[169] Fix | Delete

size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret);

[170] Fix | Delete

int rb_absint_singlebit_p(VALUE val);

[171] Fix | Delete

[172] Fix | Delete

/* rational.c */

[173] Fix | Delete

VALUE rb_rational_raw(VALUE, VALUE);

[174] Fix | Delete

#define rb_rational_raw1(x) rb_rational_raw((x), INT2FIX(1))

[175] Fix | Delete

#define rb_rational_raw2(x,y) rb_rational_raw((x), (y))

[176] Fix | Delete

VALUE rb_rational_new(VALUE, VALUE);

[177] Fix | Delete

#define rb_rational_new1(x) rb_rational_new((x), INT2FIX(1))

[178] Fix | Delete

#define rb_rational_new2(x,y) rb_rational_new((x), (y))

[179] Fix | Delete

VALUE rb_Rational(VALUE, VALUE);

[180] Fix | Delete

#define rb_Rational1(x) rb_Rational((x), INT2FIX(1))

[181] Fix | Delete

#define rb_Rational2(x,y) rb_Rational((x), (y))

[182] Fix | Delete

VALUE rb_rational_num(VALUE rat);

[183] Fix | Delete

VALUE rb_rational_den(VALUE rat);

[184] Fix | Delete

VALUE rb_flt_rationalize_with_prec(VALUE, VALUE);

[185] Fix | Delete

VALUE rb_flt_rationalize(VALUE);

[186] Fix | Delete

/* complex.c */

[187] Fix | Delete

VALUE rb_complex_raw(VALUE, VALUE);

[188] Fix | Delete

#define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0))

[189] Fix | Delete

#define rb_complex_raw2(x,y) rb_complex_raw((x), (y))

[190] Fix | Delete

VALUE rb_complex_new(VALUE, VALUE);

[191] Fix | Delete

#define rb_complex_new1(x) rb_complex_new((x), INT2FIX(0))

[192] Fix | Delete

#define rb_complex_new2(x,y) rb_complex_new((x), (y))

[193] Fix | Delete

VALUE rb_complex_new_polar(VALUE abs, VALUE arg);

[194] Fix | Delete

DEPRECATED_BY(rb_complex_new_polar, VALUE rb_complex_polar(VALUE abs, VALUE arg));

[195] Fix | Delete

VALUE rb_complex_real(VALUE z);

[196] Fix | Delete

VALUE rb_complex_imag(VALUE z);

[197] Fix | Delete

VALUE rb_complex_plus(VALUE x, VALUE y);

[198] Fix | Delete

VALUE rb_complex_minus(VALUE x, VALUE y);

[199] Fix | Delete

VALUE rb_complex_mul(VALUE x, VALUE y);

[200] Fix | Delete

VALUE rb_complex_div(VALUE x, VALUE y);

[201] Fix | Delete

VALUE rb_complex_uminus(VALUE z);

[202] Fix | Delete

VALUE rb_complex_conjugate(VALUE z);

[203] Fix | Delete

VALUE rb_complex_abs(VALUE z);

[204] Fix | Delete

VALUE rb_complex_arg(VALUE z);

[205] Fix | Delete

VALUE rb_complex_pow(VALUE base, VALUE exp);

[206] Fix | Delete

VALUE rb_dbl_complex_new(double real, double imag);

[207] Fix | Delete

#define rb_complex_add rb_complex_plus

[208] Fix | Delete

#define rb_complex_sub rb_complex_minus

[209] Fix | Delete

#define rb_complex_nagate rb_complex_uminus

[210] Fix | Delete

[211] Fix | Delete

VALUE rb_Complex(VALUE, VALUE);

[212] Fix | Delete

#define rb_Complex1(x) rb_Complex((x), INT2FIX(0))

[213] Fix | Delete

#define rb_Complex2(x,y) rb_Complex((x), (y))

[214] Fix | Delete

/* class.c */

[215] Fix | Delete

VALUE rb_class_new(VALUE);

[216] Fix | Delete

VALUE rb_mod_init_copy(VALUE, VALUE);

[217] Fix | Delete

VALUE rb_singleton_class_clone(VALUE);

[218] Fix | Delete

void rb_singleton_class_attached(VALUE,VALUE);

[219] Fix | Delete

void rb_check_inheritable(VALUE);

[220] Fix | Delete

VALUE rb_define_class_id(ID, VALUE);

[221] Fix | Delete

VALUE rb_define_class_id_under(VALUE, ID, VALUE);

[222] Fix | Delete

VALUE rb_module_new(void);

[223] Fix | Delete

VALUE rb_define_module_id(ID);

[224] Fix | Delete

VALUE rb_define_module_id_under(VALUE, ID);

[225] Fix | Delete

VALUE rb_mod_included_modules(VALUE);

[226] Fix | Delete

VALUE rb_mod_include_p(VALUE, VALUE);

[227] Fix | Delete

VALUE rb_mod_ancestors(VALUE);

[228] Fix | Delete

VALUE rb_class_instance_methods(int, const VALUE*, VALUE);

[229] Fix | Delete

VALUE rb_class_public_instance_methods(int, const VALUE*, VALUE);

[230] Fix | Delete

VALUE rb_class_protected_instance_methods(int, const VALUE*, VALUE);

[231] Fix | Delete

VALUE rb_class_private_instance_methods(int, const VALUE*, VALUE);

[232] Fix | Delete

VALUE rb_obj_singleton_methods(int, const VALUE*, VALUE);

[233] Fix | Delete

void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int);

[234] Fix | Delete

void rb_undef(VALUE, ID);

[235] Fix | Delete

void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int);

[236] Fix | Delete

void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int);

[237] Fix | Delete

void rb_define_singleton_method(VALUE, const char*, VALUE(*)(ANYARGS), int);

[238] Fix | Delete

VALUE rb_singleton_class(VALUE);

[239] Fix | Delete

/* compar.c */

[240] Fix | Delete

int rb_cmpint(VALUE, VALUE, VALUE);

[241] Fix | Delete

NORETURN(void rb_cmperr(VALUE, VALUE));

[242] Fix | Delete

/* cont.c */

[243] Fix | Delete

VALUE rb_fiber_new(rb_block_call_func_t, VALUE);

[244] Fix | Delete

VALUE rb_fiber_resume(VALUE fib, int argc, const VALUE *argv);

[245] Fix | Delete

VALUE rb_fiber_resume_kw(VALUE fib, int argc, const VALUE *argv, int kw_splat);

[246] Fix | Delete

VALUE rb_fiber_yield(int argc, const VALUE *argv);

[247] Fix | Delete

VALUE rb_fiber_yield_kw(int argc, const VALUE *argv, int kw_splat);

[248] Fix | Delete

VALUE rb_fiber_current(void);

[249] Fix | Delete

VALUE rb_fiber_alive_p(VALUE);

[250] Fix | Delete

/* enum.c */

[251] Fix | Delete

VALUE rb_enum_values_pack(int, const VALUE*);

[252] Fix | Delete

/* enumerator.c */

[253] Fix | Delete

VALUE rb_enumeratorize(VALUE, VALUE, int, const VALUE *);

[254] Fix | Delete

typedef VALUE rb_enumerator_size_func(VALUE, VALUE, VALUE);

[255] Fix | Delete

VALUE rb_enumeratorize_with_size(VALUE, VALUE, int, const VALUE *, rb_enumerator_size_func *);

[256] Fix | Delete

VALUE rb_enumeratorize_with_size_kw(VALUE, VALUE, int, const VALUE *, rb_enumerator_size_func *, int);

[257] Fix | Delete

#ifndef RUBY_EXPORT

[258] Fix | Delete

#define rb_enumeratorize_with_size(obj, id, argc, argv, size_fn) \

[259] Fix | Delete

rb_enumeratorize_with_size(obj, id, argc, argv, (rb_enumerator_size_func *)(size_fn))

[260] Fix | Delete

#define rb_enumeratorize_with_size_kw(obj, id, argc, argv, size_fn, kw_splat) \

[261] Fix | Delete

rb_enumeratorize_with_size_kw(obj, id, argc, argv, (rb_enumerator_size_func *)(size_fn), kw_splat)

[262] Fix | Delete

#endif

[263] Fix | Delete

#define SIZED_ENUMERATOR(obj, argc, argv, size_fn) \

[264] Fix | Delete

rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), \

[265] Fix | Delete

(argc), (argv), (size_fn))

[266] Fix | Delete

#define SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat) \

[267] Fix | Delete

rb_enumeratorize_with_size_kw((obj), ID2SYM(rb_frame_this_func()), \

[268] Fix | Delete

(argc), (argv), (size_fn), (kw_splat))

[269] Fix | Delete

#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do { \

[270] Fix | Delete

if (!rb_block_given_p()) \

[271] Fix | Delete

return SIZED_ENUMERATOR(obj, argc, argv, size_fn); \

[272] Fix | Delete

} while (0)

[273] Fix | Delete

#define RETURN_SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat) do { \

[274] Fix | Delete

if (!rb_block_given_p()) \

[275] Fix | Delete

return SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat); \

[276] Fix | Delete

} while (0)

[277] Fix | Delete

#define RETURN_ENUMERATOR(obj, argc, argv) RETURN_SIZED_ENUMERATOR(obj, argc, argv, 0)

[278] Fix | Delete

#define RETURN_ENUMERATOR_KW(obj, argc, argv, kw_splat) RETURN_SIZED_ENUMERATOR_KW(obj, argc, argv, 0, kw_splat)

[279] Fix | Delete

typedef struct {

[280] Fix | Delete

VALUE begin;

[281] Fix | Delete

VALUE end;

[282] Fix | Delete

VALUE step;

[283] Fix | Delete

int exclude_end;

[284] Fix | Delete

} rb_arithmetic_sequence_components_t;

[285] Fix | Delete

int rb_arithmetic_sequence_extract(VALUE, rb_arithmetic_sequence_components_t *);

[286] Fix | Delete

/* error.c */

[287] Fix | Delete

VALUE rb_exc_new(VALUE, const char*, long);

[288] Fix | Delete

VALUE rb_exc_new_cstr(VALUE, const char*);

[289] Fix | Delete

VALUE rb_exc_new_str(VALUE, VALUE);

[290] Fix | Delete

#define rb_exc_new2 rb_exc_new_cstr

[291] Fix | Delete

#define rb_exc_new3 rb_exc_new_str

[292] Fix | Delete

PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2);

[293] Fix | Delete

PRINTF_ARGS(NORETURN(void rb_loaderror_with_path(VALUE path, const char*, ...)), 2, 3);

[294] Fix | Delete

PRINTF_ARGS(NORETURN(void rb_name_error(ID, const char*, ...)), 2, 3);

[295] Fix | Delete

PRINTF_ARGS(NORETURN(void rb_name_error_str(VALUE, const char*, ...)), 2, 3);

[296] Fix | Delete

PRINTF_ARGS(NORETURN(void rb_frozen_error_raise(VALUE, const char*, ...)), 2, 3);

[297] Fix | Delete

NORETURN(void rb_invalid_str(const char*, const char*));

[298] Fix | Delete

NORETURN(void rb_error_frozen(const char*));

[299] Fix | Delete

NORETURN(void rb_error_frozen_object(VALUE));

[300] Fix | Delete

void rb_error_untrusted(VALUE);

[301] Fix | Delete

void rb_check_frozen(VALUE);

[302] Fix | Delete

void rb_check_trusted(VALUE);

[303] Fix | Delete

#define rb_check_frozen_internal(obj) do { \

[304] Fix | Delete

VALUE frozen_obj = (obj); \

[305] Fix | Delete

if (RB_UNLIKELY(RB_OBJ_FROZEN(frozen_obj))) { \

[306] Fix | Delete

rb_error_frozen_object(frozen_obj); \

[307] Fix | Delete

} \

[308] Fix | Delete

} while (0)

[309] Fix | Delete

#ifdef __GNUC__

[310] Fix | Delete

#define rb_check_frozen(obj) __extension__({rb_check_frozen_internal(obj);})

[311] Fix | Delete

#else

[312] Fix | Delete

static inline void

[313] Fix | Delete

rb_check_frozen_inline(VALUE obj)

[314] Fix | Delete

{

[315] Fix | Delete

rb_check_frozen_internal(obj);

[316] Fix | Delete

}

[317] Fix | Delete

#define rb_check_frozen(obj) rb_check_frozen_inline(obj)

[318] Fix | Delete

static inline void

[319] Fix | Delete

rb_check_trusted_inline(VALUE obj)

[320] Fix | Delete

{

[321] Fix | Delete

rb_check_trusted(obj);

[322] Fix | Delete

}

[323] Fix | Delete

#define rb_check_trusted(obj) rb_check_trusted_inline(obj)

[324] Fix | Delete

#endif

[325] Fix | Delete

void rb_check_copyable(VALUE obj, VALUE orig);

[326] Fix | Delete

[327] Fix | Delete

#define RB_OBJ_INIT_COPY(obj, orig) \

[328] Fix | Delete

((obj) != (orig) && (rb_obj_init_copy((obj), (orig)), 1))

[329] Fix | Delete

#define OBJ_INIT_COPY(obj, orig) RB_OBJ_INIT_COPY(obj, orig)

[330] Fix | Delete

[331] Fix | Delete

/* eval.c */

[332] Fix | Delete

int rb_sourceline(void);

[333] Fix | Delete

const char *rb_sourcefile(void);

[334] Fix | Delete

VALUE rb_check_funcall(VALUE, ID, int, const VALUE*);

[335] Fix | Delete

VALUE rb_check_funcall_kw(VALUE, ID, int, const VALUE*, int);

[336] Fix | Delete

[337] Fix | Delete

NORETURN(MJIT_STATIC void rb_error_arity(int, int, int));

[338] Fix | Delete

static inline int

[339] Fix | Delete

rb_check_arity(int argc, int min, int max)

[340] Fix | Delete

{

[341] Fix | Delete

if ((argc < min) || (max != UNLIMITED_ARGUMENTS && argc > max))

[342] Fix | Delete

rb_error_arity(argc, min, max);

[343] Fix | Delete

return argc;

[344] Fix | Delete

}

[345] Fix | Delete

#define rb_check_arity rb_check_arity /* for ifdef */

[346] Fix | Delete

[347] Fix | Delete

#if defined(NFDBITS) && defined(HAVE_RB_FD_INIT)

[348] Fix | Delete

typedef struct {

[349] Fix | Delete

int maxfd;

[350] Fix | Delete

fd_set *fdset;

[351] Fix | Delete

} rb_fdset_t;

[352] Fix | Delete

[353] Fix | Delete

void rb_fd_init(rb_fdset_t *);

[354] Fix | Delete

void rb_fd_term(rb_fdset_t *);

[355] Fix | Delete

void rb_fd_zero(rb_fdset_t *);

[356] Fix | Delete

void rb_fd_set(int, rb_fdset_t *);

[357] Fix | Delete

void rb_fd_clr(int, rb_fdset_t *);

[358] Fix | Delete

int rb_fd_isset(int, const rb_fdset_t *);

[359] Fix | Delete

void rb_fd_copy(rb_fdset_t *, const fd_set *, int);

[360] Fix | Delete

void rb_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);

[361] Fix | Delete

[362] Fix | Delete

struct timeval;

[363] Fix | Delete

int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);

[364] Fix | Delete

[365] Fix | Delete

#define rb_fd_ptr(f) ((f)->fdset)

[366] Fix | Delete

#define rb_fd_max(f) ((f)->maxfd)

[367] Fix | Delete

[368] Fix | Delete

#elif defined(_WIN32)

[369] Fix | Delete

[370] Fix | Delete

typedef struct {

[371] Fix | Delete

int capa;

[372] Fix | Delete

fd_set *fdset;

[373] Fix | Delete

} rb_fdset_t;

[374] Fix | Delete

[375] Fix | Delete

void rb_fd_init(rb_fdset_t *);

[376] Fix | Delete

void rb_fd_term(rb_fdset_t *);

[377] Fix | Delete

#define rb_fd_zero(f) ((f)->fdset->fd_count = 0)

[378] Fix | Delete

void rb_fd_set(int, rb_fdset_t *);

[379] Fix | Delete

#define rb_fd_clr(n, f) rb_w32_fdclr((n), (f)->fdset)

[380] Fix | Delete

#define rb_fd_isset(n, f) rb_w32_fdisset((n), (f)->fdset)

[381] Fix | Delete

#define rb_fd_copy(d, s, n) rb_w32_fd_copy((d), (s), (n))

[382] Fix | Delete

void rb_w32_fd_copy(rb_fdset_t *, const fd_set *, int);

[383] Fix | Delete

#define rb_fd_dup(d, s) rb_w32_fd_dup((d), (s))

[384] Fix | Delete

void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);

[385] Fix | Delete

static inline int

[386] Fix | Delete

rb_fd_select(int n, rb_fdset_t *rfds, rb_fdset_t *wfds, rb_fdset_t *efds, struct timeval *timeout)

[387] Fix | Delete

{

[388] Fix | Delete

return rb_w32_select(n,

[389] Fix | Delete

rfds ? rfds->fdset : NULL,

[390] Fix | Delete

wfds ? wfds->fdset : NULL,

[391] Fix | Delete

efds ? efds->fdset : NULL,

[392] Fix | Delete

timeout);

[393] Fix | Delete

}

[394] Fix | Delete

#define rb_fd_resize(n, f) ((void)(f))

[395] Fix | Delete

[396] Fix | Delete

#define rb_fd_ptr(f) ((f)->fdset)

[397] Fix | Delete

#define rb_fd_max(f) ((f)->fdset->fd_count)

[398] Fix | Delete

[399] Fix | Delete

#else

[400] Fix | Delete

[401] Fix | Delete

typedef fd_set rb_fdset_t;

[402] Fix | Delete

#define rb_fd_zero(f) FD_ZERO(f)

[403] Fix | Delete

#define rb_fd_set(n, f) FD_SET((n), (f))

[404] Fix | Delete

#define rb_fd_clr(n, f) FD_CLR((n), (f))

[405] Fix | Delete

#define rb_fd_isset(n, f) FD_ISSET((n), (f))

[406] Fix | Delete

#define rb_fd_copy(d, s, n) (*(d) = *(s))

[407] Fix | Delete

#define rb_fd_dup(d, s) (*(d) = *(s))

[408] Fix | Delete

#define rb_fd_resize(n, f) ((void)(f))

[409] Fix | Delete

#define rb_fd_ptr(f) (f)

[410] Fix | Delete

#define rb_fd_init(f) FD_ZERO(f)

[411] Fix | Delete

#define rb_fd_init_copy(d, s) (*(d) = *(s))

[412] Fix | Delete

#define rb_fd_term(f) ((void)(f))

[413] Fix | Delete

#define rb_fd_max(f) FD_SETSIZE

[414] Fix | Delete

#define rb_fd_select(n, rfds, wfds, efds, timeout) select((n), (rfds), (wfds), (efds), (timeout))

[415] Fix | Delete

[416] Fix | Delete

#endif

[417] Fix | Delete

[418] Fix | Delete

NORETURN(void rb_exc_raise(VALUE));

[419] Fix | Delete

NORETURN(void rb_exc_fatal(VALUE));

[420] Fix | Delete

NORETURN(VALUE rb_f_exit(int, const VALUE*));

[421] Fix | Delete

NORETURN(VALUE rb_f_abort(int, const VALUE*));

[422] Fix | Delete

void rb_remove_method(VALUE, const char*);

[423] Fix | Delete

void rb_remove_method_id(VALUE, ID);

[424] Fix | Delete

#define HAVE_RB_DEFINE_ALLOC_FUNC 1

[425] Fix | Delete

typedef VALUE (*rb_alloc_func_t)(VALUE);

[426] Fix | Delete

void rb_define_alloc_func(VALUE, rb_alloc_func_t);

[427] Fix | Delete

void rb_undef_alloc_func(VALUE);

[428] Fix | Delete

rb_alloc_func_t rb_get_alloc_func(VALUE);

[429] Fix | Delete

void rb_clear_constant_cache(void);

[430] Fix | Delete

void rb_clear_method_cache_by_class(VALUE);

[431] Fix | Delete

void rb_alias(VALUE, ID, ID);

[432] Fix | Delete

void rb_attr(VALUE,ID,int,int,int);

[433] Fix | Delete

int rb_method_boundp(VALUE, ID, int);

[434] Fix | Delete

int rb_method_basic_definition_p(VALUE, ID);

[435] Fix | Delete

VALUE rb_eval_cmd(VALUE, VALUE, int);

[436] Fix | Delete

VALUE rb_eval_cmd_kw(VALUE, VALUE, int);

[437] Fix | Delete

int rb_obj_respond_to(VALUE, ID, int);

[438] Fix | Delete

int rb_respond_to(VALUE, ID);

[439] Fix | Delete

NORETURN(VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker));

[440] Fix | Delete

#if !defined(RUBY_EXPORT) && defined(_WIN32)

[441] Fix | Delete

RUBY_EXTERN VALUE (*const rb_f_notimplement_)(int, const VALUE *, VALUE, VALUE marker);

[442] Fix | Delete

#define rb_f_notimplement (*rb_f_notimplement_)

[443] Fix | Delete

#endif

[444] Fix | Delete

NORETURN(void rb_interrupt(void));

[445] Fix | Delete

VALUE rb_apply(VALUE, ID, VALUE);

[446] Fix | Delete

void rb_backtrace(void);

[447] Fix | Delete

ID rb_frame_this_func(void);

[448] Fix | Delete

VALUE rb_obj_instance_eval(int, const VALUE*, VALUE);

[449] Fix | Delete

VALUE rb_obj_instance_exec(int, const VALUE*, VALUE);

[450] Fix | Delete

VALUE rb_mod_module_eval(int, const VALUE*, VALUE);

[451] Fix | Delete

VALUE rb_mod_module_exec(int, const VALUE*, VALUE);

[452] Fix | Delete

void rb_load(VALUE, int);

[453] Fix | Delete

void rb_load_protect(VALUE, int, int*);

[454] Fix | Delete

NORETURN(void rb_jump_tag(int));

[455] Fix | Delete

int rb_provided(const char*);

[456] Fix | Delete

int rb_feature_provided(const char *, const char **);

[457] Fix | Delete

void rb_provide(const char*);

[458] Fix | Delete

VALUE rb_f_require(VALUE, VALUE);

[459] Fix | Delete

VALUE rb_require_safe(VALUE, int); /* Remove in 3.0 */

[460] Fix | Delete

VALUE rb_require_string(VALUE);

[461] Fix | Delete

void rb_obj_call_init(VALUE, int, const VALUE*);

[462] Fix | Delete

void rb_obj_call_init_kw(VALUE, int, const VALUE*, int);

[463] Fix | Delete

VALUE rb_class_new_instance(int, const VALUE*, VALUE);

[464] Fix | Delete

VALUE rb_class_new_instance_kw(int, const VALUE*, VALUE, int);

[465] Fix | Delete

VALUE rb_block_proc(void);

[466] Fix | Delete

VALUE rb_block_lambda(void);

[467] Fix | Delete

VALUE rb_proc_new(rb_block_call_func_t, VALUE);

[468] Fix | Delete

VALUE rb_obj_is_proc(VALUE);

[469] Fix | Delete

VALUE rb_proc_call(VALUE, VALUE);

[470] Fix | Delete

VALUE rb_proc_call_kw(VALUE, VALUE, int);

[471] Fix | Delete

VALUE rb_proc_call_with_block(VALUE, int argc, const VALUE *argv, VALUE);

[472] Fix | Delete

VALUE rb_proc_call_with_block_kw(VALUE, int argc, const VALUE *argv, VALUE, int);

[473] Fix | Delete

int rb_proc_arity(VALUE);

[474] Fix | Delete

VALUE rb_proc_lambda_p(VALUE);

[475] Fix | Delete

VALUE rb_binding_new(void);

[476] Fix | Delete

VALUE rb_obj_method(VALUE, VALUE);

[477] Fix | Delete

VALUE rb_obj_is_method(VALUE);

[478] Fix | Delete

VALUE rb_method_call(int, const VALUE*, VALUE);

[479] Fix | Delete

VALUE rb_method_call_kw(int, const VALUE*, VALUE, int);

[480] Fix | Delete

VALUE rb_method_call_with_block(int, const VALUE *, VALUE, VALUE);

[481] Fix | Delete

VALUE rb_method_call_with_block_kw(int, const VALUE *, VALUE, VALUE, int);

[482] Fix | Delete

int rb_mod_method_arity(VALUE, ID);

[483] Fix | Delete

int rb_obj_method_arity(VALUE, ID);

[484] Fix | Delete

VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*);

[485] Fix | Delete

void rb_set_end_proc(void (*)(VALUE), VALUE);

[486] Fix | Delete

void rb_thread_schedule(void);

[487] Fix | Delete

void rb_thread_wait_fd(int);

[488] Fix | Delete

int rb_thread_fd_writable(int);

[489] Fix | Delete

void rb_thread_fd_close(int);

[490] Fix | Delete

int rb_thread_alone(void);

[491] Fix | Delete

void rb_thread_sleep(int);

[492] Fix | Delete

void rb_thread_sleep_forever(void);

[493] Fix | Delete

void rb_thread_sleep_deadly(void);

[494] Fix | Delete

VALUE rb_thread_stop(void);

[495] Fix | Delete

VALUE rb_thread_wakeup(VALUE);

[496] Fix | Delete

VALUE rb_thread_wakeup_alive(VALUE);

[497] Fix | Delete

VALUE rb_thread_run(VALUE);

[498] Fix | Delete

VALUE rb_thread_kill(VALUE);

[499] Fix | Delete