Ruby 2.7.7p221 (2022-11-24 revision 168ec2b1e5ad0e4688e963d9de019557c78feed9)
intern.h
Go to the documentation of this file.
1/**********************************************************************
2
3 intern.h -
4
5 $Author$
6 created at: Thu Jun 10 14:22:17 JST 1993
7
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
9 Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
10 Copyright (C) 2000 Information-technology Promotion Agency, Japan
11
12**********************************************************************/
13
14#ifndef RUBY_INTERN_H
15#define RUBY_INTERN_H 1
16
17#if defined(__cplusplus)
18extern "C" {
19#if 0
20} /* satisfy cc-mode */
21#endif
22#endif
23
24#if !defined(__has_attribute)
25#define __has_attribute(x) 0
26#endif
27
28#include "ruby/defines.h"
29#ifdef RUBY_EXTCONF_H
30#include RUBY_EXTCONF_H
31#endif
32
33#ifdef HAVE_STDARG_PROTOTYPES
34# include <stdarg.h>
35#else
36# include <varargs.h>
37#endif
38
39#include "ruby/st.h"
40
41/* On mswin, MJIT header transformation can't be used since cl.exe can't output
42 preprocessed output preserving macros. So this `MJIT_STATIC` is needed
43 to force non-static function to static on MJIT header to avoid symbol conflict. */
44#ifdef MJIT_HEADER
45# define MJIT_STATIC static
46#else
47# define MJIT_STATIC
48#endif
49
51
52/*
53 * Functions and variables that are used by more than one source file of
54 * the kernel.
55 */
56
57#define UNLIMITED_ARGUMENTS (-1)
58
59/* array.c */
60void rb_mem_clear(VALUE*, long);
63VALUE rb_ary_new(void);
64VALUE rb_ary_new_capa(long capa);
66VALUE rb_ary_new_from_values(long n, const VALUE *elts);
68void rb_ary_free(VALUE);
72VALUE rb_ary_aref(int, const VALUE*, VALUE);
73VALUE rb_ary_subseq(VALUE, long, long);
74void rb_ary_store(VALUE, long, VALUE);
79VALUE rb_ary_cat(VALUE, const VALUE *, long);
100VALUE rb_ary_replace(VALUE copy, VALUE orig);
101VALUE rb_get_values_at(VALUE, long, int, const VALUE*, VALUE(*)(VALUE,long));
102VALUE rb_ary_resize(VALUE ary, long len);
103#define rb_ary_new2 rb_ary_new_capa
104#define rb_ary_new3 rb_ary_new_from_args
105#define rb_ary_new4 rb_ary_new_from_values
106/* bignum.c */
107VALUE rb_big_new(size_t, int);
108int rb_bigzero_p(VALUE x);
110void rb_big_2comp(VALUE);
112void rb_big_resize(VALUE big, size_t len);
113VALUE rb_cstr_to_inum(const char*, int, int);
114VALUE rb_str_to_inum(VALUE, int, int);
115VALUE rb_cstr2inum(const char*, int);
118long rb_big2long(VALUE);
119#define rb_big2int(x) rb_big2long(x)
120unsigned long rb_big2ulong(VALUE);
121#define rb_big2uint(x) rb_big2ulong(x)
122#if HAVE_LONG_LONG
124unsigned LONG_LONG rb_big2ull(VALUE);
125#endif /* HAVE_LONG_LONG */
126void rb_big_pack(VALUE val, unsigned long *buf, long num_longs);
127VALUE rb_big_unpack(unsigned long *buf, long num_longs);
128int rb_uv_to_utf8(char[6],unsigned long);
129VALUE rb_dbl2big(double);
130double rb_big2dbl(VALUE);
147
148/* For rb_integer_pack and rb_integer_unpack: */
149/* "MS" in MSWORD and MSBYTE means "most significant" */
150/* "LS" in LSWORD and LSBYTE means "least significant" */
151#define INTEGER_PACK_MSWORD_FIRST 0x01
152#define INTEGER_PACK_LSWORD_FIRST 0x02
153#define INTEGER_PACK_MSBYTE_FIRST 0x10
154#define INTEGER_PACK_LSBYTE_FIRST 0x20
155#define INTEGER_PACK_NATIVE_BYTE_ORDER 0x40
156#define INTEGER_PACK_2COMP 0x80
157#define INTEGER_PACK_FORCE_GENERIC_IMPLEMENTATION 0x400
158/* For rb_integer_unpack: */
159#define INTEGER_PACK_FORCE_BIGNUM 0x100
160#define INTEGER_PACK_NEGATIVE 0x200
161/* Combinations: */
162#define INTEGER_PACK_LITTLE_ENDIAN \
163 (INTEGER_PACK_LSWORD_FIRST | \
164 INTEGER_PACK_LSBYTE_FIRST)
165#define INTEGER_PACK_BIG_ENDIAN \
166 (INTEGER_PACK_MSWORD_FIRST | \
167 INTEGER_PACK_MSBYTE_FIRST)
168int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags);
169VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags);
170size_t rb_absint_size(VALUE val, int *nlz_bits_ret);
171size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret);
173
174/* rational.c */
176#define rb_rational_raw1(x) rb_rational_raw((x), INT2FIX(1))
177#define rb_rational_raw2(x,y) rb_rational_raw((x), (y))
179#define rb_rational_new1(x) rb_rational_new((x), INT2FIX(1))
180#define rb_rational_new2(x,y) rb_rational_new((x), (y))
182#define rb_Rational1(x) rb_Rational((x), INT2FIX(1))
183#define rb_Rational2(x,y) rb_Rational((x), (y))
188/* complex.c */
190#define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0))
191#define rb_complex_raw2(x,y) rb_complex_raw((x), (y))
193#define rb_complex_new1(x) rb_complex_new((x), INT2FIX(0))
194#define rb_complex_new2(x,y) rb_complex_new((x), (y))
208VALUE rb_dbl_complex_new(double real, double imag);
209#define rb_complex_add rb_complex_plus
210#define rb_complex_sub rb_complex_minus
211#define rb_complex_nagate rb_complex_uminus
212
214#define rb_Complex1(x) rb_Complex((x), INT2FIX(0))
215#define rb_Complex2(x,y) rb_Complex((x), (y))
216/* class.c */
224VALUE rb_module_new(void);
235void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int);
236void rb_undef(VALUE, ID);
237void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
238void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
239void rb_define_singleton_method(VALUE, const char*, VALUE(*)(ANYARGS), int);
241/* compar.c */
244/* cont.c */
246VALUE rb_fiber_resume(VALUE fib, int argc, const VALUE *argv);
247VALUE rb_fiber_resume_kw(VALUE fib, int argc, const VALUE *argv, int kw_splat);
248VALUE rb_fiber_yield(int argc, const VALUE *argv);
249VALUE rb_fiber_yield_kw(int argc, const VALUE *argv, int kw_splat);
252/* enum.c */
253VALUE rb_enum_values_pack(int, const VALUE*);
254/* enumerator.c */
255VALUE rb_enumeratorize(VALUE, VALUE, int, const VALUE *);
259#ifndef RUBY_EXPORT
260#define rb_enumeratorize_with_size(obj, id, argc, argv, size_fn) \
261 rb_enumeratorize_with_size(obj, id, argc, argv, (rb_enumerator_size_func *)(size_fn))
262#define rb_enumeratorize_with_size_kw(obj, id, argc, argv, size_fn, kw_splat) \
263 rb_enumeratorize_with_size_kw(obj, id, argc, argv, (rb_enumerator_size_func *)(size_fn), kw_splat)
264#endif
265#define SIZED_ENUMERATOR(obj, argc, argv, size_fn) \
266 rb_enumeratorize_with_size((obj), ID2SYM(rb_frame_this_func()), \
267 (argc), (argv), (size_fn))
268#define SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat) \
269 rb_enumeratorize_with_size_kw((obj), ID2SYM(rb_frame_this_func()), \
270 (argc), (argv), (size_fn), (kw_splat))
271#define RETURN_SIZED_ENUMERATOR(obj, argc, argv, size_fn) do { \
272 if (!rb_block_given_p()) \
273 return SIZED_ENUMERATOR(obj, argc, argv, size_fn); \
274 } while (0)
275#define RETURN_SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat) do { \
276 if (!rb_block_given_p()) \
277 return SIZED_ENUMERATOR_KW(obj, argc, argv, size_fn, kw_splat); \
278 } while (0)
279#define RETURN_ENUMERATOR(obj, argc, argv) RETURN_SIZED_ENUMERATOR(obj, argc, argv, 0)
280#define RETURN_ENUMERATOR_KW(obj, argc, argv, kw_splat) RETURN_SIZED_ENUMERATOR_KW(obj, argc, argv, 0, kw_splat)
281typedef struct {
282 VALUE begin;
283 VALUE end;
284 VALUE step;
285 int exclude_end;
288/* error.c */
289VALUE rb_exc_new(VALUE, const char*, long);
290VALUE rb_exc_new_cstr(VALUE, const char*);
292#define rb_exc_new2 rb_exc_new_cstr
293#define rb_exc_new3 rb_exc_new_str
294PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2);
295PRINTF_ARGS(NORETURN(void rb_loaderror_with_path(VALUE path, const char*, ...)), 2, 3);
296PRINTF_ARGS(NORETURN(void rb_name_error(ID, const char*, ...)), 2, 3);
297PRINTF_ARGS(NORETURN(void rb_name_error_str(VALUE, const char*, ...)), 2, 3);
298PRINTF_ARGS(NORETURN(void rb_frozen_error_raise(VALUE, const char*, ...)), 2, 3);
299NORETURN(void rb_invalid_str(const char*, const char*));
300NORETURN(void rb_error_frozen(const char*));
305#define rb_check_frozen_internal(obj) do { \
306 VALUE frozen_obj = (obj); \
307 if (RB_UNLIKELY(RB_OBJ_FROZEN(frozen_obj))) { \
308 rb_error_frozen_object(frozen_obj); \
309 } \
310 } while (0)
311#ifdef __GNUC__
312#define rb_check_frozen(obj) __extension__({rb_check_frozen_internal(obj);})
313#else
314static inline void
315rb_check_frozen_inline(VALUE obj)
316{
318}
319#define rb_check_frozen(obj) rb_check_frozen_inline(obj)
320static inline void
321rb_check_trusted_inline(VALUE obj)
322{
324}
325#define rb_check_trusted(obj) rb_check_trusted_inline(obj)
326#endif
327void rb_check_copyable(VALUE obj, VALUE orig);
328
329#define RB_OBJ_INIT_COPY(obj, orig) \
330 ((obj) != (orig) && (rb_obj_init_copy((obj), (orig)), 1))
331#define OBJ_INIT_COPY(obj, orig) RB_OBJ_INIT_COPY(obj, orig)
332
333/* eval.c */
334int rb_sourceline(void);
335const char *rb_sourcefile(void);
336VALUE rb_check_funcall(VALUE, ID, int, const VALUE*);
337VALUE rb_check_funcall_kw(VALUE, ID, int, const VALUE*, int);
338
340static inline int
341rb_check_arity(int argc, int min, int max)
342{
343 if ((argc < min) || (max != UNLIMITED_ARGUMENTS && argc > max))
344 rb_error_arity(argc, min, max);
345 return argc;
346}
347#define rb_check_arity rb_check_arity /* for ifdef */
348
349#if defined(NFDBITS) && defined(HAVE_RB_FD_INIT)
350typedef struct {
351 int maxfd;
352 fd_set *fdset;
353} rb_fdset_t;
354
355void rb_fd_init(rb_fdset_t *);
356void rb_fd_term(rb_fdset_t *);
357void rb_fd_zero(rb_fdset_t *);
358void rb_fd_set(int, rb_fdset_t *);
359void rb_fd_clr(int, rb_fdset_t *);
360int rb_fd_isset(int, const rb_fdset_t *);
361void rb_fd_copy(rb_fdset_t *, const fd_set *, int);
362void rb_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
363
364struct timeval;
365int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
366
367#define rb_fd_ptr(f) ((f)->fdset)
368#define rb_fd_max(f) ((f)->maxfd)
369
370#elif defined(_WIN32)
371
372typedef struct {
373 int capa;
374 fd_set *fdset;
375} rb_fdset_t;
376
377void rb_fd_init(rb_fdset_t *);
378void rb_fd_term(rb_fdset_t *);
379#define rb_fd_zero(f) ((f)->fdset->fd_count = 0)
380void rb_fd_set(int, rb_fdset_t *);
381#define rb_fd_clr(n, f) rb_w32_fdclr((n), (f)->fdset)
382#define rb_fd_isset(n, f) rb_w32_fdisset((n), (f)->fdset)
383#define rb_fd_copy(d, s, n) rb_w32_fd_copy((d), (s), (n))
384void rb_w32_fd_copy(rb_fdset_t *, const fd_set *, int);
385#define rb_fd_dup(d, s) rb_w32_fd_dup((d), (s))
386void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
387static inline int
388rb_fd_select(int n, rb_fdset_t *rfds, rb_fdset_t *wfds, rb_fdset_t *efds, struct timeval *timeout)
389{
390 return rb_w32_select(n,
391 rfds ? rfds->fdset : NULL,
392 wfds ? wfds->fdset : NULL,
393 efds ? efds->fdset : NULL,
394 timeout);
395}
396#define rb_fd_resize(n, f) ((void)(f))
397
398#define rb_fd_ptr(f) ((f)->fdset)
399#define rb_fd_max(f) ((f)->fdset->fd_count)
400
401#else
402
404#define rb_fd_zero(f) FD_ZERO(f)
405#define rb_fd_set(n, f) FD_SET((n), (f))
406#define rb_fd_clr(n, f) FD_CLR((n), (f))
407#define rb_fd_isset(n, f) FD_ISSET((n), (f))
408#define rb_fd_copy(d, s, n) (*(d) = *(s))
409#define rb_fd_dup(d, s) (*(d) = *(s))
410#define rb_fd_resize(n, f) ((void)(f))
411#define rb_fd_ptr(f) (f)
412#define rb_fd_init(f) FD_ZERO(f)
413#define rb_fd_init_copy(d, s) (*(d) = *(s))
414#define rb_fd_term(f) ((void)(f))
415#define rb_fd_max(f) FD_SETSIZE
416#define rb_fd_select(n, rfds, wfds, efds, timeout) select((n), (rfds), (wfds), (efds), (timeout))
417
418#endif
419
423NORETURN(VALUE rb_f_abort(int, const VALUE*));
424void rb_remove_method(VALUE, const char*);
426#define HAVE_RB_DEFINE_ALLOC_FUNC 1
431void rb_clear_constant_cache(void);
433void rb_alias(VALUE, ID, ID);
434void rb_attr(VALUE,ID,int,int,int);
435int rb_method_boundp(VALUE, ID, int);
439int rb_obj_respond_to(VALUE, ID, int);
442#if !defined(RUBY_EXPORT) && defined(_WIN32)
444#define rb_f_notimplement (*rb_f_notimplement_)
445#endif
448void rb_backtrace(void);
452VALUE rb_mod_module_eval(int, const VALUE*, VALUE);
453VALUE rb_mod_module_exec(int, const VALUE*, VALUE);
454void rb_load(VALUE, int);
455void rb_load_protect(VALUE, int, int*);
457int rb_provided(const char*);
458int rb_feature_provided(const char *, const char **);
459void rb_provide(const char*);
461VALUE rb_require_safe(VALUE, int); /* Remove in 3.0 */
463void rb_obj_call_init(VALUE, int, const VALUE*);
464void rb_obj_call_init_kw(VALUE, int, const VALUE*, int);
466VALUE rb_class_new_instance_kw(int, const VALUE*, VALUE, int);
467VALUE rb_block_proc(void);
480VALUE rb_method_call(int, const VALUE*, VALUE);
481VALUE rb_method_call_kw(int, const VALUE*, VALUE, int);
486VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*);
487void rb_set_end_proc(void (*)(VALUE), VALUE);
488void rb_thread_schedule(void);
489void rb_thread_wait_fd(int);
490int rb_thread_fd_writable(int);
491void rb_thread_fd_close(int);
492int rb_thread_alone(void);
493void rb_thread_sleep(int);
494void rb_thread_sleep_forever(void);
495void rb_thread_sleep_deadly(void);
501VALUE rb_thread_create(VALUE (*)(void *), void*);
503void rb_thread_wait_for(struct timeval);
508void rb_thread_atfork(void);
514/* dir.c */
515VALUE rb_dir_getwd(void);
516/* file.c */
517VALUE rb_file_s_expand_path(int, const VALUE *);
522int rb_find_file_ext_safe(VALUE*, const char* const*, int); /* Remove in 3.0 */
523VALUE rb_find_file_safe(VALUE, int); /* Remove in 3.0 */
524int rb_find_file_ext(VALUE*, const char* const*);
528int rb_is_absolute_path(const char *);
529/* gc.c */
530COLDFUNC NORETURN(void rb_memerror(void));
532void rb_gc_mark_locations(const VALUE*, const VALUE*);
533void rb_mark_tbl(struct st_table*);
534void rb_mark_tbl_no_pin(struct st_table*);
535void rb_mark_set(struct st_table*);
536void rb_mark_hash(struct st_table*);
539void rb_gc_mark(VALUE);
543void rb_gc(void);
545VALUE rb_gc_enable(void);
546VALUE rb_gc_disable(void);
547VALUE rb_gc_start(void);
550size_t rb_gc_count(void);
551size_t rb_gc_stat(VALUE);
554/* hash.c */
556#define st_foreach_safe rb_st_foreach_safe
560VALUE rb_hash_new(void);
571VALUE rb_hash_set_ifnone(VALUE hash, VALUE ifnone);
572void rb_hash_bulk_insert(long, const VALUE *, VALUE);
573typedef VALUE rb_hash_update_func(VALUE newkey, VALUE oldkey, VALUE value);
575struct st_table *rb_hash_tbl(VALUE, const char *file, int line);
576int rb_path_check(const char*);
577int rb_env_path_tainted(void);
578VALUE rb_env_clear(void);
581/* io.c */
582#define rb_defout rb_stdout
599VALUE rb_io_printf(int, const VALUE*, VALUE);
600VALUE rb_io_print(int, const VALUE*, VALUE);
601VALUE rb_io_puts(int, const VALUE*, VALUE);
602VALUE rb_io_fdopen(int, int, const char*);
604VALUE rb_file_open(const char*, const char*);
605VALUE rb_file_open_str(VALUE, const char*);
606VALUE rb_gets(void);
607void rb_write_error(const char*);
608void rb_write_error2(const char*, long);
609void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds);
610int rb_pipe(int *pipes);
612int rb_cloexec_open(const char *pathname, int flags, mode_t mode);
613int rb_cloexec_dup(int oldfd);
614int rb_cloexec_dup2(int oldfd, int newfd);
615int rb_cloexec_pipe(int fildes[2]);
616int rb_cloexec_fcntl_dupfd(int fd, int minfd);
617#define RB_RESERVED_FD_P(fd) rb_reserved_fd_p(fd)
618void rb_update_max_fd(int fd);
619void rb_fd_fix_cloexec(int fd);
620/* marshal.c */
623void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE));
624/* numeric.c */
625NORETURN(void rb_num_zerodiv(void));
626#define RB_NUM_COERCE_FUNCS_NEED_OPID 1
633CONSTFUNC(VALUE rb_dbl_cmp(double, double));
634/* object.c */
635int rb_eql(VALUE, VALUE);
659VALUE rb_convert_type(VALUE,int,const char*,const char*);
660VALUE rb_check_convert_type(VALUE,int,const char*,const char*);
661VALUE rb_check_to_integer(VALUE, const char *);
671double rb_cstr_to_dbl(const char*, int);
672double rb_str_to_dbl(VALUE, int);
673/* parse.y */
682int rb_symname_p(const char*);
688/* process.c */
689void rb_last_status_set(int status, rb_pid_t pid);
691int rb_proc_exec(const char*);
692NORETURN(VALUE rb_f_exec(int, const VALUE*));
693rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags);
694void rb_syswait(rb_pid_t pid);
695rb_pid_t rb_spawn(int, const VALUE*);
696rb_pid_t rb_spawn_err(int, const VALUE*, char*, size_t);
699/* range.c */
701VALUE rb_range_beg_len(VALUE, long*, long*, long, int);
702int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp);
703/* random.c */
704unsigned int rb_genrand_int32(void);
705double rb_genrand_real(void);
706void rb_reset_random_seed(void);
707VALUE rb_random_bytes(VALUE rnd, long n);
709unsigned int rb_random_int32(VALUE rnd);
710double rb_random_real(VALUE rnd);
711unsigned long rb_random_ulong_limited(VALUE rnd, unsigned long limit);
712unsigned long rb_genrand_ulong_limited(unsigned long i);
713/* re.c */
714#define rb_memcmp memcmp
715int rb_memcicmp(const void*,const void*,long);
716void rb_match_busy(VALUE);
719int rb_reg_backref_number(VALUE match, VALUE backref);
724#define HAVE_RB_REG_NEW_STR 1
726VALUE rb_reg_new(const char *, long, int);
727VALUE rb_reg_alloc(void);
728VALUE rb_reg_init_str(VALUE re, VALUE s, int options);
732/* ruby.c */
733#define rb_argv rb_get_argv()
735VALUE rb_get_argv(void);
736void *rb_load_file(const char*);
738/* signal.c */
739VALUE rb_f_kill(int, const VALUE*);
740#ifdef POSIX_SIGNAL
741#define posix_signal ruby_posix_signal
742RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int);
743#endif
744const char *ruby_signal_name(int);
745void ruby_default_signal(int);
746/* sprintf.c */
747VALUE rb_f_sprintf(int, const VALUE*);
748PRINTF_ARGS(VALUE rb_sprintf(const char*, ...), 1, 2);
749VALUE rb_vsprintf(const char*, va_list);
750PRINTF_ARGS(VALUE rb_str_catf(VALUE, const char*, ...), 2, 3);
751VALUE rb_str_vcatf(VALUE, const char*, va_list);
752VALUE rb_str_format(int, const VALUE *, VALUE);
753/* string.c */
754VALUE rb_str_new(const char*, long);
755VALUE rb_str_new_cstr(const char*);
758VALUE rb_str_new_with_class(VALUE, const char*, long);
759VALUE rb_tainted_str_new_cstr(const char*);
760VALUE rb_tainted_str_new(const char*, long);
761VALUE rb_external_str_new(const char*, long);
763VALUE rb_locale_str_new(const char*, long);
764VALUE rb_locale_str_new_cstr(const char*);
765VALUE rb_filesystem_str_new(const char*, long);
768VALUE rb_str_buf_new_cstr(const char*);
771VALUE rb_usascii_str_new(const char*, long);
772VALUE rb_usascii_str_new_cstr(const char*);
773VALUE rb_utf8_str_new(const char*, long);
774VALUE rb_utf8_str_new_cstr(const char*);
775VALUE rb_str_new_static(const char *, long);
776VALUE rb_usascii_str_new_static(const char *, long);
777VALUE rb_utf8_str_new_static(const char *, long);
778void rb_str_free(VALUE);
781VALUE rb_str_buf_cat(VALUE, const char*, long);
783VALUE rb_str_buf_cat_ascii(VALUE, const char*);
792#define rb_str_dup_frozen rb_str_new_frozen
795long rb_str_sublen(VALUE, long);
796VALUE rb_str_substr(VALUE, long, long);
797VALUE rb_str_subseq(VALUE, long, long);
798char *rb_str_subpos(VALUE, long, long*);
799void rb_str_modify(VALUE);
800void rb_str_modify_expand(VALUE, long);
802void rb_str_set_len(VALUE, long);
804VALUE rb_str_cat(VALUE, const char*, long);
805VALUE rb_str_cat_cstr(VALUE, const char*);
806VALUE rb_str_cat2(VALUE, const char*);
809st_index_t rb_memhash(const void *ptr, long len);
814#define rb_hash_uint32(h, i) st_hash_uint32((h), (i))
815#define rb_hash_uint(h, i) st_hash_uint((h), (i))
816#define rb_hash_end(h) st_hash_end(h)
821VALUE rb_str_equal(VALUE str1, VALUE str2);
823void rb_str_update(VALUE, long, long, VALUE);
827VALUE rb_str_split(VALUE, const char*);
831long rb_str_strlen(VALUE);
833long rb_str_offset(VALUE, long);
837/* symbol.c */
839
840#ifdef HAVE_BUILTIN___BUILTIN_CONSTANT_P
841#define rb_str_new(str, len) RB_GNUC_EXTENSION_BLOCK( \
842 (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \
843 rb_str_new_static((str), (len)) : \
844 rb_str_new((str), (len)) \
845)
846#define rb_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
847 (__builtin_constant_p(str)) ? \
848 rb_str_new_static((str), (long)strlen(str)) : \
849 rb_str_new_cstr(str) \
850)
851#define rb_usascii_str_new(str, len) RB_GNUC_EXTENSION_BLOCK( \
852 (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \
853 rb_usascii_str_new_static((str), (len)) : \
854 rb_usascii_str_new((str), (len)) \
855)
856#define rb_utf8_str_new(str, len) RB_GNUC_EXTENSION_BLOCK( \
857 (__builtin_constant_p(str) && __builtin_constant_p(len)) ? \
858 rb_utf8_str_new_static((str), (len)) : \
859 rb_utf8_str_new((str), (len)) \
860)
861#define rb_tainted_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
862 (__builtin_constant_p(str)) ? \
863 rb_tainted_str_new((str), (long)strlen(str)) : \
864 rb_tainted_str_new_cstr(str) \
865)
866#define rb_usascii_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
867 (__builtin_constant_p(str)) ? \
868 rb_usascii_str_new_static((str), (long)strlen(str)) : \
869 rb_usascii_str_new_cstr(str) \
870)
871#define rb_utf8_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
872 (__builtin_constant_p(str)) ? \
873 rb_utf8_str_new_static((str), (long)strlen(str)) : \
874 rb_utf8_str_new_cstr(str) \
875)
876#define rb_external_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
877 (__builtin_constant_p(str)) ? \
878 rb_external_str_new((str), (long)strlen(str)) : \
879 rb_external_str_new_cstr(str) \
880)
881#define rb_locale_str_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
882 (__builtin_constant_p(str)) ? \
883 rb_locale_str_new((str), (long)strlen(str)) : \
884 rb_locale_str_new_cstr(str) \
885)
886#define rb_str_buf_new_cstr(str) RB_GNUC_EXTENSION_BLOCK( \
887 (__builtin_constant_p(str)) ? \
888 rb_str_buf_cat(rb_str_buf_new((long)strlen(str)), \
889 (str), (long)strlen(str)) : \
890 rb_str_buf_new_cstr(str) \
891)
892#define rb_str_cat_cstr(str, ptr) RB_GNUC_EXTENSION_BLOCK( \
893 (__builtin_constant_p(ptr)) ? \
894 rb_str_cat((str), (ptr), (long)strlen(ptr)) : \
895 rb_str_cat_cstr((str), (ptr)) \
896)
897#define rb_exc_new_cstr(klass, ptr) RB_GNUC_EXTENSION_BLOCK( \
898 (__builtin_constant_p(ptr)) ? \
899 rb_exc_new((klass), (ptr), (long)strlen(ptr)) : \
900 rb_exc_new_cstr((klass), (ptr)) \
901)
902#endif
903#define rb_str_new2 rb_str_new_cstr
904#define rb_str_new3 rb_str_new_shared
905#define rb_str_new4 rb_str_new_frozen
906#define rb_str_new5 rb_str_new_with_class
907#define rb_tainted_str_new2 rb_tainted_str_new_cstr
908#define rb_str_buf_new2 rb_str_buf_new_cstr
909#define rb_usascii_str_new2 rb_usascii_str_new_cstr
910#define rb_str_buf_cat rb_str_cat
911#define rb_str_buf_cat2 rb_str_cat_cstr
912#define rb_str_cat2 rb_str_cat_cstr
913#define rb_strlen_lit(str) (sizeof(str "") - 1)
914#define rb_str_new_lit(str) rb_str_new_static((str), rb_strlen_lit(str))
915#define rb_usascii_str_new_lit(str) rb_usascii_str_new_static((str), rb_strlen_lit(str))
916#define rb_utf8_str_new_lit(str) rb_utf8_str_new_static((str), rb_strlen_lit(str))
917#define rb_enc_str_new_lit(str, enc) rb_enc_str_new_static((str), rb_strlen_lit(str), (enc))
918#define rb_str_new_literal(str) rb_str_new_lit(str)
919#define rb_usascii_str_new_literal(str) rb_usascii_str_new_lit(str)
920#define rb_utf8_str_new_literal(str) rb_utf8_str_new_lit(str)
921#define rb_enc_str_new_literal(str, enc) rb_enc_str_new_lit(str, enc)
922
923/* struct.c */
925VALUE rb_struct_define(const char*, ...);
926VALUE rb_struct_define_under(VALUE, const char*, ...);
937VALUE rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc, ...);
938
939/* thread.c */
940typedef void rb_unblock_function_t(void *);
942void rb_thread_check_ints(void);
944
945#define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
946#define RUBY_UBF_PROCESS ((rb_unblock_function_t *)-1)
947VALUE rb_mutex_new(void);
952VALUE rb_mutex_sleep(VALUE self, VALUE timeout);
954/* time.c */
955struct timespec;
956void rb_timespec_now(struct timespec *);
959VALUE rb_time_timespec_new(const struct timespec *, int);
961struct timeval rb_time_interval(VALUE num);
966/* variable.c */
970void rb_set_class_path(VALUE, VALUE, const char*);
973VALUE rb_path2class(const char*);
977VALUE rb_f_trace_var(int, const VALUE*);
978VALUE rb_f_untrace_var(int, const VALUE*);
980void rb_alias_variable(ID, ID);
991void *rb_mod_const_at(VALUE, void*);
992void *rb_mod_const_of(VALUE, void*);
993VALUE rb_const_list(void*);
994VALUE rb_mod_constants(int, const VALUE *, VALUE);
1002void rb_const_set(VALUE, ID, VALUE);
1004#if 0 /* EXPERIMENTAL: remove if no problem */
1006#endif
1008void rb_cvar_set(VALUE, ID, VALUE);
1010void rb_cv_set(VALUE, const char*, VALUE);
1011VALUE rb_cv_get(VALUE, const char*);
1012void rb_define_class_variable(VALUE, const char*, VALUE);
1015
1016ID rb_frame_callee(void);
1017int rb_frame_method_id_and_class(ID *idp, VALUE *klassp);
1021VALUE rb_make_exception(int, const VALUE*);
1022
1024
1025#if defined(__cplusplus)
1026#if 0
1027{ /* satisfy cc-mode */
1028#endif
1029} /* extern "C" { */
1030extern "C++" {
1031#endif
1032
1033#if defined(HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P)
1034# define rb_f_notimplement_p(f) __builtin_types_compatible_p(__typeof__(f),__typeof__(rb_f_notimplement))
1035#else
1036# define rb_f_notimplement_p(f) 0
1037#endif
1038
1039#if defined(HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P) && !defined(_WIN32) && !defined(__CYGWIN__)
1040#if defined(__has_attribute) && __has_attribute(transparent_union) && __has_attribute(unused) && __has_attribute(weakref) && __has_attribute(nonnull)
1041#define RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,funcargs) \
1042 __attribute__((__unused__,__weakref__(#def),__nonnull__ nonnull))static void defname(RB_UNWRAP_MACRO decl,VALUE(*func)funcargs,int arity);
1043#endif
1044#endif
1045
1046#if defined(RB_METHOD_DEFINITION_DECL_C) || defined(__cplusplus)
1047#ifndef RB_METHOD_DEFINITION_DECL_C
1048#define RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,funcargs) \
1049 static inline void defname(RB_UNWRAP_MACRO decl,VALUE(*func)funcargs,int arity) \
1050 { \
1051 def(RB_UNWRAP_MACRO vars,(VALUE(*)(ANYARGS))(func),arity); \
1052 }
1053#endif
1054
1055#define RB_UNWRAP_MACRO(...) __VA_ARGS__
1056
1057#ifdef __cplusplus
1058#define RB_METHOD_DEFINITION_DECL_CXX_BEGIN(def) template <int Arity> struct def##_tmpl {};
1059#define RB_METHOD_DEFINITION_DECL_CXX(def,defname,decl,vars,funcargs,arity) \
1060 template <> struct def##_tmpl<arity> { \
1061 static void define(RB_UNWRAP_MACRO decl, VALUE (*func)funcargs) {::defname(RB_UNWRAP_MACRO vars, func, arity);} \
1062 static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(...)) {::defname(RB_UNWRAP_MACRO vars, reinterpret_cast<VALUE(*)funcargs>(func), arity);} \
1063 };
1064#else
1065#define RB_METHOD_DEFINITION_DECL_CXX_BEGIN(def) /* nothing */
1066#define RB_METHOD_DEFINITION_DECL_CXX(def,defname,decl,vars,funcargs,arity) /* nothing */
1067#endif
1068#define RB_METHOD_DEFINITION_DECL_1(def,nonnull,defname,arity,decl,vars,funcargs) \
1069 RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,funcargs) \
1070 RB_METHOD_DEFINITION_DECL_CXX(def,defname,decl,vars,funcargs,arity)
1071
1072#define RB_METHOD_DEFINITION_DECL(def,nonnull,decl,vars) \
1073RB_METHOD_DEFINITION_DECL_CXX_BEGIN(def) \
1074RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##0 ,0 ,decl,vars,(VALUE)) \
1075RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##1 ,1 ,decl,vars,(VALUE,VALUE)) \
1076RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##2 ,2 ,decl,vars,(VALUE,VALUE,VALUE)) \
1077RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##3 ,3 ,decl,vars,(VALUE,VALUE,VALUE,VALUE)) \
1078RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##4 ,4 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE)) \
1079RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##5 ,5 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1080RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##6 ,6 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1081RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##7 ,7 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1082RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##8 ,8 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1083RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##9 ,9 ,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1084RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##10,10,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1085RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##11,11,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1086RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##12,12,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1087RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##13,13,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1088RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##14,14,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1089RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##15,15,decl,vars,(VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE,VALUE)) \
1090RB_METHOD_DEFINITION_DECL_M3(def,nonnull,def##m3,decl,vars) \
1091RB_METHOD_DEFINITION_DECL_1(def,nonnull,def##m2,-2,decl,vars,(VALUE,VALUE)) \
1092RB_METHOD_DEFINITION_DECL_M1(def,nonnull,def##m1,decl,vars) /* END */
1093#ifdef __cplusplus
1094#define RB_METHOD_DEFINITION_DECL_M1(def,nonnull,defname,decl,vars) \
1095 RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,VALUE*,VALUE)) \
1096 RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,const VALUE*,VALUE)) \
1097 RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,const VALUE*,VALUE,VALUE)) \
1098 RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(...)) \
1099 template <> struct def##_tmpl<-1> { \
1100 static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(int,VALUE*,VALUE)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \
1101 static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(int,const VALUE*,VALUE)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \
1102 static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(int,const VALUE*,VALUE,VALUE)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \
1103 static void define(RB_UNWRAP_MACRO decl, VALUE (*func)(...)) {::defname(RB_UNWRAP_MACRO vars, func, -1);} \
1104 };
1105#define RB_METHOD_DEFINITION_DECL_M3(def,nonnull,defname,decl,vars) /* nothing */
1106#else
1107#define RB_METHOD_DEFINITION_DECL_M1(def,nonnull,defname,decl,vars) \
1108 RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,(int,union{VALUE*x;const VALUE*y;}__attribute__((__transparent_union__)),VALUE))
1109#define RB_METHOD_DEFINITION_DECL_M3(def,nonnull,defname,decl,vars) \
1110 RB_METHOD_DEFINITION_DECL_C(def,nonnull,defname,decl,vars,())
1111#endif
1112
1113#endif
1114
1115#ifdef RB_METHOD_DEFINITION_DECL
1116
1117RB_METHOD_DEFINITION_DECL(rb_define_method_id, (3), (VALUE klass, ID name), (klass, name))
1118#ifdef __cplusplus
1119#define rb_define_method_id(m, n, f, a) rb_define_method_id_tmpl<a>::define(m, n, f)
1120#else
1121#define rb_define_method_id_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_method_id15,rb_define_method_idm3)
1122#define rb_define_method_id_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_method_id14,rb_define_method_id_choose_prototype15(n))
1123#define rb_define_method_id_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_method_id13,rb_define_method_id_choose_prototype14(n))
1124#define rb_define_method_id_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_method_id12,rb_define_method_id_choose_prototype13(n))
1125#define rb_define_method_id_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_method_id11,rb_define_method_id_choose_prototype12(n))
1126#define rb_define_method_id_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_method_id10,rb_define_method_id_choose_prototype11(n))
1127#define rb_define_method_id_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_method_id9, rb_define_method_id_choose_prototype10(n))
1128#define rb_define_method_id_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_method_id8, rb_define_method_id_choose_prototype9(n))
1129#define rb_define_method_id_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_method_id7, rb_define_method_id_choose_prototype8(n))
1130#define rb_define_method_id_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_method_id6, rb_define_method_id_choose_prototype7(n))
1131#define rb_define_method_id_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_method_id5, rb_define_method_id_choose_prototype6(n))
1132#define rb_define_method_id_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_method_id4, rb_define_method_id_choose_prototype5(n))
1133#define rb_define_method_id_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_method_id3, rb_define_method_id_choose_prototype4(n))
1134#define rb_define_method_id_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_method_id2, rb_define_method_id_choose_prototype3(n))
1135#define rb_define_method_id_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_method_id1, rb_define_method_id_choose_prototype2(n))
1136#define rb_define_method_id_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_method_id0, rb_define_method_id_choose_prototype1(n))
1137#define rb_define_method_id_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_method_idm1,rb_define_method_id_choose_prototype0(n))
1138#define rb_define_method_id_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_method_idm2,rb_define_method_id_choose_prototypem1(n))
1139#define rb_define_method_id_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_method_idm3,rb_define_method_id_choose_prototypem2(n))
1140#define rb_define_method_id(klass, mid, func, arity) rb_define_method_id_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity));
1141#endif
1142
1143RB_METHOD_DEFINITION_DECL(rb_define_protected_method, (2,3), (VALUE klass, const char *name), (klass, name))
1144#ifdef __cplusplus
1145#define rb_define_protected_method(m, n, f, a) rb_define_protected_method_tmpl<a>::define(m, n, f)
1146#else
1147#define rb_define_protected_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_protected_method15,rb_define_protected_methodm3)
1148#define rb_define_protected_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_protected_method14,rb_define_protected_method_choose_prototype15(n))
1149#define rb_define_protected_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_protected_method13,rb_define_protected_method_choose_prototype14(n))
1150#define rb_define_protected_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_protected_method12,rb_define_protected_method_choose_prototype13(n))
1151#define rb_define_protected_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_protected_method11,rb_define_protected_method_choose_prototype12(n))
1152#define rb_define_protected_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_protected_method10,rb_define_protected_method_choose_prototype11(n))
1153#define rb_define_protected_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_protected_method9, rb_define_protected_method_choose_prototype10(n))
1154#define rb_define_protected_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_protected_method8, rb_define_protected_method_choose_prototype9(n))
1155#define rb_define_protected_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_protected_method7, rb_define_protected_method_choose_prototype8(n))
1156#define rb_define_protected_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_protected_method6, rb_define_protected_method_choose_prototype7(n))
1157#define rb_define_protected_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_protected_method5, rb_define_protected_method_choose_prototype6(n))
1158#define rb_define_protected_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_protected_method4, rb_define_protected_method_choose_prototype5(n))
1159#define rb_define_protected_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_protected_method3, rb_define_protected_method_choose_prototype4(n))
1160#define rb_define_protected_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_protected_method2, rb_define_protected_method_choose_prototype3(n))
1161#define rb_define_protected_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_protected_method1, rb_define_protected_method_choose_prototype2(n))
1162#define rb_define_protected_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_protected_method0, rb_define_protected_method_choose_prototype1(n))
1163#define rb_define_protected_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_protected_methodm1,rb_define_protected_method_choose_prototype0(n))
1164#define rb_define_protected_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_protected_methodm2,rb_define_protected_method_choose_prototypem1(n))
1165#define rb_define_protected_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_protected_methodm3,rb_define_protected_method_choose_prototypem2(n))
1166#define rb_define_protected_method(klass, mid, func, arity) rb_define_protected_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity));
1167#endif
1168
1169RB_METHOD_DEFINITION_DECL(rb_define_private_method, (2,3), (VALUE klass, const char *name), (klass, name))
1170#ifdef __cplusplus
1171#define rb_define_private_method(m, n, f, a) rb_define_private_method_tmpl<a>::define(m, n, f)
1172#else
1173#define rb_define_private_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_private_method15,rb_define_private_methodm3)
1174#define rb_define_private_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_private_method14,rb_define_private_method_choose_prototype15(n))
1175#define rb_define_private_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_private_method13,rb_define_private_method_choose_prototype14(n))
1176#define rb_define_private_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_private_method12,rb_define_private_method_choose_prototype13(n))
1177#define rb_define_private_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_private_method11,rb_define_private_method_choose_prototype12(n))
1178#define rb_define_private_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_private_method10,rb_define_private_method_choose_prototype11(n))
1179#define rb_define_private_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_private_method9, rb_define_private_method_choose_prototype10(n))
1180#define rb_define_private_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_private_method8, rb_define_private_method_choose_prototype9(n))
1181#define rb_define_private_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_private_method7, rb_define_private_method_choose_prototype8(n))
1182#define rb_define_private_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_private_method6, rb_define_private_method_choose_prototype7(n))
1183#define rb_define_private_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_private_method5, rb_define_private_method_choose_prototype6(n))
1184#define rb_define_private_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_private_method4, rb_define_private_method_choose_prototype5(n))
1185#define rb_define_private_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_private_method3, rb_define_private_method_choose_prototype4(n))
1186#define rb_define_private_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_private_method2, rb_define_private_method_choose_prototype3(n))
1187#define rb_define_private_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_private_method1, rb_define_private_method_choose_prototype2(n))
1188#define rb_define_private_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_private_method0, rb_define_private_method_choose_prototype1(n))
1189#define rb_define_private_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_private_methodm1,rb_define_private_method_choose_prototype0(n))
1190#define rb_define_private_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_private_methodm2,rb_define_private_method_choose_prototypem1(n))
1191#define rb_define_private_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_private_methodm3,rb_define_private_method_choose_prototypem2(n))
1192#define rb_define_private_method(klass, mid, func, arity) rb_define_private_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity));
1193#endif
1194
1195RB_METHOD_DEFINITION_DECL(rb_define_singleton_method, (2,3), (VALUE klass, const char *name), (klass, name))
1196#ifdef __cplusplus
1197#define rb_define_singleton_method(m, n, f, a) rb_define_singleton_method_tmpl<a>::define(m, n, f)
1198#else
1199#define rb_define_singleton_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_singleton_method15,rb_define_singleton_methodm3)
1200#define rb_define_singleton_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_singleton_method14,rb_define_singleton_method_choose_prototype15(n))
1201#define rb_define_singleton_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_singleton_method13,rb_define_singleton_method_choose_prototype14(n))
1202#define rb_define_singleton_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_singleton_method12,rb_define_singleton_method_choose_prototype13(n))
1203#define rb_define_singleton_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_singleton_method11,rb_define_singleton_method_choose_prototype12(n))
1204#define rb_define_singleton_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_singleton_method10,rb_define_singleton_method_choose_prototype11(n))
1205#define rb_define_singleton_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_singleton_method9, rb_define_singleton_method_choose_prototype10(n))
1206#define rb_define_singleton_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_singleton_method8, rb_define_singleton_method_choose_prototype9(n))
1207#define rb_define_singleton_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_singleton_method7, rb_define_singleton_method_choose_prototype8(n))
1208#define rb_define_singleton_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_singleton_method6, rb_define_singleton_method_choose_prototype7(n))
1209#define rb_define_singleton_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_singleton_method5, rb_define_singleton_method_choose_prototype6(n))
1210#define rb_define_singleton_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_singleton_method4, rb_define_singleton_method_choose_prototype5(n))
1211#define rb_define_singleton_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_singleton_method3, rb_define_singleton_method_choose_prototype4(n))
1212#define rb_define_singleton_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_singleton_method2, rb_define_singleton_method_choose_prototype3(n))
1213#define rb_define_singleton_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_singleton_method1, rb_define_singleton_method_choose_prototype2(n))
1214#define rb_define_singleton_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_singleton_method0, rb_define_singleton_method_choose_prototype1(n))
1215#define rb_define_singleton_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_singleton_methodm1,rb_define_singleton_method_choose_prototype0(n))
1216#define rb_define_singleton_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_singleton_methodm2,rb_define_singleton_method_choose_prototypem1(n))
1217#define rb_define_singleton_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_singleton_methodm3,rb_define_singleton_method_choose_prototypem2(n))
1218#define rb_define_singleton_method(klass, mid, func, arity) rb_define_singleton_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity));
1219#endif
1220
1221#endif
1222
1223#if defined(__cplusplus)
1224#if 0
1225{ /* satisfy cc-mode */
1226#endif
1227} /* extern "C++" { */
1228#endif
1229
1230#endif /* RUBY_INTERN_H */
void rb_cmperr(VALUE x, VALUE y)
Definition: compar.c:25
VALUE rb_complex_polar(VALUE x, VALUE y)
Definition: complex.c:1539
#define range(low, item, hi)
Definition: date_strftime.c:21
struct RIMemo * ptr
Definition: debug.c:65
char str[HTML_ESCAPE_MAX_LEN+1]
Definition: escape.c:18
void rb_memerror(void)
Definition: gc.c:9611
int rb_during_gc(void)
Definition: gc.c:8703
VALUE rb_class_protected_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1305
VALUE rb_class_new(VALUE)
Creates a new class.
Definition: class.c:244
VALUE rb_singleton_class_clone(VALUE)
Definition: class.c:373
VALUE rb_singleton_class(VALUE)
Returns the singleton class of obj.
Definition: class.c:1743
VALUE rb_obj_singleton_methods(int, const VALUE *, VALUE)
Definition: class.c:1467
VALUE rb_module_new(void)
Definition: class.c:771
VALUE rb_class_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1290
void rb_check_inheritable(VALUE)
Ensures a class can be derived from super.
Definition: class.c:222
VALUE rb_class_public_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1343
VALUE rb_define_module_id_under(VALUE, ID)
Definition: class.c:816
void rb_singleton_class_attached(VALUE, VALUE)
Attach a object to a singleton class.
Definition: class.c:444
VALUE rb_mod_included_modules(VALUE)
Definition: class.c:1049
VALUE rb_define_class_id_under(VALUE, ID, VALUE)
Defines a class under the namespace of outer.
Definition: class.c:734
VALUE rb_mod_ancestors(VALUE)
Definition: class.c:1117
VALUE rb_mod_include_p(VALUE, VALUE)
Definition: class.c:1085
VALUE rb_class_private_instance_methods(int, const VALUE *, VALUE)
Definition: class.c:1328
VALUE rb_mod_init_copy(VALUE, VALUE)
Definition: class.c:316
VALUE rb_define_module_id(ID)
Definition: class.c:779
VALUE rb_define_class_id(ID, VALUE)
Defines a new class.
Definition: class.c:615
ID rb_frame_callee(void)
The name of the current method.
Definition: eval.c:1200
void rb_define_protected_method(VALUE, const char *, VALUE(*)(ANYARGS), int)
Definition: class.c:1578
ID rb_frame_this_func(void)
The original name of the current method.
Definition: eval.c:1183
void rb_define_private_method(VALUE, const char *, VALUE(*)(ANYARGS), int)
Definition: class.c:1587
void rb_define_singleton_method(VALUE, const char *, VALUE(*)(ANYARGS), int)
Defines a singleton method for obj.
Definition: class.c:1773
void rb_define_method_id(VALUE, ID, VALUE(*)(ANYARGS), int)
Definition: class.c:1560
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
Definition: eval.c:668
void rb_name_error(ID id, const char *fmt,...)
Definition: error.c:1515
void rb_check_copyable(VALUE obj, VALUE orig)
Definition: error.c:3049
void rb_error_frozen(const char *what)
Definition: error.c:2976
void rb_interrupt(void)
Raises an Interrupt exception.
Definition: eval.c:697
void rb_error_untrusted(VALUE)
Definition: error.c:3036
void rb_name_error_str(VALUE str, const char *fmt,...)
Definition: error.c:1530
void rb_frozen_error_raise(VALUE frozen_obj, const char *fmt,...)
Definition: error.c:2982
VALUE rb_protect(VALUE(*)(VALUE), VALUE, int *)
Protects a function call from potential global escapes from the function.
Definition: eval.c:1072
void rb_invalid_str(const char *str, const char *type)
Definition: error.c:1867
VALUE rb_make_exception(int, const VALUE *)
Make an Exception object from the list of arguments in a manner similar to Kernel#raise.
Definition: eval.c:851
void rb_exc_fatal(VALUE mesg)
Raises a fatal error in the current thread.
Definition: eval.c:684
VALUE rb_exc_new_cstr(VALUE, const char *)
Definition: error.c:968
VALUE rb_exc_new(VALUE, const char *, long)
Definition: error.c:961
void rb_error_frozen_object(VALUE frozen_obj)
Definition: error.c:3008
VALUE rb_exc_new_str(VALUE, VALUE)
Definition: error.c:974
void rb_loaderror(const char *fmt,...)
Definition: error.c:2690
void rb_loaderror_with_path(VALUE path, const char *fmt,...)
Definition: error.c:2702
void rb_jump_tag(int tag)
Continues the exception caught by rb_protect() and rb_eval_string_protect().
Definition: eval.c:884
VALUE rb_class_superclass(VALUE)
Returns the superclass of klass.
Definition: object.c:1976
VALUE rb_obj_taint(VALUE)
call-seq: obj.taint -> obj
Definition: object.c:999
VALUE rb_obj_trust(VALUE)
call-seq: obj.trust -> obj
Definition: object.c:1057
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...
Definition: object.c:2001
VALUE rb_convert_type(VALUE, int, const char *, const char *)
Converts an object into another type.
Definition: object.c:2900
VALUE rb_Float(VALUE)
Equivalent to Kernel#Float in Ruby.
Definition: object.c:3493
VALUE rb_check_to_int(VALUE)
Tries to convert val into Integer.
Definition: object.c:3036
VALUE rb_check_convert_type(VALUE, int, const char *, const char *)
Tries to convert an object into another type.
Definition: object.c:2941
void rb_obj_call_init(VALUE, int, const VALUE *)
Calls #initialize method of obj with the given arguments.
Definition: eval.c:1681
VALUE rb_any_to_s(VALUE)
Default implementation of #to_s.
Definition: object.c:527
VALUE rb_obj_alloc(VALUE)
Allocates an instance of klass.
Definition: object.c:1895
VALUE rb_class_new_instance(int, const VALUE *, VALUE)
Allocates and initializes an instance of klass.
Definition: object.c:1955
VALUE rb_class_new_instance_kw(int, const VALUE *, VALUE, int)
Definition: object.c:1931
VALUE rb_check_to_float(VALUE)
Tries to convert an object into Float.
Definition: object.c:3559
VALUE rb_Hash(VALUE)
Equivalent to Kernel#Hash in Ruby.
Definition: object.c:3727
VALUE rb_obj_frozen_p(VALUE obj)
Determines if the object is frozen.
Definition: object.c:1099
VALUE rb_obj_init_copy(VALUE, VALUE)
Default implementation of #initialize_copy.
Definition: object.c:500
int rb_eql(VALUE, VALUE)
Determines if obj1 and obj2 are equal in terms of Object::eql?.
Definition: object.c:147
double rb_str_to_dbl(VALUE, int)
Parses a string representation of a floating point number.
Definition: object.c:3371
VALUE rb_Integer(VALUE)
Equivalent to Kernel#Integer in Ruby.
Definition: object.c:3106
VALUE rb_Array(VALUE)
Equivalent to Kernel#Array in Ruby.
Definition: object.c:3684
VALUE rb_obj_class(VALUE)
Equivalent to Object#class in Ruby.
Definition: object.c:217
VALUE rb_obj_dup(VALUE)
Equivalent to Object#dup in Ruby.
Definition: object.c:420
VALUE rb_inspect(VALUE)
Convenient wrapper of Object::inspect.
Definition: object.c:551
VALUE rb_obj_untrust(VALUE)
call-seq: obj.untrust -> obj
Definition: object.c:1042
VALUE rb_class_inherited_p(VALUE mod, VALUE arg)
Determines if mod inherits arg.
Definition: object.c:1574
VALUE rb_obj_is_instance_of(VALUE, VALUE)
Determines if obj is an instance of c.
Definition: object.c:675
VALUE rb_class_real(VALUE cl)
Looks up the nearest ancestor of cl, skipping singleton classes or module inclusions.
Definition: object.c:202
VALUE rb_to_float(VALUE)
Converts a Numeric object into Float.
Definition: object.c:3542
VALUE rb_obj_clone(VALUE)
Almost same as Object::clone.
Definition: object.c:410
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Determines if obj is a kind of c.
Definition: object.c:692
double rb_cstr_to_dbl(const char *, int)
Parses a string representation of a floating point number.
Definition: object.c:3319
VALUE rb_obj_freeze(VALUE)
Make the object unmodifiable.
Definition: object.c:1080
VALUE rb_check_to_integer(VALUE, const char *)
Tries to convert val into Integer.
Definition: object.c:2999
VALUE rb_obj_untrusted(VALUE obj)
call-seq: obj.untrusted? -> false
Definition: object.c:1028
VALUE rb_String(VALUE)
Equivalent to Kernel#String in Ruby.
Definition: object.c:3652
VALUE rb_obj_untaint(VALUE)
call-seq: obj.untaint -> obj
Definition: object.c:1014
VALUE rb_obj_tainted(VALUE obj)
call-seq: obj.tainted? -> false
Definition: object.c:985
VALUE rb_to_int(VALUE)
Converts val into Integer.
Definition: object.c:3021
VALUE rb_class_name(VALUE)
Definition: variable.c:274
void rb_load(VALUE, int)
Definition: load.c:693
void rb_thread_wait_for(struct timeval)
Definition: thread.c:1346
int rb_integer_pack(VALUE val, void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
Definition: bignum.c:3547
VALUE rb_ary_new_from_values(long n, const VALUE *elts)
Definition: array.c:762
int rb_reg_backref_number(VALUE match, VALUE backref)
Definition: re.c:1181
unsigned long rb_genrand_ulong_limited(unsigned long i)
Definition: random.c:811
VALUE rb_str_unlocktmp(VALUE)
Definition: string.c:2675
VALUE rb_hash_lookup(VALUE, VALUE)
Definition: hash.c:2063
VALUE rb_check_funcall_kw(VALUE, ID, int, const VALUE *, int)
Definition: vm_eval.c:499
VALUE rb_file_s_expand_path(int, const VALUE *)
Definition: file.c:4092
VALUE rb_dir_getwd(void)
Definition: dir.c:1141
VALUE rb_fiber_resume_kw(VALUE fib, int argc, const VALUE *argv, int kw_splat)
Definition: cont.c:2097
void rb_hash_foreach(VALUE, int(*)(VALUE, VALUE, VALUE), VALUE)
double rb_random_real(VALUE rnd)
Definition: random.c:874
void rb_undef(VALUE, ID)
Definition: vm_method.c:1217
VALUE rb_f_trace_var(int, const VALUE *)
Definition: variable.c:528
VALUE rb_exec_recursive_paired(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE, VALUE)
Definition: thread.c:5085
VALUE rb_str_freeze(VALUE)
Definition: string.c:2616
void rb_provide(const char *)
Definition: load.c:607
unsigned int rb_random_int32(VALUE rnd)
Definition: random.c:839
int rb_thread_interrupted(VALUE thval)
Definition: thread.c:1378
VALUE rb_str_resize(VALUE, long)
Definition: string.c:2709
VALUE rb_hash(VALUE)
Definition: hash.c:129
VALUE rb_random_int(VALUE rnd, VALUE max)
VALUE rb_last_status_get(void)
Definition: process.c:546
VALUE rb_complex_uminus(VALUE z)
Definition: complex.c:758
VALUE rb_complex_div(VALUE x, VALUE y)
Definition: complex.c:948
#define UNLIMITED_ARGUMENTS
Definition: intern.h:57
VALUE rb_get_argv(void)
Definition: io.c:12904
VALUE rb_thread_wakeup_alive(VALUE)
Definition: thread.c:2548
VALUE rb_class_path_cached(VALUE)
Definition: variable.c:162
#define rb_str_buf_cat2
Definition: intern.h:911
VALUE rb_str_scrub(VALUE, VALUE)
Definition: string.c:10248
VALUE rb_struct_alloc_noinit(VALUE)
Definition: struct.c:349
VALUE rb_big_pow(VALUE, VALUE)
Definition: bignum.c:6244
RUBY_EXTERN VALUE rb_output_fs
Definition: intern.h:584
int rb_cloexec_pipe(int fildes[2])
Definition: io.c:378
VALUE rb_io_getbyte(VALUE)
Definition: io.c:4219
VALUE rb_vsprintf(const char *, va_list)
Definition: sprintf.c:1191
VALUE rb_usascii_str_new_cstr(const char *)
Definition: string.c:820
VALUE rb_thread_local_aref(VALUE, ID)
Definition: thread.c:3215
void rb_remove_method_id(VALUE, ID)
Definition: vm_method.c:1043
int rb_proc_exec(const char *)
Definition: process.c:1693
void rb_set_class_path_string(VALUE, VALUE, VALUE)
Definition: variable.c:198
#define rb_hash_uint(h, i)
Definition: intern.h:815
VALUE rb_const_get(VALUE, ID)
Definition: variable.c:2391
VALUE rb_Rational(VALUE, VALUE)
Definition: rational.c:1963
VALUE rb_exec_recursive_outer(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE)
Definition: thread.c:5097
void rb_attr(VALUE, ID, int, int, int)
Definition: vm_method.c:1180
VALUE rb_obj_instance_eval(int, const VALUE *, VALUE)
Definition: vm_eval.c:1997
long rb_str_offset(VALUE, long)
Definition: string.c:2416
VALUE rb_ary_aref(int, const VALUE *, VALUE)
Definition: array.c:1574
void rb_set_class_path(VALUE, VALUE, const char *)
Definition: variable.c:218
VALUE rb_mod_class_variables(int, const VALUE *, VALUE)
Definition: variable.c:3248
void rb_mark_tbl(struct st_table *)
Definition: gc.c:5021
void rb_copy_generic_ivar(VALUE, VALUE)
Definition: variable.c:1447
void rb_gc_mark_maybe(VALUE)
Definition: gc.c:5060
VALUE rb_big_eql(VALUE, VALUE)
Definition: bignum.c:5544
void rb_must_asciicompat(VALUE)
Definition: string.c:2166
VALUE rb_flt_rationalize_with_prec(VALUE, VALUE)
Definition: rational.c:2238
VALUE rb_big_minus(VALUE, VALUE)
Definition: bignum.c:5853
struct st_table * rb_hash_tbl(VALUE, const char *file, int line)
Definition: hash.c:1601
VALUE rb_reg_nth_defined(int, VALUE)
Definition: re.c:1696
VALUE rb_hash_set_ifnone(VALUE hash, VALUE ifnone)
Definition: hash.c:99
#define rb_hash_end(h)
Definition: intern.h:816
VALUE rb_struct_define_without_accessor_under(VALUE outer, const char *class_name, VALUE super, rb_alloc_func_t alloc,...)
Definition: struct.c:405
VALUE rb_assoc_new(VALUE, VALUE)
Definition: array.c:896
VALUE rb_mutex_new(void)
Definition: thread_sync.c:165
rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags)
Definition: process.c:1241
VALUE rb_struct_s_members(VALUE)
Definition: struct.c:58
#define rb_hash_uint32(h, i)
Definition: intern.h:814
int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp)
Definition: range.c:1248
VALUE rb_hash_aref(VALUE, VALUE)
Definition: hash.c:2037
VALUE rb_backref_get(void)
Definition: vm.c:1304
VALUE rb_io_eof(VALUE)
Definition: io.c:2149
VALUE rb_str_encode_ospath(VALUE)
Definition: file.c:236
VALUE rb_memory_id(VALUE)
Definition: gc.c:3753
VALUE rb_str_new_shared(VALUE)
Definition: string.c:1197
VALUE rb_big_div(VALUE, VALUE)
Definition: bignum.c:6091
VALUE rb_gc_disable(void)
Definition: gc.c:9262
int rb_bigzero_p(VALUE x)
Definition: bignum.c:2919
VALUE rb_file_open(const char *, const char *)
Definition: io.c:6263
void rb_str_shared_replace(VALUE, VALUE)
Definition: string.c:1391
VALUE rb_big_idiv(VALUE, VALUE)
Definition: bignum.c:6097
VALUE rb_path2class(const char *)
Definition: variable.c:268
long rb_big2long(VALUE)
Definition: bignum.c:5140
VALUE rb_cvar_defined(VALUE, ID)
Definition: variable.c:3123
VALUE rb_require_string(VALUE)
Definition: load.c:1145
VALUE rb_gc_start(void)
Definition: gc.c:8688
VALUE rb_enum_values_pack(int, const VALUE *)
Definition: enum.c:33
void rb_hash_free(VALUE)
VALUE rb_str_new_cstr(const char *)
Definition: string.c:808
char * rb_str_subpos(VALUE, long, long *)
Definition: string.c:2497
int rb_proc_arity(VALUE)
Definition: proc.c:1112
VALUE rb_const_list(void *)
Definition: variable.c:2598
VALUE rb_ary_cat(VALUE, const VALUE *, long)
Definition: array.c:1208
VALUE rb_str_concat(VALUE, VALUE)
Definition: string.c:3065
double rb_big2dbl(VALUE)
Definition: bignum.c:5310
VALUE rb_range_beg_len(VALUE, long *, long *, long, int)
Definition: range.c:1278
VALUE rb_num_coerce_bin(VALUE, VALUE, ID)
Definition: numeric.c:446
VALUE rb_obj_method(VALUE, VALUE)
Definition: proc.c:1861
#define rb_str_cat2
Definition: intern.h:912
VALUE rb_flt_rationalize(VALUE)
Definition: rational.c:2254
int rb_obj_respond_to(VALUE, ID, int)
Definition: vm_method.c:2197
VALUE rb_big_norm(VALUE)
Definition: bignum.c:3152
VALUE rb_dbl2big(double)
Definition: bignum.c:5249
VALUE rb_enumeratorize(VALUE, VALUE, int, const VALUE *)
Definition: enumerator.c:516
int rb_cloexec_dup2(int oldfd, int newfd)
Definition: io.c:325
VALUE rb_ivar_get(VALUE, ID)
Definition: variable.c:1070
VALUE rb_gc_latest_gc_info(VALUE)
Definition: gc.c:8832
const char * rb_sourcefile(void)
Definition: vm.c:1331
VALUE rb_time_num_new(VALUE, VALUE)
Definition: time.c:2567
VALUE rb_fiber_alive_p(VALUE)
Definition: cont.c:2152
VALUE rb_io_printf(int, const VALUE *, VALUE)
Definition: io.c:7509
int rb_feature_provided(const char *, const char **)
Definition: load.c:562
#define rb_check_frozen(obj)
Definition: intern.h:319
VALUE rb_ary_pop(VALUE)
Definition: array.c:1241
VALUE rb_external_str_new(const char *, long)
Definition: string.c:1087
VALUE rb_reg_last_match(VALUE)
Definition: re.c:1739
void rb_thread_wait_fd(int)
Definition: thread.c:4041
VALUE rb_method_call_with_block(int, const VALUE *, VALUE, VALUE)
Definition: proc.c:2309
VALUE rb_cstr2inum(const char *, int)
Definition: bignum.c:4538
VALUE rb_big_clone(VALUE)
Definition: bignum.c:3020
VALUE rb_hash_delete_if(VALUE)
Definition: hash.c:2493
VALUE rb_thread_kill(VALUE)
Definition: thread.c:2445
VALUE rb_reg_match_post(VALUE)
Definition: re.c:1783
VALUE rb_ary_each(VALUE)
Definition: array.c:2129
VALUE rb_io_close(VALUE)
Definition: io.c:4824
st_index_t rb_ivar_count(VALUE)
Definition: variable.c:1511
VALUE rb_big_xor(VALUE, VALUE)
Definition: bignum.c:6573
VALUE rb_io_fdopen(int, int, const char *)
Definition: io.c:8008
VALUE rb_gc_enable(void)
Definition: gc.c:9225
VALUE rb_define_finalizer(VALUE, VALUE)
Definition: gc.c:3302
void rb_free_generic_ivar(VALUE)
Definition: variable.c:993
VALUE rb_struct_size(VALUE s)
Definition: struct.c:1291
int rb_thread_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *)
Definition: thread.c:4066
VALUE rb_file_directory_p(VALUE, VALUE)
Definition: file.c:1617
VALUE rb_big_lshift(VALUE, VALUE)
Definition: bignum.c:6621
VALUE rb_complex_plus(VALUE x, VALUE y)
Definition: complex.c:778
void rb_str_update(VALUE, long, long, VALUE)
Definition: string.c:4643
VALUE rb_ary_resurrect(VALUE ary)
Definition: array.c:2251
VALUE rb_undefine_finalizer(VALUE)
Definition: gc.c:3206
VALUE rb_str_plus(VALUE, VALUE)
Definition: string.c:1894
#define rb_str_buf_new2
Definition: intern.h:908
VALUE rb_obj_is_method(VALUE)
Definition: proc.c:1459
VALUE rb_str_vcatf(VALUE, const char *, va_list)
Definition: sprintf.c:1210
#define rb_enumeratorize_with_size(obj, id, argc, argv, size_fn)
Definition: intern.h:260
VALUE rb_big_rshift(VALUE, VALUE)
Definition: bignum.c:6651
void rb_clear_constant_cache(void)
Definition: vm_method.c:87
PRINTF_ARGS(NORETURN(void rb_loaderror(const char *,...)), 1, 2)
VALUE rb_obj_is_proc(VALUE)
Definition: proc.c:152
VALUE rb_thread_run(VALUE)
Definition: thread.c:2586
st_index_t rb_memhash(const void *ptr, long len)
Definition: random.c:1444
VALUE rb_find_file_safe(VALUE, int)
Definition: file.c:6390
#define rb_str_buf_cat
Definition: intern.h:910
VALUE rb_str_new(const char *, long)
Definition: string.c:774
VALUE rb_str_format(int, const VALUE *, VALUE)
Definition: sprintf.c:204
VALUE rb_check_funcall(VALUE, ID, int, const VALUE *)
Definition: vm_eval.c:505
VALUE rb_io_ungetc(VALUE, VALUE)
Definition: io.c:4319
void rb_ary_modify(VALUE)
Definition: array.c:548
void rb_reset_random_seed(void)
Definition: random.c:1502
VALUE rb_complex_new_polar(VALUE abs, VALUE arg)
Definition: complex.c:1533
VALUE rb_method_call(int, const VALUE *, VALUE)
Definition: proc.c:2273
VALUE rb_fiber_current(void)
Definition: cont.c:1956
size_t rb_absint_size(VALUE val, int *nlz_bits_ret)
Definition: bignum.c:3247
void rb_match_busy(VALUE)
Definition: re.c:1295
VALUE rb_complex_arg(VALUE z)
Definition: complex.c:1208
size_t rb_absint_numwords(VALUE val, size_t word_numbits, size_t *nlz_bits_ret)
Definition: bignum.c:3382
VALUE rb_hash_update_func(VALUE newkey, VALUE oldkey, VALUE value)
Definition: intern.h:573
VALUE rb_random_bytes(VALUE rnd, long n)
Definition: random.c:1025
VALUE rb_str_cat(VALUE, const char *, long)
Definition: string.c:2812
VALUE rb_filesystem_str_new(const char *, long)
Definition: string.c:1111
int rb_absint_singlebit_p(VALUE val)
Definition: bignum.c:3446
VALUE rb_io_gets(VALUE)
Definition: io.c:3577
VALUE rb_locale_str_new(const char *, long)
Definition: string.c:1099
VALUE rb_integer_unpack(const void *words, size_t numwords, size_t wordsize, size_t nails, int flags)
Definition: bignum.c:3633
VALUE rb_fix2str(VALUE, int)
Definition: numeric.c:3513
VALUE rb_thread_main(void)
Definition: thread.c:2696
void rb_big_2comp(VALUE)
Definition: bignum.c:3049
VALUE rb_f_untrace_var(int, const VALUE *)
Definition: variable.c:574
unsigned long rb_big2ulong(VALUE)
Definition: bignum.c:5125
VALUE rb_sym_all_symbols(void)
Definition: symbol.c:840
VALUE rb_proc_call_with_block(VALUE, int argc, const VALUE *argv, VALUE)
Definition: proc.c:1000
st_index_t rb_hash_start(st_index_t)
Definition: random.c:1438
VALUE rb_str_cat_cstr(VALUE, const char *)
Definition: string.c:2822
void rb_thread_sleep_forever(void)
Definition: thread.c:1313
VALUE rb_io_write(VALUE, VALUE)
Definition: io.c:1804
VALUE rb_obj_instance_exec(int, const VALUE *, VALUE)
Definition: vm_eval.c:2029
int rb_path_check(const char *)
Definition: file.c:6229
VALUE rb_rational_raw(VALUE, VALUE)
Definition: rational.c:1951
void rb_str_set_len(VALUE, long)
Definition: string.c:2692
int rb_respond_to(VALUE, ID)
Definition: vm_method.c:2207
VALUE rb_mod_module_eval(int, const VALUE *, VALUE)
Definition: vm_eval.c:2069
double rb_genrand_real(void)
Definition: random.c:126
int rb_env_path_tainted(void)
Definition: hash.c:4904
VALUE rb_ary_push(VALUE, VALUE)
Definition: array.c:1195
VALUE rb_ary_join(VALUE, VALUE)
Definition: array.c:2347
int rb_obj_method_arity(VALUE, ID)
Definition: proc.c:2652
VALUE rb_io_ascii8bit_binmode(VALUE)
Definition: io.c:5384
VALUE rb_str_replace(VALUE, VALUE)
Definition: string.c:5363
VALUE rb_thread_wakeup(VALUE)
Definition: thread.c:2539
VALUE rb_ary_shared_with_p(VALUE, VALUE)
Definition: array.c:661
VALUE rb_str_substr(VALUE, long, long)
Definition: string.c:2584
size_t rb_gc_stat(VALUE)
Definition: gc.c:9190
VALUE rb_cv_get(VALUE, const char *)
Definition: variable.c:3149
void rb_str_free(VALUE)
Definition: string.c:1349
void rb_str_modify(VALUE)
Definition: string.c:2114
void rb_update_max_fd(int fd)
Definition: io.c:218
VALUE rb_big_mul(VALUE, VALUE)
Definition: bignum.c:5933
VALUE rb_ary_concat(VALUE, VALUE)
Definition: array.c:4069
VALUE rb_hash_lookup2(VALUE, VALUE, VALUE)
Definition: hash.c:2050
int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
Definition: vm.c:2206
VALUE rb_time_new(time_t, long)
Definition: time.c:2506
VALUE rb_str_buf_new(long)
Definition: string.c:1315
VALUE rb_check_string_type(VALUE)
Definition: string.c:2314
VALUE rb_mutex_trylock(VALUE mutex)
Definition: thread_sync.c:203
VALUE rb_mutex_locked_p(VALUE mutex)
Definition: thread_sync.c:177
VALUE rb_big_eq(VALUE, VALUE)
Definition: bignum.c:5524
VALUE rb_mutex_synchronize(VALUE mutex, VALUE(*func)(VALUE arg), VALUE arg)
Definition: thread_sync.c:522
struct timespec rb_time_timespec(VALUE time)
Definition: time.c:2706
VALUE rb_str_resurrect(VALUE str)
Definition: string.c:1522
VALUE rb_fiber_yield_kw(int argc, const VALUE *argv, int kw_splat)
Definition: cont.c:2123
VALUE rb_str_inspect(VALUE)
Definition: string.c:5930
int rb_const_defined_at(VALUE, ID)
Definition: variable.c:2692
VALUE rb_filesystem_str_new_cstr(const char *)
Definition: string.c:1117
VALUE rb_obj_id(VALUE)
Definition: gc.c:3786
VALUE rb_sym_to_s(VALUE)
Definition: string.c:10793
VALUE rb_cstr_to_inum(const char *, int, int)
Definition: bignum.c:4012
VALUE rb_hash_dup(VALUE)
Definition: hash.c:1564
VALUE rb_external_str_new_cstr(const char *)
Definition: string.c:1093
long rb_str_strlen(VALUE)
Definition: string.c:1829
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
RUBY_EXTERN VALUE rb_rs
Definition: intern.h:585
void rb_cvar_set(VALUE, ID, VALUE)
Definition: variable.c:3085
VALUE rb_thread_stop(void)
Definition: thread.c:2595
VALUE rb_complex_new(VALUE, VALUE)
Definition: complex.c:1527
RUBY_EXTERN VALUE rb_argv0
Definition: intern.h:734
VALUE rb_rational_num(VALUE rat)
Definition: rational.c:1972
VALUE rb_file_open_str(VALUE, const char *)
Definition: io.c:6256
VALUE rb_utf8_str_new_cstr(const char *)
Definition: string.c:828
VALUE rb_utf8_str_new_static(const char *, long)
Definition: string.c:884
void rb_hash_bulk_insert(long, const VALUE *, VALUE)
Definition: hash.c:4590
int rb_cloexec_open(const char *pathname, int flags, mode_t mode)
Definition: io.c:292
CONSTFUNC(VALUE rb_dbl_cmp(double, double))
NORETURN(void rb_cmperr(VALUE, VALUE))
VALUE rb_io_flush(VALUE)
Definition: io.c:1903
VALUE rb_class_path(VALUE)
Definition: variable.c:153
rb_pid_t rb_spawn_err(int, const VALUE *, char *, size_t)
Definition: process.c:4470
VALUE rb_ary_delete(VALUE, VALUE)
Definition: array.c:3365
void rb_gc(void)
Definition: gc.c:8695
VALUE rb_thread_create(VALUE(*)(void *), void *)
Definition: thread.c:965
VALUE rb_block_proc(void)
Definition: proc.c:837
VALUE rb_ary_sort_bang(VALUE)
Definition: array.c:2777
VALUE rb_path_to_class(VALUE)
Definition: variable.c:226
VALUE rb_exec_recursive_paired_outer(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE, VALUE)
Definition: thread.c:5109
VALUE rb_reg_match_pre(VALUE)
Definition: re.c:1757
void rb_remove_method(VALUE, const char *)
Definition: vm_method.c:1049
VALUE rb_complex_raw(VALUE, VALUE)
Definition: complex.c:1521
VALUE rb_mutex_sleep(VALUE self, VALUE timeout)
Definition: thread_sync.c:465
rb_gvar_setter_t rb_str_setter
Definition: intern.h:828
int rb_find_file_ext_safe(VALUE *, const char *const *, int)
Definition: file.c:6324
VALUE rb_ary_rotate(VALUE, long)
Definition: array.c:2617
VALUE rb_const_get_at(VALUE, ID)
Definition: variable.c:2397
void rb_syswait(rb_pid_t pid)
Definition: process.c:4343
VALUE rb_time_succ(VALUE)
Definition: time.c:4243
VALUE rb_gc_location(VALUE)
Definition: gc.c:8127
VALUE rb_enumerator_size_func(VALUE, VALUE, VALUE)
Definition: intern.h:256
VALUE rb_dbl_complex_new(double real, double imag)
Creates a Complex object.
Definition: complex.c:1561
VALUE rb_complex_abs(VALUE z)
Definition: complex.c:1161
VALUE rb_complex_real(VALUE z)
Definition: complex.c:726
#define rb_check_frozen_internal(obj)
Definition: intern.h:305
fd_set rb_fdset_t
Definition: intern.h:403
VALUE rb_tainted_str_new(const char *, long)
Definition: string.c:896
VALUE rb_ary_replace(VALUE copy, VALUE orig)
Definition: array.c:3811
VALUE rb_find_file(VALUE)
Definition: file.c:6397
void * rb_load_file(const char *)
Definition: ruby.c:2205
VALUE rb_str_new_with_class(VALUE, const char *, long)
Definition: string.c:1298
rb_pid_t rb_spawn(int, const VALUE *)
Definition: process.c:4476
VALUE rb_ary_cmp(VALUE, VALUE)
Definition: array.c:4420
void rb_st_foreach_safe(struct st_table *, int(*)(st_data_t, st_data_t, st_data_t), st_data_t)
void rb_alias(VALUE, ID, ID)
Definition: vm_method.c:1598
VALUE rb_str_equal(VALUE str1, VALUE str2)
Definition: string.c:3267
int rb_method_basic_definition_p(VALUE, ID)
Definition: vm_method.c:2089
VALUE rb_str_buf_new_cstr(const char *)
Definition: string.c:1331
#define rb_fd_select(n, rfds, wfds, efds, timeout)
Definition: intern.h:416
VALUE rb_str_to_inum(VALUE, int, int)
Definition: bignum.c:4268
int rb_reg_options(VALUE)
Definition: re.c:3579
VALUE rb_struct_define_without_accessor(const char *, VALUE, rb_alloc_func_t,...)
Definition: struct.c:418
VALUE rb_hash_freeze(VALUE)
Definition: hash.c:87
VALUE rb_proc_call_with_block_kw(VALUE, int argc, const VALUE *argv, VALUE, int)
Definition: proc.c:986
VALUE rb_str_split(VALUE, const char *)
Definition: string.c:8116
VALUE rb_fiber_new(rb_block_call_func_t, VALUE)
Definition: cont.c:1794
VALUE rb_file_absolute_path(VALUE, VALUE)
Definition: file.c:4133
VALUE rb_str_times(VALUE, VALUE)
Definition: string.c:1966
VALUE rb_ary_sort(VALUE)
Definition: array.c:2866
void rb_unblock_function_t(void *)
Definition: intern.h:940
void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds)
VALUE rb_big_divmod(VALUE, VALUE)
Definition: bignum.c:6135
#define rb_fd_clr(n, f)
Definition: intern.h:406
VALUE rb_Complex(VALUE, VALUE)
Definition: complex.c:1545
VALUE rb_ary_clear(VALUE)
Definition: array.c:3862
VALUE rb_ary_tmp_new(long)
Definition: array.c:768
void rb_load_protect(VALUE, int, int *)
Definition: load.c:701
VALUE rb_proc_call_kw(VALUE, VALUE, int)
Definition: proc.c:948
int rb_str_comparable(VALUE, VALUE)
Definition: string.c:3203
VALUE rb_ary_new(void)
Definition: array.c:723
void rb_gc_update_tbl_refs(st_table *ptr)
Definition: gc.c:7999
VALUE rb_tainted_str_new_cstr(const char *)
Definition: string.c:903
void rb_thread_atfork_before_exec(void)
Definition: thread.c:4552
int rb_mod_method_arity(VALUE, ID)
Definition: proc.c:2644
void rb_ivar_foreach(VALUE, int(*)(ID, VALUE, st_data_t), st_data_t)
VALUE rb_io_addstr(VALUE, VALUE)
Definition: io.c:1843
VALUE rb_const_get_from(VALUE, ID)
Definition: variable.c:2385
VALUE rb_reg_match(VALUE, VALUE)
Definition: re.c:3180
VALUE rb_complex_mul(VALUE x, VALUE y)
Definition: complex.c:872
VALUE rb_num_coerce_bit(VALUE, VALUE, ID)
Definition: numeric.c:4431
VALUE rb_complex_conjugate(VALUE z)
Definition: complex.c:1254
int rb_reserved_fd_p(int fd)
VALUE rb_proc_lambda_p(VALUE)
Definition: proc.c:275
VALUE rb_rational_new(VALUE, VALUE)
Definition: rational.c:1957
DEPRECATED_BY(rb_complex_new_polar, VALUE rb_complex_polar(VALUE abs, VALUE arg))
VALUE rb_ary_to_ary(VALUE)
Definition: array.c:1853
VALUE rb_ivar_defined(VALUE, ID)
Definition: variable.c:1317
void rb_gc_adjust_memory_usage(ssize_t)
Definition: gc.c:10333
VALUE rb_str_tmp_new(long)
Definition: string.c:1343
void rb_thread_check_ints(void)
Definition: thread.c:1361
void rb_gc_mark(VALUE)
Definition: gc.c:5228
VALUE rb_ary_reverse(VALUE)
Definition: array.c:2544
VALUE rb_reg_new(const char *, long, int)
Definition: re.c:2947
VALUE rb_ary_to_s(VALUE)
Definition: array.c:2453
VALUE rb_hash_size(VALUE)
Definition: hash.c:2939
VALUE rb_ary_subseq(VALUE, long, long)
Definition: array.c:1518
void rb_fd_fix_cloexec(int fd)
Definition: io.c:268
void rb_write_error(const char *)
Definition: io.c:7934
VALUE rb_ary_new_capa(long capa)
Definition: array.c:717
int rb_memcicmp(const void *, const void *, long)
Definition: re.c:80
VALUE rb_ary_freeze(VALUE)
Definition: array.c:648
VALUE rb_hash_update_by(VALUE hash1, VALUE hash2, rb_hash_update_func *func)
Definition: hash.c:3910
int rb_symname_p(const char *)
Definition: symbol.c:182
VALUE rb_utf8_str_new(const char *, long)
Definition: string.c:788
VALUE rb_obj_remove_instance_variable(VALUE, VALUE)
Definition: variable.c:1634
VALUE rb_str_new_static(const char *, long)
Definition: string.c:872
VALUE rb_big_unpack(unsigned long *buf, long num_longs)
Definition: bignum.c:3223
VALUE rb_cvar_get(VALUE, ID)
Definition: variable.c:3107
int rb_is_absolute_path(const char *)
Definition: file.c:6150
struct timeval rb_time_timeval(VALUE time)
Definition: time.c:2689
int rb_sym_interned_p(VALUE)
VALUE rb_mutex_unlock(VALUE mutex)
Definition: thread_sync.c:403
struct timeval rb_time_interval(VALUE num)
Definition: time.c:2683
#define MJIT_STATIC
Definition: intern.h:47
void rb_define_class_variable(VALUE, const char *, VALUE)
Definition: variable.c:3156
VALUE rb_apply(VALUE, ID, VALUE)
Calls a method.
Definition: vm_eval.c:890
VALUE rb_struct_members(VALUE)
Definition: struct.c:72
VALUE rb_str_ellipsize(VALUE, long)
Shortens str and adds three dots, an ellipsis, if it is longer than len characters.
Definition: string.c:10185
VALUE rb_num_coerce_cmp(VALUE, VALUE, ID)
Definition: numeric.c:453
VALUE rb_big_new(size_t, int)
Definition: bignum.c:3014
void rb_const_set(VALUE, ID, VALUE)
Definition: variable.c:2756
VALUE rb_big_modulo(VALUE, VALUE)
Definition: bignum.c:6103
VALUE rb_ary_resize(VALUE ary, long len)
expands or shrinks ary to len elements.
Definition: array.c:1955
void rb_set_end_proc(void(*)(VALUE), VALUE)
Definition: eval_jump.c:59
void * rb_load_file_str(VALUE)
Definition: ruby.c:2212
int rb_str_cmp(VALUE, VALUE)
Definition: string.c:3228
VALUE rb_num2fix(VALUE)
Definition: numeric.c:3088
RUBY_EXTERN VALUE rb_output_rs
Definition: intern.h:587
VALUE rb_str_subseq(VALUE, long, long)
Definition: string.c:2474
VALUE rb_proc_new(rb_block_call_func_t, VALUE)
Definition: proc.c:2991
unsigned long rb_random_ulong_limited(VALUE rnd, unsigned long limit)
Definition: random.c:934
VALUE rb_struct_aref(VALUE, VALUE)
Definition: struct.c:1061
VALUE rb_mod_remove_const(VALUE, VALUE)
Definition: variable.c:2483
VALUE rb_hash_delete(VALUE, VALUE)
Definition: hash.c:2344
void rb_thread_sleep_deadly(void)
Definition: thread.c:1320
VALUE rb_mod_module_exec(int, const VALUE *, VALUE)
Definition: vm_eval.c:2103
VALUE rb_struct_initialize(VALUE, VALUE)
Definition: struct.c:659
VALUE rb_struct_aset(VALUE, VALUE, VALUE)
Definition: struct.c:1088
int rb_cmpint(VALUE, VALUE, VALUE)
Definition: bignum.c:2925
VALUE rb_struct_define(const char *,...)
Definition: struct.c:431
VALUE rb_f_kill(int, const VALUE *)
Definition: signal.c:418
VALUE rb_big_cmp(VALUE, VALUE)
Definition: bignum.c:5419
VALUE rb_str_dump(VALUE)
Definition: string.c:6042
VALUE rb_f_sprintf(int, const VALUE *)
Definition: sprintf.c:198
VALUE rb_str_append(VALUE, VALUE)
Definition: string.c:2965
VALUE rb_str_buf_cat_ascii(VALUE, const char *)
Definition: string.c:2926
unsigned int rb_genrand_int32(void)
Definition: random.c:119
VALUE rb_file_s_absolute_path(int, const VALUE *)
Definition: file.c:4140
VALUE rb_mod_constants(int, const VALUE *, VALUE)
Definition: variable.c:2630
RUBY_EXTERN VALUE rb_default_rs
Definition: intern.h:586
VALUE rb_str_new_frozen(VALUE)
Definition: string.c:1203
void rb_gc_mark_locations(const VALUE *, const VALUE *)
Definition: gc.c:4715
VALUE rb_ary_dup(VALUE)
Definition: array.c:2238
VALUE rb_attr_get(VALUE, ID)
Definition: variable.c:1084
void rb_alias_variable(ID, ID)
Definition: variable.c:756
#define rb_fd_set(n, f)
Definition: intern.h:405
int rb_thread_fd_writable(int)
Definition: thread.c:4047
#define rb_fd_dup(d, s)
Definition: intern.h:409
void * rb_mod_const_of(VALUE, void *)
Definition: variable.c:2576
VALUE rb_method_call_kw(int, const VALUE *, VALUE, int)
Definition: proc.c:2266
VALUE rb_io_puts(int, const VALUE *, VALUE)
Definition: io.c:7751
VALUE rb_fiber_yield(int argc, const VALUE *argv)
Definition: cont.c:2129
#define rb_check_trusted(obj)
Definition: intern.h:325
VALUE rb_time_nano_new(time_t, long)
Definition: time.c:2533
int rb_pipe(int *pipes)
Definition: io.c:6373
void rb_str_modify_expand(VALUE, long)
Definition: string.c:2122
VALUE rb_io_get_io(VALUE)
Definition: io.c:733
void rb_thread_atfork(void)
Definition: thread.c:4547
VALUE rb_str_buf_append(VALUE, VALUE)
Definition: string.c:2950
VALUE rb_str_intern(VALUE)
Definition: symbol.c:710
void rb_write_error2(const char *, long)
Definition: io.c:7915
VALUE rb_str_drop_bytes(VALUE, long)
Definition: string.c:4573
void * rb_mod_const_at(VALUE, void *)
Definition: variable.c:2563
int rb_str_hash_cmp(VALUE, VALUE)
Definition: string.c:3173
VALUE rb_complex_minus(VALUE x, VALUE y)
Definition: complex.c:812
VALUE rb_io_print(int, const VALUE *, VALUE)
Definition: io.c:7580
VALUE rb_big_or(VALUE, VALUE)
Definition: bignum.c:6479
VALUE rb_time_utc_offset(VALUE time)
Definition: time.c:4810
VALUE rb_lastline_get(void)
Definition: vm.c:1316
VALUE rb_gets(void)
Definition: io.c:8906
VALUE rb_check_hash_type(VALUE)
Definition: hash.c:1852
VALUE rb_thread_current(void)
Definition: thread.c:2675
VALUE rb_reg_nth_match(int, VALUE)
Definition: re.c:1714
VALUE rb_hash_fetch(VALUE, VALUE)
Definition: hash.c:2134
VALUE rb_check_array_type(VALUE)
Definition: array.c:909
int rb_cloexec_fcntl_dupfd(int fd, int minfd)
Definition: io.c:419
int rb_const_defined_from(VALUE, ID)
Definition: variable.c:2680
VALUE rb_num_coerce_relop(VALUE, VALUE, ID)
Definition: numeric.c:461
VALUE rb_reg_match2(VALUE)
Definition: re.c:3239
#define rb_str_dup_frozen
Definition: intern.h:792
VALUE rb_proc_call(VALUE, VALUE)
Definition: proc.c:966
int rb_thread_alone(void)
Definition: thread.c:3491
VALUE rb_str_locktmp(VALUE)
VALUE rb_marshal_load(VALUE)
Definition: marshal.c:2365
void rb_gc_force_recycle(VALUE)
Definition: gc.c:7027
void rb_gc_mark_movable(VALUE)
Definition: gc.c:5222
VALUE rb_reg_init_str(VALUE re, VALUE s, int options)
Definition: re.c:2901
VALUE rb_ary_unshift(VALUE, VALUE)
Definition: array.c:1494
VALUE rb_obj_as_string(VALUE)
Definition: string.c:1440
VALUE rb_big_and(VALUE, VALUE)
Definition: bignum.c:6360
VALUE rb_block_lambda(void)
Definition: proc.c:856
int rb_arithmetic_sequence_extract(VALUE, rb_arithmetic_sequence_components_t *)
Definition: enumerator.c:3374
void rb_ary_free(VALUE)
Definition: array.c:786
VALUE rb_ary_shift(VALUE)
Definition: array.c:1294
void rb_gc_copy_finalizer(VALUE, VALUE)
Definition: gc.c:3310
VALUE rb_ivar_set(VALUE, ID, VALUE)
Definition: variable.c:1300
VALUE rb_ary_delete_at(VALUE, long)
Definition: array.c:3419
VALUE rb_require_safe(VALUE, int)
Definition: load.c:1128
int rb_method_boundp(VALUE, ID, int)
Definition: vm_method.c:1119
VALUE rb_marshal_dump(VALUE, VALUE)
Definition: marshal.c:2359
VALUE rb_reg_new_str(VALUE, int)
Definition: re.c:2895
void rb_thread_fd_close(int)
Definition: thread.c:2385
void rb_thread_sleep(int)
Definition: thread.c:1384
void rb_thread_schedule(void)
Definition: thread.c:1407
VALUE rb_struct_alloc(VALUE, VALUE)
Definition: struct.c:724
VALUE rb_thread_local_aset(VALUE, ID, VALUE)
Definition: thread.c:3363
void rb_undef_alloc_func(VALUE)
Definition: vm_method.c:729
struct timespec rb_time_timespec_interval(VALUE num)
Definition: time.c:2720
void rb_big_pack(VALUE val, unsigned long *buf, long num_longs)
Definition: bignum.c:3215
VALUE rb_reg_match_last(VALUE)
Definition: re.c:1800
VALUE rb_locale_str_new_cstr(const char *)
Definition: string.c:1105
VALUE rb_range_new(VALUE, VALUE, int)
Definition: range.c:54
VALUE rb_ary_new_from_args(long n,...)
Definition: array.c:729
VALUE rb_ary_plus(VALUE, VALUE)
Definition: array.c:4000
void rb_mem_clear(VALUE *, long)
Definition: array.c:243
rb_alloc_func_t rb_get_alloc_func(VALUE)
Definition: vm_method.c:735
VALUE rb_io_ungetbyte(VALUE, VALUE)
Definition: io.c:4280
VALUE rb_hash_aset(VALUE, VALUE, VALUE)
Definition: hash.c:2852
void rb_last_status_set(int status, rb_pid_t pid)
Definition: process.c:573
VALUE rb_env_clear(void)
Definition: hash.c:5628
PUREFUNC(int rb_during_gc(void))
VALUE rb_complex_pow(VALUE base, VALUE exp)
Definition: complex.c:985
#define rb_fd_zero(f)
Definition: intern.h:404
int rb_provided(const char *)
Definition: load.c:556
VALUE rb_const_remove(VALUE, ID)
Definition: variable.c:2494
#define rb_check_arity
Definition: intern.h:347
VALUE rb_ary_includes(VALUE, VALUE)
Definition: array.c:4340
long rb_str_sublen(VALUE, long)
Definition: string.c:2463
void rb_lastline_set(VALUE)
Definition: vm.c:1322
VALUE rb_struct_getmember(VALUE, ID)
Definition: struct.c:211
void rb_obj_call_init_kw(VALUE, int, const VALUE *, int)
Definition: eval.c:1688
VALUE rb_eval_cmd_kw(VALUE, VALUE, int)
Definition: vm_eval.c:1801
VALUE rb_str2inum(VALUE, int)
Definition: bignum.c:4544
VALUE rb_io_binmode(VALUE)
Definition: io.c:5338
VALUE rb_autoload_load(VALUE, ID)
Definition: variable.c:2226
VALUE rb_big2str(VALUE, int)
Definition: bignum.c:5091
VALUE rb_ary_rassoc(VALUE, VALUE)
Definition: array.c:4189
VALUE rb_time_timespec_new(const struct timespec *, int)
Returns a time object with UTC/localtime/fixed offset.
Definition: time.c:2544
VALUE rb_get_values_at(VALUE, long, int, const VALUE *, VALUE(*)(VALUE, long))
Definition: array.c:3106
RUBY_EXTERN VALUE rb_fs
Definition: intern.h:583
ID rb_id_attrset(ID)
Definition: symbol.c:98
VALUE rb_blocking_function_t(void *)
Definition: intern.h:941
#define rb_fd_copy(d, s, n)
Definition: intern.h:408
void rb_mark_set(struct st_table *)
Definition: gc.c:4814
int rb_find_file_ext(VALUE *, const char *const *)
Definition: file.c:6331
VALUE rb_method_call_with_block_kw(int, const VALUE *, VALUE, VALUE, int)
Definition: proc.c:2296
int rb_cloexec_dup(int oldfd)
Definition: io.c:318
const char * ruby_signal_name(int)
Definition: signal.c:310
void rb_mark_hash(struct st_table *)
Definition: gc.c:4878
void ruby_default_signal(int)
Definition: signal.c:402
VALUE rb_f_global_variables(void)
Definition: variable.c:728
VALUE rb_str_dup(VALUE)
Definition: string.c:1516
void rb_big_resize(VALUE big, size_t len)
Definition: bignum.c:2989
VALUE rb_file_expand_path(VALUE, VALUE)
Definition: file.c:4079
VALUE rb_exec_recursive(VALUE(*)(VALUE, VALUE, int), VALUE, VALUE)
Definition: thread.c:5074
VALUE rb_binding_new(void)
Definition: proc.c:364
st_index_t rb_str_hash(VALUE)
Definition: string.c:3163
VALUE rb_struct_define_under(VALUE, const char *,...)
Definition: struct.c:446
VALUE rb_mod_remove_cvar(VALUE, VALUE)
Definition: variable.c:3284
VALUE rb_reg_alloc(void)
Definition: re.c:2889
VALUE rb_detach_process(rb_pid_t pid)
Definition: process.c:1451
void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE(*dumper)(VALUE), VALUE(*loader)(VALUE, VALUE))
Definition: marshal.c:134
VALUE rb_eval_cmd(VALUE, VALUE, int)
Definition: vm_eval.c:1824
VALUE rb_hash_clear(VALUE)
Definition: hash.c:2769
VALUE rb_proc_times(VALUE)
VALUE rb_big_plus(VALUE, VALUE)
Definition: bignum.c:5824
VALUE rb_autoload_p(VALUE, ID)
Definition: variable.c:2285
VALUE rb_str_length(VALUE)
Definition: string.c:1843
VALUE rb_usascii_str_new(const char *, long)
Definition: string.c:780
void rb_clear_method_cache_by_class(VALUE)
Definition: vm_method.c:93
#define rb_enumeratorize_with_size_kw(obj, id, argc, argv, size_fn, kw_splat)
Definition: intern.h:262
VALUE(* rb_alloc_func_t)(VALUE)
Definition: intern.h:427
VALUE rb_make_backtrace(void)
Definition: vm_backtrace.c:872
void rb_backref_set(VALUE)
Definition: vm.c:1310
void rb_cv_set(VALUE, const char *, VALUE)
Definition: variable.c:3142
VALUE rb_hash_new(void)
Definition: hash.c:1523
void rb_backtrace(void)
Definition: vm_backtrace.c:829
VALUE rb_struct_new(VALUE,...)
Definition: struct.c:730
VALUE rb_mod_name(VALUE)
Definition: variable.c:102
int rb_uv_to_utf8(char[6], unsigned long)
Definition: pack.c:1651
VALUE rb_fiber_resume(VALUE fib, int argc, const VALUE *argv)
Definition: cont.c:2117
size_t rb_gc_count(void)
Definition: gc.c:8727
VALUE rb_rational_den(VALUE rat)
Definition: rational.c:1978
VALUE rb_str_succ(VALUE)
Definition: string.c:4090
void rb_ary_store(VALUE, long, VALUE)
Definition: array.c:1079
#define rb_fd_term(f)
Definition: intern.h:414
#define rb_fd_init(f)
Definition: intern.h:412
int rb_sourceline(void)
Definition: vm.c:1346
void rb_timespec_now(struct timespec *)
Definition: time.c:1873
VALUE rb_usascii_str_new_static(const char *, long)
Definition: string.c:878
VALUE rb_mutex_lock(VALUE mutex)
Definition: thread_sync.c:333
VALUE rb_obj_instance_variables(VALUE)
Definition: variable.c:1579
#define rb_fd_isset(n, f)
Definition: intern.h:407
VALUE rb_f_require(VALUE, VALUE)
Definition: load.c:853
VALUE rb_ary_assoc(VALUE, VALUE)
Definition: array.c:4156
VALUE rb_ary_entry(VALUE, long)
Definition: array.c:1512
int rb_const_defined(VALUE, ID)
Definition: variable.c:2686
VALUE rb_file_dirname(VALUE fname)
Definition: file.c:4706
VALUE rb_complex_imag(VALUE z)
Definition: complex.c:743
void rb_mark_tbl_no_pin(struct st_table *)
Definition: gc.c:5027
const char * name
Definition: nkf.c:208
void rb_num_zerodiv(void)
Definition: numeric.c:194
VALUE rb_dbl_cmp(double a, double b)
Definition: numeric.c:1431
VALUE rb_f_abort(int argc, const VALUE *argv)
Definition: process.c:4312
VALUE rb_f_exit(int argc, const VALUE *argv)
Definition: process.c:4238
VALUE rb_f_exec(int argc, const VALUE *argv)
Definition: process.c:2910
__uint32_t uint32_t
#define NULL
unsigned long st_data_t
int abs(int)
time_t time(time_t *_timer)
#define COLDFUNC
const VALUE VALUE obj
void rb_gvar_setter_t(VALUE val, ID id, VALUE *data)
const char size_t n
#define RUBY_SYMBOL_EXPORT_BEGIN
unsigned long VALUE
#define posix_signal
__inline__ const void *__restrict__ src
unsigned long long rb_big2ull(VALUE)
uint32_t i
__inline__ const void *__restrict__ size_t len
__gnuc_va_list va_list
#define RUBY_SYMBOL_EXPORT_END
#define rb_pid_t
VALUE rb_str_catf(VALUE, const char *,...) __attribute__((format(printf
rb_block_call_func * rb_block_call_func_t
long long rb_big2ll(VALUE)
struct rb_call_cache buf
st_data_t st_index_t
const VALUE * argv
_ssize_t ssize_t
__inline__ int
const VALUE VALUE VALUE marker
#define RETSIGTYPE
#define RUBY_EXTERN
VALUE rb_sprintf(const char *,...) __attribute__((format(printf
unsigned long ID
double exp(double)
__mode_t mode_t
#define ANYARGS
#define LONG_LONG
size_t rb_str_capacity(VALUE str)
Definition: string.c:712
int rb_is_global_id(ID id)
Definition: symbol.c:866
int rb_is_instance_id(ID id)
Definition: symbol.c:872
int rb_is_junk_id(ID id)
Definition: symbol.c:890
int rb_is_const_id(ID id)
Definition: symbol.c:854
int rb_is_class_id(ID id)
Definition: symbol.c:860
int rb_is_attrset_id(ID id)
Definition: symbol.c:878
int rb_is_local_id(ID id)
Definition: symbol.c:884
VALUE rb_mod_const_missing(VALUE klass, VALUE name)
Definition: variable.c:1739
MJIT_STATIC void rb_error_arity(int argc, int min, int max)
VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)
Definition: vm_method.c:120
void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src)
Definition: win32.c:2902
VALUE(*const rb_f_notimplement_)(int, const VALUE *, VALUE, VALUE)
Definition: win32.c:8139
void rb_w32_fd_copy(rb_fdset_t *dst, const fd_set *src, int max)
Definition: win32.c:2887
int WSAAPI rb_w32_select(int, fd_set *, fd_set *, fd_set *, struct timeval *)
Definition: win32.c:3280