14#include "ruby/internal/config.h"
36#include "debug_counter.h"
37#include "eval_intern.h"
39#include "internal/eval.h"
40#include "internal/sanitizers.h"
41#include "internal/signal.h"
42#include "internal/string.h"
43#include "internal/thread.h"
44#include "ruby_atomic.h"
46#include "ractor_core.h"
48#ifdef NEED_RUBY_ATOMIC_OPS
50ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val)
52 rb_atomic_t old = *ptr;
58ruby_atomic_compare_and_swap(rb_atomic_t *ptr, rb_atomic_t cmp,
61 rb_atomic_t old = *ptr;
69#define FOREACH_SIGNAL(sig, offset) \
70 for (sig = siglist + (offset); sig < siglist + numberof(siglist); ++sig)
71enum { LONGEST_SIGNAME = 7 };
73 char signm[LONGEST_SIGNAME + 1];
136 {
"CHLD", RUBY_SIGCHLD },
137 {
"CLD", RUBY_SIGCHLD },
155 {
"VTALRM", SIGVTALRM},
182 {
"DANGER", SIGDANGER},
185 {
"MIGRATE", SIGMIGRATE},
194 {
"RETRACT", SIGRETRACT},
204static const char signame_prefix[] =
"SIG";
205static const int signame_prefix_len = 3;
208signm2signo(VALUE *sig_ptr,
int negative,
int exit,
int *prefix_ptr)
211 VALUE vsig = *sig_ptr;
222 rb_raise(rb_eArgError,
"bad signal type %s",
225 *sig_ptr = vsig = str;
230 if (memchr(nm,
'\0', len)) {
231 rb_raise(rb_eArgError,
"signal name with null byte");
234 if (len > 0 && nm[0] ==
'-') {
236 rb_raise(rb_eArgError,
"negative signal name: % "PRIsVALUE, vsig);
242 if (len >= prefix + signame_prefix_len) {
243 if (memcmp(nm + prefix, signame_prefix, signame_prefix_len) == 0)
244 prefix += signame_prefix_len;
246 if (len <= (
long)prefix) {
250 if (prefix_ptr) *prefix_ptr = prefix;
251 nmlen = len - prefix;
253 if (nmlen > LONGEST_SIGNAME)
goto unsupported;
254 FOREACH_SIGNAL(sigs, !exit) {
255 if (memcmp(sigs->signm, nm, nmlen) == 0 &&
256 sigs->signm[nmlen] ==
'\0') {
257 return negative ? -sigs->signo : sigs->signo;
262 if (prefix == signame_prefix_len) {
265 else if (prefix > signame_prefix_len) {
266 prefix -= signame_prefix_len;
274 prefix = signame_prefix_len;
276 rb_raise(rb_eArgError,
"unsupported signal `%.*s%"PRIsVALUE
"'",
277 prefix, signame_prefix, vsig);
286 FOREACH_SIGNAL(sigs, 0) {
287 if (sigs->signo == no)
308sig_signame(VALUE recv, VALUE signo)
310 const char *signame = signo2signm(
NUM2INT(signo));
311 if (!signame)
return Qnil;
318 return signo2signm(no);
322rb_signo2signm(
int signo)
324 const char *
const signm = signo2signm(signo);
343esignal_init(
int argc, VALUE *argv, VALUE
self)
351 if (!
NIL_P(sig)) argnum = 2;
357 if (signo < 0 || signo > NSIG) {
358 rb_raise(rb_eArgError,
"invalid signal number (%d)", signo);
364 sig = rb_signo2signm(signo);
369 signo = signm2signo(&sig, FALSE, FALSE, &prefix);
370 if (prefix != signame_prefix_len) {
388esignal_signo(VALUE
self)
395interrupt_init(
int argc, VALUE *argv, VALUE
self)
404void rb_malloc_info_show_results(
void);
410 rb_debug_counter_show_results(
"killed by signal.");
412 rb_malloc_info_show_results();
414 signal(sig, SIG_DFL);
418static void sighandler(
int sig);
419static int signal_ignored(
int sig);
420static void signal_enque(
int sig);
426#define killpg(pg, sig) kill(-(pg), (sig))
439 sig = signm2signo(&str, TRUE, FALSE, NULL);
442 if (argc <= 1)
return INT2FIX(0);
446 for (i=1; i<argc; i++) {
447 if (killpg(
NUM2PIDT(argv[i]), sig) < 0)
452 const rb_pid_t
self = (GET_THREAD() == GET_VM()->ractor.main_thread) ? getpid() : -1;
455 for (i=1; i<argc; i++) {
458 if ((sig != 0) && (
self != -1) && (pid ==
self)) {
484 t = signal_ignored(sig);
486 if (t < 0 && kill(pid, sig))
494 else if (kill(pid, sig) < 0) {
499 rb_threadptr_check_signal(GET_VM()->ractor.main_thread);
508 rb_atomic_t cnt[RUBY_NSIG];
512volatile unsigned int ruby_nocldwait;
515#define sighandler_t ruby_sighandler_t
517#ifdef USE_SIGALTSTACK
518typedef void ruby_sigaction_t(
int,
siginfo_t*,
void*);
519#define SIGINFO_ARG , siginfo_t *info, void *ctx
520#define SIGINFO_CTX ctx
522typedef void ruby_sigaction_t(
int);
527#ifdef USE_SIGALTSTACK
529#define RUBY_SIGALTSTACK_SIZE (16*1024)
532rb_sigaltstack_size(
void)
534 int size = RUBY_SIGALTSTACK_SIZE;
538 int minsigstksz = (int)MINSIGSTKSZ;
539 if (size < minsigstksz)
543#if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
546 pagesize = (int)sysconf(_SC_PAGE_SIZE);
555static int rb_sigaltstack_size_value = 0;
558rb_allocate_sigaltstack(
void)
561 if (!rb_sigaltstack_size_value) {
562 rb_sigaltstack_size_value = rb_sigaltstack_size();
564 altstack = malloc(rb_sigaltstack_size_value);
571rb_register_sigaltstack(
void *altstack)
575 newSS.ss_size = rb_sigaltstack_size_value;
576 newSS.ss_sp = altstack;
587ruby_signal(
int signum, sighandler_t handler)
592 rb_trap_accept_nativethreads[signum] = 0;
595 sigemptyset(&sigact.sa_mask);
596#ifdef USE_SIGALTSTACK
597 if (handler == SIG_IGN || handler == SIG_DFL) {
598 sigact.sa_handler = handler;
602 sigact.sa_sigaction = (ruby_sigaction_t*)handler;
603 sigact.sa_flags = SA_SIGINFO;
606 sigact.sa_handler = handler;
613 if (handler == SIG_IGN) {
615# ifdef USE_SIGALTSTACK
616 if (sigact.sa_flags & SA_SIGINFO) {
617 sigact.sa_sigaction = (ruby_sigaction_t*)sighandler;
620 sigact.sa_handler = sighandler;
623 sigact.sa_handler = handler;
632#if defined(SA_ONSTACK) && defined(USE_SIGALTSTACK)
637 sigact.sa_flags |= SA_ONSTACK;
641 (void)VALGRIND_MAKE_MEM_DEFINED(&old,
sizeof(old));
642 if (
sigaction(signum, &sigact, &old) < 0) {
645 if (old.sa_flags & SA_SIGINFO)
646 handler = (sighandler_t)old.sa_sigaction;
648 handler = old.sa_handler;
649 ASSUME(handler != SIG_ERR);
654posix_signal(
int signum, sighandler_t handler)
656 return ruby_signal(signum, handler);
660static inline sighandler_t
661ruby_signal(
int signum, sighandler_t handler)
663 if (signum == SIGKILL) {
667 return signal(signum, handler);
671#define ruby_signal(sig,handler) ( signal((sig),(handler)))
674ruby_nativethread_signal(
int signum, sighandler_t handler)
678 old = signal(signum, handler);
679 rb_trap_accept_nativethreads[signum] = 1;
686signal_ignored(
int sig)
691 (void)VALGRIND_MAKE_MEM_DEFINED(&old,
sizeof(old));
692 if (
sigaction(sig, NULL, &old) < 0)
return FALSE;
693 func = old.sa_handler;
695 sighandler_t old = signal(sig, SIG_DFL);
699 if (func == SIG_IGN)
return 1;
700 return func == sighandler ? 0 : -1;
706 ATOMIC_INC(signal_buff.cnt[sig]);
707 ATOMIC_INC(signal_buff.size);
711static rb_atomic_t sigchld_hit;
713# define GET_SIGCHLD_HIT() ATOMIC_EXCHANGE(sigchld_hit, 0)
715# define GET_SIGCHLD_HIT() 0
721 int old_errnum = errno;
724 if (sig == RUBY_SIGCHLD) {
727 ATOMIC_EXCHANGE(sigchld_hit, 1);
730 if (vm && ACCESS_ONCE(VALUE, vm->trap_list.cmd[sig])) {
738 rb_thread_wakeup_timer_thread(sig);
739#if !defined(BSD_SIGNAL) && !defined(POSIX_SIGNAL)
740 ruby_signal(sig, sighandler);
747rb_signal_buff_size(
void)
749 return signal_buff.size;
753rb_disable_interrupt(
void)
755#ifdef HAVE_PTHREAD_SIGMASK
758 pthread_sigmask(SIG_SETMASK, &mask, NULL);
763rb_enable_interrupt(
void)
765#ifdef HAVE_PTHREAD_SIGMASK
768 pthread_sigmask(SIG_SETMASK, &mask, NULL);
773rb_get_next_signal(
void)
777 if (signal_buff.size != 0) {
778 for (i=1; i<RUBY_NSIG; i++) {
779 if (signal_buff.cnt[i] > 0) {
780 ATOMIC_DEC(signal_buff.cnt[i]);
781 ATOMIC_DEC(signal_buff.size);
790#if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
791static const char *received_signal;
792# define clear_received_signal() (void)(ruby_disable_gc = 0, received_signal = 0)
794# define clear_received_signal() ((void)0)
797#if defined(USE_SIGALTSTACK) || defined(_WIN32)
799# if defined __HAIKU__
800# define USE_UCONTEXT_REG 1
801# elif !(defined(HAVE_UCONTEXT_H) && (defined __i386__ || defined __x86_64__ || defined __amd64__))
802# elif defined __linux__
803# define USE_UCONTEXT_REG 1
804# elif defined __APPLE__
805# define USE_UCONTEXT_REG 1
806# elif defined __FreeBSD__
807# define USE_UCONTEXT_REG 1
809#if defined(HAVE_PTHREAD_SIGMASK)
810# define ruby_sigunmask pthread_sigmask
811#elif defined(HAVE_SIGPROCMASK)
812# define ruby_sigunmask sigprocmask
815reset_sigmask(
int sig)
817#if defined(ruby_sigunmask)
820 clear_received_signal();
821#if defined(ruby_sigunmask)
823 sigaddset(&mask, sig);
824 if (ruby_sigunmask(SIG_UNBLOCK, &mask, NULL)) {
825 rb_bug_errno(STRINGIZE(ruby_sigunmask)
":unblock", errno);
830# ifdef USE_UCONTEXT_REG
832check_stack_overflow(
int sig,
const uintptr_t addr,
const ucontext_t *ctx)
834 const DEFINE_MCONTEXT_PTR(mctx, ctx);
835# if defined __linux__
837 const greg_t sp = mctx->gregs[REG_RSP];
838 const greg_t bp = mctx->gregs[REG_RBP];
840 const greg_t sp = mctx->gregs[REG_ESP];
841 const greg_t bp = mctx->gregs[REG_EBP];
843# elif defined __APPLE__
845# define MCTX_SS_REG(reg) __ss.__##reg
847# define MCTX_SS_REG(reg) ss.reg
849# if defined(__LP64__)
850 const uintptr_t sp = mctx->MCTX_SS_REG(rsp);
851 const uintptr_t bp = mctx->MCTX_SS_REG(rbp);
853 const uintptr_t sp = mctx->MCTX_SS_REG(esp);
854 const uintptr_t bp = mctx->MCTX_SS_REG(ebp);
856# elif defined __FreeBSD__
857# if defined(__amd64__)
858 const __register_t sp = mctx->mc_rsp;
859 const __register_t bp = mctx->mc_rbp;
861 const __register_t sp = mctx->mc_esp;
862 const __register_t bp = mctx->mc_ebp;
864# elif defined __HAIKU__
865# if defined(__amd64__)
866 const unsigned long sp = mctx->rsp;
867 const unsigned long bp = mctx->rbp;
869 const unsigned long sp = mctx->esp;
870 const unsigned long bp = mctx->ebp;
873 enum {pagesize = 4096};
874 const uintptr_t sp_page = (uintptr_t)sp / pagesize;
875 const uintptr_t bp_page = (uintptr_t)bp / pagesize;
876 const uintptr_t fault_page = addr / pagesize;
880 if (sp_page == fault_page || sp_page == fault_page + 1 ||
881 (sp_page <= fault_page && fault_page <= bp_page)) {
884 int uplevel = roomof(pagesize,
sizeof(*ec->tag)) / 2;
885 while ((uintptr_t)ec->tag->buf / pagesize <= fault_page + 1) {
889 if ((crit = (!ec->tag->prev || !--uplevel)) != FALSE)
break;
890 ec->tag = ec->tag->prev;
893 rb_ec_stack_overflow(ec, crit);
898check_stack_overflow(
int sig,
const void *addr)
900 int ruby_stack_overflowed_p(
const rb_thread_t *,
const void *);
902 if (ruby_stack_overflowed_p(th, addr)) {
904 rb_ec_stack_overflow(th->ec, FALSE);
909# define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, 0)
911# define FAULT_ADDRESS info->si_addr
912# ifdef USE_UCONTEXT_REG
913# define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, (uintptr_t)FAULT_ADDRESS, ctx)
915# define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, FAULT_ADDRESS)
917# define MESSAGE_FAULT_ADDRESS " at %p", FAULT_ADDRESS
920# define CHECK_STACK_OVERFLOW() (void)0
922#ifndef MESSAGE_FAULT_ADDRESS
923# define MESSAGE_FAULT_ADDRESS
926#if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
927NOINLINE(
static void check_reserved_signal_(
const char *name,
size_t name_len));
930#define check_reserved_signal(name) check_reserved_signal_(name, sizeof(name)-1)
934static sighandler_t default_sigbus_handler;
935NORETURN(
static ruby_sigaction_t sigbus);
938sigbus(
int sig SIGINFO_ARG)
940 check_reserved_signal(
"BUS");
947#if defined __APPLE__ || defined __linux__
948 CHECK_STACK_OVERFLOW();
950 rb_bug_for_fatal_signal(default_sigbus_handler, sig, SIGINFO_CTX,
"Bus Error" MESSAGE_FAULT_ADDRESS);
956static sighandler_t default_sigsegv_handler;
957NORETURN(
static ruby_sigaction_t sigsegv);
960sigsegv(
int sig SIGINFO_ARG)
962 check_reserved_signal(
"SEGV");
963 CHECK_STACK_OVERFLOW();
964 rb_bug_for_fatal_signal(default_sigsegv_handler, sig, SIGINFO_CTX,
"Segmentation fault" MESSAGE_FAULT_ADDRESS);
970static sighandler_t default_sigill_handler;
971NORETURN(
static ruby_sigaction_t sigill);
974sigill(
int sig SIGINFO_ARG)
976 check_reserved_signal(
"ILL");
977#if defined __APPLE__ || defined __linux__
978 CHECK_STACK_OVERFLOW();
980 rb_bug_for_fatal_signal(default_sigill_handler, sig, SIGINFO_CTX,
"Illegal instruction" MESSAGE_FAULT_ADDRESS);
985NORETURN(
static void ruby_abort(
void));
1002check_reserved_signal_(
const char *name,
size_t name_len)
1004 const char *prev = ATOMIC_PTR_EXCHANGE(received_signal, name);
1007 ssize_t RB_UNUSED_VAR(err);
1008#define NOZ(name, str) name[sizeof(str)-1] = str
1009 static const char NOZ(msg1,
" received in ");
1010 static const char NOZ(msg2,
" handler\n");
1013 struct iovec iov[4];
1015 iov[0].iov_base = (
void *)name;
1016 iov[0].iov_len = name_len;
1017 iov[1].iov_base = (
void *)msg1;
1018 iov[1].iov_len =
sizeof(msg1);
1019 iov[2].iov_base = (
void *)prev;
1020 iov[2].iov_len = strlen(prev);
1021 iov[3].iov_base = (
void *)msg2;
1022 iov[3].iov_len =
sizeof(msg2);
1023 err = writev(2, iov, 4);
1025 err = write(2, name, name_len);
1026 err = write(2, msg1,
sizeof(msg1));
1027 err = write(2, prev, strlen(prev));
1028 err = write(2, msg2,
sizeof(msg2));
1033 ruby_disable_gc = 1;
1037#if defined SIGPIPE || defined SIGSYS
1039sig_do_nothing(
int sig)
1045signal_exec(VALUE cmd,
int sig)
1048 volatile rb_atomic_t old_interrupt_mask = ec->interrupt_mask;
1049 enum ruby_tag_type state;
1060 ec->interrupt_mask |= TRAP_INTERRUPT_MASK;
1062 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
1068 ec->interrupt_mask = old_interrupt_mask;
1072 EC_JUMP_TAG(ec, state);
1080 VALUE trap_exit = vm->trap_list.cmd[0];
1083 vm->trap_list.cmd[0] = 0;
1084 signal_exec(trap_exit, 0);
1088void ruby_waitpid_all(
rb_vm_t *);
1091ruby_sigchld_handler(
rb_vm_t *vm)
1093 if (SIGCHLD_LOSSY || GET_SIGCHLD_HIT()) {
1094 ruby_waitpid_all(vm);
1103 VALUE cmd = vm->trap_list.cmd[sig];
1128 rb_threadptr_signal_raise(th, sig);
1132 else if (cmd ==
Qundef) {
1133 rb_threadptr_signal_exit(th);
1136 return signal_exec(cmd, sig);
1142default_handler(
int sig)
1172 func = (sighandler_t)sigbus;
1177 func = (sighandler_t)sigsegv;
1182 func = sig_do_nothing;
1187 func = sig_do_nothing;
1199trap_handler(VALUE *cmd,
int sig)
1201 sighandler_t func = sighandler;
1211 if (!command)
rb_raise(rb_eArgError,
"bad handler");
1213 if (!
NIL_P(command)) {
1225 func = default_handler(sig);
1232 if (memcmp(cptr,
"SYSTEM_DEFAULT", 14) == 0) {
1233 if (sig == RUBY_SIGCHLD) {
1241 if (memcmp(cptr,
"SIG_IGN", 7) == 0) {
1244 else if (memcmp(cptr,
"SIG_DFL", 7) == 0) {
1247 else if (memcmp(cptr,
"DEFAULT", 7) == 0) {
1252 if (memcmp(cptr,
"IGNORE", 6) == 0) {
1257 if (memcmp(cptr,
"EXIT", 4) == 0) {
1265 GetProcPtr(*cmd, proc);
1274trap_signm(VALUE vsig)
1280 if (sig < 0 || sig >= NSIG) {
1281 rb_raise(rb_eArgError,
"invalid signal number (%d)", sig);
1285 sig = signm2signo(&vsig, FALSE, TRUE, NULL);
1291trap(
int sig, sighandler_t func, VALUE command)
1293 sighandler_t oldfunc;
1306 oldfunc = ruby_signal(sig, func);
1309 oldcmd = vm->trap_list.cmd[sig];
1313 if (oldfunc == SIG_IGN) oldcmd =
rb_str_new2(
"IGNORE");
1314 else if (oldfunc == SIG_DFL) oldcmd =
rb_str_new2(
"SYSTEM_DEFAULT");
1315 else if (oldfunc == sighandler) oldcmd =
rb_str_new2(
"DEFAULT");
1325 ACCESS_ONCE(VALUE, vm->trap_list.cmd[sig]) = command;
1331reserved_signal_p(
int signo)
1335 if (signo == SIGSEGV)
1339 if (signo == SIGBUS)
1343 if (signo == SIGILL)
1347 if (signo == SIGFPE)
1353 if (signo == SIGVTALRM)
1392sig_trap(
int argc, VALUE *argv, VALUE
_)
1400 sig = trap_signm(argv[0]);
1401 if (reserved_signal_p(sig)) {
1402 const char *name = signo2signm(sig);
1404 rb_raise(rb_eArgError,
"can't trap reserved signal: SIG%s", name);
1406 rb_raise(rb_eArgError,
"can't trap reserved signal: %d", sig);
1415 func = trap_handler(&cmd, sig);
1420 cmd = rb_proc_isolate(cmd);
1423 return trap(sig, func, cmd);
1441 FOREACH_SIGNAL(sigs, 0) {
1447#define INSTALL_SIGHANDLER(cond, signame, signum) do { \
1448 static const char failed[] = "failed to install "signame" handler"; \
1449 if (!(cond)) break; \
1450 if (reserved_signal_p(signum)) rb_bug(failed); \
1454install_sighandler_core(
int signum, sighandler_t handler, sighandler_t *old_handler)
1458 old = ruby_signal(signum, handler);
1459 if (old == SIG_ERR)
return -1;
1461 *old_handler = (old == SIG_DFL || old == SIG_IGN) ? 0 : old;
1465 if (old != SIG_DFL) {
1466 ruby_signal(signum, old);
1472# define install_sighandler(signum, handler) \
1473 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, NULL), #signum, signum)
1474# define force_install_sighandler(signum, handler, old_handler) \
1475 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, old_handler), #signum, signum)
1479init_sigchld(
int sig)
1481 sighandler_t oldfunc;
1482 sighandler_t func = sighandler;
1484 oldfunc = ruby_signal(sig, SIG_DFL);
1485 if (oldfunc == SIG_ERR)
return -1;
1486 ruby_signal(sig, func);
1487 ACCESS_ONCE(VALUE, GET_VM()->trap_list.cmd[sig]) = 0;
1492# define init_sigchld(signum) \
1493 INSTALL_SIGHANDLER(init_sigchld(signum), #signum, signum)
1499 sighandler_t oldfunc;
1501 oldfunc = ruby_signal(SIGINT, SIG_IGN);
1502 if (oldfunc == sighandler) {
1503 ruby_signal(SIGINT, SIG_DFL);
1508int ruby_enable_coredump = 0;
1563 rb_disable_interrupt();
1565 install_sighandler(SIGINT, sighandler);
1567 install_sighandler(SIGHUP, sighandler);
1570 install_sighandler(SIGQUIT, sighandler);
1573 install_sighandler(SIGTERM, sighandler);
1576 install_sighandler(SIGALRM, sighandler);
1579 install_sighandler(SIGUSR1, sighandler);
1582 install_sighandler(SIGUSR2, sighandler);
1585 if (!ruby_enable_coredump) {
1587 force_install_sighandler(SIGBUS, (sighandler_t)sigbus, &default_sigbus_handler);
1590 force_install_sighandler(SIGILL, (sighandler_t)sigill, &default_sigill_handler);
1593 RB_ALTSTACK_INIT(GET_VM()->main_altstack, rb_allocate_sigaltstack());
1594 force_install_sighandler(SIGSEGV, (sighandler_t)sigsegv, &default_sigsegv_handler);
1598 install_sighandler(SIGPIPE, sig_do_nothing);
1601 install_sighandler(SIGSYS, sig_do_nothing);
1605 init_sigchld(RUBY_SIGCHLD);
1608 rb_enable_interrupt();
1611#if defined(HAVE_GRANTPT)
1612extern int grantpt(
int);
1615fake_grantfd(
int masterfd)
1620#define grantpt(fd) fake_grantfd(fd)
1624rb_grantpt(
int masterfd)
1644 ret = grantpt(masterfd);
1645 if (ret < 0) e = errno;
1649 if (ret < 0) errno = e;
1653 return grantpt(masterfd);
VALUE rb_define_module(const char *name)
Defines a top-level module.
void rb_define_module_function(VALUE module, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a module function for a module.
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a method.
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define FIX2INT
Old name of RB_FIX2INT.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define Qtrue
Old name of RUBY_Qtrue.
#define NUM2INT
Old name of RB_NUM2INT.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define NIL_P
Old name of RB_NIL_P.
#define IMMEDIATE_P
Old name of RB_IMMEDIATE_P.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
void ruby_sig_finalize(void)
Clear signal handlers.
void rb_raise(VALUE exc, const char *fmt,...)
Exception entry point.
void rb_sys_fail(const char *mesg)
Converts a C errno into a Ruby exception, then raises it.
void rb_bug_errno(const char *mesg, int errno_arg)
This is a wrapper of rb_bug() which automatically constructs appropriate message from the passed errn...
void rb_sys_fail_str(VALUE mesg)
Identical to rb_sys_fail(), except it takes the message in Ruby's String instead of C's.
VALUE rb_check_to_integer(VALUE val, const char *mid)
Identical to rb_check_convert_type(), except the return value type is fixed to rb_cInteger.
VALUE rb_call_super(int argc, const VALUE *argv)
This resembles ruby's super.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
void rb_interrupt(void)
Raises an instance of rb_eInterrupt.
void rb_memerror(void)
Triggers out-of-memory error.
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Inserts or replaces ("upsert"s) the objects into the given hash table.
VALUE rb_hash_new(void)
Creates a new, empty hash object.
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
VALUE rb_obj_is_proc(VALUE recv)
Queries if the given object is a proc.
void ruby_default_signal(int sig)
Pretends as if there was no custom signal handler.
const char * ruby_signal_name(int signo)
Queries the name of the signal.
VALUE rb_f_kill(int argc, const VALUE *argv)
Sends a signal ("kills") to processes.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
VALUE rb_str_subseq(VALUE str, long beg, long len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
void rb_must_asciicompat(VALUE obj)
Asserts that the given string's encoding is (Ruby's definition of) ASCII compatible.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
VALUE rb_str_new_cstr(const char *ptr)
Identical to rb_str_new(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_thread_current(void)
Obtains the "current" thread.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
void rb_alias(VALUE klass, ID dst, ID src)
Resembles alias.
VALUE rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
This API is practically a variant of rb_proc_call_kw() now.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
VALUE rb_sym2str(VALUE id)
Identical to rb_id2str(), except it takes an instance of rb_cSymbol rather than an ID.
VALUE rb_sprintf(const char *fmt,...)
Ruby's extended sprintf(3).
#define NUM2PIDT
Converts an instance of rb_cNumeric into C's pid_t.
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
#define StringValue(v)
Ensures that the parameter object is a String.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
#define RB_NO_KEYWORDS
Do not pass keywords.
#define _(args)
This was a transition path from K&R to ANSI.
void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock)
Blocks until the current thread obtains a lock.
void rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock)
Releases a lock.
static bool RB_SYMBOL_P(VALUE obj)
Queries if the object is an instance of rb_cSymbol.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.